purefn

import scalaz._, Free._

sealed trait Arithmetic[+A]
sealed case class Addition[A](a: Int, b: Int, f: Int => A) extends Arithmetic[A]

object Arithmetic {
  implicit val ArithmeticFunctor: Functor[Arithmetic] = new Functor[Arithmetic] {
    def map[A, B](fa: Arithmetic[A])(f: A => B) = fa match {
      case z@Addition(_, _, g) => z.copy(f = f compose g)
    }

luciferous

do.js

An experimental Javascript library that can be used for asynchronous control flow, non-determinism, parsing, and other kinds of computations which implement the interface:

bind :: m a -> (a -> m b) -> m b
return :: a -> m a

This gist is a temporary living situation for do.js, and will most likely be expanded into a full blown Github repository in the future.

arosien

import scalaz._
import Scalaz._
import Free._

/** "Pure" interactions with a console. */
sealed trait Console[+A]
case class GetLine[A](k: String => A) extends Console[A]
case class PutLine[A](s: String, a: A) extends Console[A]

object Console {

YoEight

{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE GADTs #-}
module Data.Process where

import Prelude hiding (zipWith)

import Control.Applicative
import Control.Monad
import Data.Foldable

pchiusano

trait ConsoleAlg[F[_]] {
  def readLine: F[Option[String]]
  def printLine(line: String): F[Unit]
}

trait Console[+A] {
  def run[F[+_]](F: ConsoleAlg[F]): F[A]
}

object Console {