Deferred

The kind of binding this node holds, such as BindingType.Record for a record. It fixes the types of metadata and binding.

The type that this reflect describes.

Returns this node as a Reflect.Dynamic, or None for another kind of node.

Returns this node as a Reflect.Map typed with the key, value and map types that IsMap gives for A, or None for another kind of node.

Returns this node as a map node whose key, value and map types are not known statically, or None for another kind of node. Use it when A is not known to be a map type.

Returns this node as a Reflect.Primitive, or None for another kind of node.

Returns this node as a Reflect.Record, or None for another kind of node.

Returns this node as a Reflect.Sequence typed with the element and collection types that IsCollection gives for A, or None for another kind of node.

Returns this node as a sequence node whose element and collection types are not known statically, or None for another kind of node. Use it when A is not known to be a collection type.

Returns this node as a Reflect.Variant, or None for another kind of node.

Returns this node as a wrapper node whose wrapped type is not known statically, or None for another kind of node.

Returns the Binding of this node: the functions that build and take apart values of A.

Returns a copy whose default value is dv. Unlike the other nodes, it does not evaluate dv: getDefaultValue evaluates it on every call.

Returns a copy that stands for the node with the documentation value.

Returns the documentation of value.

Checks whether this instance is equal to that. This universal equality method is defined in AnyRef.

Returns the examples set on this node, or else the examples of value.

Returns a copy whose examples are value and values, kept as values of A instead of DynamicValues.

Returns the default value set on this node, evaluated on each call, or else the default value of value.

Calculates a hash code value for the object.

The default hashing algorithm is platform dependent.

Note that it is allowed for two objects to have identical hash codes (o1.hashCode.equals(o2.hashCode)) yet not be equal (o1.equals(o2) returns false). A degenerate implementation could always return 0. However, it is required that if two objects are equal (o1.equals(o2) returns true) that they have identical hash codes (o1.hashCode.equals(o2.hashCode)). Therefore, when overriding this method, be sure to verify that the behavior is consistent with the equals method.

Returns true when this is a Reflect.Dynamic node.

Returns true when this is a Reflect.Map node.

Returns true when this is a Reflect.Primitive node.

Returns true when this is a Reflect.Record node.

Returns true when this is a Reflect.Sequence node.

Returns true when this is a Reflect.Variant node.

Returns true when this is a Reflect.Wrapper node.

Returns what this node holds besides its structure: a Binding in a bound reflect, NoBinding in an unbound one.

Returns a copy that stands for the node with modifier added.

Returns the modifiers of value.

Returns a copy that stands for the node with modifiers added.

Returns the kind of value.

Converts value into a DynamicValue with the same shape as this reflect: a DynamicValue.Record with the fields in declaration order, a DynamicValue.Variant named after the value's case, a DynamicValue.Sequence, a DynamicValue.Map or a DynamicValue.Primitive. A wrapper gives the dynamic value of the value it wraps, and a dynamic node returns value as it is. fromDynamicValue converts the result back.

case class Book(title: String, year: Int)
object Book {
 implicit val schema: Schema[Book] = Schema.derived
}

val value = Book.schema.reflect.toDynamicValue(Book("Zionomicon", 2021))
// {
//   title: "Zionomicon",
//   year: 2021
// }

Returns a string representation of the object.

The default representation is platform dependent.

Returns a deferred node that transforms value with f when it is first needed. The result is cached per thread under this node and f, which is what makes the transformation of a recursive type terminate.

Returns _typeId when it is set, or else the type ID of value, or the placeholder `` when looking it up comes back to this node.

Returns a copy whose type ID is newTypeId, without building value.

Returns a Term named name whose value is this node, to use as a field or case of a record or variant of type S.

Returns this reflect with aspect applied to the node that optic focuses on, or this reflect unchanged when the optic's path does not lead to a node.

Returns this reflect with the SchemaAspect aspect applied to it.

Returns a copy of this node whose documentation is value, as a single paragraph of plain text, replacing any it had. doc without an argument reads it back.

case class Book(title: String, year: Int)
object Book {
 implicit val schema: Schema[Book] = Schema.derived
}

val documented = Book.schema.reflect.doc("A book in the catalogue")
val text       = documented.doc.toString.trim // A book in the catalogue

Converts value into an A, or returns a SchemaError that lists where value does not fit this reflect. The errors of all the fields, elements and map entries are collected, not only the first one.

Each kind of node expects its own kind of DynamicValue:

• a record expects a DynamicValue.Record. It matches the fields by name, in any order, and ignores fields it does not know.
• a variant expects a DynamicValue.Variant whose case name it knows.
• a sequence expects a DynamicValue.Sequence, and a map a DynamicValue.Map.
• a primitive expects a DynamicValue.Primitive; numeric types and Char also accept other numeric or Char values that convert to them, without loss except for the cases listed at PrimitiveType#fromDynamicValue.
• a wrapper decodes the value of the type it wraps, then wraps it.
• a dynamic node accepts any value as it is.

The errors are ExpectationMismatch for the wrong kind of value, MissingField, DuplicatedField and UnknownCase, each at the path where it happened, and ConversionFailed at a path ending in .wrapped when a wrapper's wrap function throws. A missing field is an error even when the field has a default value, and Validation constraints are not checked (DynamicSchema#check checks them).

case class Book(title: String, year: Int)
object Book {
 implicit val schema: Schema[Book] = Schema.derived
}

val title = DynamicValue.Primitive(PrimitiveValue.String("Zionomicon"))
val year  = DynamicValue.Primitive(PrimitiveValue.Int(2021))

val book = Book.schema.reflect.fromDynamicValue(
 DynamicValue.Record("title" -> title, "year" -> year)
) // Right(Book(Zionomicon,2021))
val missing = Book.schema.reflect.fromDynamicValue(
 DynamicValue.Record("title" -> title)
) // Left(zio.blocks.schema.SchemaError: Missing field 'year' at: .)

Returns the node at the path dynamic, or None when the path does not lead to a node of this reflect.

Each step moves to a child node: a field step to the record field of that name, a case step to the variant case of that name, an index, indices or elements step to the element node of a sequence, a wrapped step to the wrapped node, a map-keys step to the key node of a map, and any other map step to its value node. A type search step moves to the first node, in depth-first order, whose type ID is the searched one, and a schema search step to the first node that matches its pattern; the rest of the path continues from there.

Returns the node that optic focuses on, or None when the optic's path does not lead to a node of this reflect.

case class Author(name: String)
object Author {
 implicit val schema: Schema[Author] = Schema.derived
}

case class Book(title: String, author: Author)
object Book extends CompanionOptics[Book] {
 implicit val schema: Schema[Book]   = Schema.derived
 val authorName: Lens[Book, String] = $(_.author.name)
}

val node = Book.schema.reflect.get(Book.authorName) // Some(String)

Returns true when this is a sequence or map node.

Returns true when this is a variant whose cases carry no data: each case is a record without fields, such as a case object, or is itself such a variant.

Returns true when this is the variant of a zio.blocks.maybe.Maybe: a variant whose type ID is Maybe, with two cases, the second named Present.

Returns true when this is the variant of a scala.Option: a variant whose type ID is Option in package scala, with two cases, the second named Some.

For an Option or Maybe variant, returns the node of the value it holds: the single field of its Some or Present case. Returns None for any other node.

An iterator over the names of all the elements of this product.

An iterator over all the elements of this product.

Returns a copy of this reflect in which the node at the path dynamic is replaced by f.update of it, or None when the path does not lead to a node. It follows field, case, sequence, wrapped, map-keys and map-values steps as get does, but it does not run type or schema searches: on a map node a type or schema search step is treated as a map-values step, and on any other node it returns None.

Returns a copy of this reflect in which the node that optic focuses on is replaced by f of it, or None when the optic's path does not lead to a node of this reflect.

The node that this one stands for, built on first access.

This reflect without bindings: the same tree, with the metadata of every node replaced by NoBinding. It keeps the structure, documentation, modifiers, default values and examples. Schema#toDynamicSchema wraps it in a DynamicSchema.