Haskell

Contents

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
n/a	import module hiding (c)	Import everything from the module directly into the namespec, except selected items

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]

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

Python	Haskell	Notes
[1,2,3,4]	[1,2,3,4]
[1, 'a', "foo"]	n/a	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