trait PPrism[S, T, A, B] extends POptional[S, T, A, B]
A PPrism can be seen as a pair of functions:
getOrModify: S => Either[T, A]reverseGet : B => T
A PPrism could also be defined as a weaker PIso where get can fail.
Typically a PPrism or Prism encodes the relation between a Sum or CoProduct type (e.g. sealed trait) and one of its element.
PPrism stands for Polymorphic Prism as it replace and modify methods change a type A to B and S to T.
Prism is a type alias for PPrism where the type of target cannot be modified:
type Prism[S, A] = PPrism[S, S, A, A]A PPrism is also a valid Fold, POptional, PTraversal and PSetter
- S
the source of a PPrism
- T
the modified source of a PPrism
- A
the target of a PPrism
- B
the modified target of a PPrism
- Self Type
- PPrism[S, T, A, B]
- Source
- Prism.scala
- See also
- Alphabetic
- By Inheritance
- PPrism
- POptional
- PTraversal
- Fold
- PSetter
- Serializable
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Abstract Value Members
- abstract def getOption(s: S): Option[A]
get the target of a POptional or nothing if there is no target
- abstract def getOrModify(s: S): Either[T, A]
get the target of a POptional or return the original value while allowing the type to change if it does not match
- abstract def reverseGet(b: B): T
get the modified source of a PPrism
Concrete Value Members
- def all(p: (A) => Boolean): (S) => Boolean
check if there is no target or the target satisfies the predicate
- def andThen[C, D](other: PPrism[A, B, C, D]): PPrism[S, T, C, D]
- def andThen[C, D](other: POptional[A, B, C, D]): POptional[S, T, C, D]
- def andThen[C, D](other: PTraversal[A, B, C, D]): PTraversal[S, T, C, D]
compose a PTraversal with another PTraversal
compose a PTraversal with another PTraversal
- Definition Classes
- PTraversal
- def andThen[B](other: Fold[A, B]): Fold[S, B]
- def andThen[C, D](other: PSetter[A, B, C, D]): PSetter[S, T, C, D]
- def apply[C, D, E, F, G, H](c: C, d: D, e: E, f: F, g: G, h: H)(implicit ev: <~<[(C, D, E, F, G, H), B]): T
- def apply[C, D, E, F, G](c: C, d: D, e: E, f: F, g: G)(implicit ev: <~<[(C, D, E, F, G), B]): T
- def apply[C, D, E, F](c: C, d: D, e: E, f: F)(implicit ev: <~<[(C, D, E, F), B]): T
- def apply[C, D, E](c: C, d: D, e: E)(implicit ev: <~<[(C, D, E), B]): T
- def apply[C, D](c: C, d: D)(implicit ev: <~<[(C, D), B]): T
- def apply(b: B): T
- def apply()(implicit ev: Is[B, Unit]): T
**********************************************************************
- def asFold: Fold[S, A]
view a PTraversal as a Fold
view a PTraversal as a Fold
- Definition Classes
- PTraversal
- def asOptional: POptional[S, T, A, B]
- def asSetter: PSetter[S, T, A, B]
view a PTraversal as a PSetter
view a PTraversal as a PSetter
- Definition Classes
- PTraversal
- def asTraversal: PTraversal[S, T, A, B]
view a POptional as a PTraversal
view a POptional as a PTraversal
- Definition Classes
- POptional
- def exist(p: (A) => Boolean): (S) => Boolean
check if there is a target and it satisfies the predicate
- def find(p: (A) => Boolean): (S) => Option[A]
find if the target satisfies the predicate
- def fold(s: S)(implicit ev: Monoid[A]): A
combine all targets using a target's Monoid
combine all targets using a target's Monoid
- Definition Classes
- Fold
- def foldMap[M](f: (A) => M)(s: S)(implicit arg0: Monoid[M]): M
map each target to a Monoid and combine the results
map each target to a Monoid and combine the results
- Definition Classes
- PTraversal → Fold
- def getAll(s: S): List[A]
get all the targets of a Fold
- def headOption(s: S): Option[A]
get the first target
get the first target
- Definition Classes
- Fold
- def index[I, A1](i: I)(implicit evIndex: Index[A, I, A1], evMonoS: =:=[S, T], evMonoA: =:=[A, B]): Optional[S, A1]
- Definition Classes
- PPrism → POptional → PTraversal → PSetter
- def index[I, A1](i: I)(implicit evIndex: Index[A, I, A1]): Fold[S, A1]
- Definition Classes
- Fold
- def isEmpty(s: S): Boolean
check if there is no target
- def lastOption(s: S): Option[A]
get the last target
get the last target
- Definition Classes
- Fold
- def length(s: S): Int
calculate the number of targets
calculate the number of targets
- Definition Classes
- Fold
- def modify(f: (A) => B): (S) => T
modify polymorphically the target of a PPrism with a function
modify polymorphically the target of a PPrism with a function
- Definition Classes
- PPrism → PTraversal → PSetter
- def modifyA[F[_]](f: (A) => F[B])(s: S)(implicit arg0: Applicative[F]): F[T]
modify polymorphically the target of a PPrism with an Applicative function
modify polymorphically the target of a PPrism with an Applicative function
- Definition Classes
- PPrism → PTraversal
- def modifyOption(f: (A) => B): (S) => Option[T]
modify polymorphically the target of a POptional with a function.
- def nonEmpty(s: S): Boolean
check if there is a target
- def orElse(other: POptional[S, T, A, B]): POptional[S, T, A, B]
fall-back to another POptional in case this one doesn't match
- def parModifyF[F[_]](f: (A) => F[B])(s: S)(implicit F: Parallel[F]): F[T]
PTraversal.modifyA for a
Parallelapplicative functor.PTraversal.modifyA for a
Parallelapplicative functor.- Definition Classes
- PTraversal
- def re: Getter[B, T]
create a Getter from the modified target to the modified source of a PPrism
- def replace(b: B): (S) => T
get the modified source of a POptional
get the modified source of a POptional
- Definition Classes
- PPrism → POptional → PTraversal → PSetter
- def replaceOption(b: B): (S) => Option[T]
replace polymorphically the target of a POptional with a value.
- def some[A1, B1](implicit ev1: =:=[A, Option[A1]], ev2: =:=[B, Option[B1]]): PPrism[S, T, A1, B1]
- Definition Classes
- PPrism → POptional → PTraversal → PSetter
- def some[A1](implicit ev1: =:=[A, Option[A1]]): Fold[S, A1]
- Definition Classes
- Fold
- def to[C](f: (A) => C): Fold[S, C]
Compose with a function lifted into a Getter
Compose with a function lifted into a Getter
- Definition Classes
- Fold
- def unapply(obj: S): Option[A]
Deprecated Value Members
- def first[C]: PPrism[(S, C), (T, C), (A, C), (B, C)]
- def left[C]: PPrism[Either[S, C], Either[T, C], Either[A, C], Either[B, C]]
- def right[C]: PPrism[Either[C, S], Either[C, T], Either[C, A], Either[C, B]]
- def second[C]: PPrism[(C, S), (C, T), (C, A), (C, B)]
- def set(b: B): (S) => T
alias to replace
alias to replace
- Definition Classes
- PSetter
- Annotations
- @deprecated
- Deprecated
(Since version 3.0.0-M1) use replace instead
- def setOption(b: B): (S) => Option[T]
alias to replaceOption
alias to replaceOption
- Definition Classes
- POptional
- Annotations
- @deprecated
- Deprecated
(Since version 3.0.0-M1) use replaceOption instead