Repository F# setup

open Reified
open Reified.Refinements
open Reified.Result

Match selected parts of data

Matching checks only the values relevant to a test. Unmentioned fields and items can vary without breaking it.

Verified

open Reified
open Reified.DataDSL

let actual =
    data [
        "customer" => [
            "id" => "c-123"
            "name" => "Ada"
            "address" => [ "city" => "Adelaide"; "postcode" => 5000 ]
        ]
        "roles" => [ "author"; "billing"; "admin" ]
        "timeline" => [ "created"; "checked"; "activated" ]
        "events" => [ [ "id" => "e-1" ]; [ "id" => "e-2" ] ]
        "values" => [ 1; 2; 3 ]
        "total" => 19.95m
    ]

Reified

Reified.DataDSL

Concise opt-in syntax for literals, immutable edits, cases, and matching.

actual: Data

data: DataField list -> Data

Builds an object from ordered field instructions. data [ "name" => "Ada"; "active" => true ] // Data.Object [ "name", Data.Text "Ada"; "active", Data.Bool true ]

(=>): string -> ^value -> DataField

Associates a field name with an exact value or recursive data pattern.

Check selected paths

Use at and absent when only a few observations matter:

Verified

actual
|> matching [
    at "customer.name" "Ada"
    at "customer.id" anyText
    absent "error"
]

actual: Data

(|>): 'T1 -> ('T1 -> 'U) -> 'U

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

matching: DataExpectation list -> Data -> unit

Checks expectations or raises DataMatchException. open Reified.DataDSL let actual = data [ "user" => data [ "name" => "Ada" ] ] matching [ at "user.name" "Ada"; absent "error" ] actual // returns unit when both expectations hold; otherwise raises DataMatchException

at: string -> ^a -> DataExpectation

Requires a path to contain an exact value or recursive pattern.

anyText: DataPattern

Matches any text value.

absent: string -> DataExpectation

Requires a path to be absent.

Every expectation is checked against the same root. Failures accumulate instead of stopping after the first mismatch.

The match returns unit without comparing unmentioned response fields.

For a result-returning assertion:

Verified

let result =
    Data.tryMatch [
        at "customer.name" "Grace"
        absent "customer.id"
    ] actual

result: Result<unit,DataMismatch list>

Reified.DataModule

tryMatch: DataExpectation list -> Data -> Result<unit,DataMismatch list>

Checks path-based expectations and accumulates structured mismatches. Data.tryMatch [ at "name" "Ada" ] (data [ "name" => "Grace" ]) // Error [ mismatch at path "name": expected "Ada", found "Grace" ]

at: string -> ^a -> DataExpectation

Requires a path to contain an exact value or recursive pattern.

absent: string -> DataExpectation

Requires a path to be absent.

actual: Data

result is Error containing two DataMismatch values: one at customer.name with the actual text "Ada", and one at customer.id with the present identifier "c-123" that was expected to be absent.

Verified

result
// => Error [
//      { ExpectationIndex = 0; Path = DataPath.parse "customer.name"; Actual = Some (Data.Text "Ada"); ... }
//      { ExpectationIndex = 1; Path = DataPath.parse "customer.id"; Actual = Some (Data.Text "c-123"); ... }
//    ]

result: Result<unit,DataMismatch list>

Match a partial object

Use containing to check related fields as one object:

Verified

actual
|> matching [
    at "customer" (
        containing [
            "name" => "Ada"
            "address" => containing [
                "city" => "Adelaide"
            ]
        ])
]

actual: Data

(|>): 'T1 -> ('T1 -> 'U) -> 'U

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

matching: DataExpectation list -> Data -> unit

at: string -> ^a -> DataExpectation

Requires a path to contain an exact value or recursive pattern.

containing: DataField list -> DataPattern

Creates a partial object pattern from required fields. Data.tryMatch [ at "" (containing [ "id" => 42 ]) ] (data [ "id" => 42; "extra" => true ]) // Ok ()

(=>): string -> ^value -> DataField

Associates a field name with an exact value or recursive data pattern.

Extra fields are allowed. Required fields must be present and match their literal or recursive pattern.

This succeeds for an object such as {"name":"Ada","address":{"city":"Adelaide","postcode":5000},"id":"c-123"}. Neither postcode nor id is rejected because the pattern does not mention them at their respective object levels.

Verified

Data.tryMatch [
    at "customer" (containing [
        "name" => "Ada"
        "address" => containing [ "city" => "Adelaide" ]
    ])
] actual
// => Ok ()

Reified.DataModule

tryMatch: DataExpectation list -> Data -> Result<unit,DataMismatch list>

at: string -> ^a -> DataExpectation

Requires a path to contain an exact value or recursive pattern.

containing: DataField list -> DataPattern

Creates a partial object pattern from required fields. Data.tryMatch [ at "" (containing [ "id" => 42 ]) ] (data [ "id" => 42; "extra" => true ]) // Ok ()

(=>): string -> ^value -> DataField

Associates a field name with an exact value or recursive data pattern.

actual: Data

Choose list semantics explicitly

Verified

actual
|> matching [
    at "roles" (containingItems [ "admin"; "author" ])
    at "timeline" (inOrder [ "created"; "activated" ])
    at "events" (allItems (containing [ "id" => anyText ]))
    at "values" (someItem anyNumber)
]

actual: Data

(|>): 'T1 -> ('T1 -> 'U) -> 'U

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

matching: DataExpectation list -> Data -> unit

at: string -> ^a -> DataExpectation

Requires a path to contain an exact value or recursive pattern.

containingItems: ^a list -> DataPattern

Matches expected items as an unordered consumed subset. open Reified.DataDSL let actual = data [ "items" => [ "Ada"; "Grace"; "Mallory" ] ] Data.tryMatch [ at "items" (containingItems [ "Ada"; "Grace" ]) ] actual // Ok () when both values occur, in either order

inOrder: ^a list -> DataPattern

Matches expected items as an ordered subsequence.

allItems: ^a -> DataPattern

Requires every actual list item to satisfy a pattern.

containing: DataField list -> DataPattern

Creates a partial object pattern from required fields. Data.tryMatch [ at "" (containing [ "id" => 42 ]) ] (data [ "id" => 42; "extra" => true ]) // Ok ()

(=>): string -> ^value -> DataField

Associates a field name with an exact value or recursive data pattern.

anyText: DataPattern

Matches any text value.

someItem: ^a -> DataPattern

Requires at least one actual list item to satisfy a pattern.

anyNumber: DataPattern

Matches any number token.

containingItems consumes actual occurrences, so an actual item cannot satisfy two expected occurrences.

inOrder allows unrelated values between expected items. It does not reorder the actual list.

For roles = ["author","billing","admin"], containingItems [ "admin"; "author" ] succeeds regardless of order. For timeline = ["created","checked","activated"], inOrder [ "created"; "activated" ] succeeds.

containingItems [ "admin"; "admin" ] fails when admin occurs once. inOrder [ "activated"; "created" ] fails because those values occur in the opposite order.

Verified

Data.tryMatch [ at "roles" (containingItems [ "admin"; "author" ]) ] actual
// => Ok ()

Data.tryMatch [ at "roles" (containingItems [ "admin"; "admin" ]) ] actual
// => Error [ { Path = DataPath.parse "roles[1]"; Expected = "a matching list item"; ... } ]

Reified.DataModule

tryMatch: DataExpectation list -> Data -> Result<unit,DataMismatch list>

at: string -> ^a -> DataExpectation

Requires a path to contain an exact value or recursive pattern.

containingItems: ^a list -> DataPattern

actual: Data

Use a predicate for a local rule

Verified

let positiveNumber =
    satisfying "a positive number token" (function
        | Data.Number token -> decimal token > 0m
        | _ -> false)

actual
|> matching [
    at "total" positiveNumber
]

positiveNumber: DataPattern

satisfying: string -> (Data -> bool) -> DataPattern

Matches an ordinary predicate and uses its description in diagnostics.

Reified.Data

A portable tree for structured data. Data preserves null, text, number, Boolean, list, and object distinctions without depending on a serializer or input format. Data is a structured-value model, not a source syntax tree. It does not model whitespace, comments, source locations, or other format-specific syntax. Number values currently retain a lexical token so adapters do not narrow arbitrary-size integers, decimal precision, or exponent notation to one runtime numeric type.

Number

A number whose portable lexical token avoids narrowing it to one runtime numeric type.

token: string

decimal: ^T -> decimal

Converts the argument to System.Decimal using a direct conversion for all primitive numeric types. For strings, the input is converted using UInt64.Parse() with InvariantCulture settings. Otherwise the operation requires an appropriate static conversion method on the input type. The input value. The converted decimal. decimal "42.23" // evaluates to 42.23M decimal 0xff // evaluates to 255M decimal -10 // evaluates to -10M

(>): 'T -> 'T -> bool

Structural greater-than The first parameter. The second parameter. The result of the comparison. 5 > 1 // Evaluates to true 5 > 5 // Evaluates to false (1, "a") > (1, "z") // Evaluates to false

actual: Data

(|>): 'T1 -> ('T1 -> 'U) -> 'U

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

matching: DataExpectation list -> Data -> unit

at: string -> ^a -> DataExpectation

Requires a path to contain an exact value or recursive pattern.

The description appears in mismatch output, so use wording that explains the failed requirement.

Data.Number "19.95" satisfies this predicate. Data.Number "0" produces a mismatch whose expected description is a positive number token; Data.Text "19.95" also fails because the predicate requires a number shape.

Verified

Data.tryMatch [ at "total" positiveNumber ] (data [ "total" => 19.95m ])
// => Ok ()

Data.tryMatch [ at "total" positiveNumber ] (data [ "total" => 0 ])
// => Error [ { Path = DataPath.parse "total"; Expected = "a positive number token"; ... } ]

Reified.DataModule

tryMatch: DataExpectation list -> Data -> Result<unit,DataMismatch list>

at: string -> ^a -> DataExpectation

Requires a path to contain an exact value or recursive pattern.

positiveNumber: DataPattern

data: DataField list -> Data

Builds an object from ordered field instructions. data [ "name" => "Ada"; "active" => true ] // Data.Object [ "name", Data.Text "Ada"; "active", Data.Bool true ]

(=>): string -> ^value -> DataField

Associates a field name with an exact value or recursive data pattern.

Complete matching vocabulary

The full pattern inventory is in the DataPattern API reference; a few representative patterns:

Verified

Data.tryMatch [
    at "customer.name" (oneOf [ exactly "Ada"; exactly "Grace" ])
    at "customer.id" anyText
    at "values" (allItems anyNumber)
] actual
// => Ok ()

Reified.DataModule

tryMatch: DataExpectation list -> Data -> Result<unit,DataMismatch list>

at: string -> ^a -> DataExpectation

Requires a path to contain an exact value or recursive pattern.

oneOf: DataPattern list -> DataPattern

Matches when one supplied alternative matches.

exactly: ^a -> DataPattern

Creates an exact recursive pattern.

anyText: DataPattern

Matches any text value.

allItems: ^a -> DataPattern

Requires every actual list item to satisfy a pattern.

anyNumber: DataPattern

Matches any number token.

actual: Data

Why patterns are not constraints

anyText, anyNumber, and satisfying check Data nodes: whether a branch is text, a value is present, or a list contains an item. Constraint checks extracted typed values, such as whether a string is a valid email or an int is at least 13. Tests of produced JSON need the former.

Reified.Data has no dependencies, so test projects can use it without a validation library. Accepting a Constraint<'value> in at would add a dependency on Reified.Constraint for a test convenience.

For typed rules inside a Data tree, parse it with a schema and check the model; the schema reports paths and accumulated errors. Use satisfying for a local structural rule that no schema owns.

Match selected parts of data

Check selected paths

Match a partial object

Choose list semantics explicitly

Use a predicate for a local rule

Complete matching vocabulary

Why patterns are not constraints

Overview

Docs

API Reference