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']