Prism

Returns s as the case A when it is that case, and None otherwise.

sealed trait Format
case class Paperback(pages: Int) extends Format
case class Ebook(sizeMb: Double) extends Format
object Format extends CompanionOptics[Format] {
 implicit val schema: Schema[Format] = Schema.derived
 val paperback: Prism[Format, Paperback] = $(_.when[Paperback])
}

Format.paperback.getOption(Paperback(870)) // Some(Paperback(870))
Format.paperback.getOption(Ebook(5.2))     // None

Returns a when s is the case A, and s unchanged otherwise.

sealed trait Format
case class Paperback(pages: Int) extends Format
case class Ebook(sizeMb: Double) extends Format
object Format extends CompanionOptics[Format] {
 implicit val schema: Schema[Format] = Schema.derived
 val paperback: Prism[Format, Paperback] = $(_.when[Paperback])
}

Format.paperback.replace(Paperback(870), Paperback(920)) // Paperback(920)
Format.paperback.replace(Ebook(5.2), Paperback(920))     // Ebook(5.2)

Like replace, but returns None when s is another case.

Returns a as a value of the variant S. It never fails, because a case is always a value of its variant.

Composes this prism with that prism. The result is a Prism.

Composes this prism with that lens. The result is an Optional.

Composes this prism with that optional. The result is an Optional.

Composes this prism with that traversal. The result is a Traversal.

Like getOption, but returns Left with an OpticCheck.UnexpectedCase when s is another case, for example During attempted access at .when[Paperback], encountered an unexpected case at .when[Paperback]: expected Paperback, but got Ebook. For a composed prism, it names the first step that does not match.

Like replace, but returns Left with an OpticCheck.UnexpectedCase when s is another case.

Builds a SchemaExpr that is true where the focus of this optic differs from the literal that.

Builds a SchemaExpr that is true where the focus of this optic differs from the focus of that.

Builds a SchemaExpr for the remainder of this optic's numeric focus divided by the literal that.

Builds a SchemaExpr for the bitwise and of this optic's integral focus and the literal that.

Builds a SchemaExpr for the logical and of this optic's Boolean focus and the literal that.

Builds a SchemaExpr for the logical and of this optic's Boolean focus and the focus of that.

Builds a SchemaExpr for this optic's numeric focus times the literal that.

Builds a SchemaExpr for this optic's numeric focus plus the literal that.

Builds a SchemaExpr for this optic's numeric focus minus the literal that.

Builds a SchemaExpr for this optic's numeric focus divided by the literal that.

Builds a SchemaExpr that is true where the focus of this optic is less than the literal that.

Builds a SchemaExpr that is true where the focus of this optic is less than the focus of that.

Builds a SchemaExpr for this optic's integral focus shifted left by the literal that.

Builds a SchemaExpr that is true where the focus of this optic is less than or equal to the literal that.

Builds a SchemaExpr that is true where the focus of this optic is less than or equal to the focus of that.

Builds a SchemaExpr that is true where the focus of this optic equals the focus of that.

Builds a SchemaExpr that is true where the focus of this optic equals the literal that. Evaluate it on an S with SchemaExpr#eval.

Builds a SchemaExpr that is true where the focus of this optic is greater than the literal that.

Builds a SchemaExpr that is true where the focus of this optic is greater than the focus of that.

Builds a SchemaExpr that is true where the focus of this optic is greater than or equal to the literal that.

Builds a SchemaExpr that is true where the focus of this optic is greater than or equal to the focus of that.

Builds a SchemaExpr for this optic's integral focus shifted right by the literal that, keeping the sign.

Builds a SchemaExpr for this optic's integral focus shifted right by the literal that, filling with zeros.

Builds a SchemaExpr for the bitwise exclusive or of this optic's integral focus and the literal that.

Returns this optic with its focus type changed to B, which ev proves is the same type. The optic is cast, not copied.

Builds a SchemaExpr for this optic's String focus followed by the literal that.

Builds a SchemaExpr for the length of this optic's String focus.

Composes this optic, whose focus is a List, with a traversal over every element of that list.

Builds a SchemaExpr that is true where this optic's String focus matches the Java regular expression that as a whole (java.util.regex.Pattern.matches).

Builds a SchemaExpr for this optic's numeric focus raised to the power of the literal that.

Composes this optic, whose focus is a Set, with a traversal over every element of that set.

Builds a SchemaExpr for the negation of this optic's Boolean focus.

Builds a SchemaExpr for the bitwise complement of this optic's integral focus.

Composes this optic, whose focus is a Vector, with a traversal over every element of that vector.

Builds a SchemaExpr for the bitwise or of this optic's integral focus and the literal that.

Builds a SchemaExpr for the logical or of this optic's Boolean focus and the literal that.

Builds a SchemaExpr for the logical or of this optic's Boolean focus and the focus of that.

Returns None when this optic reaches its focus in s, and otherwise an OpticCheck that says why not. The possible problems are another case of a variant, a wrapper whose unwrap throws a SchemaError (both errors), an index past the end, a missing map key, an empty collection, and, for searchFor, no match at all (all four warnings). Except for searchFor, which decodes every candidate with its schema, check never runs a wrapper's wrap, so it does not see failures that only replace or modify meet.

A Lens always returns None. A Prism and an Optional report the first problem on the path. A Traversal reports the problems in every branch it visits, even when it reaches other parts: atIndices(0, 2) on a one-element list reports index 2.

The schema of the parts this optic focuses on. For a composed optic, it is the focus of the last step.

Returns s with f applied to every part this optic focuses on. When there is nothing to focus on, the result equals s: a Prism on another case, an Optional on a missing index or key, a Traversal over an empty collection. It also equals s when a wrapped step on the path throws a SchemaError, including one that f throws below that step (a bug, see docs/dev/issues.md); other exceptions, from the path or from f, propagate. modifyOption and modifyOrFail say when nothing was modified.

case class Book(title: String, tags: List[String])
object Book extends CompanionOptics[Book] {
 implicit val schema: Schema[Book] = Schema.derived
 val tags: Traversal[Book, String] = $(_.tags.each)
}

Book.tags.modify(Book("Zionomicon", List("zio", "scala")), _.toUpperCase)
// Book(Zionomicon,List(ZIO, SCALA))

Like modify, but returns None instead of an unchanged value when there is nothing to focus on, and when a wrapped step on the path throws a SchemaError, including one that f throws below that step (a bug, see docs/dev/issues.md). A Lens always returns Some.

Like modify, but returns Left with an OpticCheck that says why nothing was modified, as check does, and a OpticCheck.WrappingError when a wrapped step on the path throws a SchemaError, including one that f throws below that step (a bug, see docs/dev/issues.md). A Lens always returns Right. A Traversal returns Right once it has modified at least one part, even when other parts are missing; check reports those.

The schema of the value this optic starts from. For a composed optic, it is the source of the first step.

Returns the path of this optic as a DynamicOptic, with one node per step. For example, $(_.format.when[Paperback].pages).toDynamic.toString is .format.pages.