The of Type System

of(T, args...; constant::Bool=false)

Create an OfType specification from various inputs.

Main Methods

Arrays

of(Array, dims...)              # Float64 array with given dimensions
of(Array, T, dims...)           # Array with numeric element type T and given dimensions

Real Numbers

of(Float64)                     # Unbounded Float64
of(Float64, lower, upper)       # Bounded Float64
of(Float32)                     # Unbounded Float32
of(Float32, lower, upper)       # Bounded Float32
of(Real)                        # Unbounded Real (defaults to Float64)
of(Real, lower, upper)          # Bounded Real (defaults to Float64)

Integers

of(Int)                         # Unbounded integer
of(Int, lower, upper)           # Bounded integer

Named Tuples

of((;field1=spec1, field2=spec2, ...))  # NamedTuple with typed fields

From Values (Type Inference)

of(1.0)                         # Infers of(Float64)
of([1, 2, 3])                   # Infers of(Array, Int, 3)
of((a=1, b=2.0))               # Infers OfNamedTuple

Arguments

• T: Type to create specification for
• args...: Type-specific arguments (bounds, dimensions, etc.)
• constant: Mark type as constant/hyperparameter (default: false)

Returns

An OfType subtype encoding the specification in its type parameters.

Examples

# Basic types
T1 = of(Float64, 0, 1)          # OfReal{Float64, 0, 1}
T2 = of(Array, 3, 4)            # OfArray{Float64, 2, (3, 4)}
T3 = of(Int; constant=true)     # OfConstantWrapper{OfInt{Nothing, Nothing}}

# With @of macro for cleaner syntax
T4 = @of(
    n = of(Int; constant=true),
    data = of(Array, n, 2)      # Symbolic dimension
)

# Type concretization
T5 = of(T4; n=10)               # Concrete type with n=10

See also

@of, OfType

of(::Type{T}, replacements::NamedTuple) where T<:OfType
of(::Type{T}; kwargs...) where T<:OfType
of(::Type{T}, pairs::Pair{Symbol}...) where T<:OfType

Create a concrete type by resolving symbolic dimensions and removing constants.

This function takes an OfType with symbolic dimensions or constants and creates a new type with some or all symbols resolved to concrete values. Constants that are provided are removed from the resulting type.

Arguments

• T<:OfType: The type to concretize
• replacements: Named tuple or keyword arguments mapping symbols to values

Returns

A new OfType with symbols replaced and constants removed.

Examples

# Define type with symbolic dimensions
T = @of(
    n = of(Int; constant=true),
    data = of(Array, n, 2)
)

# Create concrete type
ConcreteT = of(T; n=10)      # @of(data=of(Array, 10, 2))

# Partial concretization
T2 = @of(
    rows = of(Int; constant=true),
    cols = of(Int; constant=true),
    matrix = of(Array, rows, cols)
)
Partial = of(T2; rows=5)     # @of(cols=of(Int; constant=true), matrix=of(Array, 5, :cols))

See also

of, @of

@of(field1=spec1, field2=spec2, ...)

Create an OfNamedTuple type with cleaner syntax for field references.

The @of macro provides a more intuitive syntax for creating named tuple types where fields can reference each other. Field names used in dimensions or bounds are automatically converted to symbolic references.

Syntax

@of(
    field_name = of_specification,
    ...
)

Features

• Direct references to earlier constant fields without quoting (e.g., n instead of :n)
• Support for arithmetic expressions in dimensions (e.g., n+1, 2*n)
• Automatic conversion to appropriate OfNamedTuple type
• Fields are processed in order, allowing later fields to reference earlier constants

Examples

# Basic usage with constants and arrays
T = @of(
    n = of(Int; constant=true),
    mu = of(Real),
    data = of(Array, n, 2)  # 'n' automatically converted to symbolic reference
)

# With arithmetic expressions
T = @of(
    n = of(Int; constant=true),
    original = of(Array, n, n),
    padded = of(Array, n+1, n+1),
    doubled = of(Array, 2*n, n)
)

# Nested structures: field references resolve within the @of that declares them, so keep
# a dimension's constants in the same block (cross-level paths like `dims.rows` are not
# supported), then concretize the whole tree at once.
Inner = @of(
    rows = of(Int; constant=true),
    cols = of(Int; constant=true),
    matrix = of(Array, rows, cols)
)
T = @of(block = Inner)
CT = of(T; rows=3, cols=4)

See also

of, OfNamedTuple

flatten(::Type{T}, values) where T<:OfType

Convert structured values to a flat numeric vector.

Walks values in field order, vectorising arrays (column-major) and recursing into named tuples, and returns a flat vector whose element type is the promotion of the declared leaf element types (so a pure-Int structure stays Vector{Int}, while any float field widens the whole vector). This is the form an optimiser or sampler wants. Constants are excluded by construction, since a flattenable type has none.

Returns

A Vector{V} where V is promote_type of the declared leaf element types.

Examples

flatten(of(Float64), 3.14)            # [3.14]            (Vector{Float64})
flatten(of(Array, 2, 2), [1 2; 3 4])  # [1.0, 3.0, 2.0, 4.0]

T = @of(x=of(Real), y=of(Array, 2, 2))
flatten(T, (x=1.5, y=[1 2; 3 4]))     # [1.5, 1.0, 3.0, 2.0, 4.0]

Errors

• Throws if values do not match the specification (shape or bounds).
• Throws for types with unresolved symbolic dimensions, bounds, or constants.

See also

unflatten, length

unflatten(::Type{T}, flat_values::AbstractVector{<:Real}) where T<:OfType
unflatten(::Type{T}, ::Missing) where T<:OfType

Reconstruct structured values from a flat numeric vector (the inverse of flatten).

Arrays are reshaped, named tuples are rebuilt in field order, and bounds are validated. Floating-point leaves take promote_type(declared, eltype(flat_values)): the declared float type acts as a precision floor, while wider numbers in flat_values — AD numbers (ForwardDiff.Dual), BigFloat — flow through unchanged. Integer leaves are rounded to Int.

The missing method builds a structure with every element set to missing.

Examples

unflatten(of(Float64), [3.14])            # 3.14
unflatten(of(Array, 2, 2), [1, 3, 2, 4])  # [1.0 2.0; 3.0 4.0]

T = @of(x=of(Real), y=of(Array, 2, 2))
unflatten(T, [1.5, 1.0, 3.0, 2.0, 4.0])   # (x=1.5, y=[1.0 2.0; 3.0 4.0])

unflatten(T, missing)                     # (x=missing, y=[missing missing; missing missing])

Errors

• Throws if length(flat_values) differs from length(T).
• Throws if values violate bounds.
• Throws for types with unresolved symbolic dimensions, bounds, or constants.

See also

flatten, length

rand([rng::AbstractRNG], ::Type{T}) where T<:OfType

Generate random values matching the type specification.

Creates random instances that satisfy the constraints encoded in the OfType. Arrays are filled with random values, named tuples recurse over their fields, and bounded scalars respect their bounds. Pass an rng for reproducible draws; the method without one uses Random.default_rng().

The bounded/unbounded distributions are deliberate but unspecified conveniences:

• OfReal: uniform on [lower, upper]; for a single bound, a (reflected) shifted exponential; standard normal when unbounded.
• OfInt: uniform on lower:upper; for a single bound, an arbitrary 100-wide window anchored at it; -100:100 when unbounded.
• OfArray: each element drawn as for its element type.
• OfNamedTuple: each field drawn recursively.
• OfConstantWrapper: not supported (throws).

Examples

using Random

rand(of(Float64, 0, 1))                       # a Float64 in [0, 1]
rand(of(Array, 3, 4))                         # a 3×4 Matrix{Float64}
rand(StableRNG(1), @of(x=of(Real, 0, 1)))     # reproducible NamedTuple draw

T = @of(n=of(Int; constant=true), data=of(Array, n, 2))
rand(of(T; n=5))                              # (data = <random 5×2 array>,)

Errors

• Throws for types with unresolved symbolic dimensions or bounds.
• Throws for constant wrapper types.

See also

zero, of

zero(::Type{T}) where T<:OfType

Generate zero/default values matching the type specification.

Creates instances initialized to appropriate zero values that satisfy the constraints. For bounded types where zero is outside the bounds, returns the nearest bound value.

Behavior by Type

• OfReal: Returns 0.0 if within bounds, otherwise nearest bound
• OfInt: Returns 0 if within bounds, otherwise nearest bound
• OfArray: Returns array filled with zeros
• OfNamedTuple: Recursively generates zero values for all fields
• OfConstantWrapper: Not supported (throws error)

Examples

# Unbounded types
zero(of(Float64))           # 0.0
zero(of(Int))               # 0
zero(of(Array, 3, 2))       # 3×2 matrix of zeros

# Bounded types respect bounds
zero(of(Real, 1.0, 2.0))    # 1.0 (lower bound since 0 is outside)
zero(of(Int, -10, -5))      # -5 (upper bound since 0 is outside)

# Named tuples
T = @of(x=of(Real), y=of(Array, 2, 2))
zero(T)  # (x=0.0, y=[0.0 0.0; 0.0 0.0])

# With resolved constants
T = @of(n=of(Int; constant=true), data=of(Array, n, n))
zero(of(T; n=3))  # (data = 3×3 zero matrix)

Errors

• Throws error for types with unresolved symbolic dimensions
• Throws error for constant wrapper types

See also

rand, of

size(::Type{T}) where T<:OfType

Get the dimensions/shape of an OfType specification.

Returns the size information encoded in the type. For arrays, returns a tuple of dimensions. For scalars, returns an empty tuple. For named tuples, returns a named tuple with the size of each field.

Returns

• OfArray: Tuple of dimensions
• OfReal, OfInt: Empty tuple ()
• OfNamedTuple: Named tuple with sizes of each field
• OfConstantWrapper: Delegates to wrapped type

Examples

size(of(Array, 3, 4))        # (3, 4)
size(of(Float64))            # ()
size(of(Int, 0, 10))         # ()

T = @of(x=of(Real), y=of(Array, 2, 3))
size(T)                      # (x=(), y=(2, 3))

Errors

• Throws error for arrays with unresolved symbolic dimensions

See also

length, of

length(::Type{T}) where T<:OfType

Get the total number of elements when the type is flattened.

Returns the total count of numerical values that would be in a flattened representation. Arrays contribute their total element count, scalars contribute 1, and named tuples sum the lengths of all fields. Constants (wrapped in OfConstantWrapper) contribute 0 as they are not part of the flattened representation.

Returns

• OfArray: Product of dimensions (total elements)
• OfReal, OfInt: 1
• OfNamedTuple: Sum of lengths of all fields
• OfConstantWrapper: 0 (constants excluded from flattening)

Examples

length(of(Array, 3, 4))      # 12
length(of(Float64))          # 1
length(of(Int, 0, 10))       # 1

T = @of(x=of(Real), y=of(Array, 2, 3))
length(T)                    # 7 (1 + 6)

# Constants contribute 0; concrete fields still count
T2 = @of(n=of(Int; constant=true), data=of(Array, 3, 3))
length(T2)                   # 9 (n contributes 0, data contributes 9)
length(of(T2; n=5))          # 9 (n removed; data unchanged)

Errors

• Throws error for arrays with unresolved symbolic dimensions

See also

size, flatten, unflatten

OfType

Abstract base type for all types in the of type system.

The of type system provides a declarative way to specify parameter types for probabilistic programming. All of types encode their specifications (dimensions, bounds, etc.) in type parameters so downstream libraries can use them as schema types in their own annotation systems.

Subtypes

• OfReal{T,Lower,Upper}: Bounded or unbounded floating-point numbers
• OfInt{Lower,Upper}: Bounded or unbounded integers
• OfArray{T,N,Dims}: Arrays with specified element type and dimensions
• OfNamedTuple{Names,Types}: Named tuples with typed fields
• OfConstantWrapper{T}: Wrapper marking a type as constant/hyperparameter

See also

of, @of

OfReal{T<:AbstractFloat,Lower,Upper}

Type specification for bounded or unbounded floating-point numbers.

Type Parameters

• T<:AbstractFloat: The concrete floating-point type (e.g., Float64, Float32)
• Lower: Lower bound (numeric value, Nothing for unbounded, or SymbolicRef)
• Upper: Upper bound (numeric value, Nothing for unbounded, or SymbolicRef)

Examples

of(Float64)              # OfReal{Float64, Nothing, Nothing}
of(Float32, 0.0, 1.0)    # OfReal{Float32, 0.0, 1.0}
of(Real, 0, nothing)     # OfReal{Float64, 0, Nothing} (defaults to Float64)

See also

of, @of

OfInt{Lower,Upper}

Type specification for bounded or unbounded integers.

Type Parameters

• Lower: Lower bound (integer value, Nothing for unbounded, or SymbolicRef)
• Upper: Upper bound (integer value, Nothing for unbounded, or SymbolicRef)

Examples

of(Int)           # OfInt{Nothing, Nothing}
of(Int, 1, 10)    # OfInt{1, 10}
of(Int, 0, nothing)  # OfInt{0, Nothing}

See also

of, @of

OfArray{T,N,Dims}

Type specification for arrays with fixed element type and dimensions.

Type Parameters

• T: Element type of the array
• N: Number of dimensions
• Dims: Tuple type encoding the size of each dimension (can include SymbolicRef or SymbolicExpr)

Examples

of(Array, 3, 4)          # OfArray{Float64, 2, (3, 4)}
of(Array, Float32, 10)   # OfArray{Float32, 1, (10,)}
@of(n=of(Int; constant=true), data=of(Array, n, 2))  # Symbolic dimension

See also

of, @of

OfNamedTuple{Names,Types<:Tuple}

Type specification for named tuples with typed fields.

Type Parameters

• Names: Tuple of field names as symbols
• Types<:Tuple: Tuple of field types (each must be an OfType)

Examples

@of(mu=of(Real), tau=of(Real, 0, nothing))
of((a=of(Int), b=of(Array, 3, 3)))

See also

of, @of

OfConstantWrapper{T<:OfType}

Wrapper type marking a field as a constant/hyperparameter.

Constants are not included in flattened representations and must be provided when creating instances or concretizing types with symbolic dimensions.

Type Parameters

• T<:OfType: The wrapped type specification

Examples

of(Int; constant=true)    # OfConstantWrapper{OfInt{Nothing, Nothing}}
of(Real; constant=true)   # OfConstantWrapper{OfReal{Float64, Nothing, Nothing}}

See also

of, @of

SymbolicRef{S}

Wrapper type for symbolic references in bounds and dimensions.

Used internally to encode references to earlier constant fields when specifying bounds or dimensions. For example, when using @of(n=of(Int; constant=true), data=of(Array, n, 2)), the reference to n in the array dimension is encoded as SymbolicRef{:n}.

Type Parameters

• S: The symbol being referenced

See also

@of, of

SymbolicExpr{E}

Wrapper type for symbolic expressions in dimensions.

Used internally to encode arithmetic expressions involving earlier constant fields. For example, when using @of(n=of(Int; constant=true), padded=of(Array, n+1, n+1)), the expression n+1 is encoded as SymbolicExpr{(:+, :n, 1)}.

Supported operations: +, -, *, /. Division operations must result in integers when used for array dimensions.

Type Parameters

• E: A tuple representing the expression in prefix notation

See also

@of, of