Custom rules

An abbreviation for the CLI type . Basic Types

Structural equality The first parameter. The second parameter. The result of the comparison. 5 = 5 // Evaluates to true 5 = 6 // Evaluates to false [1; 2] = [1; 2] // Evaluates to true (1, 5) = (1, 6) // Evaluates to false

Creates, executes, composes, and inspects constraints.

Runs an arbitrary predicate, reporting the supplied prose and the author's own catalogue key when it fails. Opaque exactly as custom is — the key names a message, not a rule, and claims nothing inspectable. What it buys is translation: a failure from plain custom projects as verbatim prose, which no resource system can look up, so an application with localization and one custom rule would otherwise have one permanently untranslatable message. The prose is still required, and remains the default English rendering. Reified supplies no key of its own here; only an author who has a catalogue can name an entry in it. let isValidIsbn (isbn: string) = isbn.Length = 13 in Constraint.customLocalized "books.isbn.invalid" "must be a valid ISBN" isValidIsbn

Runs an arbitrary predicate, reporting the supplied prose plus a catalogue key and named arguments a translation can interpolate. The arguments are fixed at construction, which is what a rule's own operands are: an ISBN rule's expected length does not vary per value. A failure that must report something computed from the value takes customWith and builds its own violation. No plural operand is inferred. Ordinary .one/.other lookup applies only where a catalogue declares an operand, and guessing one from an argument's name or value would silently change which key a translator has to supply. let isValidIsbn (isbn: string) = isbn.Length = 13 in Constraint.customLocalizedWith "books.isbn.invalid" "must be a valid ISBN" (Map.ofList [ "expectedLength", ConstraintValue.Integer 13L ]) isValidIsbn

Contains operations for working with values of type .

Returns a new map made from the given bindings. The input list of key/value pairs. The resulting map. let input = [ (1, "a"); (2, "b") ] input |> Map.ofList // evaluates to map [(1, "a"); (2, "b")]

The closed set of operand and actual-value representations a constraint may carry across a description, diagnostic, or localization boundary. A value is admitted only when the representation is lossless in the semantics Reified's runtime diagnostics and exporters use. Semantic sorts keep their own case rather than being flattened into Text because their wire rendering happens to be textual: an instant and the string spelling it are different facts, and an interpreter that cannot tell them apart cannot decide whether wire equality substitutes for typed equality. Guid and TimeSpan are reached through typed dispatch rather than a runtime type test. Fable erases a Guid to a plain string and a TimeSpan to a number, so a boxed type test silently labels them Text and Integer there while .NET labels them correctly — the same constraint meaning two different things per platform. ConstraintValue.ofOperand resolves the overload at the call site, where the type is still known, so both platforms agree. Values outside this set are never boxed through the public surface. The constraint still executes against its private typed closure; the atom describes and fails as UnsupportedOperand instead. This is not a solver literal theory. A later proof phase declares its own numeric, date, and string sorts and adds a translation from the cases here; nothing may be added to this type for the solver alone.

An integral value that fits a signed 64-bit integer.

Runs a constraint, returning why the value failed. let retryCount = Constraint.between 0 10 42 |> Constraint.check retryCount |> Result.mapError Violation.render

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

Fail-fast helpers over the standard F# Result type.

Maps the error value of a result.

Inspects, traverses, and renders violations.

Renders a violation as an English sentence fragment with no trailing punctuation, keeping conjunction and alternative groups distinct. Violation.render (Atomic (Expected (PresenceAtom Present, None))) // "value must be present"

Renders a violation through a caller-supplied lookup, keeping the same grouping and separators render uses. The whole localization path in one call. toMessageTree remains available for a translator that needs to control word order across a group; this is for the common case, where a resource lookup per message is the entire job and matching the tree by hand is pure ceremony. Verbatim leaves — author prose with no catalogue key — are passed through untranslated, because there is nothing to look up. violation |> Violation.renderWith (fun descriptor -> resources.Format(descriptor.Key, descriptor.Arguments))

Lookup an element in the map, returning a Some value if the element is in the domain of the map and None if not. The input key. The input map. The found Some value or None. let sample = Map [ (1, "a"); (2, "b") ] sample |> Map.tryFind 1 // evaluates to Some "a" sample |> Map.tryFind 3 // evaluates to None

Reads and builds message identities.

The canonical unencoded key, exactly as authored. This is identity, not a lookup key. The encoded contextual resource keys a lookup receives come from Renderer.Advanced.lookupCandidates. let descriptor = MessageDescriptor.Advanced.create "books.isbn.invalid" Map.empty in MessageDescriptor.key descriptor // "books.isbn.invalid"

Contains operations for working with options. Options

Gets the value of the option if the option is Some, otherwise returns the specified default value. The specified default value. The input option. The option if the option is Some, else the default value. Identical to the built-in operator, except with the arguments swapped. (99, None) ||> Option.defaultValue // evaluates to 99 (99, Some 42) ||> Option.defaultValue // evaluates to 42