t

scalaz

# Foldable 

### Companion object Foldable

#### 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

### 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. 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()
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])

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

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

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

20. final def eq(arg0: AnyRef)
Definition Classes
AnyRef
21. def equals(arg0: Any)
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
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]
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. final def ne(arg0: AnyRef)
Definition Classes
AnyRef
64. final def notify(): Unit
Definition Classes
AnyRef
Annotations
@native()
65. final def notifyAll(): Unit
Definition Classes
AnyRef
Annotations
@native()
66. 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

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

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

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

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

Selects groups of elements that satisfy p and discards others.

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

`sequence_` for Free.

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

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

`sequence_` specialized to `State` *

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

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

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

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

77. def suml[A](fa: F[A])(implicit A: Monoid[A]): A
78. def suml1Opt[A](fa: F[A])(implicit A: Semigroup[A]): Option[A]
79. def sumr[A](fa: F[A])(implicit A: Monoid[A]): A
80. def sumr1Opt[A](fa: F[A])(implicit A: Semigroup[A]): Option[A]
81. final def synchronized[T0](arg0: ⇒ T0): T0
Definition Classes
AnyRef
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
@native() @throws( ... )

### Deprecated Value Members

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

(Since version 7.3.0) use psum

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

(Since version 7.3.0) use psum