julien-truffaut

abstract class Equal[T]{
  def eq(v1: T, v2: T): Boolean
}

object Equal{
  def apply[T](implicit ev: Equal[T]): Equal[T] = ev
  def equalA[T]: Equal[T] = new Equal[T] {
    def eq(v1: T, v2: T): Boolean = v1 == v2
  }

julien-truffaut

sealed trait Foo

case class A(i: Int) extends Foo
case class B(x: Double, y: Double) extends Foo
case object C extends Foo

// 1st option:

GenPrism[Foo, A]: Prism[Foo, A]

julien-truffaut

import java.net.InetSocketAddress
import scalaz.concurrent.Task
import scalaz.stream.tcp
import java.util.concurrent.Executors

object TcpServerApp extends App {

  val executor  = Executors.newSingleThreadExecutor
  implicit val S = scalaz.concurrent.Strategy.DefaultStrategy
  implicit val AG = tcp.DefaultAsynchronousChannelGroup

julien-truffaut

import monocle._ Monocle._

case class Order(name: String, articles: List[Article])
case class Article(properties: Map[String, String])

val order = Order("name", List(Article(Map("name" -> "door", "colour" -> "red")), Article(Map("name" -> "shoes"))))

val _articles = Lenser[Order](_.articles)
val _properties = SimpleIso[Article, Map[String, String]](_.properties, Article(_))

julien-truffaut

Method	Current Aliases	New Aliases
composeTraversal	|->>	^|->>
composeOptional	|-?	^|-?
composePrism	<-?	^<-?
composeLens	|->	^|->
composeIso	<->	^<->
applyTraversal	|->>	^^|->>
applyOptional	|-?	^^|-?
applyPrism	<-?	^^<-?

julien-truffaut

package monocle

import scala.concurrent.Future


case class State[S, A](f: S => (S, A)) {

  def apply(s: S): (S, A) = f(s)

  def map[B](g: A => B): State[S, B] = State[S, B] { s =>