Michael Pilquist mpilquist

This page contains notes about a possible improvement to Scala for defining and working with type classes. It is mostly just notes at this point, not a proposal to be taken seriously.

Consider the following:

type class Functor[F[_]] {
  def map[A, B](fa: F[A], f: A => B): F[B]
  def replace[A, B](fa: F[A], replacement: => B): F[B] = map(fa, _ => replacement)
  def lift[A, B](f: A => B): F[A] => F[B] = fa => map(fa, f)
}

	// build.sbt:
	// scalaVersion := "2.11.0
	//
	// libraryDependencies += "org.scalaz" %% "scalaz-core" % "7.1.0-M7"
	//
	import scalaz._
	import Scalaz._

	/**
	* Scalaz port of Ed Kmett's code in http://comonad.com/reader/2008/rotten-bananas/

	import akka.actor._
	import scalaz.State

	/**
	* Minimal integration between State monad and Akka's Actor.
	*
	* Usage: upon receiving a message, create a State instance and then call runState(st). The state value
	* is persisted in an actor field between invocations of runState.
	*/
	abstract class StateActor[S] extends Actor {

	› scala -Xlint
	Welcome to Scala version 2.11.1 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0).
	Type in expressions to have them evaluated.
	Type :help for more information.

	scala> val x: PartialFunction[Any, Unit] = PartialFunction.empty
	x: PartialFunction[Any,Unit] = <function1>

	scala> val y: PartialFunction[Any, Unit] = PartialFunction.empty
	y: PartialFunction[Any,Unit] = <function1>

	def noReasons(x: Int): Option[Int] = for {
	y <- Option(x).filter(_ > 0)
	z <- Option(y / 2).filter(_ > 1)
	} yield z

	(0 to 4) map noReasons
	// scala.collection.immutable.IndexedSeq[Option[Int]] = Vector(None, None, None, None, Some(2))

	import scalaz.\/
	import scalaz.syntax.std.option._

	sealed trait Interact[A]

	case class Ask(prompt: String)
	extends Interact[String]

	case class Tell(msg: String)
	extends Interact[Unit]

	trait Monad[M[_]] {
	def pure[A](a: A): M[A]

	package scodec

	import shapeless._
	import shapeless.ops.coproduct._

	object CoproductOps {

	sealed trait Align[A <: Coproduct, B <: Coproduct] {
	def apply(a: A): B
	}

	package cats
	package data

	import free.Free.Trampoline
	import free.Trampoline

	// Quick port of http://blog.higher-order.com/assets/trampolines.pdf for cats
	sealed abstract class State[S, A] {

	import State._

	def local[A](implicits: Any*)(f: => A): A = macro localMacro[A]

	def localMacro[A](c: Context)(implicits: c.Expr[Any]*)(f: c.Expr[A]): c.Expr[A] = {
	import c.universe._
	val implicitVals = implicits.map { imp =>
	val name = TermName(c.freshName())
	q"implicit val $name = $imp"
	}
	c.Expr[A](q"{ ..$implicitVals; $f }")
	}

	import foo._

	object MyApp extends App {
	println(this.foo)
	}