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[[γ$39$]WriterT[F, L, γ$39$]]

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

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

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

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

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

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

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

implicit def catsDataComonadForWriterT[F[_], L](implicit F: Comonad[F]): Comonad[[γ$48$]WriterT[F, L, γ$48$]]

implicit def catsDataComonadForWriterTId[L](implicit F: Comonad[Id]): Comonad[[γ$33$]WriterT[[A]A, L, γ$33$]]

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

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

implicit def catsDataDeferForWriterT[F[_], L](implicit F: Defer[F]): Defer[[γ$6$]WriterT[F, L, γ$6$]]

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[[γ$37$]WriterT[F, L, γ$37$]]

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

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

implicit def catsDataFoldableForWriterT[F[_], L](implicit F: Foldable[F]): Foldable[[γ$31$]WriterT[F, L, γ$31$]]

implicit def catsDataFoldableForWriterTId[L](implicit F: Foldable[Id]): Foldable[[γ$9$]WriterT[[A]A, L, γ$9$]]

implicit def catsDataInvariantForWriterT[F[_], L](implicit F0: Invariant[F]): Invariant[[γ$46$]WriterT[F, L, γ$46$]]

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

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

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

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[[γ$41$]WriterT[F, L, γ$41$]]

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

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[[γ$44$]WriterT[F, L, γ$44$]]

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

implicit def catsDataTraverseForWriterT[F[_], L](implicit F: Traverse[F]): Traverse[[γ$8$]WriterT[F, L, γ$8$]]

implicit def catsDataTraverseForWriterTId[L](implicit F: Traverse[Id]): Traverse[[γ$5$]WriterT[[A]A, L, γ$5$]]

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]