b-studios

class Table(var rows: List[Row] = Nil) {
  def add(r: Row) = { rows = r :: rows }
}
class Row(var cells: List[Cell] = Nil) {
  def add(c: Cell) = { cells = c :: cells }
}
case class Cell(content: String)

object test {
  def table(init: implicit Table => Unit) = {

b-studios

When defining complex functions in pointfree style, I often find myself switching to pointful style. Sometimes, I even convert to ANF and annotate the types to understand the steps.

After completing the function definition, I often convert back to pointfree style for conciseness. End of the story: To understand it again a couple of weeks later, I start expanding to annotated pointful again.

The small 10-lines library at the end of this post allows to define pointfree functions with intermediate type annotations.

Credits: Agda and EqReasoning for syntactical inspiration.

b-studios

effect expr<a> {
  lit (n: int): a;
  add (l: a, r: a): a
}

effect mulExpr<a> {
  mul (l: a, r: a): a
}

// forall<a,e>. (() -> <expr<int>|e> a) -> e a

b-studios

package object fixpoint {

  // The idea here is similar (though inverted) to Matryoschka Based: 
  //   https://github.com/slamdata/matryoshka/blob/master/core/shared/src/main/scala/matryoshka/Based.scala
  trait Fix[F[_]] {
    type Out
    def roll: F[Out] => Out
    def unroll: Out => F[Out]
  }
  trait Functor[F[_]] {

b-studios

  trait Expr[-I, +O] {
    def Lit: Int => O
    def Add: (I, I) => O
  }

  trait Term {
    def apply[R](alg: Expr[R, R]): R
  }

b-studios

object tc {
  sealed trait =::=[F[_], G[_]] {
    def apply[A](f: F[A]): G[A]
  }
  object =::= {
    implicit def idFunctors[F[_]]: F =::= F = new =::=[F, F] {
      def apply[A](f: F[A]): F[A] = f
    }
  }
  

b-studios

// 1. Instead of using type parameters, we use type members
trait Expr {
  type ExprIn
  type ExprOut
  type Base[+_]
}

trait Monadic {
  type M[+_]
}

b-studios

package object pipe {
  implicit class Pipe[T](t: T) {
    def |>[S](f: T => S): S = f(t)
  }

  def filter[T](f: T => Boolean): List[T] => List[T] = _.filter(f)
  def map[A, B](f: A => B): List[A] => List[B] = _.map(f)

  // Type inference indeed does play along quite well:
  val x: Option[Int] = List(1, 2, 3) |>

b-studios

// Finds a R in an T
trait Select[T, R] {
  def apply(t: T): R
}

trait LowPrio {
  def apply[T, R](f: T => R): Select[T, R] = new Select[T, R] {
    def apply(t: T): R = f(t)
  }
  implicit def autoLeft[T, R, O]: Select[(R, O), R] = Select(_._1)

b-studios

// Finds a R in an T
trait Select[T, R] {
  def apply(t: T): R
}

trait LowPrio {
  implicit def autoLeft[T, R, O]: Select[(R, O), R] = ???
}
object Select extends LowPrio {
  implicit def autoRight[T, R, O]: Select[(O, R), R] = ???