jdegoes

// ####### If you use a more generic lens you can transform types along the way.
case class Lens[S, A](get: S => A, set: (S, A) => S)
case class Prism[S, A](get: S => Option[A], unget: A => S) extends (A => S) {
  def apply(a: A): S = unget(a)
  
  def unapply(s: S): Option[A] = get(s)
}

// ####### Sum type

jdegoes

/**
 * Defines an equivalence between types A and B.
 * 
 * Let ~_A be an equivalence relation on A, and ~_B be an equivalence relation
 * on B.
 *
 * Let [a] denote the equivalence class of a in A ({a' | a ~_A a'}), and [b] 
 * denote the equivalence class of b in B ({b' | b ~_B b'}).
 *
 * Let `f: {[a] | a in A} -> {[b] | b in B]`, 'g: {[b] | b in B} -> {[a] | a in A}' 

jdegoes

import scala.language.higherKinds

trait Monad[M[_]] {
  implicit def `Monad ~> Functor`[M[_]: Monad]: Functor[M] = new Functor[M]{}
}

trait Functor[F[_]] {
}
object Functor {

jdegoes

SCORE: ????

Track 1
  A Lattice of Tightropes: Tradeoffs in Language Design - 90
  Monads: Why Should You Care? - 60
  Intro to Functional Game Programming - 120
  Building Web Services with RedEyes & Scala - 60
  Building Web Applications with Clojure - 90
  There's no Clusterf*ck without a Cluster - 60

jdegoes

case class Choice[A](chosen: List[A], unchosen: List[A])

def nChoose1[A](n: List[A]): Stream[Choice[A]] = n match {
  case Nil => Stream.empty[Choice[A]]
  case head :: tail => Choice(head :: Nil, tail) #:: nChoose1(tail).map(choice => choice.copy(unchosen = head :: choice.unchosen))
}

def nChooseK[A](n: List[A], k: Int): Stream[Choice[A]] = {
  if (k <= 0) Stream.empty[Choice[A]]
  else if (k == 1) nChoose1(n)

jdegoes

trait T[A, B]

object T { 
  def apply[A]: TA[A] = new TA[A] {}
  
  trait TA[A] { 
    type Type[B] = T[A, B]
    
    def apply[B]: TAB[B] = new TAB[B] {}
    

jdegoes

Introduction

LambdaConf has multiple tracks, so no attendee can possibly attend all sessions.

Yet, we'd like to schedule the sessions to maximize attendee happiness (for some definition of "maximum" and "happiness").

Sounds like a job for functional programming!

Your mission, should you choose to accept it, is to write a small functional program to produce an "optimal" schedule (your schedule may have any number of tracks you want -- you do not have to stick with 3 or 4).

jdegoes

  implicit def LiftedApplicativePlus[F[_], G[_]]
      (implicit F: Applicative[F], G: ApplicativePlus[G]) = new ApplicativePlus[({type f[A]=F[G[A]]})#f] {
    def empty[A] = F.point(G.empty)

    def point[A](a: => A): F[G[A]] = F.point(G.point(a))

    def plus[A](v1: F[G[A]], v2: => F[G[A]]): F[G[A]] = {
      F.apply2(v1, v2)(G.plus(_, _))
    }

jdegoes

def whatif[S, A](f: StateT[M, S, A]): StateT[M, S, A] = {
  for {
    oldState <- read(identity[S])
    rez      <- f.imap(Function.const(oldState))
  } yield rez
}

jdegoes

type Pattern[A, B] = A => Option[B]

def some[A, B](p: Pattern[A, B]): Pattern[Option[A], B] = _.flatMap(p)

def none[A, B]: Pattern[A, B] = Function.const(None)

def k[A](v0: A): Pattern[A, A] = v => if (v == v0) Some(v0) else None

def or[A, B](p1: Pattern[A, B], p2: Pattern[A, B]): Pattern[A, B] = 
  v => p1(v).orElse(p2(v))