Packages

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
AnyRef, Any
Known Subclasses
FromFoldMap, FromFoldr, Foldable1, IsomorphismFoldable, IsomorphismFoldable1, IsomorphismTraverse, IsomorphismTraverse1, Traverse, Traverse1
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

Abstract Value Members

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

    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

    Right-associative fold of a structure.

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def all[A](fa: F[A])(p: (A) ⇒ Boolean): Boolean

    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]

    all with monadic traversal.

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

    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]

    any with monadic traversal.

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

    Alias for psum.

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

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

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

  11. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )
  12. def collapse[X[_], A](x: F[A])(implicit A: ApplicativePlus[X]): X[A]
  13. def compose[G[_]](implicit G0: Foldable[G]): Foldable[[α]F[G[α]]]

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

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

    Alias for length.

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

    O(n log n) complexity

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

    O(n2) complexity

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

    Whether a is an element of fa.

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

    Deforested alias for toStream(fa).isEmpty.

  20. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  21. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  22. def extrema[A](fa: F[A])(implicit arg0: Order[A]): Option[(A, A)]

    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)]

    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)]

    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
  26. def finalize(): Unit
    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]
  28. final def findMapM[M[_], A, B](fa: F[A])(f: (A) ⇒ M[Option[B]])(implicit arg0: Monad[M]): M[Option[B]]

    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]
  30. def fold[M](t: F[M])(implicit arg0: Monoid[M]): M

    Combine the elements of a structure using a monoid.

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

    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

    Left-associative fold of a structure.

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

    Left-associative, monadic fold of a structure.

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

    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]
  37. def foldMapM[G[_], A, B](fa: F[A])(f: (A) ⇒ G[B])(implicit B: Monoid[B], G: Monad[G]): G[B]

    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]
  39. def foldRight1Opt[A](fa: F[A])(f: (A, ⇒ A) ⇒ A): Option[A]
  40. def foldRightM[G[_], A, B](fa: F[A], z: ⇒ B)(f: (A, ⇒ B) ⇒ G[B])(implicit M: Monad[G]): G[B]

    Right-associative, monadic fold of a structure.

  41. def foldableLaw: FoldableLaw
  42. val foldableSyntax: FoldableSyntax[F]
  43. final def foldl[A, B](fa: F[A], z: B)(f: (B) ⇒ (A) ⇒ B): B

    Curried version of foldLeft

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

    Curried version of foldLeftM

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

    Curried version of foldRight

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

    Curried version of foldRightM

  49. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  50. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  51. def index[A](fa: F[A], i: Int): Option[A]

    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

    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

    Insert an A between every A, yielding the sum.

  54. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  55. def length[A](fa: F[A]): Int

    Deforested alias for toStream(fa).size.

  56. def longDigits[A](fa: F[A])(implicit d: <:<[A, Digit]): Long
  57. def maximum[A](fa: F[A])(implicit arg0: Order[A]): Option[A]

    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]

    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]

    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]

    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]

    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]

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

  63. def msuml[G[_], A](fa: F[G[A]])(implicit G: PlusEmpty[G]): G[A]
  64. def msumlU[GA](fa: F[GA])(implicit G: Unapply[PlusEmpty, GA]): M[A]
  65. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  66. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  67. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  68. def product[G[_]](implicit G0: Foldable[G]): Foldable[[α](F[α], G[α])]

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

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

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

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

    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.

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

    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.

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

    Selects groups of elements that satisfy p and discards others.

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

    sequence_ for Free.

    sequence_ for Free. collapses into a single Free *

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

    sequence_ specialized to State *

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

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

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

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

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

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

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

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

  79. def suml[A](fa: F[A])(implicit A: Monoid[A]): A
  80. def suml1Opt[A](fa: F[A])(implicit A: Semigroup[A]): Option[A]
  81. def sumr[A](fa: F[A])(implicit A: Monoid[A]): A
  82. def sumr1Opt[A](fa: F[A])(implicit A: Semigroup[A]): Option[A]
  83. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  84. def to[A, G[_]](fa: F[A])(implicit c: CanBuildFrom[Nothing, A, G[A]]): G[A]
  85. def toEphemeralStream[A](fa: F[A]): EphemeralStream[A]
  86. def toIList[A](fa: F[A]): IList[A]
  87. def toList[A](fa: F[A]): List[A]
  88. def toSet[A](fa: F[A]): Set[A]
  89. def toStream[A](fa: F[A]): Stream[A]
  90. def toString(): String
    Definition Classes
    AnyRef → Any
  91. def toVector[A](fa: F[A]): Vector[A]
  92. def traverseS_[S, A, B](fa: F[A])(f: (A) ⇒ State[S, B]): State[S, Unit]

    traverse_ specialized to State *

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

    A version of traverse_ that infers the type constructor M.

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

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

  95. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  96. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  97. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @throws( ... )

Inherited from AnyRef

Inherited from Any

Ungrouped