zio.schema

Base trait for mutable builders producing a value based on a schema, such as codec decoders.

The implementation is stack safe and consists of a series of invocations of the protected methods the trait defines. Maintaining the state of the builder, such as stream position etc. is the responsibility of the implementation class via mutable state.

The Target type parameter is the base type for the generated values - this in many cases can be Any but potentially could be used to track errors in value level as well - although failure in the context handler manipulation methods cannot be expressed this way.

The Context type parameter is a use-case dependent type that is managed in a stack during the execution of the builder. The implementation can generate new context values for the value's subtrees and it can be used to track local state required for gathering all information for the value to be created. The current context value is also propagated to any exception thrown so it can be used to provide detailed location information for decoder errors.

Base trait for mutable value processors, processing a value with a known schema. An example is protocol encoders.

The implementation is stack safe and consists of invocations of a series of processXYZ methods, as well as built-in support for a context value which is handled in a stacked way.

Maintaining any global state (per process) such as stream writers etc. is the responsibility of the implementation class.

The Target type parameter is the base type for the process function's output value. In case the process is built entirely using side effects (such as calls to a mutable writer interface) this type can be Unit.

The Context type parameter is the use-case specific context type which is passed for each process invocation, and can be manipulated before each process call achieving a local state.

A Schema[A] describes the structure of some data type A, in terms of case classes, enumerations (sealed traits), collections, and various primitive types (including not only Scala's own primitive types, but enhanced with java.time and big integers / decimals).

Schemas models the structure of data types as first class values, so they can be introspected, transformed, and combined using ordinary Scala code, without macros, metaprogramming, or codegen.

There are implicit schemas provided for all standard Scala types, and you can automatically derive schemas for your own data types by using DeriveSchema.gen[A]. Whether you write them by hand by using constructors and operators,

final case class Person(name: String, age: Int)
object Person {
 implicit val personSchema: Schema[Person] = DeriveSchema.gen[Person]
}

A simpler version of SimpleMutableSchemaBasedValueBuilder without using any Context

A simpler version of MutableSchemaBasedValueProcessor without using any Context