Pro Yearly is on sale from $80 to $50! »

Introduction to KΛTEGORY

Introduction to KΛTEGORY

http://kategory.io/

KΛTEGORY is a library that started as a port of Typelevel Scala cats for the Kotlin Programming Language and is now evolving to bring the best of typed FP to Kotlin. This talk covers some of the main data types and abstractions that make typed Functional Programming in Kotlin Possible. Kategory features techniques such as monadic comprehensions, laws, applicative builders, emulated higher kinds, free monads, and global typeclass instances for the increasingly popular Kotlin programming language. We discuss some pragmatic applications of KΛTEGORY and some of the different styles you can adopt when working with typed FP in Kotlin alogn with a proposal to introduce type classes and higher kinds as part of the language.

https://github.com/47deg/kategory-intro

Ad2476bf0540dfaa0fc30cb62c8e07da?s=128

Raúl Raja Martínez

October 27, 2017
Tweet

Transcript

  1. KΛTEGORY Functional Data Types & Abstractions for Kotlin 1

  2. About Us Raul Raja CTO @47deg Paco Mistake-driven learning Simon

    Vergauwen Optometrist @raulraja @pacoworks @vergauwen_simon 2
  3. What started as... Learning Exercise to learn FP over Slack

    3
  4. ...Ended in Solution for Typed FP in Kotlin 4

  5. What is KΛTEGORY? A library for typed FP in Kotlin

    with the traditional type classes and data types 5
  6. Data types Many data types to cover general use cases.

    Error Handling Option , Try , Validated , Either , Ior Collections ListKW , SequenceKW , MapKW , SetKW RWS Reader , Writer , State Transformers ReaderT , WriterT , OptionT , StateT , EitherT Evaluation Eval , Trampoline , Free , FunctionN Effects IO , Free , ObservableKW Others Coproduct , Coreader , Const , ... 6
  7. A few syntax examples import kategory.Option Option(1).map { it +

    1 } //Option(2) 7
  8. A few syntax examples import kategory.Try Try { throw RuntimeException("BOOM!")

    }.map { it + 1 } //Failure(RuntimeException("BOOM!")) 8
  9. A few syntax examples import kategory.* import kategory.Either.* val x

    = Right(1) val y = 1.right() x == y //true 9
  10. Applicative Builder import kategory.* data class Profile(val id: Long, val

    name: String, val phone: Int) fun profile(val maybeId: Option<Long>, val maybeName: Option<String>, val maybePhone: Option<Int>): Option<Profile> = Option.applicative().map(id, name, phone, { (a, b, c) -> Profile(a, b, c) }) profile(1L.some(), "William Alvin Howard".some(), 555555555.some()) //Some(Profile(1L, "William Alvin Howard", 555555555) 10
  11. Comprehensions - Vanilla Generalized to all monads fun profile(val maybeId:

    Option<Long>, val maybeName: Option<String>, val maybePhone: Option<Int>): Option<Profile> = Option.monad().binding { // <-- `coroutine starts` val id = maybeId.bind() // <-- `suspended` val name = maybeName.bind() // <-- `suspended` val phone = maybePhone.bind() // <-- `suspended` yields(Profile(id, name, phone)) } // <-- `coroutine ends` profile(2L.some(), "Haskell Brooks Curry".some(), 555555555.some()) 11
  12. Comprehensions - Exception Aware Automatically captures exceptions for instances of

    MonadError<F, Throwable> Try.monadError().bindingE { val name = profileService().bind() val phone = phoneService().bind() throw RuntimeException("BOOM") // <-- `raises errors to MonadError<F, Throwable>` val addresses = addressService().bind() yields(Profile(name, phone, addresses)) } //Failure(RuntimeException("BOOM")) 12
  13. Comprehensions - Stack-Safe Stack-Safe comprehensions for Stack-Unsafe data types fun

    <F> stackSafeTestProgram(M: Monad<F>, n: Int = 0, stopAt: Int = 1000000): Free<F, Int> = M.bindingStackSafe { val v = pure(n + 1).bind() // <-- auto binds on `Free<F, Int>` val r = if (v < stopAt) stackSafeTestProgram(M, v, stopAt).bind() else pure(v).bind() yields(r) } val M = Id.monad() stackSafeTestProgram(M).run(M).ev() //Id(1000000) 13
  14. Monad Comprehensions - Cancellable Supports cancelling tasks initiated inside the

    coroutine val (binding: IO<List<User>>, unsafeCancel: Disposable) = ioMonadError.bindingECancellable { val userProfile = bindAsync(ioAsync) { getUserProfile("123") } val friendProfiles = userProfile.friends().map { friend -> bindAsync(ioAsync) { getProfile(friend.id) } } yields(listOf(userProfile) + friendProfiles) } // <- returns `Tuple2<IO<List<User>>, Disposable>` unsafeCancel() //the disposable instance can cancel all operations inside the coroutine 14
  15. Monad Comprehensions - Context Aware Allows switching contexts in which

    bind/flatMap takes place ioMonad.binding { val user = bindAsync(ioAsync) { getUserProfile("123") } //<-- binds on IO's pool bindIn(DatabaseContext) { storeUser(user) } //<-- binds on DB's pool bindIn(UIContext) { toastMessage("User cached!") } //<-- binds on UI thread yields(user) } 15
  16. Monad Comprehensions - 3rd party integrations Allows seamless integration with

    existing libraries like RxJava observableMonad.binding { val ticks = runAsync(observableAsync) { videoPlayer.getCurrentMilliseconds() }.subscribeOn(mainThread()) val initialTick = ticks.bind() val timer = Observable.interval(100, MilliSeconds).k().bind() val currentTick = ticks.bind() yields(currentTick - initialTick) } 16
  17. Transforming immutable data KΛTEGORY includes an optics library that make

    working with immutable data a breeze data class Street(val number: Int, val name: String) data class Address(val city: String, val street: Street) data class Company(val name: String, val address: Address) data class Employee(val name: String, val company: Company) val employee = Employee("John Doe", Company("Kategory", Address("Functional city", Street(23, "lambda street")))) employee //Employee(name=John Doe, company=Company(name=Kategory, address=Address(city=Functional city, street=Street(number=23, name 17
  18. Transforming immutable data while kotlin provides a synthetic copy dealing

    with nested data can be tedious employee.copy( company = employee.company.copy( address = employee.company.address.copy( street = employee.company.address.street.copy( name = employee.company.address.street.name.capitalize() ) ) ) ) //Employee(name=John Doe, company=Company(name=Kategory, address=Address(city=Functional city, street=Street(number=23, name 18
  19. Optics without boilerplate You may define composable Lenses to work

    with immutable data transformations import kategory.* import kategory.optics.* val employeeCompany: Lens<Employee, Company> = Lens( get = { it.company }, set = { company -> { employee -> employee.copy(company = company) } } ) val companyAddress: Lens<Company, Address> = Lens( get = { it.address }, set = { address -> { company -> company.copy(address = address) } } ) ... val employeeStreetName: Lens<Employee, String> = employeeCompany compose companyAddress compose addressStrees compose streetName employeeStreetName.modify(employee, String::capitalize) 19
  20. Optics without boilerplate Or just let KΛTEGORY @lenses do the

    dirty work + @lenses data class Employee(val name: String, val company: Company) - val employeeCompany: Lens<Employee, Company> = Lens( - get = { it.company }, - set = { company -> { employee -> employee.copy(company = company) } } - ) - - val companyAddress: Lens<Company, Address> = Lens( - get = { it.address }, - set = { address -> { company -> company.copy(address = address) } } - ) - ... val employeeStreetName: Lens<Employee, String> = employeeCompany compose companyAddress compose addressStrees compose streetName employeeStreetName.modify(employee, String::capitalize) 20
  21. Optics without boilerplate You can also define custom Prism for

    your sum types sealed class NetworkResult { data class Success(val content: String): NetworkResult() object Failure: NetworkResult() } val networkSuccessPrism: Prism<NetworkResult, NetworkResult.Success> = Prism( getOrModify = { networkResult -> when(networkResult) { is NetworkResult.Success -> networkResult.right() else -> networkResult.left() } }, reverseGet = { networkResult -> networkResult } //::identity ) val networkResult = NetworkResult.Success("content") networkSuccessPrism.modify(networkResult) { success -> success.copy(content = "different content") } //Success(content=different content) 21
  22. Optics without boilerplate Or let @prisms do that for you

    + @prisms sealed class NetworkResult { + data class Success(val content: String) : NetworkResult() + object Failure : NetworkResult() + } - sealed class NetworkResult { - data class Success(val content: String): NetworkResult() - object Failure: NetworkResult() - } - val networkSuccessPrism: Prism<NetworkResult, NetworkResult.Success> = Prism( - getOrModify = { networkResult -> - when(networkResult) { - is NetworkResult.Success -> networkResult.right() - else -> networkResult.left() - } - }, - reverseGet = { networkResult -> networkResult } //::identity - ) val networkResult = NetworkResult.Success("content") networkSuccessPrism.modify(networkResult) { success -> success.copy(content = "different content") } 22
  23. @free & @tagless is being ported to Kotlin by the

    team . Freestyle @47deg + @free interface GesturesDSL<F> : GesturesDSLKind<A> { + fun click(view: UiObject): FreeS<F, Boolean> + fun pinchIn(view: UiObject, percent: Int, val steps: Int): FreeS<F, Boolean> + fun pinchOut(view: UiObject, percent: Int, val steps: Int): FreeS<F, Boolean> + } - typealias ActionDSL<A> = Free<GesturesDSLHK, A> - @higherkind sealed class GesturesDSL<A> : GesturesDSLKind<A> { - object PressHome : GesturesDSL<Boolean>() - data class Click(val view: UiObject) : GesturesDSL<Boolean>() - data class PinchIn(val view: UiObject, val percent: Int, val steps: Int) : GesturesDSL<Boolean>() - data class PinchOut(val view: UiObject, val percent: Int, val steps: Int) : GesturesDSL<Boolean>() - companion object : FreeMonadInstance<GesturesDSLHK> - } - fun click(view: UiObject): ActionDSL<Boolean> = - Free.liftF(GesturesDSL.Click(ui)) - fun pinchIn(view: UiObject, percent: Int, val steps: Int): ActionDSL<Boolean> = - Free.liftF(GesturesDSL.PinchIn(percent, steps)) - fun pinchOut(view: UiObject, percent: Int, val steps: Int): ActionDSL<Boolean> = - Free.liftF(GesturesDSL.PinchOut(ui, percent, steps)) 23
  24. KΛTEGORY is becoming modular Pick and choose what you'd like

    to use. Module Contents typeclasses Semigroup , Monoid , Functor , Applicative , Monad ... data Option , Try , Either , Validated ... effects IO effects-rx2 ObservableKW , FlowableKW mtl MonadReader , MonadState , MonadFilter ,... free Free , FreeApplicative , Trampoline , ... freestyle @free , @tagless recursion-schemes optics Prism , Iso , Lens , ... collections meta @higherkind , @deriving , @implicit , @instance , @lenses , @prisms , @isos 24
  25. Kotlin limitations for Typed FP 25

  26. Kotlin limitations for Typed FP Emulated Higher Kinds through Lightweight

    higher-kinded Polymorphism interface HK<out F, out A> class OptionHK private constructor() typealias OptionKind<A> = kategory.HK<OptionHK, A> inline fun <A> OptionKind<A>.ev(): Option<A> = this as Option<A> sealed class Option<out A> : OptionKind<A> 26
  27. Kotlin limitations for Typed FP Fear not, @higherkind 's got

    your back! + @higherkind sealed class Either<A, B> : EitherKind<A, B> - - class EitherHK private constructor() - - typealias EitherKindPartial<A> = kindedj.Hk<EitherHK, A> - typealias EitherKind<A, B> = kindedj.Hk<EitherKindPartial<A>, B> - - inline fun <A, B> EitherKind<A, B>.ev(): Either<A, B> = this as Either<A, B> 27
  28. Kotlin limitations for Typed FP No notion of implicits or

    Type class instance evidences verified at compile time fun <F, A> A.some( AA: Applicative<OptionHK> /*<-- User is forced to provide instances explicitly */): Option<A> = AA.pure(this).ev() 1.some(Option.applicative()) //Option(1) 28
  29. Kotlin limitations for Typed FP (for now) an implicit lookup

    system based on a global registry is provided fun <A> A.some( AA: Applicative<OptionHK> = applicative() /*<-- Instances are discovered implicitly */): Option<A> = AA.pure(this).ev() 1.some() //Option(1) 29
  30. KΛTEGORY ad-hoc polymorphism With emulated Higher Kinds and Type classes

    we can now write polymorphic code inline fun <reified F, reified E, A> raiseError(e: E, ME: MonadError<F, E> = monadError()): HK<F, A> = ME.raiseError(e) raiseError<EitherKindPartial<String>, String, Int>("Not Found").ev() // <-- Not ideal //Left("Not Found") 30
  31. Type Classes This is how you define Type Classes in

    KΛTEGORY (for now) interface Functor<F> : Typeclass { fun <A, B> map(fa: HK<F, A>, f: (A) -> B): HK<F, B> } 31
  32. Implementing type class instances is easy... 32

  33. @deriving KΛTEGORY can derive instances based on conventions in your

    data types @higherkind @deriving( Functor::class, Applicative::class, Monad::class, Foldable::class, Traverse::class, TraverseFilter::class, MonadFilter::class) sealed class Option<out A> : OptionKind<A> { ... } 33
  34. @instance KΛTEGORY can also derive implicit discovery for manual instances

    @instance(Either::class) interface EitherFunctorInstance<L> : Functor<EitherKindPartial<L>> { override fun <A, B> map(fa: EitherKind<L, A>, f: (A) -> B): Either<L, B> = fa.ev().map(f) } 34
  35. KEEP-87 But we are not stopping here, we want to

    get rid of some of these hacks! KEEP-87 is A KEEP to introduce Type Classes in Kotlin https:/ /github.com/Kotlin/KEEP/pull/87 35
  36. KEEP-87 If KEEP-87 makes it to the lang extension interface

    Functor<F<_>> { // <-- real Higher kinds positions fun <A, B> map(fa: F<A>, f: (A) -> B): F<B> } extension object OptionFunctor: Functor<Option> { // <-- real Higher kinds positions fun <A, B> map(fa: Option<A>, f: (A) -> B): Option<B> } fun <F<_>, A, B> transform( fa: F<A>, f: (A) -> B): F<B> given Functor<F> = map(fa, f) // <-- compile time verified transform(Option(1), { it + 1 })// <-- no need to cast from HK representation //Option(2) 36
  37. What if KEEP-87 does not make it to Kotlin? @implicit

    as global implicits through a annotation processor / compiler plugin. Discuss if a fork to the compiler with compatibility for KEEP-87 under a compiler flag makes sense. 37
  38. Credits KΛTEGORY is inspired in great libraries that have proven

    useful to the FP community: Cats Scalaz Freestyle Monocle Funktionale Paguro 38
  39. Team anstaendig arturogutierrez ffgiraldez Guardiola31337 javipacheco JMPergar JorgeCastilloPrz jrgonzalezg nomisRev

    npatarino pablisco pakoito pedrovgs pt2121 raulraja wiyarmir andyscott Atternatt calvellido dominv GlenKPeterson israelperezglez sanogueralorenzo Takhion victorg1991 tonilopezmr NigelHeylen ersin-ertan 39
  40. Join us! Github Slack Gitter We provide 1:1 mentoring for

    both users & new contributors! https:/ /github.com/kategory https:/ /kotlinlang.slack.com/messages/C5UPMM0A0 https:/ /gitter.im/kategory/Lobby 40
  41. Thanks! Thanks to everyone that makes KΛTEGORY possible 41