Functional Programming with Arrow in Kotlin · Functional Programming with Arrow in Kotlin @ragunathjawahar • Obvious (previously, Uncommon Bangalore)

Functional Programming with Arrow in Kotlin@ragunathjawahar • Obvious (previously, Uncommon Bangalore)

fun findFirst(array: Array<Char>, key: Char): Int { for (i in array.indices) { if (array[i] == key) return i } return -1 }












fun findFirst(array: Array<Char>, key: Char): Index { for (i in array.indices) { if (array[i] == key) return i } return -1 }

typealias Index = Int







// findFirst(chars, ‘e’) != -1



// findFirst(chars, ‘e’) != -1



fun findFirst(array: Array<Char>, key: Char): Index? { for (i in array.indices) { if (array[i] == key) return i } return null }


fun findFirst(array: Array<Char>, key: Char): Option<Index> { for (i in array.indices) { if (array[i] == key) return Some(i) } return None }




// absence

// presence







fun <A> findFirst(array: Array<A>, key: A): Option<Index> { for (i in array.indices) { if (array[i] == key) return Some(i) } return None }






fun <A> findFirst(array: Array<A>, p: (A) -> Boolean): Option<Index> { for (i in array.indices) { if (p(array[i])) return Some(i) } return None }




// findFirst(people, { it.firstName == “Ajay” })



// findFirst(people) { it.firstName == “Ajay” }







// findFirst(people) { it.firstName == “Ajay” }

fun <A> Array<A>.findFirst(p:,(A) -> Boolean): Option<Index> { for (i in this.indices) { if (p(this[i])) return Some(i) } return None }


// people.findFirst { it.firstName == “Ajay” }





fun <A> findFirst(array: Array<A>, p:,(A) -> Boolean): Option<Index> { tailrec fun go(array: Array<A>, index: Index): Option<Index> { return when { index == array.size -> None p(array[index]) -> Some(index) else -> go(array, index + 1) } }

return go(array, 0) }

But!



But!



But!



But!



But!



But!



But!



But!



But!



But!



But!



But!



But!



But!



But!

Core Ideas

Core Ideas

• Purity

• Referential Transparency

• Immutability

• Lazy Evaluation

Notations

fun add(a: Int, b: Int): Int = a + b

val addRef: (Int, Int) -> Int = ::add

val subtractLambda = { a: Int, b: Int -> a - b }





































// (a: Int, b: Int) -> Int























addRef.invoke(4, 5)

addRef(4, 5)

Arrow Syntaxcompile "io.arrow-kt:arrow-syntax:$arrow_version"

val bold: (String) -> String = { "$it" }

val italic: (String) -> String = { "$it" }

val boldItalic = bold compose italic

val italicBold = bold forwardCompose italic

Composition





Composition





Composition

// bold(“Hello”)





Composition

// Hello





Composition





Composition

// italic(“Hello”)





Composition

// Hello





Composition





Composition

// boldItalic(“Hello”)





Composition

// Hello





Composition





Composition

// italicBold(“Hello”)





Composition

// Hello





Composition

fun multiply(a: Int, b: Int): Int = a * b

val x2: (Int) -> Int = ::multiply.partially1(2)


Partial Application




Partial Application




Partial Application




Partial Application




Partial Application




Partial Application




Partial Application




Partial Application




Partial Application

// x2(10)




Partial Application

// 20




Partial Application




Partial Application




Partial Application




Partial Application




Partial Application




Partial Application




Partial Application

// x5(10)




Partial Application

// 50




Partial Application

Reverse

fun findFirst( animals: List<Animal>, predicate: (Animal) -> Boolean ): Option<Animal> { /* … */ }

val findCat: (List<Animal>) -> Option<Animal> = ::findFirst.reverse().partially1 { it is Cat }

val findDog: (List<Animal>) -> Option<Animal> = ::findFirst.reverse().partially1 { it is Dog }

Reverse




Reverse




Reverse




Reverse




Reverse




Reverse




Reverse




Reverse




Reverse




Reverse




Reverse




Reverse




Reverse




Reverse




Reverse




// findCat(animals)

Reverse




Reverse




Reverse




Reverse




Reverse




Reverse




Reverse



val findDog: (List<Animal>) -> Option<Animal> = ::findFirst.reverse().partially1 { it is Dog } // findDog(animals)

Reverse




Logical Complement

val onlyCats: (Animal) -> Boolean = { it is Cat } val allCats = filter(animals, onlyCats)

val noCats = onlyCats.complement() val allExceptCats = filter(animals, noCats)

Logical Complement



Logical Complement



Logical Complement



Logical Complement



Logical Complement



Logical Complement



Logical Complement



Logical Complement



Currying (1/2)

fun volume(width: Int, height: Int, length: Int): Int = width * height * length

volume(10, 10, 1)

val curriedVolume: (width: Int) -> (height: Int) -> (length: Int) -> Int = ::volume.curried()

curriedVolume(10)(10)(1)

Currying (1/2)


volume(10, 10, 1)



Currying (1/2)


volume(10, 10, 1)



Currying (1/2)


volume(10, 10, 1)



Currying (1/2)


volume(10, 10, 1)



Currying (1/2)


volume(10, 10, 1)



Currying (1/2)


volume(10, 10, 1)



Currying (1/2)


volume(10, 10, 1)



// 100

Currying (1/2)


volume(10, 10, 1)



Currying (1/2)


volume(10, 10, 1)



Currying (1/2)


volume(10, 10, 1)



Currying (1/2)


volume(10, 10, 1)



Currying (1/2)


volume(10, 10, 1)



Currying (1/2)


volume(10, 10, 1)



Currying (1/2)


volume(10, 10, 1)



Currying (1/2)


volume(10, 10, 1)



Currying (1/2)


volume(10, 10, 1)


curriedVolume(10)(10)(1) // 100

Currying (1/2)


volume(10, 10, 1)



Currying (2/2)


val area = ::volume .reverse().curried()(1) .uncurried().reverse()

area(10, 10)

Currying (2/2)



area(10, 10)

Currying (2/2)



area(10, 10)

Currying (2/2)



area(10, 10)

// (width, height, length)

Currying (2/2)



area(10, 10)

// (length, height, width)

Currying (2/2)



area(10, 10)

// (length) -> (height) -> (width)

Currying (2/2)



area(10, 10)

// (height) -> (width)

Currying (2/2)



area(10, 10)

// (height, width)

Currying (2/2)



area(10, 10)

// (width, height)

Currying (2/2)



area(10, 10)

Currying (2/2)



area(10, 10)

Currying (2/2)



area(10, 10) // 100

Currying (2/2)



area(10, 10)

More…

• memoize() // FunctionN

• firstOption() // Array, Sequence, and Iterable

• flatten() - tail() - prependTo(List<T>) // List

• plus(C) // TupleN

• paired() - tripled() // FunctionN

• pipe() // FunctionN

Data Typescompile “io.arrow-kt:arrow-core-data:$arrow_version”

Data Types

• Option

• Either

• Try

• Validated

• Eval

Option

sealed class Option<out A> { object None : Option<Nothing>() data class Some<out T>(val t: T) : Option<T>() }

Option is an Algebraic Data Type that is used to model the absence of value. In Kotlin they are encoded with sealed class hierarchies.

Option



Option



Option



Option



Option (Construction)

val intOption: Option<Int> = Option(1)

val intOption: Option<Int> = None

val intOption: Option<Int> = Option.fromNullable(a) // a: Int?

val intOption: Option<Int> = 1.some()

val intOption: Option<Int> = none()





































Option (Extraction)


val nullableResult: Int? = intOption.orNull()

val result: Int = intOption.getOrElse { 0 }

Option (Extraction)




Option (Extraction)




Option (Extraction)




Option (Extraction)




Option (Extraction - when)


when (intOption) { is None -> 0 is Some -> intOption.t } // Some(1)



















Option (Extraction - fold)


intOption.fold( { 0 }, { it + 1 } ) // Some(2)



















Option (map)

val intOption: Option<Int> = Option(1) intOption.map { it * 2 } // Some(2)

val intOption: Option<Int> = None intOption.map { it * 2 } // None

Option (map)



Option (map)



Option (map)



Option (map)



Option (map)



Option (map)



Option (map)



Option (flatMap)

val oneOption: Option<Int> = Option(1) val twoOption: Option<Int> = Option(2)

oneOption.flatMap { one -> twoOption.map { two -> one + two } } // Some(3)

Option (flatMap)



Option (flatMap)



Option (flatMap)



Option (flatMap)



Option (flatMap)



Option (flatMap)



Option (flatMap)

val oneOption: Option<Int> = Option(1) val twoOption: Option<Int> = None

oneOption.flatMap { one -> twoOption.map { two -> one + two } } // None

Option (flatMap)



Option (flatMap)



Option (Monad Binding)


Option.monad().binding { val one = oneOption.bind() val two = twoOption.bind() one + two }.fix() // Some(3)



























Option.monad().binding { val one = oneOption.bind() val two = twoOption.bind() one + two }.fix() // None







Option (Applicative Builder)

val maybeEspresso: Option<Espresso> = Option(Espresso(0.3)) val maybeMilkOption: Option<Milk> = Option(Milk(0.3)) val foamOption: Option<Foam> = Option(Foam(0.3))

Option.applicative() .map(maybeEspresso, maybeMilk, maybeFoam) { (espresso, milk, foam) -> Cappuccino(espresso, milk, foam) }.fix()

// Some(Cappuccino(espresso=Espresso(%=0.3), milk=Milk(%=0.3), // foam=Foam(%=0.3)))










































val maybeEspresso: Option<Espresso> = Option(Espresso(0.3)) val maybeMilkOption: Option<Milk> = Option(Milk(0.3)) val foamOption: Option<Foam> = None


// None




// None




// None

Either

sealed class Either<out A, out B> { data class Left<out A, out B>(val a: A) : Either<A, B>() data class Right<out A, out B>(val b: B) : Either<A, B>() }

Either is an Algebraic Data Type that is used to model a return type that may return one of two possible values.

Either



Either



Either



Either



Either (Construction)

sealed class DomainError { /* ... */ }

val result: Either<DomainError, Int> = Right(1)

val result: Either<DomainError, Int> = Left(UnknownUser)

val result: Either<DomainError, Int> = 1.right()

val result: Either<DomainError, Int> = UnknownUser.left()





































Either (Extraction - when)



when (result) { is Left -> 0 is Right -> result.b } // Right(1)
















when (result) { is Left -> 0 is Right -> result.b } // Right(1) F









Either (Extraction - fold)



result.fold( { 0 }, { it + 1 } ) // Right(2)

























Either (map)


val result: Either<DomainError, Int> = Right(1) result.map { it * 2 } // Right(2)

val result: Either<DomainError, Int> = Left(UnknownUser) result.map { it * 2 } // Left(UnknownUser)

Either (map)




Either (map)




Either (map)




Either (map)




Either (map)




Either (map)




Either (map)




Either (map)




Either (flatMap)


val result1: Either<DomainError, Int> = Right(1) val result2: Either<DomainError, Int> = Right(2)

result1.flatMap { one -> result2.map { two -> one + two } } // Right(3)

Either (flatMap)




Either (flatMap)




Either (flatMap)




Either (flatMap)




Either (flatMap)




Either (flatMap)




Either (flatMap)


val result1: Either<DomainError, Int> = Right(1) val result2: Either<DomainError, Int> = Left(UnknownUser)

result1.flatMap { one -> result2.map { two -> one + two } } // Left(UnknownUser)

Either (flatMap)




Either (flatMap)




Either (Monad Binding)



Either.monad<DomainError>.binding { val one = result1.bind() val two = result2.bind() one + two }.fix() // Right(3)




































Either.monad<DomainError>.binding { val one = result1.bind() val two = result2.bind() one + two }.fix() // Left(UnknownUser)









Either (Applicative Builder)sealed class CoffeeMakerError { /* ... */ }

val espressoResult: Either<CoffeeMakerError, Espresso> = Right(Espresso(0.4)) val waterResult: Either<CoffeeMakerError, Water> = Right(Water(0.6))

Either.applicative<CoffeeMakerError>() .map(espressoResult, waterResult) { (espresso, water) -> Americano(espresso, water) }.fix()

// Right(Americano(espresso=Espresso(%=0.4), water=Water(%=0.6)))










































val espressoResult: Either<CoffeeMakerError, Espresso> = Right(Espresso(0.4)) val waterResult: Either<CoffeeMakerError, Water> = Left(RefillWater)


// Left(RefillWater)









More…

• Try // Success - Failure

• Validated // Valid - Invalid

• Eval // Now - Always - Later - Defer

• TupleN // Tuple2 - Tuple22

Typeclassescompile “io.arrow-kt:arrow-typeclasses:$arrow_version” kapt “io.arrow-kt:arrow-meta:$arrow_version”

Typeclasses

• Polymorphism in functional programming.

• Separates data from behaviour.

• Maybe governed by algebraic / category theoretic laws.

• Implemented as interfaces in Kotlin.

• One Typeclass instance per type.

Typeclasses

• Show

• Eq

• Semigroup

• Functor

• Monad

• …

Show

interface Show<in A> { fun A.show(): String }

The Show typeclass abstracts the ability to obtain a String representation of any object.

Show



Show



Show



Eq

interface Eq<in F> { fun F.eqv(b: F): Boolean fun F.neqv(b: F): Boolean = !eqv(b) }

The Eq typeclass abstracts the ability to compare two instances of any object. It can be compared to the typeclass equivalent of Java’s Object#equals.

Eq



Eq



Eq



Eq



Semigroup

interface Semigroup<A> { fun A.combine(b: A): A operator fun A.plus(b: A): A = this.combine(b) }

The Semigroup for some given type A has a single operation combine which takes two values of type A, and returns a value of type A. This operation must be associative.

Semigroup



Semigroup



Semigroup



Semigroup



Creating Instancesdata class Person(val firstName: String, val lastName: String) { companion object }

@extension interface PersonShow : Show<Person> { override fun Person.show(): String = "$firstName $lastName" }

val john = Person("John", "Doe") Person.show().run { john.show() } // John Doe


































More…

• Hash

• Order

• Traverse

• Applicative

• And many more…

Opticscompile “io.arrow-kt:arrow-optics:$arrow_version” kapt “io.arrow-kt:arrow-meta:$arrow_version”

Lens

@optics data class UserProfile( val name: Name, /* Not shown for brevity */ val contact: Contact ) { companion object }

@optics data class Contact( val email: String, val phone: String ) { companion object }

Lens



Lens



Lens



Lens



Lens



Lens



Lens



Lens



Lens



Lens



Lens



Lens



Lens



Lens



Lens



Lens



Lens



Lens



Without Lens

val profile = UserProfile( Name("John", "Doe"), Contact("[email protected]", "6483920164") )

val updatedProfile = profile.copy( contact = profile.contact.copy( email = "[email protected]" ) )

Without Lens



Without Lens



Without Lens



Without Lens



Without Lens



With Lens

val profile = UserProfile( /* … */ )

val emailLens: Lens<UserProfile, String> = UserProfile.contact.email

val workEmail = "[email protected]" val updatedProfile = emailLens.modify(profile) { workEmail }

val email = emailLens.get(profile)

With Lens





With Lens





With Lens





With Lens





With Lens





With Lens





With Lens





With Lens





With Lens





With Lens





With Lens





With Lens





With Lens





With Lens





With Lens




val email = emailLens.get(profile) // “[email protected]”

With Lens





Optional

@optics data class ShoppingCart( val id: String, val cartItems: ListK<CartItem> ) { companion object }

@optics data class CartItem( val product: Product, /* Not shown for brevity */ val quantity: Int ) { companion object }

Optional



Optional



Optional



Optional



Optional



Optional



Optional (Set)

val shoppingCart = ShoppingCart("CRT19321", cartItems)

val quantityOptional: Optional<ShoppingCart, Int> = ShoppingCart .cartItems .index(ListK.index(), productIndex) .quantity

val updatedCart = quantityOptional.modify(shoppingCart) { it + 1 }

Optional (Set)




Optional (Set)




Optional (Set)




Optional (Set)




Optional (Set)




Optional (Set)




Optional (Set)




Optional (Set)




Optional (Set)




Optional (Set)




Optional (Set)




Optional (Set)




Optional (Get)

val cartItemOption = ShoppingCart .cartItems .index(ListK.index(), productIndex) .getOption(shoppingCart)

val sameCartItemOption = ListK.index<CartItem>().run { ShoppingCart.cartItems[productIndex].getOption(shoppingCart) }

Optional (Get)



Optional (Get)



Optional (Get)



Optional (Get)



Optional (Get)



Optional (Get)



Optional (Get)



Optional (Get)



Optional (Get)



Optional (Get)



Optional (Get)



Optional (Get)



Optional (Get)



Optional (Get)



Optional (Get)



More…

• Iso

• Prism

• Getter / Setter

• Fold

• Each

• And others …

That’s not it…

• Arrow Fx

• Effects

• Arrow Query Language

• Generic

• Integrations

• Free

• Recursion Schemes

Resources

• https://arrow-kt.io/docs/

• http://learnyouahaskell.com/

• https://caster.io/courses/functional-programming-in-kotlin-with-arrow

• https://github.com/hemanth/functional-programming-jargon#function

• https://wiki.haskell.org/Typeclassopedia

• http://nealford.com/functionalthinking.html

• https://prod.packtpub.com/in/application-development/functional-kotlin

https://arrow-kt.io/docs/

http://learnyouahaskell.com/

https://caster.io/courses/functional-programming-in-kotlin-with-arrow

https://github.com/hemanth/functional-programming-jargon#function

https://wiki.haskell.org/Typeclassopedia

http://nealford.com/functionalthinking.html

https://prod.packtpub.com/in/application-development/functional-kotlin

end;@ragunathjawaharTwitter / Medium / GitHub

Documents

Functional Programming with Arrow in Kotlin · Functional Programming with Arrow in Kotlin @ragunathjawahar • Obvious (previously, Uncommon Bangalore)