(Lightning Talk at Scala Exchange 2018) Bridges is a library to generate Elm, TypeScript, or Flow code from Scala ADTs

1. BRIDGESPERE VILLEGA (@PVILLEGA)

2. BRIDGES - BY @PVILLEGA
WHAT IS THE PROBLEM
BACK-END
MODEL
ELM
DECODER
S
ELM
MODEL

5. BRIDGES - BY @PVILLEGA
CIRCE SHAPELES
S JSON
ADT SHAPELES
S ELM

6. BRIDGES - BY @PVILLEGA

7. BRIDGES - BY @PVILLEGA

8. BRIDGES - BY @PVILLEGA
HTTPS://GITHUB.COM/DAVEGURNELL/B
RIDGES

9. BRIDGES - BY @PVILLEGA
WHAT IS THE SOLUTION
ADT BRIDGES ELM *

10. BRIDGES - BY @PVILLEGA
ELM
TYPESCRIP
T
FLOW
Types
Guards
Decoders
Encoders

11. BRIDGES - BY @PVILLEGA
case class Color(red: Int, green: Int, blue: Int)
Elm.buildFile("CustomModule", decl[Color])

12. BRIDGES - BY @PVILLEGA
module CustomModule.Color exposing (..)
import Json.Decode as Decode
import Json.Decode.Pipeline exposing (..)
import Json.Encode as Encode
type alias Color = { red: Int, green: Int, blue:
Int }
decoderColor : Decode.Decoder Color
decoderColor = decode Color |> required "red"
Decode.int |> required "green" Decode.int |>
required "blue" Decode.int
encoderColor : Color -> Encode.Value
encoderColor obj = Encode.object [ ("red",
Encode.int obj.red), ("green", Encode.int
obj.green), ("blue", Encode.int obj.blue) ]

13. BRIDGES - BY @PVILLEGA
sealed trait ADTAndObjects
case class MyClass(value: Int) extends ADTAndObjects
case object MyObject extends ADTAndObjects
case class ValueClass(value: String) extends AnyVal
case class ClassWithUUID(a: UUID)
final case class ComplexTypes(color: Color, nav: Navigation)
final case class RecursiveType(head: Int, tail: Option[RecursiveType])
val customErrorMsg = "ErrorMessage" := prod(
"error" := Ref("ErrorMessage")
)
case class ClassWithRefinedType(name: RefinedString)

14. BRIDGES - BY @PVILLEGA
WORKFLOW WITH BRIDGES
BACK-END
MODEL
RUN SBT
TASK *

15. BRIDGES - BY @PVILLEGA
case class Color(red: Int, green: Int, blue: Int)
sealed abstract class Shape
case class Circle(r: Double, c: Color) extends Shape
case class Rectangle(w: Double, h: Double, c: Color) extends Shape
case class ShapeGroup(left: Shape,right: Shape) extends Shape
Elm.render(decl[Shape])
type Shape = Circle Float Color
| Rectangle Float Float Color
| ShapeGroup Shape Shape

17. BRIDGES - BY @PVILLEGA
sealed abstract class Type
case object Str extends Type
case object Bool extends Type
case class Arr(tpe: Type) extends Type
//Others...
case class Ref(id: String) extends Type
case class Prod(fields: List[Decl]) extends Type
case class Sum(products: List[ProdDecl]) extends Type

18. BRIDGES - BY @PVILLEGA
case class DeclF[+A](name: String, tpe: A)
type Decl = DeclF[Type]
case class Pair(a: String, b: Int)
DeclF(“Pair”, prod(
"a" := Str,
"b" := Intr
)

19. BRIDGES - BY @PVILLEGA
case class DeclF[+A](name: String, tpe: A)
type TsDecl = DeclF[TsType]
DeclF("A",
Ref("B") & Ref("C") & Ref("D")
)
export type A = B & C & D;

20. BRIDGES - BY @PVILLEGA
trait Renderer[A] {
def render(decl: DeclF[A]): String
}
trait ElmRenderer extends Renderer[Type] {
def render(decl: Decl): String =
decl.tpe match {
case Sum(products) ⇒ …
case other ⇒ …
}
// ...
}

21. BRIDGES - BY @PVILLEGA
def decl[A](implicit
tpeTag: WeakTypeTag[A],
encoder: Lazy[Encoder[A]]): Decl =
DeclF(
getCleanTagName[A],
encoder.value.encode)
trait Encoder[A] {
def encode: Type
}
type Decl = DeclF[Type]

22. trait FlowRenderer extends Renderer[FlowType] {
def render(decl: FlowDecl): String =
s"""export type ${decl.name} = ${renderType(decl.tpe)};"""
private def renderType(tpe: FlowType): String =
tpe match {
case Ref(id) => id
case Str => "string"
case Chr => "string"
case Intr => "number"
case Real => "number"
case Bool => "boolean"
case Null => "null"
case Undefined => "undefined"
case StrLit(value) => s""""${escape(value)}""""
case ChrLit(value) => s""""${escape(value.toString)}""""
case IntrLit(value) => value.toString
case RealLit(value) => value.toString
case BoolLit(value) => value.toString
case tpe @ Opt(arg) => s"""?${renderParens(tpe)(arg)}"""
case tpe @ Arr(arg) => s"""${renderParens(tpe)(arg)}[]"""
case Struct(fields) => renderStruct(fields)
case tpe @ Inter(types) => types.map(renderParens(tpe)).mkString(" & ")
case tpe @ Union(types) => types.map(renderParens(tpe)).mkString(" | ")
}
private def renderStruct(fields: List[FlowDecl]): String =
fields.map(renderField).mkString("{ ", ", ", " }")
private def renderField(field: FlowDecl): String =
s"""${field.name}: ${renderType(field.tpe)}"""
private def renderParens(outer: FlowType)(inner: FlowType): String =
if (precedence(outer) > precedence(inner)) s"(${renderType(inner)})"
else renderType(inner)

23. BRIDGES - BY @PVILLEGA
HTTPS://UNDERSCORE.IO/BLOG/POSTS/
2018/12/12/BRIDGES.HTML
HTTPS://GITHUB.COM/DAVEGURNELL/B
RIDGES

24. IF YOU WORK AT
UK’S HOME
OFFICE (OR KNOW
SOMEONE) TALK
TO ME!Questions welcome, too!
THE END!