Packages

c

tofu.syntax.collections

TofuCollectionsSyntax

implicit final class TofuCollectionsSyntax[F[_], A] extends AnyVal

Linear Supertypes
AnyVal, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. TofuCollectionsSyntax
  2. AnyVal
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new TofuCollectionsSyntax(fa: F[A])

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    Any
  2. final def ##(): Int
    Definition Classes
    Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def getClass(): Class[_ <: AnyVal]
    Definition Classes
    AnyVal → Any
  6. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  7. def mapAccumF[G[_], B, C](start: B)(step: (B, A) ⇒ G[(B, C)])(implicit arg0: Monad[G], F: Traverse[F]): G[(B, F[C])]

    like mapAccumL but also combines monadic effects of G stack-safety guaranteed via Free

  8. def mapAccumF_[G[_], B, C](start: B)(step: (B, A) ⇒ G[(B, C)])(implicit arg0: Monad[G], F: Traverse[F]): G[F[C]]

    like mapAccumF but drop the final state

  9. def mapAccumL[B, C](start: B)(step: (B, A) ⇒ (B, C))(implicit F: Traverse[F]): (B, F[C])

    a combination of map and scanLeft it applies a function to each element of a structure, passing an accumulating parameter from left to right, and returning a final value of this accumulator together with the new structure.

  10. def mapAccumL_[B, C](start: B)(step: (B, A) ⇒ (B, C))(implicit F: Traverse[F]): F[C]

    like mapAccumL, but drop the final state

  11. def mapAccumM[G[_], B, C](start: B)(step: (B, A) ⇒ G[(B, C)])(implicit arg0: Monad[G], F: Traverse[F]): G[(B, F[C])]

    like mapAccumL but also combines monadic effects of G stack-safety relies on a stack safety of G

  12. def mapAccumM_[G[_], B, C](start: B)(step: (B, A) ⇒ G[(B, C)])(implicit arg0: Monad[G], F: Traverse[F]): G[F[C]]

    like mapAccumM but drop the final state

  13. def scanF[G[_], B](start: B)(step: (B, A) ⇒ G[B])(implicit arg0: Monad[G], F: Traverse[F]): G[(B, F[B])]

    accumulate values effectfully, producing intermediate results initial state will posess a first item place in the traverse order final state is returned as a separate result

  14. def scanL[B](start: B)(step: (B, A) ⇒ B)(implicit F: Traverse[F]): (B, F[B])

    accumulate values, producing intermediate results initial state will posess a first item place in the traverse order final state is returned as a separate result

  15. def toString(): String
    Definition Classes
    Any

Inherited from AnyVal

Inherited from Any

Ungrouped