shapeless cats and kittens

Data-type generic function combination 

Kai(luo) Wang 
@iHeartRadio (we'r hiring)
github, twitter: @kailuowang

with real-world examples

A quick survey

A tiny application

  object HRService {
    val numOfEmployees: DepartmentId => Int = ...
    val employeeDepartment: EmployeeId => DepartmentId = ...
  }

  object FinanceService {
    val budget: DepartmentId => Double = ...
  }

  object DirectoryService {
    val extensionNum: DepartmentId => Int = ...
  }

  case class Department(
    numOfEmployees  : Int,
    budget          : Double,
    extensionNum    : Int
  )

  def department(id: DepartmentId) : Department = ???
  def extension(employee: EmployeeId) : Int = ???

Function composed

  
  def department(id: DepartmentId): Department = 
    Department(
      numOfEmployees = HRService.numOfEmployees(id),
      budget         = FinanceService.budget(id),
      extensionNum   = DirectoryService.extensionNum(id))


  def employExtension(employeeId: EmployeeId): Int = {
    val departmentId = HRService.employeeDepartment(employeeId)
    DirectoryService.extensionNum(departmentId)
  }

Point free

  val employExtension =  
    HRService.employeeDepartment andThen DirectoryService.extensionNum
  

Function combinator

cats.instance.function

   val department: = 
       (HRService.numOfEmployees |@|
        FinanceService.budget |@|
        DirectoryService.extensionNum) map Department.apply
    

Associative combination

  val department = 
    for {
      numOfEmployee <- HRService.numOfEmployees
      budget        <- FinanceService.budget
      extensionNum  <- DirectoryService.extensionNum
    } yield Department(numOfEmployee, budget, extensionNum) 

Monadic sequential combination

 What if the function is async?

  object DirectoryService {
    val extensionNum: DepartmentId => Future[Int] = ...
  }

Given

cats.data.Kleisli

case class Kleisli[F[_], A, B](run: A => F[B]) {
  def map[C](f: B => C)(implicit F: Functor[F]): Kleisli[F, A, C] =
    Kleisli(a => F.map(run(a))(f))
}

  object HRService {
    val numOfEmployees: DepartmentId => Future[Either[Reason, Int]] = ...
  }
 

Function with error handling

Real-world functions have heterogeneous arguments 

  def assignDorm(req: AssignDormRoomRequest): Future[Either[Reason, DormRoom]]
  
  case class AssignDormRoomRequest(
    name: String,
    sex: Sex, 
    mentor: Mentor)

  
  def registerClass(req: ClassRegRequest): Future[Either[Reason, ClassRegistration]]
   
  case class ClassRegRequest(
    studentId: StudentId, 
    classId: ClassId,
    semester: Semester)

Shapeless

a type class and dependent type based generic programming library

kittens

automatic type class derivation for Cats and generic utility functions

  Map("numberOfEmployee" -> 52, "budget" -> 10000, "extensionNumber" -> 30815)

  Map("name" -> "Mike", "sex" -> "male", "address" -> "123 ABC Ave")

Genericity by Structure

Generic value combinator

List(Future(1), Future(2), Future(3)).sequence

 //gives a Future(List(1, 2, 3))

With cats.Traverse

we can do

def sequence[G[_]: Applicative, A](fga: F[G[A]]): G[F[A]]

Before we go on to generic function composition, introducing

henkan

• automatic and type safe data structure transformation
• some building blocks for data-type generic FP 

Experiments with shapless cats and kittens

henkan.k

trait Definitions {
  
  type Result[_]

  implicit def resultMonad: Monad[Result]

  type K[A, B] = Kleisli[Result, A, B]
  
  ...
}

Building blocks for generic function combinator

Built on abstract types

caveat: SI-2712 partial fix required

henkan.k

trait DefinitionWithEitherT extends Definitions {

  type Reason //reason ADT for failure

  /**
   * Effect of the operations, e.g. [[Future]]
   */
  type Effect[_]

  type Result[T] = EitherT[Effect, Reason, T]

  implicit def effectMonad: Monad[Effect]

  implicit lazy val resultMonad: Monad[Result] = 
    EitherT.catsDataMonadErrorForEitherT[Effect, Reason]

}

An example of EitherT based Result definitions

Reasonable future

object ReasonableFuture extends henkan.k.DefinitionWithEitherT {
  sealed trait MyReason

  case class ExceptionOccurred(msg: Option[String],
                               ex: Option[Throwable]) extends MyReason
  case class UserError(msg: String) extends MyReason
  case class Unavailable(missingThingy: String) extends MyReason

  type Reason = MyReason

  type Effect[X] = Future[X]

  implicit val effectMonad: Monad[Effect] = {
    import scala.concurrent.ExecutionContext.Implicits.global
    cats.std.future.futureInstance
  }
}

First let's define some types

Hogwarts Student Registration

object Domain {
  //passed in by user
  type Request = Map[String, String]

  case class RegistrationRecord(basicInfo: BasicInfo,
                                mentor: Mentor, 
                                dormRoom: DormRoom)

  case class BasicInfo(name: String, address: String, age: Int, sex: Sex)
  ...
} 

trait Services {
  def wandService: K[GetWandRequest, Wand]
  def mentorService: K[AssignMentorRequest, Mentor]
  def dormService: K[AssignDormRoomRequest, DormRoom]

  //protocols
  case class GetWandRequest(name: String, address: String)
  case class AssignMentorRequest(wand: Wand, specialty: Specialty)
  case class AssignDormRoomRequest(name: String, sex: Sex, mentor: Mentor)
}

def register: K[Request, RegistrationRecord] = ???

Services at disposal

Hogwarts Student Registration

Request Parser

We need to extract this BasicInfo out of Request (Map[String, String])

  case class BasicInfo(name: String, address: String, age: Int, sex: Sex)

  def basicInfoExtractor: K[Request, BasicInfo] = ???

Automatic Parser with Henkan

  import henkan.extractor._

  implicit val frString: FieldReader[Result, Request, String] = 
    stringExtractor _

Hogwarts Student Registration

Application

  import AutoExtractors._

  def register(services: Services): K[Request, RegistrationRecord] = {
    import services._
    for {
      bi     ← baseInformationExtractor
      mentor ← mentorService.contraMapR(
                 wand      = pure[Request](bi.to[GetWandRequest]()) andThen
                             wandService,
                 specialty = stringExtractor("specialty") andThen stringToSpecialty
      )
      room   ← pure[Request](bi.to[AssignDormRoomRequest].set(mentor = mentor)) andThen 
                  dormService
    } yield RegistrationRecord(bi, mentor, room)
  } 

A community of projects and individuals organized around ...

• Pure, typeful, functional programming in Scala
• Independent, free/libre and open source software
• A desire to share ideas and code
• Accessible and idiomatic learning resources
• An inclusive, welcoming and safe environment

Question?

Links

• Hogwarts registration program
  github.com/kailuowang/henkan
• Typelevel.org
• github.com/typelevel/cats
• github.com/milessabin/kittens
• This slide
  https://slides.com/kailuowang/deck-5-3/