Compose two validators — run both, accumulate errors from both.

let validator = s.min_length(1, "required") |> sift.and(s.email("invalid"))

Run a validator on a field value, accumulate errors, feeds into use.

use name <- sift.check("name", input.name, s.min_length(1, "required"))
use email <- sift.check("email", input.email, s.email("invalid"))
sift.ok(User(name:, email:))

Cross-field validator comparing two already-validated values. On success, passes the (possibly transformed) first value to next. On failure, records a FieldError under field and passes a through so subsequent checks still run.

use name <- sift.check("name", input.name, s.non_empty("required"))
use confirm <- sift.check("confirm", input.confirm, s.non_empty("required"))
use name <- sift.check2("confirm", name, confirm, fn(a, b) {
  case a == b { True -> Ok(a) False -> Error("must match name") }
})
sift.ok(name)

Run multiple validators on a field, accumulate all errors.

use name <- sift.check_all("name", input.name, [
  s.non_empty("required"),
  s.min_length(3, "too short"),
  s.max_length(100, "too long"),
])
sift.ok(name)

Validate every item in a list with a sub-validator function, prefixing error paths with the field name and the item’s index. Produces paths like ["tags", "0", "name"].

Use this when each item is itself a struct to validate. For a single Validator(a) per item, use each instead.

use tags <- sift.check_each("tags", input.tags, validate_tag)
// errors get paths like ["tags", "2", "name"]

Validate an Option value only when Some, skip when None.

use nickname <- sift.check_optional("nickname", input.nickname,
  s.min_length(2, "too short"))
sift.ok(User(nickname:))

Parse a raw value and feed the result into the chain. On success, passes the parsed value to next. On failure, records a FieldError and passes the default to next so that subsequent fields still validate.

use age <- sift.check_parse("age", "42", int.parse, 0, "must be a number")
use age <- sift.check("age", age, i.min(13, "must be at least 13"))
sift.ok(age)

Escape hatch for user-defined checks.

let even = sift.custom(fn(n: Int) {
  case n % 2 == 0 {
    True -> Ok(n)
    False -> Error("must be even")
  }
})
even(4)  // -> Ok(4)
even(3)  // -> Error("must be even")

Validate every item in a list, accumulating indexed error paths. Produces paths like ["tags", "0"], ["tags", "1"], etc.

use tags <- sift.each("tags", input.tags, s.non_empty("empty tag"))
// invalid items get paths like ["tags", "2"]

Value must equal the expected value.

let validator = sift.equals("yes", "must accept terms")
validator("yes")  // -> Ok("yes")
validator("no")   // -> Error("must accept terms")

Run a sub-validator function, prefixing error paths with the field name.

use address <- sift.nested("address", input.address, validate_address)
// errors get paths like ["address", "zip"]

Invert a validator — fail if it passes, pass if it fails.

let not_admin = sift.not(s.one_of(["admin"], ""), "cannot be admin")

Wrap a final value into a Validated tuple with no errors

Pass if either validator succeeds (try v1 first, then v2).

let validator = s.email("invalid") |> sift.or(s.url("invalid"))

Post-assembly whole-object check. Runs on a Validated(a) produced by ok(...), useful for cross-field constraints expressed in terms of the final struct.

sift.ok(Registration(role:, mfa:))
|> sift.refine("mfa", fn(r) {
  case r.role == "admin" && r.mfa == None {
    True -> Error("required for admins")
    False -> Ok(r)
  }
})
|> sift.validate

Convert a Validated(a) to Result(a, List(FieldError)).

sift.ok(User(name: "Jo", email: "jo@example.com"))
|> sift.validate
// -> Ok(User(name: "Jo", email: "jo@example.com"))

Conditional validator — runs the validator only when condition is True.

use state <- sift.check("state", input.state,
  sift.when(country == "US", s.non_empty("required")))