sift

Core validation functions — check fields, accumulate errors, compose validators.

Types

FieldError

A validation error with path to the field and a human-readable message.

FieldError(path: ["email"], message: "required")
FieldError(path: ["address", "zip"], message: "must be 5 digits")

pub type FieldError {
  FieldError(path: List(String), message: String)
}

Constructors

FieldError(path: List(String), message: String)

Validated

</>

Accumulated validation result — value + errors collected so far Using a tuple (not Result) enables the use pattern to run ALL validators

pub type Validated(a) =
  #(a, List(FieldError))

Validator

</>

A single constraint: takes a value, returns Ok(value) or Error(message)

pub type Validator(a) =
  fn(a) -> Result(a, String)

Values

and

</>

pub fn and(
  v1: fn(a) -> Result(a, String),
  v2: fn(a) -> Result(a, String),
) -> fn(a) -> Result(a, String)

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

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

check

</>

pub fn check(
  field: String,
  value: a,
  validator: fn(a) -> Result(a, String),
  next: fn(a) -> #(b, List(FieldError)),
) -> #(b, List(FieldError))

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:))

custom

</>

pub fn custom(
  f: fn(a) -> Result(a, String),
) -> fn(a) -> Result(a, String)

Escape hatch for user-defined checks

each

</>

pub fn each(
  field: String,
  items: List(a),
  validator: fn(a) -> Result(a, String),
  next: fn(List(a)) -> #(b, List(FieldError)),
) -> #(b, List(FieldError))

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"]

equals

</>

pub fn equals(
  expected: a,
  msg: String,
) -> fn(a) -> Result(a, String)

Value must equal the expected value

nested

</>

pub fn nested(
  field: String,
  value: a,
  validator_fn: fn(a) -> #(b, List(FieldError)),
  next: fn(b) -> #(c, List(FieldError)),
) -> #(c, List(FieldError))

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"]

not

</>

pub fn not(
  validator: fn(a) -> Result(a, String),
  msg: String,
) -> fn(a) -> Result(a, String)

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

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

ok

</>

pub fn ok(value: a) -> #(a, List(FieldError))

Wrap a final value into a Validated tuple with no errors

or

</>

pub fn or(
  v1: fn(a) -> Result(a, String),
  v2: fn(a) -> Result(a, String),
) -> fn(a) -> Result(a, String)

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

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

validate

</>

pub fn validate(
  validated: #(a, List(FieldError)),
) -> Result(a, List(FieldError))

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"))