barambani

" Initialize plugin system
call plug#begin('~/.vim/plugged')

Plug 'rizzatti/dash.vim'
Plug 'derekwyatt/vim-scala'
Plug 'vim-syntastic/syntastic'
Plug 'kien/ctrlp.vim'
Plug 'scrooloose/nerdtree'
Plug 'Xuyuanp/nerdtree-git-plugin'
Plug 'ervandew/supertab'

barambani

Advanced Functional Programming with Scala - Notes

Copyright © 2016-2017 Fantasyland Institute of Learning. All rights reserved.

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

barambani

object Functions {

  /**
    * Functions
    * - Total (every element in the domain must have a representation in the co-domain)
    * - Deterministic (give always the same result for the same input)
    * - Not side effecting (the only result of the function is the mapped value)
    */

  /**

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 : * -> *

barambani

package fpmax

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

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

    val name = readLine()

barambani

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 ...

barambani

// 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._

barambani

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)

barambani

/** 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)

barambani

// 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)))
}