runarorama

trait λ {
  type α
}

trait Functor extends λ {
  type α <: λ

  def map[A,B](x: α { type α = A })(f: A => B): α { type α = B }
}

kevinwright

As compiled by Kevin Wright a.k.a @thecoda

(executive producer of the movie, and I didn't even know it... clever huh?)

please, please, please - If you know of any slides/code/whatever not on here, then ping me on twitter or comment this Gist!

This gist will be updated as and when I find new information. So it's probably best not to fork it, or you'll miss the updates!

Monday June 16th

ymasory

Please help compile a list of all Scala-related IRC rooms.

All of these channels are on Freenode.

#akka              | concurrency & distribution framework
#argonaut          | json library
#fp-in-scala       | the book Functional Programming in Scala
#geotrellis        | geoprocessing library
#indyscala         | regional scala group
#json4s            | json library

HeinrichApfelmus

-- http://www.reddit.com/r/haskell/comments/rbgvz/conduits_vs_pipes_using_void_as_an_input_or/

import Control.Monad

data Pipe m i o r =
    NeedInput (i -> Pipe m i o r) (Pipe m () o r)
  | HaveOutput (Pipe m i o r) (m ()) o
  | Finished (Maybe i) r
  | PipeM (m (Pipe m i o r)) (m r)

EECOLOR

package test

import scala.language.higherKinds

case class Program[F[_], A](free: Free[F, A]) {

  import Coproduct.|

  def flatMap[G[_], B](f: A => Program[G, B])(
    implicit c: F | G): Program[c.Out, B] =

tonymorris

{-# LANGUAGE RankNTypes #-}

data Free f a =
  Done a
  | More (f (Free f a))

instance Functor f => Functor (Free f) where
  fmap f (Done a) =
    Done (f a)
  fmap f (More k) =

raichoo

import scala.language.higherKinds

/*
 * The usual peano numbers with addtion and multiplication  
 */
sealed trait Nat {
  type Plus[N <: Nat] <: Nat
  type Mult[N <: Nat] <: Nat
}

halcat0x15a

!SLIDE

Coyoneda + Free

halcat0x15a

!SLIDE

Coyoneda

tonymorris

Reasoning

• observations lead to conclusions
• conclusions, based on observations, lead to new conclusions
• conclusions do not lead to themselves
• conclusions do not lead to observations

---

You might suspect something to be true (a conclusion). You question why you believe it to be true -- hypothesis formation. When you fail to find reasons to believe it to be true, you abandon the hypothesis. It could be that:

tonymorris

package com.nicta
package jdbc

import java.sql.SQLException
import scalaz._, Scalaz._

// 1 + A
sealed trait ?[A] {
  import ?._