def check

bend-schema-lib@0.4.1.0 · core.bend:850

import Base

850def check(~rule: Nat -> Raw -> Maybe<&2, Err>, s: Schema, r: Raw, +prev: Maybe<&2, Nat>) -> Maybe<&2, Err>:
851  match s r:
852    case SNat{} RNum{n}:
853      None{}
854    case SNat{} x:
855      here(missing_or(x, NotNat{}))
856    case SStr{} RStr{x}:
857      None{}
858    case SStr{} x:
859      here(missing_or(x, NotString{}))
860    case SNatIn{+lo, +hi} RNum{+n}:
861      nat_in(lo, hi, RNum{n})
862    case SNatIn{lo_, hi_} +x:
863      here(missing_or(x, NotNat{}))
864    case SStrLen{+lo, +hi, +s2} +x:
865      first(check(~rule, s2, x, prev), len_err(lo, hi, x))
866    case SListLen{+lo, +hi, +s2} +r:
867      first(count_err(lo, hi, r), check(~rule, s2, r, None{}))
868    case SOpt{inner} RNull{}:
869      None{}
870    case SOpt{inner} x:
871      check(~rule, inner, x, None{})
872    case SOptional{inner} RMissing{}:
873      None{}
874    case SOptional{inner} x:
875      check(~rule, inner, x, None{})
876    case SList{e} RNil{}:
877      None{}
878    case SList{+e} RCons{h, t}:
879      first(under(AtIndex{0n}, check(~rule, e, h, None{})), later_l(check(~rule, SList{e}, t, None{})))
880    case SJson{} RJson{value}:
881      in_err(valid_json(value), NotJson{})
882    case SJson{} x:
883      here(missing_or(x, NotJson{}))
884    case SInt{} RNum{n}:
885      None{}
886    case SInt{} RNeg{n}:
887      None{}
888    case SInt{} x:
889      here(missing_or(x, NotInt{}))
890    case SIntIn{+lo, +hi} RNum{+n}:
891      in_err(int_ok(lo, hi, IPos{n}), IntNotIn{lo, hi})
892    case SIntIn{+lo, +hi} RNeg{+n}:
893      in_err(int_ok(lo, hi, INeg{n}), IntNotIn{lo, hi})
894    case SIntIn{lo_, hi_} x:
895      here(missing_or(x, NotInt{}))
896    case SList{e} x:
897      here(missing_or(x, NotList{}))
898    case SField{+name, fs, rest} REnd{}:
899      first(under(AtField{0n, name}, check(~rule, fs, RMissing{}, None{})), later_f(check(~rule, rest, REnd{}, None{})))
900    case SField{+name, fs, rest} RKey{+k, +v, +o}:
901      first(key_err(key_once(name, RKey{k, v, o}), name), first(under(AtField{0n, name}, check(~rule, fs, lookup(name, RKey{k, v, o}), None{})), later_f(check(~rule, rest, RKey{k, v, o}, None{}))))
902    case SField{name, fs, rest} x:
903      here(missing_or(x, NotObject{}))
904    case SEnd{} REnd{}:
905      None{}
906    case SEnd{} RKey{k, v, o}:
907      None{}
908    case SEnd{} x:
909      here(missing_or(x, NotObject{}))
910    case SRule{+s2, +tag} +x:
911      first(check(~rule, s2, x, prev), rule(tag, x))
912    case SStrict{+s2} +x:
913      first(check(~rule, s2, x, prev), extra_err(key_names(s2), x))
914    case STagged{+k, +n, cs, rest} +x:
915      pick_err(is_tag(k, n, x), first(key_err(key_once(k, x), k), check(~rule, cs, drop_key(k, x), None{})), check(~rule, rest, x, None{}))
916    case STagEnd{k} x:
917      tag_err(k, x)
918    case SBool{} RBool{b}:
919      None{}
920    case SBool{} +x:
921      here(missing_or(x, NotBool{}))
922    case STrue{} RBool{b}:
923      true_err(b)
924    case STrue{} x:
925      here(missing_or(x, NotTrue{}))
926    case SEnum{names} RStr{+x}:
927      enum_err(in_names(x, names))
928    case SEnum{names} x:
929      here(missing_or(x, NotOneOf{}))
930    case SVariant{+name, +vs, +rest} REnd{}:
931      later_f(check(~rule, rest, REnd{}, None{}))
932    case SVariant{+name, +vs, +rest} RKey{+k, +v, +o}:
933      pick_err(is_missing(lookup(name, RKey{k, v, o})), later_f(check(~rule, rest, RKey{k, v, o}, None{})), first(key_err(key_once(name, RKey{k, v, o}), name), first(under(AtField{0n, name}, check(~rule, vs, lookup(name, RKey{k, v, o}), None{})), later_f(dup_err(rest, RKey{k, v, o})))))
934    case SVariant{+name, +vs, +rest} x:
935      here(missing_or(x, NotObject{}))
936    case SVEnd{} REnd{}:
937      here(NoVariant{})
938    case SVEnd{} RKey{k, v, o}:
939      here(NoVariant{})
940    case SVEnd{} x:
941      here(missing_or(x, NotObject{}))
942    case STuple{ts, rest} RCons{h, t}:
943      first(under(AtIndex{0n}, check(~rule, ts, h, None{})), later_l(check(~rule, rest, t, None{})))
944    case STuple{ts, rest} RNil{}:
945      here(TooShort{})
946    case STuple{ts, rest} x:
947      here(missing_or(x, NotList{}))
948    case STEnd{} RNil{}:
949      None{}
950    case STEnd{} RCons{h, t}:
951      here(TooLong{})
952    case STEnd{} x:
953      here(missing_or(x, NotList{}))
954    case SEither{+l, +r} +x:
955      pick_err(has_kind(l, kind_of(x)), check(~rule, l, x, prev), pick_err(has_kind(r, kind_of(x)), check(~rule, r, x, prev), here(missing_or(x, no_alt(SEither{l, r})))))