envie - v1.1.0

envie/schema

Types

Field

</> 
pub type Field(a) {
  Field(
    meta: FieldMeta,
    run: fn() -> Result(a, error.Error),
    trace: fn() -> InspectField,
  )
}

Constructors

FieldMeta

</> 
pub type FieldMeta {
  FieldMeta(
    name: String,
    optional: Bool,
    has_default: Bool,
    secret: Bool,
  )
}

Constructors 

  • FieldMeta(
  name: String,
  optional: Bool,
  has_default: Bool,
  secret: Bool,
)

InspectField

</> 
pub type InspectField {
  InspectField(
    name: String,
    value: option.Option(String),
    used_default: Bool,
    optional: Bool,
    secret: Bool,
    error: option.Option(error.Error),
  )
}

Constructors

Schema

</> 
pub type Schema(a) {
  Schema(
    fields: List(FieldMeta),
    run: fn() -> Result(a, error.Error),
    trace: fn() -> List(InspectField),
  )
}

Constructors

Values

build1

</> 
pub fn build1(field: Field(a)) -> Schema(a)

build2

</> 
pub fn build2(
  first: Field(a),
  second: Field(b),
  build: fn(a, b) -> c,
) -> Schema(c)

build3

</> 
pub fn build3(
  first: Field(a),
  second: Field(b),
  third: Field(c),
  build: fn(a, b, c) -> d,
) -> Schema(d)

default

</> 
pub fn default(field: Field(a), value: a) -> Field(a)

field

</> 
pub fn field(
  name: String,
  decoder: decode.Decoder(a),
) -> Field(a)

fields

</> 
pub fn fields(schema: Schema(a)) -> List(FieldMeta)

inspect_fields

</> 
pub fn inspect_fields(schema: Schema(a)) -> List(InspectField)

load

</> 
pub fn load(schema: Schema(a)) -> Result(a, error.Error)

load_field

</> 
pub fn load_field(field: Field(a)) -> Result(a, error.Error)

map2

</> 
pub fn map2(
  first: Field(a),
  second: Field(b),
  build: fn(a, b) -> c,
) -> Schema(c)

optional

</> 
pub fn optional(field: Field(a)) -> Field(option.Option(a))

secret

</> 
pub fn secret(field: Field(a)) -> Field(a)
✨ Search Document