Functor Applicative and Monads

I am putting my understanding about functor,Applicative and Monad after spending few days to find out what monad is . Here is what I found. I am using Kotlin to explain with examples What is functor Functor can be defines in may ways as below A functor is simply something that can be mapped over. A functor is a data structure which acts like a container holding a generic type Lets define the data type or container to hold value { None : Functor () ( value: T) : Functor () } class Functor T object Nothing data class Some out T val While we introduced functors as containers holding a value, sometimes those containers can have interesting properties. For this reason, functors are often described as “ ”. values in a context When a value is wrapped in a context, you can’t apply a normal function to it, and this is where map function comes in to apply normal function to Wrapped Value sealed { object None : Functor () data = when ( ) { is None -> is Some -> Some(f(value)) } companion object { fun some(value: A): Functor = Some(value) } } class Functor out A ( : ) : () ( : ( ) -> ): class Some out A val value A Functor A inline infix fun B map f A B Functor B this this Lets apply function on the wrapped value : = value + increment = Functor( ).map {::inc} increment = Functor( ).map {it + } fun inc (value: ) Int Int 1 val 3 //OR val 3 1 So this is functor, the container with map function . Why Are Functors Useful? Because we want to reuse code. Functor generalizes how to map a function from one value to another. Functors are useful because they let us use map with collections, replacing for loops : Because Functor.map returns another Functor with the result of the function passed to map I can chain multiple map functions together Chaining Applicative Functor can only map a function which takes one argument. If we have a function that takes multiple arguments, we need Applicative. Applicative provides abstraction for how to apply a function that takes multiple arguments over multiple values. In Applicative, We can define an apply function for every type supporting Applicative, which knows how to apply a function wrapped in the context of the type to a value wrapped in the same context: { None : Functor () ( value: A) : Functor () -> B): Functor = ( ) { None -> Some -> Some(f(value)) } { : Functor = Some(value) } ( ) { None -> None Some -> f.map( .value) } } sealed class Functor out A object Nothing data class Some out A val inline infix fun map (f: ( ) A when this is this is companion object fun some (value: ) A infix Functor B>.apply(f: Functor ): Functor = fun when this is is this If you look carefully you will see that our operator only works in this specific order: Option(function) apply Option(value) Examples 1 : Apply a function that takes two arguments to two wrapped values = { b: -> a + b } Some( ) map ::curriedAddition map Some( ) Some( ) map ::curriedAddition apply Some( ) fun curriedAddition (a: ) Int Int 3 2 // => COMPILER ERROR// Use applicative 3 2 Apply triple product function: fun tripleProduct(a: Int, : Int, : Int) = a * b * c fun curry(f: (A, B, C) -> D): (A) -> (B) -> (C) -> D = { a -> { b -> { c -> f(a, b, c) } } } Some( ) map curry(::tripleProduct) apply Some( ) apply Some( ) b c 3 5 4 // => Some(60) Monads Before we start with Monads, it is important to understand in kotlin function composition Function Composition Function composition is a technique to build functions using existing functions Function Composition takes the result of invoking the right-hand function as the parameter for the left-hand function. Take a Example of adding one and multiplying 3 to given number val add : (Int) -> Int = {x -> x + } val mult : (Int) -> Int = { y -> y * }fun composeF(f: (B) -> C, : (A) ->B) { { x -> f(g(x)) } } val addOneThenMul3 = composeF(::mul3, ::add1) print(addOneThenMul3( )) 1 3 g return 2 // output 9 Take another Example , you will get the input as String of two digit separated by comma, you have to divide first digit by second digit . For Input= "126,3" , output should be output= 126/3 = 4 To solve this issue, we are going to breakdown problem in three function — Splitting — Parsing — Division We usually do this using composition as below splitString : (String) -> Pair = { s -> s.split( ).first() to s.split( ).last() } parseToDouble : (Pair ) -> Pair = {d -> d.first.toDouble() to d.second.toDouble()} division : (Pair ) -> = {d -> d.first/d.second}f un composeF(f: (B) -> C, g: (A) ->B) { { x -> f(g(x)) } } result = composeF(composeF(division,parseToDouble),splitString) print(result( )) val "," "," val Double Double val Double Double Double return val "126,3" // 42 Above use case for composition is not perfect , the reason because things can go wrong, like split function may return exception because these is no comma in between two digits, parse function may fail may be there is no number and eventually the result can fail For any exceptions, the program can be partial , then what we can do One way to do this is we compose these functions in a way to return “Embellished” results, That mean we can wrap the result in class ( ) and that is where the term comes Functor Monad Monads Monads are the mechanism which makes automatic composition of special kids of functions In another word, is minimal amount of structure needed to overload functional composition in a way to perform extra computation on the intermediate value Monad Understand Monad with above use case of split, parse divide To solve above above composition problem , we have to wrap the result in context of each function, so lets do it To wrap value we need Functor { None : Result () ( value: T) : Result () } sealed class Result out T object Nothing data class Some out T val And modify functions to return wrap result split : (String) -> Result > = { s -> listString = s.split( ) Some(listString.first() to listString.last()) } parse : (Pair ) -> Result > = {pair -> Some(pair.first.toDouble() to pair.second.toDouble()) } divide : (Pair ) -> Result = {pair -> Some(pair.first.div(pair.second)) } val val "," val Double Double val Double Double Double Here we have modified functions to returns a wrapped value, We have to apply split function to parse function and then to divide function. Since the return type of each function is wrapped value and input parameter of each function is accepting pure values, we can't easily pass these function returning wrapped value to other functions .Here is monad come in picture, Monads apply a function that returns a wrapped value to a wrapped value using flatMap function So flatMap function looks like { None : Result () ( value: T) : Result () -> Result ) : Result = ( ) { None -> Some -> f(value) } } sealed class Result out T object Nothing data class Some out T val inline fun flatMap (f: ( ) T when this is this is Here we have written flatMap function on Functor Now you can apply function returning wrapped value to wrapped value output = split( ).flatMap(parse).flatMap(divide) println(output) val "126,3" // will print 42 So ins simple word, is Functor that has flatMap Modad Here is my link for this example github Thats it. I hope this article will help you understand idea of Functor and Monads and who they are comes together . This is my first article here and I hope you have enjoyed it ;) I’ll be glad for any feedback!