functors.scala

package com.nicta
package jdbc

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

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

  def fold[X](n: => X, v: A => X): X =
    this match {
      case Null_?() =>
        n
      case Value_?(a) =>
        v(a)
    }

  def map[B](f: A => B): ?[B] =
    flatMap(a => ?(f(a)))

  def flatMap[B](f: A => ?[B]): ?[B] =
    fold(nul[B], f)

  def filter(p: A => Boolean): ?[A] =
    fold(nul[A], a => if(p(a)) ?(a) else nul[A])

  def ap[B](f: ?[A => B]): ?[B] =
    for {
      g <- f
      a <- this
    } yield g(a)

  def zip[B](x: ?[B]): ?[(A, B)] =
    for {
      a <- this
      b <- x
    } yield (a, b)

  def or(x: => ?[A]): ?[A] =
    fold(x, ?(_))

  def |(x: => ?[A]): ?[A] =
    or(x)

  def coflatMap[B](f: ?[A] => B): ?[B] =
    map(a => f(?(a)))

  def duplicate: ?[?[A]] =
    coflatMap(identity)

  def isNull: Boolean =
    fold(true, _ => false)

  def isValue: Boolean =
    !isNull

  def exists(p: A => Boolean): Boolean =
    fold(false, p)

  def forall(p: A => Boolean): Boolean =
    fold(true, p)

  def toList: List[A] =
    fold(Nil, List(_))

  def pextract[B]: ?[B] \/ A =
    fold(nul[B].left, _.right)
}
private case class Null_?[A]() extends ?[A]
private case class Value_?[A](a: A) extends ?[A]

object ? {
  def apply[A](a: A): ?[A] =
    Value_?(a)

  def nul[A](): ?[A] =
    Null_?()

  def unzip[A, B](x: ?[(A, B)]): (?[A], ?[B]) =
    x.fold((nul[A](), nul[B]()), ab => (?(ab._1), ?(ab._2)))

  def flatten[A](x: ?[?[A]]): ?[A] =
    x flatMap identity
}

// SQLException + A
sealed trait /[A] {
  import /._

  def fold[X](x: SQLException => X, v: A => X): X =
    this match {
      case SQLException_/(e) =>
        x(e)
      case Value_/(a) =>
        v(a)
    }

  def map[B](f: A => B): /[B] =
    flatMap(a => /(f(a)))

  def flatMap[B](f: A => /[B]): /[B] =
    fold(exception[B], f)

  def ap[B](f: /[A => B]): /[B] =
    for {
      g <- f
      a <- this
    } yield g(a)

  def zip[B](x: /[B]): /[(A, B)] =
    for {
      a <- this
      b <- x
    } yield (a, b)

  def or(x: => /[A]): /[A] =
    fold(_ => x, /(_))

  def |(x: => /[A]): /[A] =
    or(x)

  def coflatMap[B](f: /[A] => B): /[B] =
    map(a => f(/(a)))

  def duplicate: /[/[A]] =
    coflatMap(identity)

  def isException: Boolean =
    fold(_ => true, _ => false)

  def isValue: Boolean =
    !isException

  def exists(p: A => Boolean): Boolean =
    fold(_ => false, p)

  def forall(p: A => Boolean): Boolean =
    fold(_ => true, p)

  def toList: List[A] =
    fold(_ => Nil, List(_))

  def ? : ?[A] =
    fold(_ => com.nicta.jdbc.?.nul[A], com.nicta.jdbc.?(_))
}
private case class SQLException_/[A](e: SQLException) extends /[A]
private case class Value_/[A](a: A) extends /[A]

object / {
  def apply[A](a: A): /[A] =
    Value_/(a)

  def exception[A](e: SQLException): /[A] =
    SQLException_/(e)

  def flatten[A](x: /[/[A]]): /[A] =
    x flatMap identity
}

// InvariantNotMet + A
sealed trait ^[A] {
  import ^._

  def fold[X](x: InvariantNotMet => X, v: A => X): X =
    this match {
      case InvariantNotMet_^(q) =>
        x(q)
      case Value_^(a) =>
        v(a)
    }

  def map[B](f: A => B): ^[B] =
    flatMap(a => ^(f(a)))

  def flatMap[B](f: A => ^[B]): ^[B] =
    fold(invnotmet[B], f)

  def ap[B](f: ^[A => B]): ^[B] =
    for {
      g <- f
      a <- this
    } yield g(a)

  def zip[B](x: ^[B]): ^[(A, B)] =
    for {
      a <- this
      b <- x
    } yield (a, b)

  def or(x: => ^[A]): ^[A] =
      fold(_ => x, ^(_))

  def |(x: => ^[A]): ^[A] =
    or(x)

  def coflatMap[B](f: ^[A] => B): ^[B] =
      map(a => f(^(a)))

  def duplicate: ^[^[A]] =
    coflatMap(identity)

  def isInvnotmet: Boolean =
    fold(_ => true, _ => false)

  def isValue: Boolean =
    !isInvnotmet

  def exists(p: A => Boolean): Boolean =
    fold(_ => false, p)

  def forall(p: A => Boolean): Boolean =
    fold(_ => true, p)

  def toList: List[A] =
    fold(_ => Nil, List(_))

  def ? : ?[A] =
    fold(_ => com.nicta.jdbc.?.nul[A], com.nicta.jdbc.?(_))
}
private case class InvariantNotMet_^[A](x: InvariantNotMet) extends ^[A]
private case class Value_^[A](a: A) extends ^[A]

object ^ {
  def apply[A](a: A): ^[A] =
    Value_^(a)

  def invnotmet[A](e: InvariantNotMet): ^[A] =
    InvariantNotMet_^(e)

  def flatten[A](x: ^[^[A]]): ^[A] =
    x flatMap identity
}

sealed trait *[A] {
  val free: Free[*!, A]

  def map[B](f: A => B): *[B] =
    *(free map f)

  def flatMap[B](f: A => *[B]): *[B] =
    *(free flatMap (f(_).free))

  def ap[X](f: *[A => X]): *[X] =
    for {
      ff <- f
      aa <- this
    } yield ff(aa)

  def zip[B](x: *[B]): *[(A, B)] =
    for {
      a <- this
      b <- x
    } yield (a, b)
}

object * {
  private[jdbc] def apply[A](x: Free[*!, A]): *[A] =
    new *[A] {
      val free = x
    }
}

sealed trait *![A] {
  def map[B](f: A => B): *![B] =
    error("todo")
}

// /[?[A]]
// SQLException + 1 + A
sealed trait /?[A] {
  val value: /[?[A]]

  def fold[X](e: SQLException => X, n: => X, v: A => X): X =
    value.fold(e, _.fold(n, v))

  def map[B](f: A => B): /?[B] =
    flatMap(a => /?(f(a)))

  def flatMap[B](f: A => /?[B]): /?[B] =
    /?./?(value.flatMap(_.fold(
      /(?.nul[B])
    , a => f(a).value
    )))

  def ap[B](f: /?[A => B]): /?[B] =
    for {
      g <- f
      a <- this
    } yield g(a)

  def zip[B](x: /?[B]): /?[(A, B)] =
    for {
      a <- this
      b <- x
    } yield (a, b)

  def or(x: => /?[A]): /?[A] =
    fold(_ => x, x, /?(_))

  def |(x: => /?[A]): /?[A] =
    or(x)

  def coflatMap[B](f: /?[A] => B): /?[B] =
    map(a => f(/?(a)))

  def duplicate: /?[/?[A]] =
    coflatMap(identity)

  def isNull: Boolean =
    fold(_ => false, true, _ => false)

  def isException: Boolean =
    fold(_ => true, false, _ => false)

  def isValue: Boolean =
    fold(_ => false, false, _ => true)

  def exists(p: A => Boolean): Boolean =
    fold(_ => false, false, p)

  def forall(p: A => Boolean): Boolean =
    fold(_ => true, true, p)

  def toList: List[A] =
    fold(_ => Nil, Nil, List(_))
}

object /? {
  private[jdbc] def /?[A](x: /[?[A]]): /?[A] =
    new /?[A] {
      val value = x
    }

  def apply[A](a: A): /?[A] =
    /?(/(?(a)))

  def nul[A](): /?[A] =
    /?(/(?.nul[A]))

  def exception[A](e: SQLException): /?[A] =
    /?(/.exception[?[A]](e))
}

// ^[?[A]]
// InvariantNotMet + 1 + A
sealed trait ^?[A] {
  val value: ^[?[A]]
  
  def fold[X](e: InvariantNotMet => X, n: => X, v: A => X): X =
    value.fold(e, _.fold(n, v))

  def map[B](f: A => B): ^?[B] =
    flatMap(a => ^?(f(a)))

  def flatMap[B](f: A => ^?[B]): ^?[B] =
    ^?.^?(value.flatMap(_.fold(
      ^(?.nul[B])
    , a => f(a).value
    )))

  def ap[B](f: ^?[A => B]): ^?[B] =
    for {
      g <- f
      a <- this
    } yield g(a)

  def zip[B](x: ^?[B]): ^?[(A, B)] =
    for {
      a <- this
      b <- x
    } yield (a, b)

  def or(x: => ^?[A]): ^?[A] =
    fold(_ => x, x, ^?(_))

  def |(x: => ^?[A]): ^?[A] =
    or(x)

  def coflatMap[B](f: ^?[A] => B): ^?[B] =
    map(a => f(^?(a)))

  def duplicate: ^?[^?[A]] =
    coflatMap(identity)

  def isNull: Boolean =
    fold(_ => false, true, _ => false)

  def isInvnotmet: Boolean =
    fold(_ => true, false, _ => false)

  def isValue: Boolean =
    fold(_ => false, false, _ => true)

  def exists(p: A => Boolean): Boolean =
    fold(_ => false, false, p)

  def forall(p: A => Boolean): Boolean =
    fold(_ => true, true, p)

  def toList: List[A] =
    fold(_ => Nil, Nil, List(_))
}

object ^? {
  private[jdbc] def ^?[A](x: ^[?[A]]): ^?[A] =
    new ^?[A] {
      val value = x
    }

  def apply[A](a: A): ^?[A] =
    ^?(^(?(a)))

  def nul[A](): ^?[A] =
    ^?(^(?.nul[A]))

  def invnotmet[A](x: InvariantNotMet): ^?[A] =
    ^?(^.invnotmet[?[A]](x))
}

// *[?[A]]
// *[1 + A]
sealed trait *?[A] {
  val value: *[?[A]]
}

// /[^[A]]
// SQLException + InvariantNotMet + A
sealed trait /^[A] {
  val value: /[^[A]]
}

// /[^[?[A]]]
// SQLException + InvariantNotMet + 1 + A
sealed trait /^?[A] {
  val value: /[^[?[A]]]
}

// *[/[A]]
// *[SQLException + A]
sealed trait */[A] {
  val value: *[/[A]]
}

// *[^[A]]
// *[InvariantNotMet + A]
sealed trait *^[A] {
  val value: *[^[A]]
}

// *[/[?[A]]]
// *[SQLException + 1 + A]
sealed trait */?[A] {
  val value: *[/[?[A]]]
}

// *[^[?[A]]]
// *[InvariantNotMet + 1 + A]
sealed trait *^?[A] {
  val value: *[^[?[A]]]
}

// *[/[^[A]]]
// *[SQLException + InvariantNotMet + A]
sealed trait */^[A] {
  val value: *[/[^[A]]]
}

// *[/[^[?[A]]]]
// *[SQLException + InvariantNotMet + 1 + A]
sealed trait */^?[A] {
  val value: *[/[^[?[A]]]]
}