Kleisli Category¶
kcompose :: (c -> Maybe a) -> (a -> Maybe b) -> (c -> Maybe b)
kcompose f g = ???
bind
(>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b
(g after f) x = g(f(x))
x :: c
f(x) :: Maybe a
g(f(x)) :: Maybe b
logger example - State Monad!¶
In [18]:
global log
log = ""
def andd(x):
global log
log += "and!"
return lambda y: x and y
def orr(x):
global log
log += "or!"
return lambda y: x or y
def negate(x):
global log
log += "not!"
return not x
def increment(x):
global log
log += "inc!"
return x+1
def decrement(x):
global log
log += "dec!"
return x-1
def add(x):
global log
log += "add!"
return lambda y: x+y
def id(x):
global log
log += "id!"
return x
a2 = add(2)
a5 = add(5)
result1 = a2(increment(decrement(a5(7))))
print(result1)
print(log)
14 add!add!dec!inc!
What if we incorporate the logging within the composition operator?
In [8]:
def andd(x):
return lambda y: (x and y,"and!")
def orr(x):
return lambda y: (x or y,"or!")
def negate(x):
return (not x,"not!")
def increment(x):
return (x+1,"inc!")
def decrement(x):
return (x-1,"dec!")
def add(x):
return lambda y: (x+y,"add!")
def id(x):
return (x,"")
def compose (f,g):
return lambda x: (g(f(x)[0])[0],f(x)[1]+g(x)[1])
def main():
b1 = True
b2 = False
#result = compose(negate,negate)(b1)
#result = compose(negate,andd(b1))(b2)
#result = compose(negate,compose(negate,andd(b1)))(b2)
#result = compose(orr(b2),compose(negate,compose(negate,andd(b1))))(b2)
result = compose(add(2),compose(increment,compose(decrement,add(5))))(7)
print(result[0])
print(result[1])
main()
14 add!inc!dec!add!
Banana Split¶
In [6]:
combineN = lambda fs: lambda s,x: [f(s[i])(x) for i,f in enumerate(fs)]
In [7]:
from functools import reduce
xs = [1, 2, 3, 4, 5]
print(reduce(combineN( \
[lambda x: lambda y: x+y, \
lambda x: lambda y: x+1, \
lambda x: lambda y: x*y, \
lambda x: lambda y: x+str(y)]),xs,[0,0,1,'']))
[15, 5, 120, '12345']