okay

Types

Failure

The different types of failure messages, these can be used to later build human readable messages like: The string "John" expected to be longer then 10 characters but was actually 4

pub type Failure {
  IsGreaterFailure(value: Int, expected: Int)
  IsGreaterOrEqualFailure(value: Int, expected: Int)
  IsLongerFailure(value: String, actual: Int, expected: Int)
  IsLesserFailure(value: Int, expected: Int)
  IsLesserOrEqualFailure(value: Int, expected: Int)
  IsEqualFailure(value: String, expected: String)
  IsIncludedInFailure(value: String, expected: String)
  IsBoolFailure(value: Bool, expected: Bool)
  IsSomeFailure
  IsNoneFailure(value: String)
}

Constructors

IsGreaterFailure(value: Int, expected: Int)

Returned when is_gt failed

IsGreaterOrEqualFailure(value: Int, expected: Int)

Returned when is_gte failed

IsLongerFailure(value: String, actual: Int, expected: Int)

Returned when is_longer failed

IsLesserFailure(value: Int, expected: Int)

Returned when is_lt failed

IsLesserOrEqualFailure(value: Int, expected: Int)

Returned when is_lte failed

IsEqualFailure(value: String, expected: String)

Returned when is_equal failed

IsIncludedInFailure(value: String, expected: String)

Returned when is_included_in failed

IsBoolFailure(value: Bool, expected: Bool)

Returned when is_true/is_false failed

```
IsSomeFailure
```
Returned when is_some failed
```
IsNoneFailure(value: String)
```
Returned when is_none failed

Okay

</>

The Okay type is used to store the list of validation failures

pub type Okay {
  Okay(failures: List(ValidationError))
}

Constructors

```
Okay(failures: List(ValidationError))
```

ValidationError

</>

The ValidationError type consists of the field name and the error

pub type ValidationError {
  ValidationError(field: String, failure: Failure)
}

Constructors

ValidationError(field: String, failure: Failure)

Functions

field

</>

pub fn field(
  okay: Okay,
  field: String,
  result: Result(Nil, Failure),
) -> Okay

Based on the validation function result, it’ll append the Error to the Okay.failures list

is_equal

</>

pub fn is_equal(value: a, compare: a) -> Result(Nil, Failure)

Checks if two values are equal to each other

Examples

let assert Ok(_) = okay.is_equal("hi", "hi")
let assert Error(_error) = okay.is_equal(1, 2)

is_false

</>

pub fn is_false(value: Bool) -> Result(Nil, Failure)

Checks if bool is False

Examples

let assert Ok(_) = okay.is_false(False)
let assert Error(_error) = okay.is_false(True)

is_gt

</>

pub fn is_gt(value: Int, compare: Int) -> Result(Nil, Failure)

Checks if one Int is greater than another

Examples

let assert Ok(_) = okay.is_gt(10, 1)
let assert Error(_error) = okay.is_gt(1, 10)

is_gte

</>

pub fn is_gte(value: Int, compare: Int) -> Result(Nil, Failure)

Checks if one Int is greater than or equal to another

Examples

let assert Ok(_) = okay.is_gte(10, 10)
let assert Error(_error) = okay.is_gte(9, 10)

is_included_in

</>

pub fn is_included_in(
  value: a,
  whitelist: List(a),
) -> Result(Nil, Failure)

Checks if values is included in the list

Examples

let assert Ok(_) = okay.is_included_in(1, [1, 2])
let assert Error(_error) = okay.is_included_in(3, [1, 2])

is_longer

</>

pub fn is_longer(
  value: String,
  length: Int,
) -> Result(Nil, Failure)

Checks if string is longer than X amount

Examples

let assert Ok(_) = okay.is_longer("hello", 1)
let assert Error(_error) = okay.is_longer("A", 2)

is_lt

</>

pub fn is_lt(value: Int, compare: Int) -> Result(Nil, Failure)

Checks if one Int is less than another

Examples

let assert Ok(_) = okay.is_lt(1, 2)
let assert Error(_error) = okay.is_lt(5, 1)

is_lte

</>

pub fn is_lte(value: Int, compare: Int) -> Result(Nil, Failure)

Checks if one Int is less than or equal to another

Examples

let assert Ok(_) = okay.is_lte(8, 8)
let assert Error(_error) = okay.is_lte(9, 8)

is_none

</>

pub fn is_none(value: Option(a)) -> Result(Nil, Failure)

Checks if Option is None

Examples

let assert Ok(_) = okay.is_none(option.None)
let assert Error(_error) = okay.is_noe(option.Some(1))

is_some

</>

pub fn is_some(value: Option(a)) -> Result(Nil, Failure)

Checks if Option is Some

Examples

let assert Ok(_) = okay.is_some(option.Some(1))
let assert Error(_error) = okay.is_some(option.None)

is_true

</>

pub fn is_true(value: Bool) -> Result(Nil, Failure)

Checks if bool is True

Examples

let assert Ok(_) = okay.is_true(True)
let assert Error(_error) = okay.is_true(False)

new

</>

pub fn new() -> Okay

Initializes a Okay record with an empty list of failures

run

</>

pub fn run(okay: Okay) -> Result(Nil, Okay)

Checks if the Okay record contains any failures and responds with a Result