slovo/lib/std/result.slo

(module result (export ok_i32 err_i32 is_ok_i32 is_err_i32 unwrap_ok_i32 unwrap_err_i32 unwrap_or_i32 ok_or_none_i32 ok_u32 err_u32 is_ok_u32 is_err_u32 unwrap_ok_u32 unwrap_err_u32 unwrap_or_u32 ok_or_none_u32 ok_i64 err_i64 is_ok_i64 is_err_i64 unwrap_ok_i64 unwrap_err_i64 unwrap_or_i64 ok_or_none_i64 ok_u64 err_u64 is_ok_u64 is_err_u64 unwrap_ok_u64 unwrap_err_u64 unwrap_or_u64 ok_or_none_u64 ok_string err_string is_ok_string is_err_string unwrap_ok_string unwrap_err_string unwrap_or_string ok_or_none_string ok_f64 err_f64 is_ok_f64 is_err_f64 unwrap_ok_f64 unwrap_err_f64 unwrap_or_f64 ok_or_none_f64 ok_bool err_bool is_ok_bool is_err_bool unwrap_ok_bool unwrap_err_bool unwrap_or_bool ok_or_none_bool))

(type ResultI32 (result i32 i32))

(type OptionI32 (option i32))

(type ResultU32 (result u32 i32))

(type OptionU32 (option u32))

(type ResultI64 (result i64 i32))

(type OptionI64 (option i64))

(type ResultU64 (result u64 i32))

(type OptionU64 (option u64))

(type ResultString (result string i32))

(type OptionString (option string))

(type ResultF64 (result f64 i32))

(type OptionF64 (option f64))

(type ResultBool (result bool i32))

(type OptionBool (option bool))

(fn ok_i32 ((value i32)) -> ResultI32
  (ok i32 i32 value))

(fn err_i32 ((code i32)) -> ResultI32
  (err i32 i32 code))

(fn is_ok_i32 ((value ResultI32)) -> bool
  (std.result.is_ok value))

(fn is_err_i32 ((value ResultI32)) -> bool
  (std.result.is_err value))

(fn unwrap_ok_i32 ((value ResultI32)) -> i32
  (std.result.unwrap_ok value))

(fn unwrap_err_i32 ((value ResultI32)) -> i32
  (std.result.unwrap_err value))

(fn unwrap_or_i32 ((value ResultI32) (fallback i32)) -> i32
  (if (std.result.is_ok value)
    (std.result.unwrap_ok value)
    fallback))

(fn ok_or_none_i32 ((value ResultI32)) -> OptionI32
  (if (std.result.is_ok value)
    (some i32 (std.result.unwrap_ok value))
    (none i32)))

(fn ok_u32 ((value u32)) -> ResultU32
  (ok u32 i32 value))

(fn err_u32 ((code i32)) -> ResultU32
  (err u32 i32 code))

(fn is_ok_u32 ((value ResultU32)) -> bool
  (std.result.is_ok value))

(fn is_err_u32 ((value ResultU32)) -> bool
  (std.result.is_err value))

(fn unwrap_ok_u32 ((value ResultU32)) -> u32
  (std.result.unwrap_ok value))

(fn unwrap_err_u32 ((value ResultU32)) -> i32
  (std.result.unwrap_err value))

(fn unwrap_or_u32 ((value ResultU32) (fallback u32)) -> u32
  (if (std.result.is_ok value)
    (std.result.unwrap_ok value)
    fallback))

(fn ok_or_none_u32 ((value ResultU32)) -> OptionU32
  (if (std.result.is_ok value)
    (some u32 (std.result.unwrap_ok value))
    (none u32)))

(fn ok_i64 ((value i64)) -> ResultI64
  (ok i64 i32 value))

(fn err_i64 ((code i32)) -> ResultI64
  (err i64 i32 code))

(fn is_ok_i64 ((value ResultI64)) -> bool
  (std.result.is_ok value))

(fn is_err_i64 ((value ResultI64)) -> bool
  (std.result.is_err value))

(fn unwrap_ok_i64 ((value ResultI64)) -> i64
  (std.result.unwrap_ok value))

(fn unwrap_err_i64 ((value ResultI64)) -> i32
  (std.result.unwrap_err value))

(fn unwrap_or_i64 ((value ResultI64) (fallback i64)) -> i64
  (if (std.result.is_ok value)
    (std.result.unwrap_ok value)
    fallback))

(fn ok_or_none_i64 ((value ResultI64)) -> OptionI64
  (if (std.result.is_ok value)
    (some i64 (std.result.unwrap_ok value))
    (none i64)))

(fn ok_u64 ((value u64)) -> ResultU64
  (ok u64 i32 value))

(fn err_u64 ((code i32)) -> ResultU64
  (err u64 i32 code))

(fn is_ok_u64 ((value ResultU64)) -> bool
  (std.result.is_ok value))

(fn is_err_u64 ((value ResultU64)) -> bool
  (std.result.is_err value))

(fn unwrap_ok_u64 ((value ResultU64)) -> u64
  (std.result.unwrap_ok value))

(fn unwrap_err_u64 ((value ResultU64)) -> i32
  (std.result.unwrap_err value))

(fn unwrap_or_u64 ((value ResultU64) (fallback u64)) -> u64
  (if (std.result.is_ok value)
    (std.result.unwrap_ok value)
    fallback))

(fn ok_or_none_u64 ((value ResultU64)) -> OptionU64
  (if (std.result.is_ok value)
    (some u64 (std.result.unwrap_ok value))
    (none u64)))

(fn ok_string ((value string)) -> ResultString
  (ok string i32 value))

(fn err_string ((code i32)) -> ResultString
  (err string i32 code))

(fn is_ok_string ((value ResultString)) -> bool
  (std.result.is_ok value))

(fn is_err_string ((value ResultString)) -> bool
  (std.result.is_err value))

(fn unwrap_ok_string ((value ResultString)) -> string
  (std.result.unwrap_ok value))

(fn unwrap_err_string ((value ResultString)) -> i32
  (std.result.unwrap_err value))

(fn unwrap_or_string ((value ResultString) (fallback string)) -> string
  (match value
    ((ok payload)
      payload)
    ((err code)
      fallback)))

(fn ok_or_none_string ((value ResultString)) -> OptionString
  (if (std.result.is_ok value)
    (some string (std.result.unwrap_ok value))
    (none string)))

(fn ok_f64 ((value f64)) -> ResultF64
  (ok f64 i32 value))

(fn err_f64 ((code i32)) -> ResultF64
  (err f64 i32 code))

(fn is_ok_f64 ((value ResultF64)) -> bool
  (std.result.is_ok value))

(fn is_err_f64 ((value ResultF64)) -> bool
  (std.result.is_err value))

(fn unwrap_ok_f64 ((value ResultF64)) -> f64
  (std.result.unwrap_ok value))

(fn unwrap_err_f64 ((value ResultF64)) -> i32
  (std.result.unwrap_err value))

(fn unwrap_or_f64 ((value ResultF64) (fallback f64)) -> f64
  (if (std.result.is_ok value)
    (std.result.unwrap_ok value)
    fallback))

(fn ok_or_none_f64 ((value ResultF64)) -> OptionF64
  (if (std.result.is_ok value)
    (some f64 (std.result.unwrap_ok value))
    (none f64)))

(fn ok_bool ((value bool)) -> ResultBool
  (ok bool i32 value))

(fn err_bool ((code i32)) -> ResultBool
  (err bool i32 code))

(fn is_ok_bool ((value ResultBool)) -> bool
  (std.result.is_ok value))

(fn is_err_bool ((value ResultBool)) -> bool
  (std.result.is_err value))

(fn unwrap_ok_bool ((value ResultBool)) -> bool
  (std.result.unwrap_ok value))

(fn unwrap_err_bool ((value ResultBool)) -> i32
  (std.result.unwrap_err value))

(fn unwrap_or_bool ((value ResultBool) (fallback bool)) -> bool
  (if (std.result.is_ok value)
    (std.result.unwrap_ok value)
    fallback))

(fn ok_or_none_bool ((value ResultBool)) -> OptionBool
  (if (std.result.is_ok value)
    (some bool (std.result.unwrap_ok value))
    (none bool)))