t

scalaz

# Foldable 

### Companion object Foldable

#### trait Foldable[F[_]] extends FoldableParent[F]

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. FoldableParent
3. AnyRef
4. 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)
Definition Classes
AnyRef → Any
2. final def ##(): Int
Definition Classes
AnyRef → Any
3. final def ==(arg0: Any)
Definition Classes
AnyRef → Any
4. def all[A](fa: F[A])(p: (A) ⇒ Boolean)

Whether all `A`s 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)

Whether any `A`s 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. 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

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

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

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

Alias for `length`.

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

`O(n log n)` complexity

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

`O(n2)` complexity

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

Whether `a` is an element of `fa`.

18. def empty[A](fa: F[A])

Deforested alias for `toStream(fa).isEmpty`.

19. final def eq(arg0: AnyRef)
Definition Classes
AnyRef
20. def equals(arg0: Any)
Definition Classes
AnyRef → Any
21. 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

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

Definition Classes
FoldableParent
22. 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

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

Definition Classes
FoldableParent
23. 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

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

Definition Classes
FoldableParent
24. def filterLength[A](fa: F[A])(f: (A) ⇒ Boolean): Int
Definition Classes
FoldableParent
25. def finalize(): Unit
Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
26. def findLeft[A](fa: F[A])(f: (A) ⇒ Boolean): Option[A]
27. 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

28. def findRight[A](fa: F[A])(f: (A) ⇒ Boolean): Option[A]
29. def fold[M](t: F[M])(implicit arg0: Monoid[M]): M

Combine the elements of a structure using a monoid.

30. 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

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

Definition Classes
FoldableParent
31. def foldLeft[A, B](fa: F[A], z: B)(f: (B, A) ⇒ B): B

Left-associative fold of a structure.

32. def foldLeft1Opt[A](fa: F[A])(f: (A, A) ⇒ A): Option[A]
33. 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.

34. 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

35. def foldMapLeft1Opt[A, B](fa: F[A])(z: (A) ⇒ B)(f: (B, A) ⇒ B): Option[B]
36. 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`.

37. def foldMapRight1Opt[A, B](fa: F[A])(z: (A) ⇒ B)(f: (A, ⇒ B) ⇒ B): Option[B]
38. def foldRight1Opt[A](fa: F[A])(f: (A, ⇒ A) ⇒ A): Option[A]
39. 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.

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

Curried version of `foldLeft`

43. def foldl1Opt[A](fa: F[A])(f: (A) ⇒ (A) ⇒ A): Option[A]
44. 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`

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

Curried version of `foldRight`

46. def foldr1Opt[A](fa: F[A])(f: (A) ⇒ (⇒ A) ⇒ A): Option[A]
47. 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`

48. final def getClass(): Class[_]
Definition Classes
AnyRef → Any
49. def hashCode(): Int
Definition Classes
AnyRef → Any
50. 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

51. 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

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

Insert an `A` between every A, yielding the sum.

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

Deforested alias for `toStream(fa).size`.

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

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

57. 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.

58. 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.

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

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

60. 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.

61. 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.

62. def msuml[G[_], A](fa: F[G[A]])(implicit G: PlusEmpty[G]): G[A]
63. def msumlU[GA](fa: F[GA])(implicit G: Unapply[PlusEmpty, GA]): M[A]
Definition Classes
FoldableParent
64. final def ne(arg0: AnyRef)
Definition Classes
AnyRef
65. final def notify(): Unit
Definition Classes
AnyRef
66. final def notifyAll(): Unit
Definition Classes
AnyRef
67. 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

68. 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

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

Selects groups of elements that satisfy p and discards others.

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

`sequence_` for Free.

`sequence_` for Free. collapses into a single Free *

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

`sequence_` specialized to `State` *

72. 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`.

73. 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.

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

Definition Classes
FoldableParent
74. 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.

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

Definition Classes
FoldableParent
75. 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.

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

`traverse_` specialized to `State` *

90. 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`.

91. 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`.

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