Lambdaconf2019 talk

type Encoder[A] = A => Json
type Decoder[A] = Json => Either[Error, A]

sealed trait Employee
final case class Subordinate(
name:String,
age:Int,
boss: Employee
) extends Employee
final case class Boss(
name:String,
isActive:Boolean
) extends Employee

def toEncoder[A](schema:SchemaF[A]):Encoder[A] = ???

sealed trait MyPrim[A]
final case object IntP extends MyPrim[Int]
final case object StringP extends MyPrim[String]
final case object BooleanP extends MyPrim[Boolean]

sealed trait SchemaF[A]
final case class PrimF[A](prim:MyPrim[A]) extends SchemaF[A]

sealed trait SchemaF[Prim[_], A]
final case class PrimS[Prim[_], A](prim:Prim[A]) extends SchemaF[Prim, A]

//MyPrim[A] => Encoder[A] ---- Prim ~> Encoder
def toPrimEnc[A](prim:MyPrim[A]):Encoder[A] = prim match {
case IntP => (i:Int) => i.toString
case StringP => (s:String) => s""""$s""""
case BooleanP => (b:Boolean) => if (b) "true" else "false"
}

def toEnc[Prim[_], A](schema:SchemaF[Prim, A], toPrimEnc: Prim ~> Encoder):Encoder[A] = schema match
{
case PrimS(p) => toPrimEnc(p)
}

val intSchema:SchemaF[MyPrim, Int] = PrimS(IntP)
val strSchema:SchemaF[MyPrim, String] = PrimS(StringP)
val booleanSchema:SchemaF[MyPrim, Boolean] = PrimS(BooleanP)

val nt: MyPrim ~> Encoder = new NaturalTransformation[MyPrim, Encoder]{
override def apply[A](prim:MyPrim[A]):Encoder[A] = toPrimEnc(prim)
}
val encoder: Encoder[Int] = toEnc(intSchema, nt)

final case class PrimS[Prim[_],A](prim:Prim[A]) extends SchemaF[Prim, A]
final case class ProdS[Prim[_],A,B](l:SchemaF[Prim, A], r:SchemaF[Prim, B]) extends SchemaF[Prim, (A,B)]
final case class SumS[Prim[_],A,B](l:SchemaF[Prim, A], r:SchemaF[Prim, B]) extends SchemaF[Prim, A/B]

val productSumSchema:SchemaF[MyPrim, (Int, (String, (Boolean / Int)))] =
ProdS(intSchema, ProdS(strSchema, SumS(booleanSchema, intSchema)))

def toEnc[Prim[_], A](schema:SchemaF[Prim, A], toPrimEnc: Prim ~> Encoder):Encoder[A] = schema match {
case prod:ProdS[Prim, x, y] => (tpl:(x,y)) =>
toEnc(prod.l, toPrimEnc)(tpl._1) + "," + toEnc(prod.r, toPrimEnc)(tpl._2)
}

case sum:SumS[Prim, x, y] => (e:x / y) => e.fold(
lx => toEnc(sum.l, toPrimEnc)(lx),
ry => toEnc(sum.r, toPrimEnc)(ry)
)
}

final case class PrimS[Prim[_],A](prim:Prim[A]) extends SchemaF[Prim, A]
final case class ProdS[Prim[_],A,B](l:SchemaF[Prim, A], r:SchemaF[Prim, B]) extends SchemaF[Prim, (A,B)]
final case class SumS[Prim[_],A,B](l:SchemaF[Prim, A], r:SchemaF[Prim, B]) extends SchemaF[Prim, A/B]
final case class UnionS[Prim[_],B,A](base:SchemaF[Prim, B], iso:Iso[B,A]) extends SchemaF[Prim, A]
final case class RecordS[Prim[_],B,A](base:SchemaF[Prim, B], iso:Iso[B,A]) extends SchemaF[Prim, A]
final case class IsoS[Prim[_],B,A](base:SchemaF[Prim, B], iso:Iso[B,A]) extends SchemaF[Prim, A]

case sum:SumS[Prim, x, y] => (e:x / y) => e.fold(
lx => toEnc(sum.l, toPrimEnc)(lx),
ry => toEnc(sum.r, toPrimEnc)(ry)
)
case isoS:IsoS[Prim, b, A] => (a:A) =>
toEnc(isoS.base, toPrimEnc)(isoS.iso.reverseGet(a))
case union:UnionS[Prim, b, A] => (a:A) =>
toEnc(union.base, toPrimEnc)(union.iso.reverseGet(a))
case record:RecordS[Prim, b, A] => (a:A) =>
toEnc(record.base, toPrimEnc)(record.iso.reverseGet(a))
}

sealed trait SchemaF[Prim[_], SumTermId, ProductTermId, A]
...
final case class FieldS[Prim[_], SumTermId, ProductTermId, A](
id:ProductTermId,
base:SchemaF[Prim,SumTermId, ProductTermId, A]
) extends SchemaF[Prim, SumTermId, ProductTermId, A]
final case class BranchS[Prim[_], SumTermId, ProductTermId, A](
id:SumTermId,
base:SchemaF[Prim,SumTermId, ProductTermId, A]

//Schema[A] => Encoder[A]
def toEnc[Prim[_], SumTermId, ProductTermId, A](
schema:SchemaF[Prim,SumTermId, ProductTermId, A],
toPrimEnc: Prim ~> Encoder,
sidToString: SumTermId => String,
pidToString: ProductTermId => String
):Encoder[A] = schema match {
...
case field:FieldS[Prim,SumTermId, ProductTermId, A] => (a:A) =>
s""""${pidToString(field.id)}":${toEnc(field.base, toPrimEnc, sidToString, pidToString)(a)}"""
case branch:BranchS[Prim,SumTermId, ProductTermId, A] => (a:A) =>
s"""{"${sidToString(branch.id)}":{${toEnc(branch.base, toPrimEnc, sidToString, pidToString)(a)}}}"""
}

...
final case class SeqS[Prim[_], SumTermId, ProductTermId, A(
element:SchemaF[Prim,SumTermId, ProductTermId, A]
) extends SchemaF[Prim, SumTermId, ProductTermId, List[A]]

//Schema[A] => Encoder[A]
...
case seq:SeqS[Prim,SumTermId, ProductTermId, A] =>
(as:List[A]) =>
as.map(toEnc(seq.element, toPrimEnc, sidToString, pidToString)).mkString("[",",","]")
}

...
final case class RecursiveS[Prim[_], SumTermId, ProductTermId, A](
base: () => SchemaF[Prim,SumTermId, ProductTermId, A]

...
case self:RecursiveS[Prim,SumTermId, ProductTermId, A] =>
(a:A) => toEnc(self.base(), toPrimEnc, sidToString, pidToString)(a)
}

final case class One[Prim[_], SumTermId, ProductTermId]()
extends Schema[Prim, SumTermId, ProductTermId, Unit]

schema:Schema[Prim,SumTermId, ProductTermId, A],
...
case _:One[Prim,SumTermId,ProductTermId] => _ => "null"
}

def optional[Prim[_], SumTermId, ProductTermId, A](
schema:SchemaF[Prim, SumTermId, ProductTermId, A]
):SchemaF[Prim, SumTermId, ProductTermId, Option[A]] =
IsoS(
SumS(
One[Prim,SumTermId,ProductTermId](),
schema
),
Iso[Unit / A, Option[A]](
_.fold(_ => Option.empty[A],Option(_))
)(
_.fold(().left[A])(a => a.right[Unit])
)
)

trait Realisation {
type Prim[A]
type SumTermId
type ProductTermId
}

trait SchemaModule[R <: Realisation] {
val R: R
type Schema[A] = SchemaF[R.Prim, R.SumTermId, R.ProductTermId, A]
type Sum[A, B] = SumS[R.Prim, R.SumTermId, R.ProductTermId, A, B]
// and all the other needed aliases
}

val R: R
final def unit: Schema[Unit]
final def prim[A](prim: R.Prim[A]): Schema[A]
final def union[A, AE](choices: Schema[AE], iso: Iso[AE, A]): Schema[A]
final def optional[A](aSchema: Schema[A]): Schema[Option[A]]
final def record[A, An](terms: Schema[An], isoA: Iso[An, A]): Schema[A]
final def seq[A](element: Schema[A]): Schema[List[A]]
final def iso[A0, A](base: Schema[A0],iso: Iso[A0, A]): Schema[A]
final def self[A](root: => Schema[A]): Schema[A]
}

val R: R
implicit final class SchemaSyntax[A](schema: Schema[A]) {
def :*: [B](left: Schema[B]): Schema[(B, A)]
def :+: [B](left: Schema[B]): Schema[B / A]
def -*>: (id: R.ProductTermId): Schema[A]
def -+>: (id: R.SumTermId): Schema[A]
def imap[B](_iso: Iso[A, B]): Schema[B]
}
}

object JsonSchema extends Realisation {
type Prim[A] = JsonPrim[A]
type ProductTermId = String
type SumTermId = String
sealed trait JsonPrim[A]
final case object JsonString extends JsonPrim[String]
final case object JsonNumber extends JsonPrim[BigDecimal]
final case object JsonBool extends JsonPrim[Boolean]
final case object JsonNull extends JsonPrim[Unit]
}

trait JsonModule[R <: Realisation] extends SchemaModule[R] {
def toEnc[A](
schema:Schema[A],
toPrimEnc: R.Prim ~> Encoder,
sidToString: R.SumTermId => String,
pidToString: R.ProductTermId => String
):Encoder[A] = schema match {...}
}

object module extends JsonModule[JsonSchema.type] {
val R = JsonSchema
import R._
}

def subordinateSchema = record(
"name" -*>: prim(JsonSchema.JsonString) :*:
"age" -*>: prim(JsonSchema.JsonNumber) :*:
"boss" -*>: self(employeeSchema),
Iso[(String, (BigDecimal, Employee)), Subordinate](
tpl => Subordinate(tpl._1, tpl._2._1, tpl._2._2)
)(s => (s.name, (s.age, s.boss)))
)
def bossSchema = record(
"isActive" -*>: prim(JsonSchema.JsonBool),
Iso[(String, Boolean), Boss]((Boss.apply _).tupled)(b => (b.name, b.isActive))
)
def employeeSchema = union(
"subordinate" -+>: subordinateSchema :+:
"boss" -+>: bossSchema,
Iso[Subordinate / Boss, Employee] {
case -/(s) => s
case /-(b) => b
} {
case s: Subordinate => -/(s)
case b: Boss => /-(b)
}
)

object Representation {
type RSum[RA, A, RB, B]
type RProd[RA, A, RB, B]
type RIso[RA, A, B]
type RSelf[A]
type RSeq[R, A]
type -*>[K, V]
type -+>[K, V]
type RRecord[RA, An, A]
type RUnion[RA, An, A]
}

sealed trait SchemaF[Prim[_], SumTermId, ProductTermId, R, A]
final case class One[...]() extends SchemaF[... Unit, Unit]
final case class SumF[...](...) extends SchemaF[... RSum[RA, A, RB, B], A / B]
final case class ProdF[...](...) extends SchemaF[... RProd[RA, A, RB, B], (A, B)]
final case class BranchF[...](...) extends SchemaF[... -+>[SumTermId, RA], A]
final case class UnionF[... RA: IsUnion ...](...) extends SchemaF[... RUnion[RA, AE, A], A]
final case class FieldF[...](...) extends SchemaF[... -*>[ProductTermId, RA], A]
final case class RecordF[...RA: IsRecord...](...) extends SchemaF[... RRecord[RA, AP, A], A]
final case class SeqF[...](...) extends SchemaF[... RSeq[RA, A], List[A]]
final case class IsoSchemaF[...](...) extends SchemaF[... RIso[RA, A0, A], A]
final case class SelfReference[...](...) extends SchemaF[... RSelf[A], A]

final case class Boss(name:String, isActive:Boolean) extends Employee
def bossSchema = record(
"isActive" -*>: prim(JsonSchema.JsonBool),
Iso[(String, Boolean), Boss]((Boss.apply _).tupled)(b => (b.name, b.isActive))
)

RRecord[
RProd[
String -*> String,
String,
String -*> Boolean,
Boolean
],
(String, Boolean),
Boss
]

@implicitNotFound(
msg = "It seems like the following representation type isn't isomorphic to a product of named
fields: ${A}"
)
trait IsRecord[A]
object IsRecord {
implicit def singleFieldIsRecord[K, V]: IsRecord[K -*> V] = new IsRecord[K -*> V] {}
implicit def productIsRecord[L: IsRecord, R: IsRecord, X, Y]: IsRecord[RProd[L, X, R, Y]] =
new IsRecord[RProd[L, X, R, Y]] {}
implicit def isoIsRecord[R: IsRecord, A0, A]: IsRecord[RIso[R, A0, A]] =
new IsRecord[RIso[R, A0, A]] {}
}

sealed trait SchemaF[Prim[_], SumTermId, ProductTermId, F[_, _], R, A] {
def hmap[G[_, _]](nt: F ~~> G): SchemaF[Prim, SumTermId, ProductTermId, G, R, A]
}
…
final case class SumF[F[_, _], RA, RB, A, B, Prim[_], SumTermId, ProductTermId](
left: F[RA, A],
right: F[RB, B]
) extends SchemaF[Prim, SumTermId, ProductTermId, F, RSum[RA, A, RB, B], A / B] {
def hmap[G[_, _]](
nt: F ~~> G
): SchemaF[Prim, SumTermId, ProductTermId, G, RSum[RA, A, RB, B], A / B] =
}
...

trait Interpreter[F[_, _], F[_, _]] { self =>
def interpret: F ~~> G
def compose[H[_, _]](nt: H ~~> F) = self match {
case i: ComposedInterpreter[h, G, F] => ComposedInterpreter(i.underlying, i.nt.compose(nt))
case x => ComposedInterpreter(x, nt)
}
}

implicit final def encoderInterpreter(
implicit primNT: R.Prim ~> EncoderA,
fieldLabel: R.ProductTermId <~< String,
branchLabel: R.SumTermId <~< String
): RInterpreter[Encoder] =
Interpreter.cata[RSchema, Encoder](new (RSchema[Encoder, ?, ?] ~~> Encoder) {
//Implementation of Schema to Encoder here
})

case p: RPrim[Encoder, a] => primNT(p.prim)
case ProdF(left, right) => (a => left(a._1) + "," + right(a._2))
case SumF(left, right) => (a => a.fold(left, right))
case i: IsoSchema[Encoder, r, _, a] =>
i.base.compose(i.iso.reverseGet)
case r: Record[Encoder, r, _, a] =>
encloseInBraces.compose(r.fields).compose(r.iso.reverseGet)
case SeqF(element) => (a => a.map(element).mkString("[", ",", "]"))
case FieldF(id, base) => makeField(fieldLabel(id)).compose(base)
case u: Union[Encoder, r, _, a] =>
encloseInBraces.compose(u.choices).compose(u.iso.reverseGet)
case BranchF(id, base) => makeField(branchLabel(id)).compose(base)
case One() => (_ => "null")
case ref @ SelfReference(_, _) => (a => ref.unroll(a.asInstanceOf[A with Repr]))

val R: R
implicit final class SchemaSyntax[A](schema: Schema[A]) {
def to[F[_, _]](implicit interpreter: RInterpreter[F]): F[_, A]
}
}

val employeeEncoder:Encoder[Employee] = employeeSchema.to[Encoder]

@jdegoes @ValentinKasas @GrafBlutwurst

Lambdaconf2019 talk

Recommended

Recommended

More Related Content

What's hot

What's hot (19)

Similar to Lambdaconf2019 talk

Similar to Lambdaconf2019 talk (20)

Recently uploaded

Recently uploaded (20)

Lambdaconf2019 talk