Optional

Returns the part of s that this optional focuses on, or None when it is missing.

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

Book.firstTag.getOption(Book("Zionomicon", List("zio", "scala"))) // Some(zio)
Book.firstTag.getOption(Book("Zionomicon", Nil))                  // None

Returns a copy of s with the part this optional focuses on replaced by a. When the part is missing, or a wrapped step on the path throws a SchemaError, the result equals s.

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

Book.firstTag.replace(Book("Zionomicon", List("zio", "scala")), "effects") // Book(Zionomicon,List(effects, scala))
Book.firstTag.replace(Book("Zionomicon", Nil), "effects")                  // Book(Zionomicon,List())

Like replace, but returns None when the part is missing or a wrapped step on the path throws a SchemaError.

Like replace, but returns Left with an OpticCheck when the part is missing, or with an OpticCheck.WrappingError when a wrapped step on the path throws a SchemaError.

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

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

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

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

Like getOption, but returns Left with an OpticCheck that says why the part is missing, for example During attempted access at .tags.at(0), encountered a sequence out of bounds at .tags.at(0): index is 0, but size is 0.

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.