final def !=(arg0: Any): Boolean

Definition Classes: AnyRef → Any

final def ##(): Int

Definition Classes: AnyRef → Any

final def ==(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def ap[Z](f: WriterT[F, L, (V) ⇒ Z])(implicit F: Apply[F], L: Semigroup[L]): WriterT[F, L, Z]

Example:

scala> import cats.data.WriterT
scala> import cats.implicits._

scala> val writer: WriterT[Option, String, Int] = WriterT.liftF(Some(123))
scala> val wt: WriterT[Option, String, Int] = writer.tell("error")
res0: WriterT[Option, String, Int] = WriterT(Some((error,123)))

scala> val func = WriterT.liftF[Option, String, Int => List[Int]](Some(i => List(i)))
scala> val func2 = func.tell("log")

scala> wt.ap(func2)
res1: WriterT[Option, String, List[Int]] = WriterT(Some((logerror,List(123))))

final def asInstanceOf[T0]: T0

Definition Classes: Any

def bimap[M, U](f: (L) ⇒ M, g: (V) ⇒ U)(implicit functorF: Functor[F]): WriterT[F, M, U]

Example:

scala> import cats.data.WriterT
scala> import cats.implicits._

scala> val wr1 = WriterT.liftF[Option, String, Int](Some(123)).tell("456")
res0: WriterT[Option, String, Int] = WriterT(Some(456,123))

scala> wr1.bimap(_.toInt, _.show)
res1: WriterT[Option, Int, String] = WriterT(Some((456,123)))

def clone(): AnyRef

Attributes: protected[lang]
Definition Classes: AnyRef
Annotations: @throws( ... ) @native() @IntrinsicCandidate()

def compare(that: WriterT[F, L, V])(implicit Ord: Order[F[(L, V)]]): Int

def contramap[Z](fn: (Z) ⇒ V)(implicit F: Contravariant[F]): WriterT[F, L, Z]

final def eq(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def flatMap[U](f: (V) ⇒ WriterT[F, L, U])(implicit flatMapF: FlatMap[F], semigroupL: Semigroup[L]): WriterT[F, L, U]

Example:

scala> import cats.data.WriterT
scala> import cats.implicits._

scala> val wr1 = WriterT.liftF[Option, String, Int](Some(123)).tell("error")
res0: WriterT[Option, String, Int] = WriterT(Some(error,123))
scala> val func = (i:Int) => WriterT.liftF[Option, String, Int](Some(i * 2)).tell(i.show)

scala> wr1.flatMap(func)
res1: WriterT[Option, String, Int] = WriterT(Some((error123,246)))

def foldLeft[C](c: C)(f: (C, V) ⇒ C)(implicit F: Foldable[F]): C

Example:

scala> import cats.data.WriterT
scala> import cats.implicits._

scala> val writer = WriterT.liftF[Option, String, Int](Some(123)).tell("hi")
scala> writer.foldLeft(456)((acc,v) => acc + v)
res0: Int = 579

def foldRight[C](lc: Eval[C])(f: (V, Eval[C]) ⇒ Eval[C])(implicit F: Foldable[F]): Eval[C]

Example:

scala> import cats.data.WriterT
scala> import cats.Eval
scala> import cats.implicits._

scala> val writer = WriterT.liftF[Option, String, Int](Some(123)).tell("hi")
scala> writer
     |    .foldRight(Eval.now(456))((v,c) => c.map(_ + v))
     |    .value
res0: Int = 579

final def getClass(): Class[_]

Definition Classes: AnyRef → Any
Annotations: @native() @IntrinsicCandidate()

def imap[Z](f: (V) ⇒ Z)(g: (Z) ⇒ V)(implicit F: Invariant[F]): WriterT[F, L, Z]

Example:

scala> import cats.data.WriterT
scala> import cats.implicits._

scala> val wr1: WriterT[Option, String, Int] = WriterT.liftF(Some(123))
scala> val wr2 = wr1.tell("log...")
scala> wr2.imap(_ * 2)(_ / 2)
res0: WriterT[Option, String, Int] = WriterT(Some((log...,246)))

final def isInstanceOf[T0]: Boolean

Definition Classes: Any

def listen(implicit F: Functor[F]): WriterT[F, L, (V, L)]

Example:

scala> import cats.data.WriterT
scala> import cats.implicits._

scala> val writer: WriterT[Option, String, Int] = WriterT.liftF(Some(123))
scala> val wt: WriterT[Option, String, Int] = writer.tell("error").tell(" log")
res0: WriterT[Option, String, Int] = WriterT(Some((error log,123)))

scala> wt.listen
res1: WriterT[Option, String, (Int,String)] = WriterT(Some((error log,(123,error log))))

def map[Z](fn: (V) ⇒ Z)(implicit functorF: Functor[F]): WriterT[F, L, Z]

Example:

scala> import cats.data.WriterT
scala> import cats.implicits._

scala> val wr1: WriterT[Option, String, Int] = WriterT.liftF(None)
scala> val wr2 = wr1.tell("error")
res0: WriterT[Option, String, Int] = WriterT(None)

scala> wr2.map(_ * 2)
res1: WriterT[Option, String, Int] = WriterT(None)

scala> val wr3: WriterT[Option, String, Int] = WriterT.liftF(Some(456))
scala> val wr4 = wr3.tell("error")
scala> wr4.map(_ * 2)
res2: WriterT[Option, String, Int] = WriterT(Some((error,912)))

def mapBoth[M, U](f: (L, V) ⇒ (M, U))(implicit functorF: Functor[F]): WriterT[F, M, U]

Example:

scala> import cats.data.WriterT
scala> import cats.implicits._

scala> val wr1 = WriterT.liftF[Option, String, Int](Some(123)).tell("quack")
res0: WriterT[Option, String, Int] = WriterT(Some(quack,123))

scala> wr1.mapBoth((s,i) => (s + " " + s, i * 2))
res1: WriterT[Option, String, Int] = WriterT(Some((quack quack,246)))

def mapK[G[_]](f: ~>[F, G]): WriterT[G, L, V]

Modify the context F using transformation f.

Example:

scala> import cats.data.WriterT
scala> import cats.arrow.FunctionK
scala> import cats.implicits._

scala> val optionWriter = WriterT.liftF[Option, String, Int](Some(123)).tell("log")
res0: WriterT[Option, String, Int](Some((log,123)))

scala> def toList[A](option: Option[A]): List[A] = option.toList
scala> val listWriter = optionWriter.mapK(FunctionK.lift(toList _))
res1: WriterT[List, String, Int](List((log,123)))

def mapWritten[M](f: (L) ⇒ M)(implicit functorF: Functor[F]): WriterT[F, M, V]

Example:

scala> import cats.data.WriterT
scala> import cats.implicits._

scala> val writer = WriterT.liftF[Option, String, Int](Some(246)).tell("error")
res0: WriterT[Option, String, Int] = WriterT(Some((error,246)))

scala> writer.mapWritten(i => List(i))
res1: WriterT[Option, List[String], Int] = WriterT(Some((List(error),246)))

final def ne(arg0: AnyRef): Boolean

Definition Classes: AnyRef

final def notify(): Unit

Definition Classes: AnyRef
Annotations: @native() @IntrinsicCandidate()

final def notifyAll(): Unit

Definition Classes: AnyRef
Annotations: @native() @IntrinsicCandidate()

def reset(implicit monoidL: Monoid[L], functorF: Functor[F]): WriterT[F, L, V]

Example:

scala> import cats.data.WriterT
scala> import cats.implicits._

scala> val writer = WriterT.liftF[Option, String, Int](Some(123)).tell("error")
scala> writer.reset
res0: WriterT[Option, String, Int] = WriterT(Some((,123)))

val run: F[(L, V)]

def show(implicit F: Show[F[(L, V)]]): String

Example:

scala> import cats.data.WriterT
scala> import cats.implicits._

scala> val writer = WriterT.liftF[Option, String, Int](Some(456)).tell("log...")
scala> writer.show
res0: String = Some((log...,456))

def swap(implicit functorF: Functor[F]): WriterT[F, V, L]

Example:

scala> import cats.data.WriterT
scala> import cats.implicits._

scala> val writer = WriterT.liftF[Option, String, Int](Some(123)).tell("log")
scala> writer.swap
res0: WriterT[Option, Int, String] = WriterT(Some((123,log)))

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

Definition Classes: AnyRef

def tell(l: L)(implicit functorF: Functor[F], semigroupL: Semigroup[L]): WriterT[F, L, V]

Example:

scala> import cats.data.WriterT
scala> import cats.implicits._

scala> val writer = WriterT.liftF[Option, List[String], Int](Some(123))
scala> writer.tell(List("a","b","c")).tell(List("d","e","f"))
res0: WriterT[Option, List[String], Int] = WriterT(Some((List(a, b, c, d, e, f),123)))

def traverse[G[_], V1](f: (V) ⇒ G[V1])(implicit F: Traverse[F], G: Applicative[G]): G[WriterT[F, L, V1]]

Example:

scala> import cats.data.WriterT
scala> import cats.implicits._

scala> val writer = WriterT.liftF[Option, String, Int](Some(123)).tell("hi")
scala> writer.traverse[List,Int](i => List(i))
res0: List[WriterT[Option, String, Int]] = List(WriterT(Some((hi,123))))

def value(implicit functorF: Functor[F]): F[V]

Example:

scala> import cats.data.WriterT
scala> import cats.implicits._

scala> val writer: WriterT[Option, List[String], Int] = WriterT.liftF(Some(123))
scala> val wt: WriterT[Option, List[String], Int] = writer.tell(List("error"))
res0: WriterT[Option, List[String], Int] = WriterT(Some((List(error),123)))

scala> wt.value
res1: Option[Int] = Some(123)

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

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long): Unit

Definition Classes: AnyRef
Annotations: @throws( ... ) @native()

final def wait(): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

def written(implicit functorF: Functor[F]): F[L]

Example:

scala> import cats.data.WriterT
scala> import cats.implicits._

scala> val writer: WriterT[Option, List[String], Int] = WriterT.liftF(Some(123))
scala> writer.tell(List("a","b","c")).written.getOrElse(Nil)
res0: List[String] = List(a, b, c)

Packages

WriterT

Companion object WriterT

final case class WriterT[F[_], L, V](run: F[(L, V)]) extends Product with Serializable

Instance Constructors

Value Members

Deprecated Value Members

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Ungrouped

Packages

WriterT 

Companion object WriterT

final case class WriterT[F[_], L, V](run: F[(L, V)]) extends Product with Serializable

Instance Constructors

Value Members

Deprecated Value Members

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Ungrouped

WriterT