trait
Fold[M[_], A, B] extends AnyRef
Type Members
-
abstract
type
S
Abstract Value Members
-
abstract
def
end(s: S): M[B]
-
abstract
def
fold: (S, A) ⇒ M[S]
-
implicit abstract
def
monad: Monad[M]
-
abstract
def
start: M[S]
Concrete Value Members
-
final
def
!=(arg0: Any): Boolean
-
final
def
##(): Int
-
def
&&&[C](f: Fold[M, A, C]): Fold[M, A, (B, C)] { ... /* 2 definitions in type refinement */ }
-
def
***[V, W](f: Fold[M, V, W]): Fold[M, (A, V), (B, W)] { ... /* 2 definitions in type refinement */ }
-
def
*>[C](f: Fold[M, A, C]): Fold[M, A, C]
-
def
<*[C](f: Fold[M, A, C]): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }
-
def
<*>[C](f: Fold[M, A, C]): Fold[M, A, (B, C)] { ... /* 2 definitions in type refinement */ }
-
def
<+*(sink: Sink[M, S]): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }
-
def
<-*(sink: Sink[M, S]): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }
-
def
<<+*(sink: Sink[M, (A, S)]): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }
-
def
<<-*(sink: Sink[M, (A, S)]): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }
-
final
def
==(arg0: Any): Boolean
-
def
as[C](c: ⇒ C): Fold[M, A, C] { ... /* 2 definitions in type refinement */ }
-
final
def
asInstanceOf[T0]: T0
-
def
clone(): AnyRef
-
def
compose[C](f2: Fold[M, B, C]): Fold[M, A, C] { ... /* 2 definitions in type refinement */ }
-
def
contraFlatMap[C](f: (C) ⇒ M[A]): Fold[M, C, B] { ... /* 2 definitions in type refinement */ }
-
def
contramap[C](f: (C) ⇒ A): Fold[M, C, B] { ... /* 2 definitions in type refinement */ }
-
def
endWith(action: M[Unit]): Fold[M, A, B]
-
-
-
def
finalize(): Unit
-
final
def
getClass(): Class[_]
-
def
hashCode(): Int
-
def
into[M1[_]](implicit nat: ~>[M, M1], m: Monad[M1]): Fold[M1, A, B] { ... /* 2 definitions in type refinement */ }
-
final
def
isInstanceOf[T0]: Boolean
-
def
map[C](f: (B) ⇒ C): Fold[M, A, C] { ... /* 2 definitions in type refinement */ }
-
def
mapFlatten[C](f: (B) ⇒ M[C]): Fold[M, A, C] { ... /* 2 definitions in type refinement */ }
-
def
monadic[M1[_]](implicit nat: ~>[M, M1], m: Monad[M1]): Fold[M1, A, B] { ... /* 2 definitions in type refinement */ }
-
-
def
nest[F[_], C](f: (C) ⇒ F[A])(implicit monoid: Monoid[B], foldable: Foldable[F]): Fold[M, C, B] { ... /* 2 definitions in type refinement */ }
-
final
def
notify(): Unit
-
final
def
notifyAll(): Unit
-
def
observe[C](f: Fold[M, A, C]): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }
-
def
observeNextState(sink: Sink[M, S]): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }
-
def
observeState(sink: Sink[M, S]): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }
-
def
observeWithNextState(sink: Sink[M, (A, S)]): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }
-
def
observeWithState(sink: Sink[M, (A, S)]): Fold[M, A, B] { ... /* 2 definitions in type refinement */ }
-
def
observedBy[C](f: Fold[M, A, C]): Fold[M, A, C]
-
def
pipe[C](f: Fold[M, B, C]): Fold[M, A, C] { ... /* 2 definitions in type refinement */ }
-
def
run[F[_]](foldable: F[A])(implicit arg0: Foldable[F]): M[B]
-
def
run1(a: A): M[B]
-
def
startWith(action: M[Unit]): Fold[M, A, B]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
-
def
toString(): String
-
def
void: Fold[M, A, Unit] { ... /* 2 definitions in type refinement */ }
-
final
def
wait(): Unit
-
final
def
wait(arg0: Long, arg1: Int): Unit
-
final
def
wait(arg0: Long): Unit
-
def
zip[C](f: Fold[M, A, C]): Fold[M, A, (B, C)] { ... /* 2 definitions in type refinement */ }
A Fold is a "left fold" over a data structure with:
Those 3 methods use a monad for effects