This document discusses using a tagless final embedded domain specific language (eDSL) approach to build a functional API for the imperative WebGL graphics library. It describes wrapping WebGL calls in IO as one solution but notes issues with separation of concerns and testing. The document then introduces tagless final as a way to define algebras that model WebGL operations and can have multiple interpreters. It provides examples of defining console, key-value store, and prompt algebras and combining them. The document concludes that tagless final allows defining interactions through algebras that can be composed, layered and have multiple interpreters for flexibility and testability while working at an extra level of abstraction.

1. Building a Tagless Final DSL for WebGL
Luka Jacobowitz

2. Motivation
● We often have to interface with some super imperative
libraries.
● Hard to find anything more imperative than graphics
programming.
● How can we give these libraries a nice and clean functional
API?

3. Solution #1 Wrap all the things in IO
for {
canvas <- IO(dom.createElement("canvas"))
gl <- IO(canvas.getContext("webgl"))
_ <- IO(gl.clearColor(0,0,0,1))
_ <- IO(println("Initialized GL"))
} yield ()

4. Solution #1 Wrap all the things in IO
● Breaks separation of concerns
● Really difficult to test
● Hard to keep track of the level of abstraction

5. It’d be cool if we could use a functional
DSL to access the imperative libraries

6. Digression: What’s the ‘e’ in eDSL?
● DSLs: GLSL, SQL, Shell scripts
● Embedded DSLs: Embedded into another language, builds
up a tree of expressions that “compile” to the target
language

7. What kind of eDSLs are there?
● AST as (G)ADTs
● Free Monad/Applicative
● Tagless Final

8. Tagless Final
● Model our Algebras as traits parametrized with a type
constructor
● Programs constrain the type parameter (e.g. with Monad)
● Interpreters are simply implementations of those traits

9. Tagless Final - Basic example
trait Console[F[_]] {
def printLine(s: String): F[Unit]
def readLine: F[String]
}
def program[F[_]: Monad](C: Console[F]) = for {
_ <- C.printLine("Please enter your name")
name <- C.readLine
_ <- C.printLine(s"You entered $name")
} yield ()

10. Tagless Final - Basic example
object ConsoleTaskInterpreter extends Console[Task] {
def printLine(s: String): Task[Unit] =
Task(println(s))
def readLine: Task[String] =
Task(StdIn.readLine())
}
program(ConsoleTaskInterpreter).runAsync

11. Combining Algebras
trait KVStore[F[_]] {
def put[A](key: String, a: A): F[Unit]
def get[A](key: String): F[Option[A]]
}
def program[F[_]: FlatMap](C: Console[F], K: KVStore[F]) = for {
_ <- C.printLine("Please enter your name")
name <- C.readLine
_ <- K.put("name", name)
} yield ()

12. Language Layers
trait Prompt[F[_]] {
def prompt(msg: String): F[String]
}
class PromptConsoleInterpreter[F[_]: FlatMap](C: Console[F])
extends Prompt[F] {
def prompt(msg: String): F[String] = for {
_ <- C.printLine(msg)
s <- C.readLine
} yield s
}

13. Let’s check out some code!

14. Bonus: Parallelism
def program[M[_]: FlatMap, F[_]](K: KVStore[F])(implicit P: Parallel[M, F]) =
for {
_ <- K.put("A", a)
x <- (K.get("B"), K.get("C")).parMapN(f)
} yield x

15. Other cool things
● While difficult, it’s totally possible to inspect and optimize
our programs
● With the Mainecoon library we can generically compose
and transform our Algebras
● If we need to guarantee stack safety, we can compile our
Algebras to Free and then interpret

16. Conclusions
● Tagless Final allows us to use our own Algebras for
defining interactions
● These Algebras can be composed and layered
● We can define multiple interpreters, which gives us great
flexibility and the ability to test and refactor
● Our programs are exactly as powerful as we want them to
be
● We can work at an extra level of abstraction but maintain
flexibility

17. Thank you for listening!
Twitter: @LukaJacobowitz