Type Members

1.  abstract class Fold[S, A] extends Serializable

   A Fold can be seen as a Getter with many targets or a weaker PTraversal which cannot modify its target.

   A Fold can be seen as a Getter with many targets or a weaker PTraversal which cannot modify its target.

   Fold is on the top of the Optic hierarchy which means that Getter, PTraversal, POptional, PLens, PPrism and PIso are valid Fold

   S

   the source of a Fold

   A

   the target of a Fold

2.  sealed abstract class FoldInstances extends AnyRef
3.  abstract class Getter[S, A] extends Serializable

   A Getter can be seen as a glorified get method between a type S and a type A.

   A Getter can be seen as a glorified get method between a type S and a type A.

   A Getter is also a valid Fold

   S

   the source of a Getter

   A

   the target of a Getter

4.  sealed abstract class GetterInstances extends GetterInstances0
5.  sealed abstract class GetterInstances0 extends AnyRef
6.  type Iso[S, A] = PIso[S, S, A, A]
7.  sealed abstract class IsoInstances extends AnyRef
8.  final case class IsoSyntax[S, A](self: Iso[S, A]) extends AnyVal with Product with Serializable

   Extension methods for monomorphic Iso

9.  type Lens[S, A] = PLens[S, S, A, A]
10.  sealed abstract class LensInstances extends AnyRef
11.  final case class LensSyntax[S, A](self: Lens[S, A]) extends AnyVal with Product with Serializable

    Extension methods for monomorphic Lens

12.  type Optional[S, A] = POptional[S, S, A, A]
13.  sealed abstract class OptionalInstances extends AnyRef
14.  final case class OptionalSyntax[S, A](self: Optional[S, A]) extends AnyVal with Product with Serializable

    Extension methods for monomorphic Optional

15.  abstract class PIso[S, T, A, B] extends Serializable

    Iso is a type alias for PIso where S = A and T = B:

    Iso is a type alias for PIso where S = A and T = B:

    type Iso[S, A] = PIso[S, S, A, A]

    An Iso defines an isomorphism between a type S and A:

                get
        -------------------->
      S                       A
        <--------------------
             reverseGet
    

    A PIso allows to lift a function f: A => B to S => T and a function g: T => S to B => A

                                                              g
        S           T                                   S <-------- T
        |           ↑                                   |           ↑
        |           |                                   |           |
    get |           | reverseGet     reverse.reverseGet |           | reverse.get
        |           |                                   |           |
        ↓     f     |                                   ↓           |
        A --------> B                                   A           B
    

    A PIso is also a valid Getter, Fold, PLens, PPrism, POptional, PTraversal and PSetter

    S

    the source of a PIso

    T

    the modified source of a PIso

    A

    the target of a PIso

    B

    the modified target of a PIso

    See also

    monocle.law.IsoLaws

16.  abstract class PLens[S, T, A, B] extends Serializable

    A PLens can be seen as a pair of functions:

    A PLens can be seen as a pair of functions:

    • get: S => A i.e. from an S, we can extract an A
    • set: (B, S) => T i.e. if we replace an A by a B in an S, we obtain a T

    A PLens could also be defined as a weaker PIso where replace requires an additional parameter than reverseGet.

    PLens stands for Polymorphic Lens as it replace and modify methods change a type A to B and S to T. Lens is a type alias for PLens restricted to monomorphic updates:

    type Lens[S, A] = PLens[S, S, A, A]

    A PLens is also a valid Getter, Fold, POptional, PTraversal and PSetter

    Typically a PLens or Lens can be defined between a Product (e.g. case class, tuple, HList) and one of its component.

    S

    the source of a PLens

    T

    the modified source of a PLens

    A

    the target of a PLens

    B

    the modified target of a PLens

    See also

    monocle.law.LensLaws

17.  abstract class POptional[S, T, A, B] extends Serializable

    A POptional can be seen as a pair of functions:

    A POptional can be seen as a pair of functions:

    • getOrModify: S => Either[T, A]
    • replace : (B, S) => T

    A POptional could also be defined as a weaker PLens and weaker PPrism

    POptional stands for Polymorphic Optional as it replace and modify methods change a type A to B and S to T. Optional is a type alias for POptional restricted to monomorphic updates:

    type Optional[S, A] = POptional[S, S, A, A]

    S

    the source of a POptional

    T

    the modified source of a POptional

    A

    the target of a POptional

    B

    the modified target of a POptional

    See also

    monocle.law.OptionalLaws

18.  abstract class PPrism[S, T, A, B] extends Serializable

    A PPrism can be seen as a pair of functions:

    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

    See also

    monocle.law.PrismLaws

19.  abstract class PSetter[S, T, A, B] extends Serializable

    A PSetter is a generalisation of Functor map:

    A PSetter is a generalisation of Functor map:

    • map: (A => B) => F[A] => F[B]
    • modify: (A => B) => S => T

    PSetter stands for Polymorphic Setter as it replace and modify methods change a type A to B and S to T. Setter is a type alias for PSetter restricted to monomorphic updates:

    type Setter[S, A] = PSetter[S, S, A, A]

    PTraversal, POptional, PPrism, PLens and PIso are valid PSetter

    S

    the source of a PSetter

    T

    the modified source of a PSetter

    A

    the target of a PSetter

    B

    the modified target of a PSetter

    See also

    monocle.law.SetterLaws

20.  abstract class PTraversal[S, T, A, B] extends Serializable

    A PTraversal can be seen as a POptional generalised to 0 to n targets where n can be infinite.

    A PTraversal can be seen as a POptional generalised to 0 to n targets where n can be infinite.

    PTraversal stands for Polymorphic Traversal as it replace and modify methods change a type A to B and S to T. Traversal is a type alias for PTraversal restricted to monomorphic updates:

    type Traversal[S, A] = PTraversal[S, S, A, A]

    S

    the source of a PTraversal

    T

    the modified source of a PTraversal

    A

    the target of a PTraversal

    B

    the modified target of a PTraversal

    See also

    monocle.law.TraversalLaws

21.  type Prism[S, A] = PPrism[S, S, A, A]
22.  sealed abstract class PrismInstances extends AnyRef
23.  final case class PrismSyntax[S, A](self: Prism[S, A]) extends AnyVal with Product with Serializable
24.  type Setter[S, A] = PSetter[S, S, A, A]
25.  sealed abstract class SetterInstances extends AnyRef
26.  final case class SetterSyntax[S, A](self: Setter[S, A]) extends AnyVal with Product with Serializable

    Extension methods for monomorphic Setter

27.  type Traversal[S, A] = PTraversal[S, S, A, A]
28.  sealed abstract class TraversalInstances extends AnyRef
29.  final case class TraversalSyntax[S, A](self: Traversal[S, A]) extends AnyVal with Product with Serializable

    Extension methods for monomorphic Traversal