abstract class Fold_[S, T, A, B] extends FoldCompat[S, A]

A Fold_ is a generalization of something Foldable. It describes how to retrieve multiple values.

A Fold_ is similar to a Traversal_, but it cannot modify its foci.

A Fold_ is an Optic with fixed type proptics.internal.Forget cats.arrow.Profunctor

S

the source of a Fold_

T

the modified source of a Fold_

A

the foci of a Fold_

B

the modified foci of a Fold_

Self Type
Fold_[S, T, A, B]
Source
Fold.scala
Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Fold_
  2. FoldCompat
  3. FoldCompat0
  4. Serializable
  5. AnyRef
  6. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new Fold_()

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. final def and(s: S)(implicit ev: Heyting[A]): A

    return the result of a conjunction of all foci of a Fold_, using a spire.algebra.lattice.Heyting algebra

    return the result of a conjunction of all foci of a Fold_, using a spire.algebra.lattice.Heyting algebra

    Definition Classes
    FoldCompat
  5. final def andThen[I, C, D](other: IndexedFold_[I, A, B, C, D]): IndexedFold_[I, S, T, C, D]

    compose this Fold_ with an IndexedFold_, having this Fold_ applied first

  6. final def andThen[I, C, D](other: IndexedGetter_[I, A, B, C, D]): IndexedFold_[I, S, T, C, D]

    compose this Fold_ with an IndexedGetter_, having this Fold_ applied first

  7. final def andThen[I, C, D](other: IndexedTraversal_[I, A, B, C, D]): IndexedFold_[I, S, T, C, D]

    compose this Fold_ with an IndexedTraversal_, having this Fold_ applied first

  8. final def andThen[I, C, D](other: AnIndexedLens_[I, A, B, C, D]): IndexedFold_[I, S, T, C, D]

    compose this Fold_ with an AnIndexedLens_, having this Fold_ applied first

  9. final def andThen[I, C, D](other: IndexedLens_[I, A, B, C, D]): IndexedFold_[I, S, T, C, D]

    compose this Fold_ with an IndexedLens_, having this Fold_ applied first

  10. final def andThen[C, D](other: Fold_[A, B, C, D]): Fold_[S, T, C, D]

    compose this Fold_ with a Fold_, having this Fold_ applied first

  11. final def andThen[C, D](other: Getter_[A, B, C, D]): Fold_[S, T, C, D]

    compose this Fold_ with a Getter_, having this Fold_ applied first

  12. final def andThen[C, D](other: ATraversal_[A, B, C, D]): Fold_[S, T, C, D]

    compose this Fold_ with an ATraversal_, having this Fold_ applied first

  13. final def andThen[C, D](other: Traversal_[A, B, C, D]): Fold_[S, T, C, D]

    compose this Fold_ with a Traversal_, having this Fold_ applied first

  14. final def andThen[C, D](other: AnAffineTraversal_[A, B, C, D]): Fold_[S, T, C, D]

    compose this Fold_ with a AnAffineTraversal_, having this Fold_ applied first

  15. final def andThen[C, D](other: AffineTraversal_[A, B, C, D]): Fold_[S, T, C, D]

    compose this Fold_ with a AffineTraversal_, having this Fold_ applied first

  16. final def andThen[C, D](other: APrism_[A, B, C, D]): Fold_[S, T, C, D]

    compose this Fold_ with an APrism_, having this Fold_ applied first

  17. final def andThen[C, D](other: Prism_[A, B, C, D]): Fold_[S, T, C, D]

    compose this Fold_ with a Prism_, having this Fold_ applied first

  18. final def andThen[C, D](other: ALens_[A, B, C, D]): Fold_[S, T, C, D]

    compose this Fold_ with an ALens_, having this Fold_ applied first

  19. final def andThen[C, D](other: Lens_[A, B, C, D]): Fold_[S, T, C, D]

    compose this Fold_ with a Lens_, having this Fold_ applied first

  20. final def andThen[C, D](other: AnIso_[A, B, C, D]): Fold_[S, T, C, D]

    compose this Fold_ with an AnIso_, having this Fold_ applied first

  21. final def andThen[C, D](other: Iso_[A, B, C, D]): Fold_[S, T, C, D]

    compose this Fold_ with an Iso_, having this Fold_ applied first

  22. final def any[R](s: S)(f: (A) => R)(implicit arg0: Heyting[R]): R

    test whether a predicate holds for any focus of a Fold_, using a spire.algebra.lattice.Heyting algebra

    test whether a predicate holds for any focus of a Fold_, using a spire.algebra.lattice.Heyting algebra

    Definition Classes
    FoldCompat
  23. final def asIndexableFold: IndexedFold_[Int, S, T, A, B]

    convert a Fold_ to an IndexedFold_ by using the integer positions as indices

  24. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  25. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  26. final def compose[I, C, D](other: IndexedFold_[I, C, D, S, T]): IndexedFold_[I, C, D, A, B]

    compose this Fold_ with an IndexedFold_, having this Fold_ applied last

  27. final def compose[I, C, D](other: IndexedGetter_[I, C, D, S, T]): IndexedFold_[I, C, D, A, B]

    compose this Fold_ with an IndexedGetter_, having this Fold_ applied last

  28. final def compose[I, C, D](other: IndexedTraversal_[I, C, D, S, T]): IndexedFold_[I, C, D, A, B]

    compose this Fold_ with an IndexedTraversal_, having this Fold_ applied last

  29. final def compose[I, C, D](other: AnIndexedLens_[I, C, D, S, T]): IndexedFold_[I, C, D, A, B]

    compose this Fold_ with an AnIndexedLens_, having this Fold_ applied last

  30. final def compose[I, C, D](other: IndexedLens_[I, C, D, S, T]): IndexedFold_[I, C, D, A, B]

    compose this Fold_ with an IndexedLens_, having this Fold_ applied last

  31. final def compose[C, D](other: Fold_[C, D, S, T]): Fold_[C, D, A, B]

    compose this Fold_ with a Fold_, having this Fold_ applied last

  32. final def compose[C, D](other: Getter_[C, D, S, T]): Fold_[C, D, A, B]

    compose this Fold_ with a Getter_, having this Fold_ applied last

  33. final def compose[C, D](other: ATraversal_[C, D, S, T]): Fold_[C, D, A, B]

    compose this Fold_ with an ATraversal_, having this Fold_ applied last

  34. final def compose[C, D](other: Traversal_[C, D, S, T]): Fold_[C, D, A, B]

    compose this Fold_ with a Traversal_, having this Fold_ applied last

  35. final def compose[C, D](other: AnAffineTraversal_[C, D, S, T]): Fold_[C, D, A, B]

    compose this Fold_ with a AnAffineTraversal_, having this Fold_ applied last

  36. final def compose[C, D](other: AffineTraversal_[C, D, S, T]): Fold_[C, D, A, B]

    compose this Fold_ with a AffineTraversal_, having this Fold_ applied last

  37. final def compose[C, D](other: APrism_[C, D, S, T]): Fold_[C, D, A, B]

    compose this Fold_ with an APrism_, having this Fold_ applied last

  38. final def compose[C, D](other: Prism_[C, D, S, T]): Fold_[C, D, A, B]

    compose this Fold_ with a Prism_, having this Fold_ applied last

  39. final def compose[C, D](other: ALens_[C, D, S, T]): Fold_[C, D, A, B]

    compose this Fold_ with an ALens_, having this Fold_ applied last

  40. final def compose[C, D](other: Lens_[C, D, S, T]): Fold_[C, D, A, B]

    compose this Fold_ with a Lens_, having this Fold_ applied last

  41. final def compose[C, D](other: AnIso_[C, D, S, T]): Fold_[C, D, A, B]

    compose this Fold_ with an AnIso_, having this Fold_ applied last

  42. final def compose[C, D](other: Iso_[C, D, S, T]): Fold_[C, D, A, B]

    compose this Fold_ with an Iso_, having this Fold_ applied last

  43. final def contains(a: A)(s: S)(implicit ev: Eq[A]): Boolean

    test whether the focus of a Fold_ contains a given value

    test whether the focus of a Fold_ contains a given value

    Definition Classes
    FoldCompat0
  44. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  45. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  46. final def exists(f: (A) => Boolean): (S) => Boolean

    test whether a predicate holds for the focus of a Fold_

    test whether a predicate holds for the focus of a Fold_

    Definition Classes
    FoldCompat0
  47. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  48. final def find(f: (A) => Boolean): (S) => Option[A]

    find the first focus of a Fold_ that satisfies a predicate, if there is any

  49. final def first(s: S): Option[A]

    find the first focus of a Fold_, if there is any.

    find the first focus of a Fold_, if there is any. Synonym for preview

  50. final def fold(s: S)(implicit ev: Monoid[A]): A

    fold the foci of a Fold_ using a cats.Monoid

  51. final def foldLeft[R](s: S)(r: R)(f: (R, A) => R): R

    fold the foci of a Fold_ using a binary operator, going left to right

  52. def foldMap[R](s: S)(f: (A) => R)(implicit arg0: Monoid[R]): R

    map each focus of a Fold_ to a cats.Monoid, and combine the results

    map each focus of a Fold_ to a cats.Monoid, and combine the results

    Definition Classes
    Fold_FoldCompatFoldCompat0
  53. final def foldRight[R](s: S)(r: R)(f: (A, R) => R): R

    fold the foci of a Fold_ using a binary operator, going right to left

  54. final def forall[R](s: S)(f: (A) => R)(implicit arg0: Heyting[R]): R

    test whether there is no focus or a predicate holds for the focus of a Fold_, using a spire.algebra.lattice.Heyting algebra

    test whether there is no focus or a predicate holds for the focus of a Fold_, using a spire.algebra.lattice.Heyting algebra

    Definition Classes
    FoldCompat0
  55. final def forall(f: (A) => Boolean): (S) => Boolean

    test whether there is no focus or a predicate holds for the focus of a Fold_

    test whether there is no focus or a predicate holds for the focus of a Fold_

    Definition Classes
    FoldCompat0
  56. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  57. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  58. final def isEmpty(s: S): Boolean

    check if the Fold_ does not contain a focus

  59. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  60. final def last(s: S): Option[A]

    find the last focus of a Fold_, if there is any

  61. final def length(s: S): Int

    the number of foci of a Fold_

  62. final def maximum(s: S)(implicit ev: Order[A]): Option[A]

    the maximum of all foci of a Fold_, if there is any

  63. final def minimum(s: S)(implicit ev: Order[A]): Option[A]

    the minimum of all foci of a Fold_, if there is any

  64. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  65. final def nonEmpty(s: S): Boolean

    check if the Fold_ contains a focus

  66. final def notContains(a: A)(s: S)(implicit ev: Eq[A]): Boolean

    test whether the focus of a Fold_ does not contain a given value

    test whether the focus of a Fold_ does not contain a given value

    Definition Classes
    FoldCompat0
  67. final def notExists(f: (A) => Boolean): (S) => Boolean

    test whether a predicate does not hold for the focus of a Fold_

    test whether a predicate does not hold for the focus of a Fold_

    Definition Classes
    FoldCompat0
  68. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  69. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  70. final def or(s: S)(implicit ev: Heyting[A]): A

    return the result of a disjunction of all foci of a Fold_, using a spire.algebra.lattice.Heyting algebra

    return the result of a disjunction of all foci of a Fold_, using a spire.algebra.lattice.Heyting algebra

    Definition Classes
    FoldCompat
  71. final def preview(s: S): Option[A]

    view the first focus of a Fold_, if there is any

  72. final def product(s: S)(implicit ev: MultiplicativeMonoid[A]): A

    the product of all foci of a Fold_

    the product of all foci of a Fold_

    Definition Classes
    FoldCompat
  73. final def sum(s: S)(implicit ev: AdditiveMonoid[A]): A

    the sum of all foci of a Fold_

    the sum of all foci of a Fold_

    Definition Classes
    FoldCompat
  74. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  75. final def to[C, D](f: (A) => C): Fold_[S, T, C, D]

    compose this Fold_ with a function lifted to a Getter_, having this Fold_ applied first

  76. final def toArray[AA >: A](s: S)(implicit ev: ClassTag[AA]): Array[AA]

    collect all the foci of a Fold_ into an Array

  77. final def toList(s: S): List[A]

    synonym to viewAll

  78. def toString(): String
    Definition Classes
    AnyRef → Any
  79. final def use(implicit ev: State[S, A]): State[S, List[A]]

    collect all the foci of a Fold_ in the state of a monad

  80. final def view(s: S)(implicit ev: Monoid[A]): A

    synonym to fold

  81. final def viewAll(s: S): List[A]

    collect all the foci of a Fold_ into aList

  82. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  83. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  84. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()

Inherited from FoldCompat[S, A]

Inherited from FoldCompat0[S, A]

Inherited from Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped