trait MonadTell[F[_, _], W] extends Monad[[α]F[W, α]]
The class of monads supporting write operations
- Source
- MonadTell.scala
- Alphabetic
- By Inheritance
- MonadTell
- Monad
- Bind
- Applicative
- Apply
- Functor
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
trait
ApplicativeLaw
extends FunctorLaw
- Definition Classes
- Applicative
-
trait
FunctorLaw
extends AnyRef
- Definition Classes
- Functor
-
trait
MonadLaw
extends ApplicativeLaw
- Definition Classes
- Monad
Abstract Value Members
-
abstract
def
bind[A, B](fa: F[W, A])(f: (A) ⇒ F[W, B]): F[W, B]
Equivalent to
join(map(fa)(f))
.Equivalent to
join(map(fa)(f))
.- Definition Classes
- Bind
-
abstract
def
point[A](a: ⇒ A): F[W, A]
- Definition Classes
- Applicative
- abstract def writer[A](w: W, v: A): F[W, A]
Concrete Value Members
-
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[A, B](fa: ⇒ F[W, A])(f: ⇒ F[W, (A) ⇒ B]): F[W, B]
Sequence
f
, thenfa
, combining their results by function application.Sequence
f
, thenfa
, combining their results by function application.NB: with respect to
apply2
and all other combinators, as well as scalaz.Bind, thef
action appears to the *left*. Sof
should be the "first"F
-action to perform. This is in accordance with all other implementations of this typeclass in common use, which are "function first". -
def
ap2[A, B, C](fa: ⇒ F[W, A], fb: ⇒ F[W, B])(f: F[W, (A, B) ⇒ C]): F[W, C]
- Definition Classes
- Apply
-
def
ap3[A, B, C, D](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: ⇒ F[W, C])(f: F[W, (A, B, C) ⇒ D]): F[W, D]
- Definition Classes
- Apply
-
def
ap4[A, B, C, D, E](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: ⇒ F[W, C], fd: ⇒ F[W, D])(f: F[W, (A, B, C, D) ⇒ E]): F[W, E]
- Definition Classes
- Apply
-
def
ap5[A, B, C, D, E, R](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: ⇒ F[W, C], fd: ⇒ F[W, D], fe: ⇒ F[W, E])(f: F[W, (A, B, C, D, E) ⇒ R]): F[W, R]
- Definition Classes
- Apply
-
def
ap6[A, B, C, D, E, FF, R](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: ⇒ F[W, C], fd: ⇒ F[W, D], fe: ⇒ F[W, E], ff: ⇒ F[W, FF])(f: F[W, (A, B, C, D, E, FF) ⇒ R]): F[W, R]
- Definition Classes
- Apply
-
def
ap7[A, B, C, D, E, FF, G, R](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: ⇒ F[W, C], fd: ⇒ F[W, D], fe: ⇒ F[W, E], ff: ⇒ F[W, FF], fg: ⇒ F[W, G])(f: F[W, (A, B, C, D, E, FF, G) ⇒ R]): F[W, R]
- Definition Classes
- Apply
-
def
ap8[A, B, C, D, E, FF, G, H, R](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: ⇒ F[W, C], fd: ⇒ F[W, D], fe: ⇒ F[W, E], ff: ⇒ F[W, FF], fg: ⇒ F[W, G], fh: ⇒ F[W, H])(f: F[W, (A, B, C, D, E, FF, G, H) ⇒ R]): F[W, R]
- Definition Classes
- Apply
-
def
apF[A, B](f: ⇒ F[W, (A) ⇒ B]): (F[W, A]) ⇒ F[W, B]
Flipped variant of
ap
.Flipped variant of
ap
.- Definition Classes
- Apply
-
def
applicativeLaw: ApplicativeLaw
- Definition Classes
- Applicative
-
val
applicativeSyntax: ApplicativeSyntax[[α]F[W, α]]
- Definition Classes
- Applicative
-
def
apply[A, B](fa: F[W, A])(f: (A) ⇒ B): F[W, B]
Alias for
map
.Alias for
map
.- Definition Classes
- Functor
-
def
apply10[A, B, C, D, E, FF, G, H, I, J, R](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: ⇒ F[W, C], fd: ⇒ F[W, D], fe: ⇒ F[W, E], ff: ⇒ F[W, FF], fg: ⇒ F[W, G], fh: ⇒ F[W, H], fi: ⇒ F[W, I], fj: ⇒ F[W, J])(f: (A, B, C, D, E, FF, G, H, I, J) ⇒ R): F[W, R]
- Definition Classes
- Apply
-
def
apply11[A, B, C, D, E, FF, G, H, I, J, K, R](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: ⇒ F[W, C], fd: ⇒ F[W, D], fe: ⇒ F[W, E], ff: ⇒ F[W, FF], fg: ⇒ F[W, G], fh: ⇒ F[W, H], fi: ⇒ F[W, I], fj: ⇒ F[W, J], fk: ⇒ F[W, K])(f: (A, B, C, D, E, FF, G, H, I, J, K) ⇒ R): F[W, R]
- Definition Classes
- Apply
-
def
apply12[A, B, C, D, E, FF, G, H, I, J, K, L, R](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: ⇒ F[W, C], fd: ⇒ F[W, D], fe: ⇒ F[W, E], ff: ⇒ F[W, FF], fg: ⇒ F[W, G], fh: ⇒ F[W, H], fi: ⇒ F[W, I], fj: ⇒ F[W, J], fk: ⇒ F[W, K], fl: ⇒ F[W, L])(f: (A, B, C, D, E, FF, G, H, I, J, K, L) ⇒ R): F[W, R]
- Definition Classes
- Apply
-
def
apply2[A, B, C](fa: ⇒ F[W, A], fb: ⇒ F[W, B])(f: (A, B) ⇒ C): F[W, C]
- Definition Classes
- Applicative → Apply
-
def
apply3[A, B, C, D](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: ⇒ F[W, C])(f: (A, B, C) ⇒ D): F[W, D]
- Definition Classes
- Apply
-
def
apply4[A, B, C, D, E](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: ⇒ F[W, C], fd: ⇒ F[W, D])(f: (A, B, C, D) ⇒ E): F[W, E]
- Definition Classes
- Apply
-
def
apply5[A, B, C, D, E, R](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: ⇒ F[W, C], fd: ⇒ F[W, D], fe: ⇒ F[W, E])(f: (A, B, C, D, E) ⇒ R): F[W, R]
- Definition Classes
- Apply
-
def
apply6[A, B, C, D, E, FF, R](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: ⇒ F[W, C], fd: ⇒ F[W, D], fe: ⇒ F[W, E], ff: ⇒ F[W, FF])(f: (A, B, C, D, E, FF) ⇒ R): F[W, R]
- Definition Classes
- Apply
-
def
apply7[A, B, C, D, E, FF, G, R](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: ⇒ F[W, C], fd: ⇒ F[W, D], fe: ⇒ F[W, E], ff: ⇒ F[W, FF], fg: ⇒ F[W, G])(f: (A, B, C, D, E, FF, G) ⇒ R): F[W, R]
- Definition Classes
- Apply
-
def
apply8[A, B, C, D, E, FF, G, H, R](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: ⇒ F[W, C], fd: ⇒ F[W, D], fe: ⇒ F[W, E], ff: ⇒ F[W, FF], fg: ⇒ F[W, G], fh: ⇒ F[W, H])(f: (A, B, C, D, E, FF, G, H) ⇒ R): F[W, R]
- Definition Classes
- Apply
-
def
apply9[A, B, C, D, E, FF, G, H, I, R](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: ⇒ F[W, C], fd: ⇒ F[W, D], fe: ⇒ F[W, E], ff: ⇒ F[W, FF], fg: ⇒ F[W, G], fh: ⇒ F[W, H], fi: ⇒ F[W, I])(f: (A, B, C, D, E, FF, G, H, I) ⇒ R): F[W, R]
- Definition Classes
- Apply
-
val
applySyntax: ApplySyntax[[α]F[W, α]]
- Definition Classes
- Apply
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
val
bindSyntax: BindSyntax[[α]F[W, α]]
- Definition Classes
- Bind
-
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
def
compose[G[_]](implicit G0: Applicative[G]): Applicative[[α]F[W, G[α]]]
The composition of Applicatives
F
andG
,[x]F[G[x]]
, is an ApplicativeThe composition of Applicatives
F
andG
,[x]F[G[x]]
, is an Applicative- Definition Classes
- Applicative
-
def
compose[G[_]](implicit G0: Apply[G]): Apply[[α]F[W, G[α]]]
The composition of Applys
F
andG
,[x]F[G[x]]
, is a ApplyThe composition of Applys
F
andG
,[x]F[G[x]]
, is a Apply- Definition Classes
- Apply
-
def
compose[G[_]](implicit G0: Functor[G]): Functor[[α]F[W, G[α]]]
The composition of Functors
F
andG
,[x]F[G[x]]
, is a FunctorThe composition of Functors
F
andG
,[x]F[G[x]]
, is a Functor- Definition Classes
- Functor
-
def
counzip[A, B](a: \/[F[W, A], F[W, B]]): F[W, \/[A, B]]
- Definition Classes
- Functor
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
def
filterM[A](l: List[A])(f: (A) ⇒ F[W, Boolean]): F[W, List[A]]
Filter
l
according to an applicative predicate.Filter
l
according to an applicative predicate.- Definition Classes
- Applicative
-
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
-
def
flip: Applicative[[α]F[W, α]]
An
Applicative
forF
in which effects happen in the opposite order.An
Applicative
forF
in which effects happen in the opposite order.- Definition Classes
- Applicative
-
def
fpair[A](fa: F[W, A]): F[W, (A, A)]
Twin all
A
s infa
.Twin all
A
s infa
.- Definition Classes
- Functor
-
def
fproduct[A, B](fa: F[W, A])(f: (A) ⇒ B): F[W, (A, B)]
Pair all
A
s infa
with the result of function application.Pair all
A
s infa
with the result of function application.- Definition Classes
- Functor
-
def
functorLaw: FunctorLaw
- Definition Classes
- Functor
-
val
functorSyntax: FunctorSyntax[[α]F[W, α]]
- Definition Classes
- Functor
-
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
-
def
ifM[B](value: F[W, Boolean], ifTrue: ⇒ F[W, B], ifFalse: ⇒ F[W, B]): F[W, B]
if
lifted into a binding.if
lifted into a binding. Unlikelift3((t,c,a)=>if(t)c else a)
, this will only include context from the chosen ofifTrue
andifFalse
, not the other.- Definition Classes
- Bind
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
join[A](ffa: F[W, F[W, A]]): F[W, A]
Sequence the inner
F
ofFFA
after the outerF
, forming a singleF[A]
.Sequence the inner
F
ofFFA
after the outerF
, forming a singleF[A]
.- Definition Classes
- Bind
-
def
lift[A, B](f: (A) ⇒ B): (F[W, A]) ⇒ F[W, B]
Lift
f
intoF
.Lift
f
intoF
.- Definition Classes
- Functor
-
def
lift10[A, B, C, D, E, FF, G, H, I, J, R](f: (A, B, C, D, E, FF, G, H, I, J) ⇒ R): (F[W, A], F[W, B], F[W, C], F[W, D], F[W, E], F[W, FF], F[W, G], F[W, H], F[W, I], F[W, J]) ⇒ F[W, R]
- Definition Classes
- Apply
-
def
lift11[A, B, C, D, E, FF, G, H, I, J, K, R](f: (A, B, C, D, E, FF, G, H, I, J, K) ⇒ R): (F[W, A], F[W, B], F[W, C], F[W, D], F[W, E], F[W, FF], F[W, G], F[W, H], F[W, I], F[W, J], F[W, K]) ⇒ F[W, R]
- Definition Classes
- Apply
-
def
lift12[A, B, C, D, E, FF, G, H, I, J, K, L, R](f: (A, B, C, D, E, FF, G, H, I, J, K, L) ⇒ R): (F[W, A], F[W, B], F[W, C], F[W, D], F[W, E], F[W, FF], F[W, G], F[W, H], F[W, I], F[W, J], F[W, K], F[W, L]) ⇒ F[W, R]
- Definition Classes
- Apply
-
def
lift2[A, B, C](f: (A, B) ⇒ C): (F[W, A], F[W, B]) ⇒ F[W, C]
- Definition Classes
- Apply
-
def
lift3[A, B, C, D](f: (A, B, C) ⇒ D): (F[W, A], F[W, B], F[W, C]) ⇒ F[W, D]
- Definition Classes
- Apply
-
def
lift4[A, B, C, D, E](f: (A, B, C, D) ⇒ E): (F[W, A], F[W, B], F[W, C], F[W, D]) ⇒ F[W, E]
- Definition Classes
- Apply
-
def
lift5[A, B, C, D, E, R](f: (A, B, C, D, E) ⇒ R): (F[W, A], F[W, B], F[W, C], F[W, D], F[W, E]) ⇒ F[W, R]
- Definition Classes
- Apply
-
def
lift6[A, B, C, D, E, FF, R](f: (A, B, C, D, E, FF) ⇒ R): (F[W, A], F[W, B], F[W, C], F[W, D], F[W, E], F[W, FF]) ⇒ F[W, R]
- Definition Classes
- Apply
-
def
lift7[A, B, C, D, E, FF, G, R](f: (A, B, C, D, E, FF, G) ⇒ R): (F[W, A], F[W, B], F[W, C], F[W, D], F[W, E], F[W, FF], F[W, G]) ⇒ F[W, R]
- Definition Classes
- Apply
-
def
lift8[A, B, C, D, E, FF, G, H, R](f: (A, B, C, D, E, FF, G, H) ⇒ R): (F[W, A], F[W, B], F[W, C], F[W, D], F[W, E], F[W, FF], F[W, G], F[W, H]) ⇒ F[W, R]
- Definition Classes
- Apply
-
def
lift9[A, B, C, D, E, FF, G, H, I, R](f: (A, B, C, D, E, FF, G, H, I) ⇒ R): (F[W, A], F[W, B], F[W, C], F[W, D], F[W, E], F[W, FF], F[W, G], F[W, H], F[W, I]) ⇒ F[W, R]
- Definition Classes
- Apply
-
def
map[A, B](fa: F[W, A])(f: (A) ⇒ B): F[W, B]
Lift
f
intoF
and apply toF[A]
.Lift
f
intoF
and apply toF[A]
.- Definition Classes
- Monad → Applicative → Functor
-
def
mapply[A, B](a: A)(f: F[W, (A) ⇒ B]): F[W, B]
Lift
apply(a)
, and apply the result tof
.Lift
apply(a)
, and apply the result tof
.- Definition Classes
- Functor
-
def
monadLaw: MonadLaw
- Definition Classes
- Monad
-
val
monadSyntax: MonadSyntax[[α]F[W, α]]
- Definition Classes
- Monad
- val monadTellSyntax: MonadTellSyntax[F, W]
-
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
-
def
product[G[_]](implicit G0: Applicative[G]): Applicative[[α](F[W, α], G[α])]
The product of Applicatives
F
andG
,[x](F[x], G[x]])
, is an ApplicativeThe product of Applicatives
F
andG
,[x](F[x], G[x]])
, is an Applicative- Definition Classes
- Applicative
-
def
product[G[_]](implicit G0: Apply[G]): Apply[[α](F[W, α], G[α])]
The product of Applys
F
andG
,[x](F[x], G[x]])
, is a ApplyThe product of Applys
F
andG
,[x](F[x], G[x]])
, is a Apply- Definition Classes
- Apply
-
def
product[G[_]](implicit G0: Functor[G]): Functor[[α](F[W, α], G[α])]
The product of Functors
F
andG
,[x](F[x], G[x]])
, is a FunctorThe product of Functors
F
andG
,[x](F[x], G[x]])
, is a Functor- Definition Classes
- Functor
-
def
pure[A](a: ⇒ A): F[W, A]
- Definition Classes
- Applicative
-
def
replicateM[A](n: Int, fa: F[W, A]): F[W, List[A]]
Performs the action
n
times, returning the list of results.Performs the action
n
times, returning the list of results.- Definition Classes
- Applicative
-
def
replicateM_[A](n: Int, fa: F[W, A]): F[W, Unit]
Performs the action
n
times, returning nothing.Performs the action
n
times, returning nothing.- Definition Classes
- Applicative
-
def
sequence[A, G[_]](as: G[F[W, A]])(implicit arg0: Traverse[G]): F[W, G[A]]
- Definition Classes
- Applicative
-
def
sequence1[A, G[_]](as: G[F[W, A]])(implicit arg0: Traverse1[G]): F[W, G[A]]
- Definition Classes
- Apply
-
def
strengthL[A, B](a: A, f: F[W, B]): F[W, (A, B)]
Inject
a
to the left ofB
s inf
.Inject
a
to the left ofB
s inf
.- Definition Classes
- Functor
-
def
strengthR[A, B](f: F[W, A], b: B): F[W, (A, B)]
Inject
b
to the right ofA
s inf
.Inject
b
to the right ofA
s inf
.- Definition Classes
- Functor
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
- def tell(w: W): F[W, Unit]
-
def
toString(): String
- Definition Classes
- AnyRef → Any
-
def
traverse[A, G[_], B](value: G[A])(f: (A) ⇒ F[W, B])(implicit G: Traverse[G]): F[W, G[B]]
- Definition Classes
- Applicative
-
def
traverse1[A, G[_], B](value: G[A])(f: (A) ⇒ F[W, B])(implicit G: Traverse1[G]): F[W, G[B]]
- Definition Classes
- Apply
-
def
tuple2[A, B](fa: ⇒ F[W, A], fb: ⇒ F[W, B]): F[W, (A, B)]
- Definition Classes
- Apply
-
def
tuple3[A, B, C](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: F[W, C]): F[W, (A, B, C)]
- Definition Classes
- Apply
-
def
tuple4[A, B, C, D](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: ⇒ F[W, C], fd: ⇒ F[W, D]): F[W, (A, B, C, D)]
- Definition Classes
- Apply
-
def
tuple5[A, B, C, D, E](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: ⇒ F[W, C], fd: ⇒ F[W, D], fe: ⇒ F[W, E]): F[W, (A, B, C, D, E)]
- Definition Classes
- Apply
-
def
void[A](fa: F[W, A]): F[W, Unit]
Empty
fa
of meaningful pure values, preserving its structure.Empty
fa
of meaningful pure values, preserving its structure.- Definition Classes
- Functor
-
final
def
wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
Deprecated Value Members
-
def
map2[A, B, C](fa: ⇒ F[W, A], fb: ⇒ F[W, B])(f: (A, B) ⇒ C): F[W, C]
- Definition Classes
- Apply
- Annotations
- @deprecated
- Deprecated
(Since version 7) given
F: Apply[F]
useF.apply2(a,b)(f)
instead, or givenimplicitly[Apply[F]]
, use^(a,b)(f)
-
def
map3[A, B, C, D](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: ⇒ F[W, C])(f: (A, B, C) ⇒ D): F[W, D]
- Definition Classes
- Apply
- Annotations
- @deprecated
- Deprecated
(Since version 7) given
F: Apply[F]
useF.apply3(a,b,c)(f)
instead, or givenimplicitly[Apply[F]]
, use^^(a,b,c)(f)
-
def
map4[A, B, C, D, E](fa: ⇒ F[W, A], fb: ⇒ F[W, B], fc: ⇒ F[W, C], fd: ⇒ F[W, D])(f: (A, B, C, D) ⇒ E): F[W, E]
- Definition Classes
- Apply
- Annotations
- @deprecated
- Deprecated
(Since version 7) given
F: Apply[F]
useF.apply4(a,b,c,d)(f)
instead, or givenimplicitly[Apply[F]]
, use^^^(a,b,c,d)(f)
-
def
zip: Zip[[α]F[W, α]]
scalaz.Zip derived from
tuple2
.scalaz.Zip derived from
tuple2
.- Definition Classes
- Apply
- Annotations
- @deprecated
- Deprecated
(Since version 7.1.0) Apply#zip produces unlawful instances