Cal calvinlfer

Revisiting Tagless Final Interpreters

Tageless Final interpreters are an alternative to the traditional Algebraic Data Type (and generalized ADT) based implementation of the interpreter pattern. This document presents the Tageless Final approach with Scala, and shows how Dotty with it's recently added implicits functions makes the approach even more appealing. All examples are direct translations of their Haskell version presented in the Typed Tagless Final Interpreters: Lecture Notes (section 2).

The interpreter pattern has recently received a lot of attention in the Scala community. A lot of efforts have been invested in trying to address the biggest shortcomings of ADT/GADT based solutions: extensibility. One can first look at cats' Inject typeclass for an implementation of [Data Type à la Carte](http://www.cs.ru.nl/~W.Swierstra/Publications/DataTypesA

In your local clone of your forked repository, you can add the original GitHub repository as a "remote". ("Remotes" are like nicknames for the URLs of repositories - origin is one, for example.) Then you can fetch all the branches from that upstream repository, and rebase your work to continue working on the upstream version. In terms of commands that might look like:

Add the remote, call it "upstream":

git remote add upstream https://github.com/whoever/whatever.git

Fetch all the branches of that remote into remote-tracking branches, such as upstream/master:

git fetch upstream

Getting Started in Scala

This is my attempt to give Scala newcomers a quick-and-easy rundown to the prerequisite steps they need to a) try Scala, and b) get a standard project up and running on their machine. I'm not going to talk about the language at all; there are plenty of better resources a google search away. This is just focused on the prerequisite tooling and machine setup. I will not be assuming you have any background in JVM languages. So if you're coming from Python, Ruby, JavaScript, Haskell, or anywhere… I hope to present the information you need without assuming anything.

Disclaimer It has been over a decade since I was new to Scala, and when I was new to Scala, I was coming from a Java and Ruby background. This has probably caused me to unknowingly make some assumptions. Please feel free to call me out in comments/tweets!

One assumption I'm knowingly making is that you're on a Unix-like platform. Sorry, Windows users.

Getting the JVM

Applied Functional Programming with Scala - Notes

1. Mastering Functions

A function is a mapping from one set, called a domain, to another set, called the codomain. A function associates every element in the domain with exactly one element in the codomain. In Scala, both domain and codomain are types.

val square : Int => Int = x => x * x

Event Sourcing

Jay Kreps https://engineering.linkedin.com/distributed-systems/log-what-every-software-engineer-should-know-about-real-time-datas-unifying

http://stackoverflow.com/questions/17708489/using-kafka-as-a-cqrs-eventstore-good-idea

> What happens when you add a new model... ?

Libraries

Web Server: Play (framework) or http4s (library)
Actors: akka
Asynchronous Programming: monix (for tasks, reactors, observables, scheduler etc)
Authentication: Silhouette
Authorization: Deadbolt
Command-line option parsing: case-app
CSV Parsing: kantan.csv
DB: doobie (for PostgreSQL)

	import scalanative.native._
	import SDL._
	import SDLExtra._

	@extern
	@link("SDL2")
	object SDL {
	type Window = CStruct0
	type Renderer = CStruct0

	import scala.collection.mutable.ListBuffer

	object implicex {
	trait ImplicitFunction1[-A, +B] {
	def apply()(implicit a: A): B
	}

	def fn[A, B](f: A => B): ImplicitFunction1[A, B] = new ImplicitFunction1[A, B] {
	def apply()(implicit a: A): B = f(a)
	}

	// Based on following links:
	// http://andrew.hedges.name/experiments/haversine/
	// http://www.movable-type.co.uk/scripts/latlong.html
	df
	.withColumn("a", pow(sin(toRadians($"destination_latitude" - $"origin_latitude") / 2), 2) + cos(toRadians($"origin_latitude")) * cos(toRadians($"destination_latitude")) * pow(sin(toRadians($"destination_longitude" - $"origin_longitude") / 2), 2))
	.withColumn("distance", atan2(sqrt($"a"), sqrt(-$"a" + 1)) * 2 * 6371)

	>>>
	+--------------+-------------------+-------------+----------------+---------------+----------------+--------------------+---------------------+--------------------+------------------+
	\|origin_airport\|destination_airport\| origin_city\|destination_city\|origin_latitude\|origin_longitude\|destination_latitude\|destination_longitude\| a\| distance\|

	import akka.{Done, NotUsed}
	import akka.actor.ActorSystem
	import akka.http.scaladsl.Http
	import akka.http.scaladsl.common.EntityStreamingSupport
	import akka.http.scaladsl.model.ws.TextMessage.{Streamed, Strict}
	import akka.http.scaladsl.model.ws.{Message, TextMessage, WebSocketRequest}
	import akka.stream.ActorMaterializer
	import akka.stream.scaladsl.{Flow, Keep, Sink, Source}
	import akka.util.ByteString
	import io.circe.Json