Inspecting Schema Metadata Tutorial

The concise schema-definition vocabulary: the record computation expression, its field and constructor forms, and the collection-schema operations. Optional and opt-in, in the same shape as Reified.DataDSL and Reified.ConstraintDSL: open Reified.Schema for Schema, then open Reified.SchemaDSL for this vocabulary. There is no constraint catalogue here. One Constraint vocabulary serves direct checking, refinement, and Schema, so a field block reaches for Constraint.email or an opened Reified.ConstraintDSL exactly as standalone code does. Boundary supply is Schema-owned and stays here as mustSupply and mayOmit.

Constraint constructors usable without the Constraint. prefix inside a module that declares value rules. Optional vocabulary, not another abstraction. Opening it makes a declaration read minLength 3 instead of Constraint.minLength 3; everything here is the same value the qualified name returns. Some constructors are deliberately left out because they shadow names the same validation code is likely to need in scope: contains, distinct, all, any, length, and between shadow core F# operations. Reach for those as Constraint.contains, Constraint.all, and so on, even inside a module that has opened this DSL. Constraint execution (Constraint.satisfies, Constraint.check, Constraint.guard) is likewise always qualified: ConstraintDSL declares constraints, Constraint.* executes and inspects them. orError and mapError are structural adapters matching the corresponding Result operations. They let a constraint pipeline retain its input and finish with the application's error type without adding an Reified.Result dependency. module SignupRules = open Reified.ConstraintDSL let age : Constraint<int> = atLeast 13 let contact : Constraint<string> = Constraint.all [ present; email ] let requireContact value = value |> Constraint.guard contact |> orError EmailRequired

An abbreviation for the CLI type . Basic Types

An abbreviation for the CLI type . Basic Types

Record-schema computation expression.

Declares a field, deriving its camel-cased wire name from the property getter. type Signup = { Email: string } field (fun (s: Signup) -> s.Email) // wire name "email"

Declares a field, deriving its camel-cased wire name from the property getter. type Signup = { Email: string } field (fun (s: Signup) -> s.Email) // wire name "email"

Supplies the schema transformed by the remaining operations in this field block.

Construction, composition, parsing, and checking for universal schemas.

Describes text input.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Adds format metadata.

Functions for creating and inspecting schema value format metadata.

The well-known email address format.

Declares a field, deriving its camel-cased wire name from the property getter. type Signup = { Email: string } field (fun (s: Signup) -> s.Email) // wire name "email"

Closes a record schema with a total constructor.

The inspection API over built schemas and value schemas. Inspect is the entry point for non-validation interpreters: JSON Schema generation, documentation, UI metadata, and codec planning all start from the same descriptions. The returned trees are plain immutable data — inspecting them never parses input, runs checks, or constructs models.

Describes a built model schema as inspectable field metadata. The built model schema to describe. Thrown when is null. Thrown when is not a completed model schema. let description = Inspect.model customerSchema let names = description.Fields |> List.map _.Name

The field descriptions in declared order.

Contains operations for working with values of type . Operations for collections such as lists, arrays, sets, maps and sequences. See also F# Collection Types in the F# Language Guide.

Builds a new collection whose elements are the results of applying the given function to each of the elements of the collection. The function to transform elements from the input list. The input list. The list of transformed elements. let inputs = [ "a"; "bbb"; "cc" ] inputs |> List.map (fun x -> x.Length) Evaluates to [ 1; 3; 2 ]

The canonical boundary-facing external field name.

The zero-based field order used for trusted construction and ordered interpreter output.

One interpreted primitive: the complete semantic identity of a built-in constraint. An interpreted constructor builds exactly one atom and places that same value in both its description and any violation it produces, so a primitive's identity and its failure cannot drift. Atoms are shape-neutral; an interpreter combines an atom with the surrounding schema shape to decide what it lowers to.

A text length or collection count rule.

What a size rule expects of a text length or collection count. Shape-neutral. An interpreter combines it with the schema shape to reach maxLength, maxItems, or maxProperties. Text sizes count Unicode code points, not UTF-16 code units.

At most the supplied size.

The representation of "Value of type 'T" The input value. An option representing the value.

A built-in text format rule.

A match for the supplied .NET regular expression.

The representation of "No value"

Describes one value schema: its shape, declared format, and portable constraint metadata.

The constraint descriptions attached to this value schema layer, in declaration order.

Apply a function to a value, the value being on the left, the function on the right The argument. The function. The function result. let doubleIt x = x * 2 3 |> doubleIt // Evaluates to 6

Contains operations for working with values of type . Operations for collections such as lists, arrays, sets, maps and sequences. See also F# Collection Types in the F# Language Guide.

For each element of the list, applies the given function. Concatenates all the results and return the combined list. The function to transform each input element into a sublist to be concatenated. The input list. The concatenation of the transformed sublists. For each positive number in the array we are generating all the previous positive numbers [1..4] |> List.collect (fun x -> [1..x]) The sample evaluates to [1; 1; 2; 1; 2; 3; 1; 2; 3; 4] (added extra spaces for easy reading)

Builds and traverses constraint descriptions.

Every interpreted primitive reachable without crossing an opacity boundary, in authored order. Use this only where dropping an unexportable sibling stays sound. Dropping a conjunct weakens a conjunction and dropping a disjunct strengthens a disjunction, so an interpreter that claims enforcement must consult the whole expression rather than this projection.

Applies a function to each element in a list and then returns a list of values v where the applied function returned Some(v). Returns an empty list when the input list is empty or when the applied chooser function returns None for all elements. The function to be applied to the list elements. The input list. The resulting list comprising the values v where the chooser function returned Some(x). Using the identity function id (is defined like fun x -> x): let input1 = [ Some 1; None; Some 3; None ] input1 |> List.choose id Evaluates to [ 1; 3 ] type Happiness = | AlwaysHappy | MostOfTheTimeGrumpy type People = { Name: string; Happiness: Happiness } let takeJustHappyPersons person = match person.Happiness with | AlwaysHappy -> Some person.Name | MostOfTheTimeGrumpy -> None let candidatesForTheTrip = [ { Name = "SpongeBob" Happiness = AlwaysHappy } { Name = "Patrick" Happiness = AlwaysHappy } { Name = "Squidward" Happiness = MostOfTheTimeGrumpy } ] candidatesForTheTrip |> List.choose takeJustHappyPersons Evaluates to [ "SpongeBob"; "Patrick" ] let input3: int option list = [] input3 |> List.choose id Evaluates to: empty list let input4: string option list = [None; None] input4 |> List.choose id Evaluates to empty list Using the identity function id (is defined like fun x -> x): let input5 = [ Some 1; None; Some 3; None ] input5 |> List.choose id // evaluates [1; 3]