Struct ZNumber 

pub struct ZNumber { /* private fields */ }

Schema for number validation (f64). Created via vld::number().

Use .int() to convert to integer validation (i64).

NaN never satisfies a bound check, and .coerce() rejects strings that parse to NaN or infinity.

Example

use vld::prelude::*;

let schema = vld::number().min(0.0).max(100.0);
let int_schema = vld::number().int().min(0).max(100);

Implementations

impl ZNumber

pub fn new() -> ZNumber

Create the schema (the same as its vld:: constructor function).

pub fn type_error(self, msg: impl Into<String>) -> ZNumber

Set a custom error message for type mismatch (when the input is not a number).

Example

use vld::prelude::*;
let schema = vld::number().type_error("Must be a number!");
let err = schema.parse(r#""hello""#).unwrap_err();
assert!(err.issues[0].message.contains("Must be a number!"));

pub fn with_messages<F>(self, f: F) -> ZNumber

where F: Fn(&str) -> Option<String> + Send + Sync + 'static,

Override error messages in bulk by check key.

The closure receives the check key (e.g. "too_small", "too_big", "not_positive", "not_multiple_of", "not_safe") and should return Some(new_message) to replace, or None to keep the original.

The closure is consulted when an issue is built, so it covers checks added before and after this call; a per-check message (*_msg(...)) takes precedence over it. A later call replaces it.

Example

use vld::prelude::*;
let schema = vld::number().min(0.0).max(100.0)
    .with_messages(|key| match key {
        "too_small" => Some("Must be >= 0".into()),
        "too_big" => Some("Must be <= 100".into()),
        _ => None,
    });

pub fn min(self, val: f64) -> ZNumber

Minimum value (inclusive). Alias: gte.

pub fn max(self, val: f64) -> ZNumber

Maximum value (inclusive). Alias: lte.

pub fn gt(self, val: f64) -> ZNumber

Greater than (exclusive).

pub fn gte(self, val: f64) -> ZNumber

Greater than or equal (inclusive). Same as min.

pub fn lt(self, val: f64) -> ZNumber

Less than (exclusive).

pub fn lte(self, val: f64) -> ZNumber

Less than or equal (inclusive). Same as max.

pub fn positive(self) -> ZNumber

Must be positive (> 0).

pub fn negative(self) -> ZNumber

Must be negative (< 0).

pub fn non_negative(self) -> ZNumber

Must be non-negative (>= 0).

pub fn non_positive(self) -> ZNumber

Must be non-positive (<= 0).

pub fn multiple_of(self, val: f64) -> ZNumber

Must be a multiple of the given value.

Uses a relative tolerance of 1e-9 so decimal steps like 0.1 work. A divisor of 0 never matches (every value is rejected).

pub fn safe(self) -> ZNumber

Must be within JavaScript’s safe integer range (-(2^53 - 1) to 2^53 - 1).

pub fn int(self) -> ZInteger<i64>

Convert to integer validation. Returns ZInt with Output = i64.

pub fn coerce(self) -> ZNumber

Coerce strings and booleans to numbers.

Strings that parse to NaN or infinity are rejected.

pub fn clamp(self) -> ZNumber

Clamp values outside the inclusive bounds (min / max, non_negative / non_positive) to the bound instead of failing. Integer schemas also saturate to their type (u8: 0..=255), f32 to its finite range. Exclusive bounds (gt, lt, positive, negative) still fail. The JSON Schema leaves out the clamped bounds.

use vld::prelude::*;
let volume = vld::number().int().min(0).max(100).clamp();
assert_eq!(volume.parse("150").unwrap(), 100);
assert_eq!(volume.parse("-5").unwrap(), 0);
assert_eq!(vld::u8().clamp().parse("300").unwrap(), 255u8);

Trait Implementations

impl Clone for ZNumber

fn clone(&self) -> ZNumber

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Default for ZNumber

fn default() -> ZNumber

Returns the “default value” for a type.

impl VldSchema for ZNumber

type Output = f64

The Rust type produced by this schema after successful parsing.

fn parse_value(&self, value: &Value) -> Result<f64, VldError>

Parse and validate a serde_json::Value.

fn parse_missing(&self) -> Result<Self::Output, VldError>

Parse an object field whose key is absent.

fn parse<I>(&self, input: &I) -> Result<Self::Output, VldError>

where I: VldInput + ?Sized,

Parse from any supported input (JSON string, file path, serde_json::Value, etc.)

fn validate<T>(&self, value: &T) -> Result<Self::Output, VldError>

where T: Serialize,

Validate an existing Rust value against this schema.

fn is_valid<T>(&self, value: &T) -> bool

where T: Serialize,

Check if an existing Rust value passes this schema’s validation.

fn optional(self) -> ZOptional<Self>

Make this field optional. Missing or null values become None.

fn nullable(self) -> ZNullable<Self>

Allow null values. Null becomes None.

fn with_default(self, value: Self::Output) -> ZDefault<Self>

where Self::Output: Clone,

Provide a default value when the field is missing or null.

fn blank_as(self, value: Self::Output) -> ZDefault<Self>

where Self::Output: Clone,

Like with_default, and a blank string (empty or whitespace only) also becomes value: legacy stores that write "" or null for “unset”.

fn refine<F>(self, check: F, message: &str) -> ZRefine<Self, F>

where F: Fn(&Self::Output) -> bool,

Add a custom refinement check without changing the output type.

fn rule<R>(self, rule: R) -> ZRule<Self, R>

where Self: Sized, R: Rule<Self::Output>,

Check the output with a reusable Rule (output type unchanged).

fn rule_msg<R>(self, rule: R, msg: impl Into<String>) -> ZRule<Self, R>

where Self: Sized, R: Rule<Self::Output>,

rule with a custom error message.

fn try_transform<F, U, E>(self, f: F) -> ZTryTransform<Self, F, U>

where F: Fn(Self::Output) -> Result<U, E>, E: Display,

Transform the output with a fallible function; an Err becomes a validation issue (Custom { code: "transform" }, message = the error).

fn transform<F, U>(self, f: F) -> ZTransform<Self, F, U>

where F: Fn(Self::Output) -> U,

Transform the output value after successful parsing.

fn nullish(self) -> ZNullish<Self>

Make this field nullish (both optional and nullable).

fn catch(self, fallback: Self::Output) -> ZCatch<Self>

where Self::Output: Clone,

Return a fallback value on ANY validation error.

fn pipe<S>(self, next: S) -> ZPipe<Self, S>

where S: VldSchema, Self::Output: Serialize,

Chain this schema’s output into another schema.

fn describe(self, description: &str) -> ZDescribe<Self>

Attach a human-readable description/label to this schema.

fn super_refine<F>(self, check: F) -> ZSuperRefine<Self, F>

where F: Fn(&Self::Output, &mut VldError),

Add a custom refinement that can produce multiple errors.

fn or<B>(self, other: B) -> ZUnion2<Self, B>

where B: VldSchema,

Create a union: this schema or another. Returns Either<Self::Output, B::Output>.

fn and<B>(self, other: B) -> ZIntersection<Self, B>

where B: VldSchema,

Create an intersection: input must satisfy both schemas.

fn message(self, msg: impl Into<String>) -> ZMessage<Self>

Override the error message for this schema.