larsrh

package vanilla

sealed trait Optic[G[_,_] <: Optic[G, _, _], S, A] {
  def compose[F[_, _] <: Optic[F, _, _], B](o: F[A, B])(implicit lub : Lub[G,F]) : lub.T[S, B] =
    lub.compose(self, o)
  def self: G[S,A]
  def desc: List[String]
}

case class Traversal[A,B](desc : List[String]) extends Optic[Traversal,A,B] {

larsrh

{-# LANGUAGE ExistentialQuantification #-}

module Entities where

data Point = TwoD Int Int | ThreeD Int Int Int

class Entity a where
  pos :: a -> Point
  speed :: a -> Int
  id :: a -> String

larsrh

 // ------------------------------------------------------
 // Combined List/Option/Either
 // ------------------------------------------------------
object MonadTransformers extends App {
  import scalaz._
  import scalaz.std.option._
  import scalaz.std.list._

  type OptionTList[α] = OptionT[List, α]

larsrh

The Union Type Quiz
===================



 1. Please describe the guiding principle of your typing approach in one sentence:

    For ADTs, do not (in general) expose the cases as types.

larsrh

import scalaz.std.anyVal._
import scalaz.std.tuple._
import scalaz.std.option._
import scalaz.StateT
import scalaz.State
import scalaz.Trampoline
import scalaz.syntax.traverse._
import scalaz.std.list._
import scalaz.Free

larsrh

import java.net.URI
import scalaz.concurrent.Promise
import scalaz._
import Scalaz._
import language.implicitConversions


case class Cert(cn: String, pubKey: BigInt, webids: List[URI] )

trait RequestHeader {

larsrh

object KleisliValidation extends App {
  import scalaz._
  import Scalaz._
  import scala.util.control.Exception._

  type EEither[+T] = Either[String, T]
  
  def toDouble(s: String): EEither[Double] = allCatch.either(s.toDouble).fold(_.toString.left, _.right)
  def sqrt(d: Double): EEither[Double] = if (d >= 0) math.sqrt(d).right else "sqrt(%s) is too complex for me".format(d).left