Filippo Mariotti barambani

So we have all these types like Int, Float, String, Map String Int, [Maybe String], etc. What do all these types have in common? Well, essentially, they're "normal" types where we can make a value for them. Just as values have types, types have "kinds". In this case, just as 4 : Int, Int : *, and just as "Hello" : String, String : *. That is to say, all these normal types (the types of plain old values) have kind *.

Now, in OCaml, you have type parametricity, but only over types of kind *. Let's give an example of a type that's not of kind *.

Map : * -> * -> *

We apply this "type constructor" (which is a kind of "type function", just like constructors are a kind of function) to the type Int : *.

Map Int : * -> *

Advanced 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

	##
	# A script to help you install and config basictex
	# https://www.tug.org/mactex/morepackages.html
	#
	# References:
	# - https://gist.github.com/kadrach/6228314
	# - https://tex.stackexchange.com/a/304202
	#
	# Requirements:
	# - homebrew

	brew install pandoc
	brew tap homebrew/cask
	brew install --cask basictex
	eval "$(/usr/libexec/path_helper)"
	# Update $PATH to include `/usr/local/texlive/2022basic/bin/universal-darwin`
	sudo tlmgr update --self
	sudo tlmgr install texliveonfly
	sudo tlmgr install xelatex
	sudo tlmgr install adjustbox
	sudo tlmgr install tcolorbox

	// addCompilerPlugin("com.milessabin" % "si2712fix-plugin" % "1.2.0" cross CrossVersion.full)
	import scalaz._, Scalaz._

	implicit def f2k[F[_], A, B](f: A => F[B]) = Kleisli(f)

	val a: Int => ListT[List, Int] = {
	case 0 => ListT(List(List(0, 1)))
	case 1 => ListT(List(List(0), List(1)))
	}

	/** GADTs in Scala and their limitations */

	/** Background: what is an algebraic data type (ADT) ?
	* ADT: (possibly) recursive datatype with sums and products
	* In scala - a trait with case classes (case class is product, subtyping is sum)
	*/

	/** Motivation: untyped embedded DSL doesn't prevent nonsensical expressions */
	sealed trait Expr {
	def apply(other: Expr) = Ap(this, other)

	trait Stream[+F[_], +A]

	object Stream {
	// Make scalac get over its oudenophobia.
	type Nothing2[X] <: Nothing

	def emits[F[x] >: Nothing2[x], A](as: List[A]): Stream[F, A] = new Stream[F, A] {}

	implicit class InvariantOps[F[x] >: Nothing2[x], A](private val self: Stream[F, A]) extends AnyVal {
	def ethrough[B](p: Stream[F, A] => Stream[F, B]): Stream[F, B] = p(self)

	// local/localtests/test/localtests/LocalTests.scala
	package localtests

	import java.nio.file._
	import java.util.stream.{ Stream => JStream }

	import org.junit.{ AfterClass, Test }

	import scala.collection.JavaConverters._
	import scala.concurrent.duration._

	import scala.language.higherKinds

	// Whitebox ...
	trait Schema[T, R] {
	def conv(t: T): R
	}

	object Schema {
	// Whitebox macro: R is computed from T
	implicit def mkSchema[T, R]: Schema[T, R] = ??? // macro ...

	package fpmax

	import scala.util.Try
	import scala.io.StdIn.readLine

	object App0 {
	def main: Unit = {
	println("What is your name?")

	val name = readLine()