pedantic

Types

Codec

pub type Codec(t) =
  codec.Codec(t)

Decoder

</>

pub type Decoder(t) =
  decode.Decoder(t)

Encoder

</>

pub type Encoder(t) =
  encode.Encoder(t)

Error

</>

pub type Error =
  report.Error

ErrorKind

</>

pub type ErrorKind =
  report.ErrorKind

IssueKind

</>

pub type IssueKind =
  report.ErrorKind

Path

</>

pub type Path =
  List(report.PathSegment)

PathSegment

</>

pub type PathSegment =
  report.PathSegment

Report

</>

pub type Report =
  report.Report

TypeField

</>

pub type TypeField =
  report.TypeField

TypeGraph

</>

pub type TypeGraph =
  report.TypeGraph

ValidationIssue

</>

pub type ValidationIssue =
  report.Error

ValidationReport

</>

pub type ValidationReport =
  report.Report

ValidationWarning

</>

pub type ValidationWarning =
  report.Warning

Warning

</>

pub type Warning =
  report.Warning

WarningKind

</>

pub type WarningKind =
  report.WarningKind

Values

allow_chars

</>

pub fn allow_chars(
  codec: codec.Codec(String),
  characters: String,
) -> codec.Codec(String)

any_of

</>

pub fn any_of(
  decoders: List(decode.Decoder(t)),
) -> decode.Decoder(t)

assert_that

</>

pub fn assert_that(
  codec: codec.Codec(t),
  predicate: fn(t) -> Bool,
  error: report.ErrorKind,
) -> codec.Codec(t)

bool

</>

pub const bool: codec.Codec(Bool)

build

</>

pub fn build(
  builder: codec.ObjectBuilder(value, value),
) -> codec.Codec(value)

check

</>

pub fn check(
  codec: codec.Codec(t),
  predicate: fn(t) -> Bool,
  msg: String,
) -> codec.Codec(t)

coerced_bool

</>

pub const coerced_bool: codec.Codec(Bool)

coerced_float

</>

pub const coerced_float: codec.Codec(Float)

coerced_int

</>

pub const coerced_int: codec.Codec(Int)

coerced_string

</>

pub const coerced_string: codec.Codec(String)

collapse_whitespace

</>

pub fn collapse_whitespace(
  codec: codec.Codec(String),
) -> codec.Codec(String)

custom

</>

pub fn custom(
  decoder: decode.Decoder(t),
  encoder: encode.Encoder(t),
) -> codec.Codec(t)

Creates a Codec by custom pairing a standalone Decoder and Encoder.

decode_json

</>

pub fn decode_json(
  codec: codec.Codec(t),
  json_string: String,
) -> Result(t, report.Report)

default

</>

pub fn default(
  codec: codec.Codec(option.Option(a)),
  default_val: a,
) -> codec.Codec(a)

default_if_blank

</>

pub fn default_if_blank(
  codec: codec.Codec(String),
  default_value: String,
) -> codec.Codec(String)

default_to

</>

pub const default_to: fn(codec.Codec(option.Option(i)), i) -> codec.Codec(
  i,
)

describe

</>

pub fn describe(
  codec: codec.Codec(t),
  desc: String,
) -> codec.Codec(t)

dict

</>

pub fn dict(
  value_codec: codec.Codec(a),
) -> codec.Codec(dict.Dict(String, a))

email

</>

pub fn email(
  codec: codec.Codec(String),
  msg: String,
) -> codec.Codec(String)

empty_as_none

</>

pub fn empty_as_none(
  codec: codec.Codec(String),
) -> codec.Codec(option.Option(String))

encode_json

</>

pub fn encode_json(codec: codec.Codec(t), val: t) -> String

exact_bool

</>

pub const exact_bool: codec.Codec(Bool)

exact_float

</>

pub const exact_float: codec.Codec(Float)

exact_int

</>

pub const exact_int: codec.Codec(Int)

exact_string

</>

pub const exact_string: codec.Codec(String)

example

</>

pub fn example(
  codec: codec.Codec(t),
  ex: dynamic.Dynamic,
) -> codec.Codec(t)

field

</>

pub fn field(
  builder: codec.ObjectBuilder(fn(field_type) -> next, value),
  name: String,
  field_codec: codec.Codec(field_type),
  get: fn(value) -> field_type,
) -> codec.ObjectBuilder(next, value)

float

</>

pub const float: codec.Codec(Float)

int

</>

pub const int: codec.Codec(Int)

key

</>

pub const key: fn(
  codec.ObjectBuilder(fn(f) -> g, h),
  String,
  codec.Codec(f),
  fn(h) -> f,
) -> codec.ObjectBuilder(g, h)

key_optional

</>

pub fn key_optional(
  builder: codec.ObjectBuilder(
    fn(option.Option(field_type)) -> next,
    value,
  ),
  name: String,
  field_codec: codec.Codec(field_type),
  get: fn(value) -> option.Option(field_type),
) -> codec.ObjectBuilder(next, value)

key_required

</>

pub const key_required: fn(
  codec.ObjectBuilder(fn(c) -> d, e),
  String,
  codec.Codec(c),
  fn(e) -> c,
) -> codec.ObjectBuilder(d, e)

key_with_default

</>

pub fn key_with_default(
  builder: codec.ObjectBuilder(fn(field_type) -> next, value),
  name: String,
  field_codec: codec.Codec(field_type),
  default_val: field_type,
  get: fn(value) -> field_type,
) -> codec.ObjectBuilder(next, value)

length

</>

pub fn length(
  codec: codec.Codec(String),
  len: Int,
) -> codec.Codec(String)

list

</>

pub fn list(
  element_codec: codec.Codec(a),
) -> codec.Codec(List(a))

lowercase

</>

pub fn lowercase(
  codec: codec.Codec(String),
) -> codec.Codec(String)

map

</>

pub fn map(
  decoder: decode.Decoder(a),
  transform_fn: fn(a) -> b,
) -> decode.Decoder(b)

max

</>

pub fn max(
  codec: codec.Codec(Int),
  maximum: Int,
) -> codec.Codec(Int)

max_length

</>

pub fn max_length(
  codec: codec.Codec(String),
  maximum: Int,
) -> codec.Codec(String)

max_size

</>

pub fn max_size(
  codec: codec.Codec(List(a)),
  maximum: Int,
) -> codec.Codec(List(a))

min

</>

pub fn min(
  codec: codec.Codec(Int),
  minimum: Int,
) -> codec.Codec(Int)

min_length

</>

pub fn min_length(
  codec: codec.Codec(String),
  minimum: Int,
) -> codec.Codec(String)

min_size

</>

pub fn min_size(
  codec: codec.Codec(List(a)),
  minimum: Int,
) -> codec.Codec(List(a))

negative

</>

pub fn negative(codec: codec.Codec(Int)) -> codec.Codec(Int)

non_empty_list

</>

pub fn non_empty_list(
  element_codec: codec.Codec(a),
) -> codec.Codec(List(a))

non_negative

</>

pub fn non_negative(codec: codec.Codec(Int)) -> codec.Codec(Int)

non_positive

</>

pub fn non_positive(codec: codec.Codec(Int)) -> codec.Codec(Int)

normalize_email

</>

pub fn normalize_email(
  codec: codec.Codec(String),
) -> codec.Codec(String)

normalize_uuid

</>

pub fn normalize_uuid(
  codec: codec.Codec(String),
) -> codec.Codec(String)

object

</>

pub fn object(
  name: String,
  constructor: constructor,
) -> codec.ObjectBuilder(constructor, a)

optional

</>

pub fn optional(
  inner_codec: codec.Codec(a),
) -> codec.Codec(option.Option(a))

positive

</>

pub fn positive(codec: codec.Codec(Int)) -> codec.Codec(Int)

refine

</>

pub fn refine(
  codec: codec.Codec(t),
  rule: fn(t) -> Result(t, report.ErrorKind),
) -> codec.Codec(t)

remove_chars

</>

pub fn remove_chars(
  codec: codec.Codec(String),
  characters: String,
) -> codec.Codec(String)

replace

</>

pub fn replace(
  codec: codec.Codec(String),
  pattern: String,
  replacement: String,
) -> codec.Codec(String)

safe_parse

</>

pub fn safe_parse(
  codec: codec.Codec(t),
  val: dynamic.Dynamic,
) -> Result(t, report.Report)

safe_parse_json

</>

pub fn safe_parse_json(
  codec: codec.Codec(t),
  json_string: String,
) -> Result(t, report.Report)

string

</>

pub const string: codec.Codec(String)

strip_control_chars

</>

pub fn strip_control_chars(
  codec: codec.Codec(String),
) -> codec.Codec(String)

title

</>

pub fn title(
  codec: codec.Codec(t),
  name: String,
) -> codec.Codec(t)

trim

</>

pub fn trim(codec: codec.Codec(String)) -> codec.Codec(String)

unwrap_or

</>

pub const unwrap_or: fn(codec.Codec(option.Option(j)), j) -> codec.Codec(
  j,
)

uppercase

</>

pub fn uppercase(
  codec: codec.Codec(String),
) -> codec.Codec(String)

uuid

</>

pub fn uuid(
  codec: codec.Codec(String),
  msg: String,
) -> codec.Codec(String)

with_error_formatter

</>

pub fn with_error_formatter(
  codec: codec.Codec(t),
  formatter: fn(dynamic.Dynamic, report.ErrorKind) -> String,
) -> codec.Codec(t)

with_error_message

</>

pub fn with_error_message(
  codec: codec.Codec(t),
  msg: String,
) -> codec.Codec(t)

with_template

</>

pub fn with_template(
  codec: codec.Codec(t),
  template: String,
) -> codec.Codec(t)