UnwriterT

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

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

def tell[W](w: W): Unwriter[W, Unit]

def toString(): String

def unput[F[_], W, A](value: F[A])(w: W)(implicit F: Functor[F]): UnwriterT[F, W, A]

def unputWith[F[_], W, A](value: F[A])(w: (A) ⇒ W)(implicit F: Functor[F]): UnwriterT[F, W, A]

Puts the written value that is produced by applying the given function into a unwriter transformer and associates with value

def unwriter[W, A](v: (W, A)): Unwriter[W, A]

implicit def unwriterComonad[W]: Comonad[[α]UnwriterT[[+X]X, W, α]]

implicit def unwriterEqual[W, A](implicit W: Equal[W], A: Equal[A]): Equal[Unwriter[W, A]]

def unwriterT[F[_], W, A](v: F[(W, A)]): UnwriterT[F, W, A]

implicit def unwriterTApply[F[_], W](implicit F0: Apply[F]): Apply[[α]UnwriterT[F, W, α]]

implicit def unwriterTBifunctor[F[_]](implicit F0: Functor[F]): Bifunctor[[α, β]UnwriterT[F, α, β]]

implicit def unwriterTBind[F[_], W](implicit F0: Bind[F]): Bind[[α]UnwriterT[F, W, α]]

implicit def unwriterTBitraverse[F[_]](implicit F0: Traverse[F]): Bitraverse[[α, β]UnwriterT[F, α, β]]

implicit def unwriterTEqual[F[_], W, A](implicit E: Equal[F[(W, A)]]): Equal[UnwriterT[F, W, A]]

implicit def unwriterTFoldable[F[_], W](implicit F0: Foldable[F]): Foldable[[α]UnwriterT[F, W, α]]

implicit def unwriterTFunctor[F[_], W](implicit F0: Functor[F]): Functor[[α]UnwriterT[F, W, α]]

implicit def unwriterTTraverse[F[_], W](implicit F0: Traverse[F]): Traverse[[α]UnwriterT[F, W, α]]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

implicit def unwriterTEach[F[_], W](implicit F0: Each[F]): Each[[α]UnwriterT[F, W, α]]

implicit def unwriterTIndex[W]: Index[[α]UnwriterT[[+X]X, W, α]]