Function composition, Kleisli arrow, and Monadic laws
functional-programming, kleisli, monads, scala
Solution
What you have here is the immediate consequence of this construction being a category.
- Yes, they do conform. And that they conform is indeed the reason they are called Kleisli, because the Kleisli arrows plus types form the Kleisli category of the monad (to which every monad gives rise to). It's also why `unit` is called like that: it is the unit under composition of Kleisli arrows.
- Yes, they can be derived. Use the transformation `(f <=< g) x = f =<< (g x)` (where `<=<` is `andThen`, and `=<<` is probably something like `flip(bind)` in Scala). The exact steps of the derivation can be found here.
Problem
After reading this article I understand that `>=>` (Kleisli arrow) is just a higher order function to compose functions, that return "monadic values". For example: ``` val f: A => M[B] = ... val g: B => M[C] = ... val h: A => M[C] = f >=> g // compose f and g with Kleisli arrow ``` It looks like a simple composition of "simple" functions (i.e. pure functions that return simple values): ``` val f: A => B = ... val g: B => C = ... val h = f andThen g; // compose f and g ``` Now I guess this "simple" composition `andThen` conforms to certain laws - Identity: `f andThen g == g` and `g andThen f == g` for identity function: `f[A](a:A):A = a` - Associativity: `(f1 andThen f2) andThen f3` == `f1 andThen (f2 andThen f3)` And now my questions: - Does `>=>` conform to those laws, where identity is `f(a:A) = M[a].unit(a)` ? - Can we derive the monadic laws from the those laws ? Are those laws and the monadic laws equivalent ?