Comonad

abstract def coflatMap[A, B](fa: F[A])(f: (F[A]) ⇒ B): F[B]

abstract def extract[A](x: F[A]): A

abstract def map[A, B](fa: F[A])(f: (A) ⇒ B): F[B]

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def as[A, B](fa: F[A], b: B): F[B]

Replaces the A value in F[A] with the supplied value.

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def coflatten[A](fa: F[A]): F[F[A]]

def compose[G[_]](implicit GG: Functor[G]): Functor[[X]F[G[X]]]

Compose this functor F with a functor G to produce a composite Functor on G[F[_]], with a map method which uses an A => B to map a G[F[A]] to a G[F[B]].

def compose[G[_]](implicit arg0: Invariant[G], GG: Invariant[G]): Invariant[[X]F[G[X]]]

Compose 2 invariant Functors F and G to get a new Invariant Functor for F[G[_]].

def composeWithContravariant[G[_]](implicit GG: Contravariant[G]): Contravariant[[X]F[G[X]]]

Compose this functor F with a Contravariant Functor G to produce a new Contravariant Functor on F[G[_]].

def composeWithFunctor[G[_]](implicit arg0: Functor[G]): Functor[[X]F[G[X]]]

Compose the Invariant Functor F with a normal (Covariant) Functor to get a new Invariant Functor for [F[G[_]].

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def fproduct[A, B](fa: F[A])(f: (A) ⇒ B): F[(A, B)]

Tuple the values in fa with the result of applying a function with the value

final def getClass(): Class[_]

def hashCode(): Int

def imap[A, B](fa: F[A])(f: (A) ⇒ B)(fi: (B) ⇒ A): F[B]

final def isInstanceOf[T0]: Boolean

def lift[A, B](f: (A) ⇒ B): (F[A]) ⇒ F[B]

Lift a function f to operate on Functors

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def void[A](fa: F[A]): F[Unit]

Empty the fa of the values, preserving the structure

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit