Haskell

By analogy to Python...

Imports

Python Haskell Notes
from module import * import module Import everything from the module directly into the namespace
from module import a,b import module (a,b) Import selected items from the module directly into the namespace
import module import qualified module Make all module.NAME available in the name space
import module M = module del module import qualified module as M Give module a shorter alias
import module hiding (c) Import everything from the module directly into the namespec, except selected items

Math

Python Haskell Notes
a+b, a*b, a-b a+b, a*b, a-b  
  a/b Integer division giving a float
a and b, a or b, not a a && b, a || b, not a  
a == b, a != b a==b, a /= b  
min(a,b), max(a,b) min a b, max a b  
min([a,b,c]), max([a,b,c]), sum([a,b,c]) minimum [a,b,c], maximum [a,b,c], sum [a,b,c]  
     
     

Expressions

Python Haskell Notes
b if a else c if a then b else c Both are expressions, not statements
     
     
     

Lists

Python Haskell Notes
[1,2,3,4] [1,2,3,4]  
[1, ‘a’, “foo”]
Haskell lists must be homogeneous
[1,2] + [3,4] [1,2] ++ [3,4]  
[1] + [2,3] 1:[2,3] Haskell has more syntax for list expressions
     
[‘a’,’b’,’c’][1] [‘a’, ‘b’, ‘c’] !! 1 Extract a list element
[‘a’,’b’,’c’][:3] take 3 [‘a’,’b’,’c’] First N elements
[‘a’,’b’,’c’][3:] drop 3 [‘a’,’b’,’c’] Drop N, take rest
[‘a’,’b’,’c’][1:2] take 2 . drop 1 [‘a’,’b’,’c’] Slices are uglier in Haskell
[‘a’,’b’,’c’][0] head [‘a’,’b’,’c’] First elt
[‘a’,’b’,’c’][1:] tail [‘a’,’b’,’c’] All but first elt
[‘a’,’b’,’c’][-1] last [‘a’,’b’,’c’]  
[‘a’,’b’,’c’][:-1] init [‘a’,’b’,’c’] All but last elt
len([‘a’,’b’,’c’]) length [‘a’,’b’,’c’]  
not len([‘a’,’b’,’c’]) null [‘a’,’b’,’c’] is list empty (but would probably just do bool(list) in Python)
reverse([‘a’,’b’,’c’]) reverse [‘a’,’b’,’c’]  
‘a’ in [‘a’,’b’,’c’] ‘a’ elem [‘a’,’b’,’c’]  
range(1,21) [1..20] Python counts to the last value before the 2nd parm, Haskell includes it
set(x) - set(y) x \ y Set difference for lists x and y - except Haskell isn’t really, it just removes one value ‘z’ from x for each occurrence of ‘z’ in y. See Data.Set for real sets.
set(x) + set(y) x union y Haskell adds one occurrence of each element of y to x if x doesn’t already have one
     
     

Functions

Python Haskell Notes
def doubleMe(x):
return x + x
doubleMe x = x + x  
def doubleUs(x, y):
return x*2 + y*2
doubleUs x y = x*2 + y+2