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

A Traversal_ is an optic that focuses on zero or more values

S

the source of a Traversal_

T

the modified source of a Traversal_

A

the foci of a Traversal_

B

the modified foci of a Traversal_

Self Type
Traversal_[S, T, A, B]
Source
Traversal.scala
Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Traversal_
  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 Traversal_()

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 Traversal_ with an IndexedFold_, having this Traversal_ applied first

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

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

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

    compose this Traversal_ with an IndexedSetter_, having this Traversal_ applied first

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    compose this Traversal_ with an AnAffineTraversal_, having this Traversal_ applied first

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

    compose this Traversal_ with an AffineTraversal_, having this Traversal_ applied first

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

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

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

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

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

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

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

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

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

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

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

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

  24. 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
  25. final def asATraversal: ATraversal_[S, T, A, B]

    transform a Traversal_ to an ATraversal_

  26. final def asFold: Fold_[S, T, A, B]

    transform a Traversal_ to a Fold_

  27. final def asIndexableTraversal(implicit ev0: Applicative[[β$19$]IndexedStateT[Eval, Int, Int, β$19$]]): IndexedTraversal_[Int, S, T, A, B]

    convert a Traversal_ to an IndexedTraversal_ by using the integer positions as indices

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

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

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

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

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

    compose this Traversal_ with an IndexedSetter_, having this Traversal_ applied last

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    compose this Traversal_ with an AnAffineTraversal_, having this Traversal_ applied last

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

    compose this Traversal_ with an AffineTraversal_, having this Traversal_ applied last

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

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

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

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

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

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

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

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

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

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

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

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

  49. 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
  50. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  51. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  52. 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
  53. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  54. final def find(f: (A) => Boolean): (S) => Option[A]

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

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

    synonym for preview

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

    fold the foci of a Traversal_ using a cats.Monoid

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

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

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

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

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

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

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

  60. 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
  61. 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
  62. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  63. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  64. final def isEmpty(s: S): Boolean

    check if the Traversal_ does not contain a focus

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

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

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

    the number of foci of a Traversal_

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

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

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

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

  70. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  71. final def nonEmpty(s: S): Boolean

    check if the Traversal_ contains a focus

  72. 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
  73. 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
  74. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  75. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  76. 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
  77. final def over(f: (A) => B): (S) => T

    modify the foci type of a Traversal_ using a function, resulting in a change of type to the full structure

  78. final def overF[F[_]](f: (A) => F[B])(s: S)(implicit arg0: Applicative[F]): F[T]

    synonym for traverse, flipped

  79. final def preview(s: S): Option[A]

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

  80. 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
  81. final def sequence_[F[_]](s: S)(implicit ev: Applicative[F]): F[Unit]

    evaluate each focus of a Traversal_ from left to right, and ignore the results structure

  82. final def set(b: B): (S) => T

    set the modified foci of a Traversal_

  83. 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
  84. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  85. final def to[C, D](f: (A) => C): Fold_[S, T, C, D]

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

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

    collect all the foci of a Traversal_ into an Array

  87. final def toBazaar: Bazaar[[α$9$, β$10$](α$9$) => β$10$, A, B, S, T]

    convert a Traversal_ to a proptics.internal.Bazaar

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

    synonym to viewAll

  89. def toString(): String
    Definition Classes
    AnyRef → Any
  90. final def traverse[F[_]](s: S)(f: (A) => F[B])(implicit arg0: Applicative[F]): F[T]

    modify each focus of a Traversal_ using a Functor, resulting in a change of type to the full structure

  91. final def traverse_[F[_], R](s: S)(f: (A) => F[R])(implicit ev: Applicative[F]): F[Unit]

    map each focus of a Traversal_ to an effect, from left to right, and ignore the results

  92. final def unsafePartsOf(implicit ev0: Sellable[[α$24$, β$25$](α$24$) => β$25$, [β$26$, γ$27$, ε$28$]Bazaar[[α$22$, β$23$](α$22$) => β$23$, β$26$, γ$27$, Unit, ε$28$]], ev1: Aux[[α$29$, β$30$](α$29$) => β$30$, [β$31$]IndexedStateT[Eval, List[B], List[B], β$31$]]): Lens_[S, T, List[A], List[B]]

    convert a Traversal into a Lens over a list of the Traversal's foci

  93. final def use(implicit ev: State[S, A]): State[S, List[A]]

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

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

    synonym to fold

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

    collect all the foci of a Traversal_ into a List

  96. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  97. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  98. 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