What is functor

• 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

class Functor<T> {    
 object None : Functor<Nothing>()     
 data class Some<out T>(val value: T) : Functor<T>()   
}

sealed class Functor<out A> {

    object None : Functor<Nothing>()

    data class Some<out A>(val value: A) : Functor<A>()

    inline infix fun <B> map(f: (A) -> B): Functor<B> = when (this) {
        is None -> this
        is Some -> Some(f(value))
    }
    companion object {
        fun <A> some(value: A): Functor<A> = Some(value)
    }


}

fun inc(value: Int): Int = value + 1
val increment = Functor(3).map {::inc} //OR
val increment = Functor(3).map {it + 1}

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
• Chaining: Because Functor.map returns another Functor with the result of the function passed to map I can chain multiple map functions together

Applicative

sealed class Functor<out A> {

    object None : Functor<Nothing>()

    data class Some<out A>(val value: A) : Functor<A>()

    inline infix fun <B> map(f: (A) -> B): Functor<B> = when (this) {
        is None -> this
        is Some -> Some(f(value))
    }
    companion object {
        fun <A> some(value: A): Functor<A> = Some(value)
    }

    infix fun <A, B> Functor<(A) -> B>.apply(f: Functor<A>): Functor<B> =
        when (this) {
            is None -> None
            is Some -> f.map(this.value)
        }
    
}

Examples 1 : Apply a function that takes two arguments to two wrapped values

fun curriedAddition(a: Int) = { b: Int ->
             a + b
         }
 Some(3) map ::curriedAddition map Some(2) // => COMPILER ERROR// Use applicative
 Some(3) map ::curriedAddition apply Some(2)

Apply triple product function:

fun tripleProduct(a: Int, b: Int, c: Int) = a * b * c

fun <A, B, C, D> curry(f: (A, B, C) -> D): (A) -> (B) -> (C) -> D = { a -> { b -> { c -> f(a, b, c) } } }
 
Some(3) map curry(::tripleProduct) apply Some(5) apply Some(4)
 // => Some(60)

Monads

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 + 1 }
val mult : (Int) -> Int = { y -> y * 3}fun <A,B,C>composeF(f: (B) -> C, g: (A) ->B) {
   return { x -> f(g(x)) }
}
val addOneThenMul3 = composeF(::mul3, ::add1)
 
print(addOneThenMul3(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

1. To solve this issue, we are going to breakdown problem in three function — Splitting — Parsing — Division
2. We usually do this using composition as below

val splitString : (String) -> Pair<Stirng,String> = {
        s ->  s.split(",").first() to s.split(",").last()
}

val parseToDouble : (Pair<String,String>) -> Pair<Double,Double> = {d -> d.first.toDouble() to  d.second.toDouble()}

val division : (Pair<Double,Double>) -> Double = {d -> d.first/d.second}f

un <A,B,C>composeF(f: (B) -> C, g: (A) ->B) {
   return { x -> f(g(x)) }
 }
 
val result = composeF(composeF(division,parseToDouble),splitString)
print(result("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 (Functor) and that is where the term Monad comes

Monads

Monads are the mechanism which makes automatic composition of special kids of functions
In another word, Monad is minimal amount of structure needed to overload functional composition in a way to perform extra computation on the intermediate value
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

sealed class Result<out T> {
     object None : Result<Nothing>()
     data class Some<out T>(val value: T) : Result<T>()
 }

And modify functions to return wrap result

val split : (String) -> Result<Pair<String,String>> = { s ->
    val listString = s.split(",")
    Some(listString.first() to listString.last())
}
val parse : (Pair<String,String>) -> Result<Pair<Double,Double>> = {pair -> Some(pair.first.toDouble() to pair.second.toDouble()) }

val divide : (Pair<Double,Double>) -> Result<Double> = {pair -> Some(pair.first.div(pair.second)) }

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

sealed class Result<out T> {
   object None : Result<Nothing>()
   data class Some<out T>(val value: T) : Result<T>()
   inline fun <B> flatMap(f: (T) -> Result<B>) : Result<B>  =
   when (this) {
         is None -> this
         is Some -> f(value)
    }           
}

Here we have written flatMap function on Functor
Now you can apply function returning wrapped value to wrapped value

val output = split("126,3").flatMap(parse).flatMap(divide)
println(output) // will print 42

So ins simple word, Modad is Functor that has flatMap
Here is my github link for this example
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!