decluttering-with-functional-programming.py

defsquare(x):
returnx*x

# anonymous subroutine 
anon_square=lambdax: x*x

list1=list((1,2,3)) #=> a list from a tuple
list2= [1,2,3]; #=> a list, because of the '[...]'

range1=range(1,11) #=> a range 1 .. 10
list3=list(range(1,11)); #=> a list from a range

tuple1=1,2,3; #=> a tuple
tuple2=tuple([1,2,3]) #=> a tuple from a list
tuple3=tuple(range(1,11)) #=> creates a tuple from a range

## A function, by any other name -- functions as values

defchoose (t, f, d):
ifd:
returnt
else:
returnf

tstr="True!"
fstr="False!"

res_str=choose(tstr,fstr,True)

print(res_str) #=> says "True!"

deftt(s):
print( "True "+s+"!")
defff(s): 
print( "False"+s+"!")

res_f=choose(tt,ff,True)

print(res_f) #=> says <function tt at 0x7f829c3aa310>
res_f("rumour") #=> says "False rumour!"

## Functions don't need a name

tt=lambdas : print( "True "+s+"!" )
ff=lambdas : print( "False "+s+"!" )

res_f=choose(tt, ff, True);

print( res_f) #=> says <function <lambda> at 0x7f829b298b80>
res_f("story") #=> says "True story!"

## Examples: `map`, `grep` and `reduce`


### `map` : applying a function to all elements of a list

res=tuple( map( lambdax : x*x , range(1,11)))

res= []
forxinrange(1,11):
res.append(x*x)

### `filter` : filtering a list

res=tuple(filter( lambdax : x%5==0 ,range(1,31)))

res= []
forxinrange(1,31): 
if (x%5==0):
res.append(x)

res=tuple(filter( lambdax : x%5==0 ,map( lambdax : x*x ,tuple(range(1,31)))))

### `reduce` : combining all elements of a list into a single value

fromfunctoolsimportreduce

sum=reduce(lambdaacc,elt: acc+elt, range(1,11))

print( sum); #=> says 55

### Writing your own

assoc_func=lambdax,y: x+y
non_assoc_func=lambdax,y: x+yifx<yelsex

#### Left fold

deffoldll (f, iacc, lst):
acc=iacc
foreltinlst:
acc=f(acc,elt) 
returnacc

deffoldl (f, acc, lst):
iflst== (): 
returnacc
else:
# Python's way of splitting a tuple in the first elt and the rest
# rest will be a list, not a tuple, but we'll let that pass
 (elt,*rest) =lst
# The actual recursion
returnfoldl( f, f(acc, elt), rest)

#### Right fold

deffoldlr (f, iacc, lst):
acc=iacc
foreltinlst.reverse():
acc=f(acc,elt) 
returnacc

deffoldr (f, acc, lst):
iflst== (): 
returnacc
else:
 (*rest,elt) =lst
returnfoldr( f, f(acc, elt), rest)


#### `map` and `grep` are folds

defmap_ (f,lst):
returnfoldl( 
lambdaacc,elt:(*acc, f(elt))
 ,()
 ,lst
 )

deffilter_ (f,lst):
returnfoldl( 
lambdaacc,elt:
 (*acc,elt) iff(elt) elseacc
 , (), lst)


## Functions returning functions

defadd_1 (x) : returnx+1
defadd_2 (x) : returnx+2
defadd_3 (x) : returnx+3
defadd_4 (x) : returnx+4
defadd_5 (x) : returnx+5

print( add_1(4)) #=> says 5

add= (
lambdax : x+1,
lambdax : x+2,
lambdax : x+3,
lambdax : x+4,
lambdax : x+5
)
print( add[0](4)) #=> says 5

add= []
forninrange(0,6):
add.append(lambdax: x+n)

defgen_add(n): 
returnlambdax : x+n

add=tuple(map( gen_add, range(0,6)))

print( add[1](4)) #=> says 5

## Function composition

res_chain=map( lambdax : x+5, map( lambdax : x*x, range(1,31)))
defcompose(f,g):
returnlambdax: f(g(x))