Trait/Object

scalaz

Foldable

Related Docs: object Foldable | package scalaz

Permalink

trait Foldable[F[_]] extends AnyRef

A type parameter implying the ability to extract zero or more values of that type.

Self Type
Foldable[F]
Source
Foldable.scala
Linear Supertypes
Known Subclasses
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Foldable
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. trait FoldableLaw extends AnyRef

    Permalink

Abstract Value Members

  1. abstract def foldMap[A, B](fa: F[A])(f: (A) ⇒ B)(implicit F: Monoid[B]): B

    Permalink

    Map each element of the structure to a scalaz.Monoid, and combine the results.

  2. abstract def foldRight[A, B](fa: F[A], z: ⇒ B)(f: (A, ⇒ B) ⇒ B): B

    Permalink

    Right-associative fold of a structure.

Concrete Value Members

  1. final def !=(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  4. def all[A](fa: F[A])(p: (A) ⇒ Boolean): Boolean

    Permalink

    Whether all As in fa yield true from p.

  5. def allM[G[_], A](fa: F[A])(p: (A) ⇒ G[Boolean])(implicit G: Monad[G]): G[Boolean]

    Permalink

    all with monadic traversal.

  6. def any[A](fa: F[A])(p: (A) ⇒ Boolean): Boolean

    Permalink

    Whether any As in fa yield true from p.

  7. def anyM[G[_], A](fa: F[A])(p: (A) ⇒ G[Boolean])(implicit G: Monad[G]): G[Boolean]

    Permalink

    any with monadic traversal.

  8. final def asInstanceOf[T0]: T0

    Permalink
    Definition Classes
    Any
  9. final def asum[G[_], A](fa: F[G[A]])(implicit G: PlusEmpty[G]): G[A]

    Permalink

    Alias for psum.

    Alias for psum. asum is the name used in Haskell.

  10. def bicompose[G[_, _]](implicit arg0: Bifoldable[G]): Bifoldable[[α, β]F[G[α, β]]]

    Permalink

    The composition of Foldable F and Bifoldable G, [x, y]F[G[x, y]], is a Bifoldable

  11. def clone(): AnyRef

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  12. def collapse[X[_], A](x: F[A])(implicit A: ApplicativePlus[X]): X[A]

    Permalink
  13. def compose[G[_]](implicit G0: Foldable[G]): Foldable[[α]F[G[α]]]

    Permalink

    The composition of Foldables F and G, [x]F[G[x]], is a Foldable

  14. final def count[A](fa: F[A]): Int

    Permalink

    Alias for length.

  15. def distinct[A](fa: F[A])(implicit A: Order[A]): IList[A]

    Permalink

    O(n log n) complexity

  16. def distinctBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Equal[B]): IList[A]

    Permalink
  17. def distinctE[A](fa: F[A])(implicit A: Equal[A]): IList[A]

    Permalink

    O(n2) complexity

  18. def element[A](fa: F[A], a: A)(implicit arg0: Equal[A]): Boolean

    Permalink

    Whether a is an element of fa.

  19. def empty[A](fa: F[A]): Boolean

    Permalink

    Deforested alias for toStream(fa).isEmpty.

  20. final def eq(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  21. def equals(arg0: Any): Boolean

    Permalink
    Definition Classes
    AnyRef → Any
  22. def extrema[A](fa: F[A])(implicit arg0: Order[A]): Option[(A, A)]

    Permalink

    The smallest and largest elements of fa or None if fa is empty

  23. def extremaBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[(A, A)]

    Permalink

    The elements (amin, amax) of fa which yield the smallest and largest values of f(a), respectively, or None if fa is empty

  24. def extremaOf[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[(B, B)]

    Permalink

    The smallest and largest values of f(a) for each element a of fa , or None if fa is empty

  25. def filterLength[A](fa: F[A])(f: (A) ⇒ Boolean): Int

    Permalink
  26. def finalize(): Unit

    Permalink
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  27. def findLeft[A](fa: F[A])(f: (A) ⇒ Boolean): Option[A]

    Permalink
  28. final def findMapM[M[_], A, B](fa: F[A])(f: (A) ⇒ M[Option[B]])(implicit arg0: Monad[M]): M[Option[B]]

    Permalink

    map elements in a Foldable with a monadic function and return the first element that is mapped successfully

  29. def findRight[A](fa: F[A])(f: (A) ⇒ Boolean): Option[A]

    Permalink
  30. def fold[M](t: F[M])(implicit arg0: Monoid[M]): M

    Permalink

    Combine the elements of a structure using a monoid.

  31. def fold1Opt[A](fa: F[A])(implicit arg0: Semigroup[A]): Option[A]

    Permalink

    Like fold but returning None if the foldable is empty and Some otherwise

  32. def foldLeft[A, B](fa: F[A], z: B)(f: (B, A) ⇒ B): B

    Permalink

    Left-associative fold of a structure.

  33. def foldLeft1Opt[A](fa: F[A])(f: (A, A) ⇒ A): Option[A]

    Permalink
  34. def foldLeftM[G[_], A, B](fa: F[A], z: B)(f: (B, A) ⇒ G[B])(implicit M: Monad[G]): G[B]

    Permalink

    Left-associative, monadic fold of a structure.

  35. def foldMap1Opt[A, B](fa: F[A])(f: (A) ⇒ B)(implicit F: Semigroup[B]): Option[B]

    Permalink

    As foldMap but returning None if the foldable is empty and Some otherwise

  36. def foldMapLeft1Opt[A, B](fa: F[A])(z: (A) ⇒ B)(f: (B, A) ⇒ B): Option[B]

    Permalink
  37. def foldMapM[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit B: Monoid[B], G: Monad[G]): G[B]

    Permalink

    Specialization of foldRightM when B has a Monoid.

  38. def foldMapRight1Opt[A, B](fa: F[A])(z: (A) ⇒ B)(f: (A, ⇒ B) ⇒ B): Option[B]

    Permalink
  39. def foldRight1Opt[A](fa: F[A])(f: (A, ⇒ A) ⇒ A): Option[A]

    Permalink
  40. def foldRightM[G[_], A, B](fa: F[A], z: ⇒ B)(f: (A, ⇒ B) ⇒ G[B])(implicit M: Monad[G]): G[B]

    Permalink

    Right-associative, monadic fold of a structure.

  41. def foldableLaw: FoldableLaw

    Permalink
  42. val foldableSyntax: FoldableSyntax[F]

    Permalink
  43. final def foldl[A, B](fa: F[A], z: B)(f: (B) ⇒ (A) ⇒ B): B

    Permalink

    Curried version of foldLeft

  44. def foldl1Opt[A](fa: F[A])(f: (A) ⇒ (A) ⇒ A): Option[A]

    Permalink
  45. final def foldlM[G[_], A, B](fa: F[A], z: ⇒ B)(f: (B) ⇒ (A) ⇒ G[B])(implicit M: Monad[G]): G[B]

    Permalink

    Curried version of foldLeftM

  46. final def foldr[A, B](fa: F[A], z: ⇒ B)(f: (A) ⇒ (⇒ B) ⇒ B): B

    Permalink

    Curried version of foldRight

  47. def foldr1Opt[A](fa: F[A])(f: (A) ⇒ (⇒ A) ⇒ A): Option[A]

    Permalink
  48. final def foldrM[G[_], A, B](fa: F[A], z: ⇒ B)(f: (A) ⇒ (⇒ B) ⇒ G[B])(implicit M: Monad[G]): G[B]

    Permalink

    Curried version of foldRightM

  49. final def getClass(): Class[_]

    Permalink
    Definition Classes
    AnyRef → Any
  50. def hashCode(): Int

    Permalink
    Definition Classes
    AnyRef → Any
  51. def index[A](fa: F[A], i: Int): Option[A]

    Permalink

    returns

    the element at index i in a Some, or None if the given index falls outside of the range

  52. def indexOr[A](fa: F[A], default: ⇒ A, i: Int): A

    Permalink

    returns

    the element at index i, or default if the given index falls outside of the range

  53. def intercalate[A](fa: F[A], a: A)(implicit A: Monoid[A]): A

    Permalink

    Insert an A between every A, yielding the sum.

  54. final def isInstanceOf[T0]: Boolean

    Permalink
    Definition Classes
    Any
  55. def length[A](fa: F[A]): Int

    Permalink

    Deforested alias for toStream(fa).size.

  56. def longDigits[A](fa: F[A])(implicit d: <:<[A, Digit]): Long

    Permalink
  57. def maximum[A](fa: F[A])(implicit arg0: Order[A]): Option[A]

    Permalink

    The greatest element of fa, or None if fa is empty.

  58. def maximumBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[A]

    Permalink

    The element a of fa which yields the greatest value of f(a), or None if fa is empty.

  59. def maximumOf[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[B]

    Permalink

    The greatest value of f(a) for each element a of fa, or None if fa is empty.

  60. def minimum[A](fa: F[A])(implicit arg0: Order[A]): Option[A]

    Permalink

    The smallest element of fa, or None if fa is empty.

  61. def minimumBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[A]

    Permalink

    The element a of fa which yields the smallest value of f(a), or None if fa is empty.

  62. def minimumOf[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Order[B]): Option[B]

    Permalink

    The smallest value of f(a) for each element a of fa, or None if fa is empty.

  63. final def ne(arg0: AnyRef): Boolean

    Permalink
    Definition Classes
    AnyRef
  64. final def notify(): Unit

    Permalink
    Definition Classes
    AnyRef
  65. final def notifyAll(): Unit

    Permalink
    Definition Classes
    AnyRef
  66. def product[G[_]](implicit G0: Foldable[G]): Foldable[[α](F[α], G[α])]

    Permalink

    The product of Foldables F and G, [x](F[x], G[x]]), is a Foldable

  67. def product0[G[_]](implicit G0: Foldable1[G]): Foldable1[[α](F[α], G[α])]

    Permalink

    The product of Foldable F and Foldable1 G, [x](F[x], G[x]]), is a Foldable1

  68. def psum[G[_], A](fa: F[G[A]])(implicit G: PlusEmpty[G]): G[A]

    Permalink

    Sum using a polymorphic monoid (PlusEmpty).

    Sum using a polymorphic monoid (PlusEmpty). Should support early termination, i.e. summing no more elements than is needed to determine the result.

  69. def psumMap[A, B, G[_]](fa: F[A])(f: (A) ⇒ G[B])(implicit G: PlusEmpty[G]): G[B]

    Permalink

    Map elements to G[B] and sum using a polymorphic monoid (PlusEmpty).

    Map elements to G[B] and sum using a polymorphic monoid (PlusEmpty). Should support early termination, i.e. mapping and summing no more elements than is needed to determine the result.

  70. def selectSplit[A](fa: F[A])(p: (A) ⇒ Boolean): List[NonEmptyList[A]]

    Permalink

    Selects groups of elements that satisfy p and discards others.

  71. def sequenceF_[M[_], A](ffa: F[Free[M, A]]): Free[M, Unit]

    Permalink

    sequence_ for Free.

    sequence_ for Free. collapses into a single Free *

  72. def sequenceS_[S, A](fga: F[State[S, A]]): State[S, Unit]

    Permalink

    sequence_ specialized to State *

  73. def sequence_[M[_], A](fa: F[M[A]])(implicit a: Applicative[M]): M[Unit]

    Permalink

    Strict sequencing in an applicative functor M that ignores the value in fa.

  74. def splitBy[A, B](fa: F[A])(f: (A) ⇒ B)(implicit arg0: Equal[B]): IList[(B, NonEmptyList[A])]

    Permalink

    Splits the elements into groups that produce the same result by a function f.

  75. def splitByRelation[A](fa: F[A])(r: (A, A) ⇒ Boolean): IList[NonEmptyList[A]]

    Permalink

    Splits into groups of elements that are transitively dependant by a relation r.

  76. def splitWith[A](fa: F[A])(p: (A) ⇒ Boolean): List[NonEmptyList[A]]

    Permalink

    Splits the elements into groups that alternatively satisfy and don't satisfy the predicate p.

  77. def suml[A](fa: F[A])(implicit A: Monoid[A]): A

    Permalink
  78. def suml1Opt[A](fa: F[A])(implicit A: Semigroup[A]): Option[A]

    Permalink
  79. def sumr[A](fa: F[A])(implicit A: Monoid[A]): A

    Permalink
  80. def sumr1Opt[A](fa: F[A])(implicit A: Semigroup[A]): Option[A]

    Permalink
  81. final def synchronized[T0](arg0: ⇒ T0): T0

    Permalink
    Definition Classes
    AnyRef
  82. def toEphemeralStream[A](fa: F[A]): EphemeralStream[A]

    Permalink
  83. def toIList[A](fa: F[A]): IList[A]

    Permalink
  84. def toList[A](fa: F[A]): List[A]

    Permalink
  85. def toSet[A](fa: F[A]): Set[A]

    Permalink
  86. def toStream[A](fa: F[A]): Stream[A]

    Permalink
  87. def toString(): String

    Permalink
    Definition Classes
    AnyRef → Any
  88. def toVector[A](fa: F[A]): Vector[A]

    Permalink
  89. def traverseS_[S, A, B](fa: F[A])(f: (A) ⇒ State[S, B]): State[S, Unit]

    Permalink

    traverse_ specialized to State *

  90. final def traverseU_[A, GB](fa: F[A])(f: (A) ⇒ GB)(implicit G: Unapply[Applicative, GB]): M[Unit]

    Permalink

    A version of traverse_ that infers the type constructor M.

  91. def traverse_[M[_], A, B](fa: F[A])(f: (A) ⇒ M[B])(implicit a: Applicative[M]): M[Unit]

    Permalink

    Strict traversal in an applicative functor M that ignores the result of f.

  92. final def wait(): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  93. final def wait(arg0: Long, arg1: Int): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  94. final def wait(arg0: Long): Unit

    Permalink
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

Deprecated Value Members

  1. def msuml[G[_], A](fa: F[G[A]])(implicit G: PlusEmpty[G]): G[A]

    Permalink
    Annotations
    @deprecated
    Deprecated

    (Since version 7.3.0) use psum

  2. def msumlU[GA](fa: F[GA])(implicit G: Unapply[PlusEmpty, GA]): M[A]

    Permalink
    Annotations
    @deprecated
    Deprecated

    (Since version 7.3.0) use psum

Inherited from AnyRef

Inherited from Any

Ungrouped