WriterT

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

implicit def catsDataAlternativeForWriterT[F[_], L](implicit F: Alternative[F], L: Monoid[L]): Alternative[[γ$32$]WriterT[F, L, γ$32$]]

implicit def catsDataApplicativeErrorForWriterT[F[_], L, E](implicit F: ApplicativeError[F, E], L: Monoid[L]): ApplicativeError[[γ$31$]WriterT[F, L, γ$31$], E]

implicit def catsDataApplicativeForWriterT[F[_], L](implicit F: Applicative[F], L: Monoid[L]): Applicative[[γ$38$]WriterT[F, L, γ$38$]]

implicit def catsDataApplyForWriterT[F[_], L](implicit F: Apply[F], L: Semigroup[L]): Apply[[γ$39$]WriterT[F, L, γ$39$]]

implicit def catsDataBifunctorForWriterT[F[_]](implicit arg0: Functor[F]): Bifunctor[[β$22$, γ$23$]WriterT[F, β$22$, γ$23$]]

implicit def catsDataCoflatMapForWriterT[F[_], L](implicit F: Functor[F]): CoflatMap[[γ$40$]WriterT[F, L, γ$40$]]

implicit def catsDataCoflatMapForWriterTId[L]: CoflatMap[[γ$28$]WriterT[[A]A, L, γ$28$]]

implicit def catsDataCommutativeMonadForWriterT[F[_], L](implicit F: CommutativeMonad[F], L: CommutativeMonoid[L]): CommutativeMonad[[γ$3$]WriterT[F, L, γ$3$]]

implicit def catsDataContravariantForWriterT[F[_], L](implicit F: Contravariant[F]): Contravariant[[γ$36$]WriterT[F, L, γ$36$]]

implicit def catsDataContravariantMonoidalForWriterT[F[_], L](implicit F: ContravariantMonoidal[F]): ContravariantMonoidal[[γ$33$]WriterT[F, L, γ$33$]]

implicit def catsDataEqForWriterT[F[_], L, V](implicit F: Eq[F[(L, V)]]): Eq[WriterT[F, L, V]]

implicit def catsDataEqForWriterTId[L, V](implicit arg0: Eq[L], arg1: Eq[V]): Eq[WriterT[Id, L, V]]

implicit def catsDataFlatMapForWriterT1[F[_], L](implicit F: FlatMap[F], L: Monoid[L]): FlatMap[[γ$30$]WriterT[F, L, γ$30$]]

implicit def catsDataFlatMapForWriterT2[F[_], L](implicit F: Monad[F], L: Semigroup[L]): FlatMap[[γ$35$]WriterT[F, L, γ$35$]]

implicit def catsDataFlatMapForWriterTId[L](implicit arg0: Semigroup[L]): FlatMap[[γ$29$]WriterT[[A]A, L, γ$29$]]

implicit def catsDataMonadErrorForWriterT[F[_], L, E](implicit F: MonadError[F, E], L: Monoid[L]): MonadError[[γ$5$]WriterT[F, L, γ$5$], E]

implicit def catsDataMonadForWriterT[F[_], L](implicit F: Monad[F], L: Monoid[L]): Monad[[γ$27$]WriterT[F, L, γ$27$]]

implicit def catsDataMonadForWriterTId[L](implicit arg0: Monoid[L]): Monad[[γ$26$]WriterT[[A]A, L, γ$26$]]

implicit def catsDataMonoidForWriterT[F[_], L, V](implicit W: Monoid[F[(L, V)]]): Monoid[WriterT[F, L, V]]

implicit def catsDataMonoidForWriterTId[L, V](implicit arg0: Monoid[L], arg1: Monoid[V]): Monoid[WriterT[Id, L, V]]

implicit def catsDataMonoidKForWriterT[F[_], L](implicit F: MonoidK[F]): MonoidK[[γ$34$]WriterT[F, L, γ$34$]]

implicit def catsDataParallelForWriterT[F[_], M[_], L](implicit arg0: Monoid[L], P: Parallel[M, F]): Parallel[[γ$6$]WriterT[M, L, γ$6$], [γ$7$]WriterT[F, L, γ$7$]]

implicit def catsDataSemigroupForWriterT[F[_], L, V](implicit W: Semigroup[F[(L, V)]]): Semigroup[WriterT[F, L, V]]

implicit def catsDataSemigroupForWriterTId[L, V](implicit arg0: Semigroup[L], arg1: Semigroup[V]): Semigroup[WriterT[Id, L, V]]

implicit def catsDataSemigroupKForWriterT[F[_], L](implicit F: SemigroupK[F]): SemigroupK[[γ$37$]WriterT[F, L, γ$37$]]

implicit def catsDataShowForWriterT[F[_], L, V](implicit F: Show[F[(L, V)]]): Show[WriterT[F, L, V]]

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

def liftF[F[_], L, V](fv: F[V])(implicit monoidL: Monoid[L], F: Applicative[F]): WriterT[F, L, V]

def liftK[F[_], L](implicit monoidL: Monoid[L], F: Applicative[F]): ~>[F, [γ$0$]WriterT[F, L, γ$0$]]

Same as liftF, but expressed as a FunctionK for use with mapK

scala> import cats._, data._, implicits._
scala> val a: OptionT[Eval, Int] = 1.pure[OptionT[Eval, ?]]
scala> val b: OptionT[WriterT[Eval, String, ?], Int] = a.mapK(WriterT.liftK)
scala> b.value.run.value
res0: (String, Option[Int]) = ("",Some(1))

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def put[F[_], L, V](v: V)(l: L)(implicit applicativeF: Applicative[F]): WriterT[F, L, V]

def putT[F[_], L, V](vf: F[V])(l: L)(implicit functorF: Functor[F]): WriterT[F, L, V]

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

def tell[F[_], L](l: L)(implicit applicativeF: Applicative[F]): WriterT[F, L, Unit]

def toString(): String

def value[F[_], L, V](v: V)(implicit applicativeF: Applicative[F], monoidL: Monoid[L]): WriterT[F, L, V]

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

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def lift[F[_], L, V](fv: F[V])(implicit monoidL: Monoid[L], F: Applicative[F]): WriterT[F, L, V]