def defect

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

import Base

1194def defect(~rule: Nat -> Raw -> Maybe<&2, Err>, s: Schema, r: Raw, +prev: Maybe<&2, Nat>, p: List<&2, Step>) -> Maybe<&2, Why>:
1195  match s r p:
1196    case SJson{} RJson{value} q:
1197      guard(Bool.not(valid_json(value)), at_end(NotJson{}, q))
1198    case SJson{} x q:
1199      at_end(missing_or(x, NotJson{}), q)
1200    case SInt{} x q:
1201      int_defect(x, q)
1202    case SIntIn{+lo, +hi} x q:
1203      int_in_defect(lo, hi, x, q)
1204    case SNat{} x q:
1205      nat_defect(x, q)
1206    case SStr{} x q:
1207      str_defect(x, q)
1208    case SNatIn{+lo, +hi} x q:
1209      nat_in_defect(lo, hi, x, q)
1210    case SStrLen{+lo, +hi, +s2} +x +q:
1211      pick_why(conforms(~rule, s2, x, prev), rule_defect(len_err(lo, hi, x), q), defect(~rule, s2, x, prev, q))
1212    case SListLen{+lo, +hi, +s2} +r +q:
1213      # The count came first in check, so the count's own error is the one
1214      # reported here exactly when there was one to report -- for a list out of
1215      # bounds and for a value that is not a list at all (list_len_ok is False
1216      # for both, and count_err reported something for both).
1217      pick_why(Bool.not(list_len_ok(lo, hi, r)), rule_defect(count_err(lo, hi, r), q), defect(~rule, s2, r, None{}, q))
1218    case SOpt{inner} RNull{} q:
1219      None{}
1220    case SOpt{inner} x q:
1221      defect(~rule, inner, x, None{}, q)
1222    case SOptional{inner} RMissing{} q:
1223      None{}  # absent is not wrong, at this path or below it
1224    case SOptional{inner} x q:
1225      defect(~rule, inner, x, None{}, q)
1226    case SList{e} RNil{} q:
1227      None{}
1228    case SList{e} RCons{h, t} AtIndex{0n} <> q:
1229      defect(~rule, e, h, None{}, q)
1230    case SList{+e} RCons{h, t} AtIndex{1n+j} <> q:
1231      guard(conforms(~rule, e, h, None{}), defect(~rule, SList{e}, t, None{}, AtIndex{j} <> q))
1232    case SList{+e} RCons{h, t} q:
1233      guard(conforms(~rule, e, h, None{}), defect(~rule, SList{e}, t, None{}, q))
1234    case SList{e} x q:
1235      not_list(x, q)
1236    case SField{+name, fs, rest} REnd{} AtField{0n, n} <> q:
1237      guard(String.eq(n, name), defect(~rule, fs, RMissing{}, None{}, q))
1238    case SField{+name, fs, rest} REnd{} AtField{1n+k, n} <> q:
1239      guard(conforms(~rule, fs, RMissing{}, None{}), defect(~rule, rest, REnd{}, None{}, AtField{k, n} <> q))
1240    case SField{+name, fs, rest} REnd{} q:
1241      guard(conforms(~rule, fs, RMissing{}, None{}), defect(~rule, rest, REnd{}, None{}, q))
1242    case SField{+name, fs, rest} RKey{+k, +v, +o} AtField{0n, n} <> +q:
1243      pick_why(Bool.not(key_once(name, RKey{k, v, o})), at_end(RepeatedKey{name}, q), guard(String.eq(n, name), defect(~rule, fs, lookup(name, RKey{k, v, o}), None{}, q)))
1244    case SField{+name, fs, rest} RKey{+k, +v, +o} AtField{1n+j, n} <> q:
1245      guard(conforms(~rule, fs, lookup(name, RKey{k, v, o}), None{}), defect(~rule, rest, RKey{k, v, o}, None{}, AtField{j, n} <> q))
1246    case SField{+name, fs, rest} RKey{+k, +v, +o} q:
1247      guard(conforms(~rule, fs, lookup(name, RKey{k, v, o}), None{}), defect(~rule, rest, RKey{k, v, o}, None{}, q))
1248    case SField{name, fs, rest} x q:
1249      not_object(x, q)
1250    case SEnd{} REnd{} q:
1251      None{}
1252    case SEnd{} RKey{k, v, o} q:
1253      None{}
1254    case SEnd{} x q:
1255      not_object(x, q)
1256    case SRule{+s2, +tag} +x +q:
1257      pick_why(conforms(~rule, s2, x, prev), rule_defect(rule(tag, x), q), defect(~rule, s2, x, prev, q))
1258    case SStrict{+s2} +x +q:
1259      pick_why(conforms(~rule, s2, x, prev), extra_defect(key_names(s2), x, q), defect(~rule, s2, x, prev, q))
1260    case STagged{+k, +n, cs, rest} +x +q:
1261      pick_why(is_tag(k, n, x), first_why(tag_key_defect(Bool.not(key_once(k, x)), k, q), defect(~rule, cs, drop_key(k, x), None{}, q)), defect(~rule, rest, x, None{}, q))
1262    case STagEnd{k} x q:
1263      tag_defect(k, x, q)
1264    case SBool{} x q:
1265      bool_defect(x, q)
1266    case STrue{} x q:
1267      true_defect(x, q)
1268    case SEnum{names} x q:
1269      enum_defect(names, x, q)
1270    case SVariant{+name, +vs, +rest} REnd{} AtField{1n+j, n} <> q:
1271      defect(~rule, rest, REnd{}, None{}, AtField{j, n} <> q)
1272    case SVariant{+name, +vs, +rest} REnd{} q:
1273      defect(~rule, rest, REnd{}, None{}, q)
1274    case SVariant{+name, +vs, +rest} RKey{+k, +v, +o} AtField{0n, +n} <> +q:
1275      pick_why(is_missing(lookup(name, RKey{k, v, o})), defect(~rule, rest, RKey{k, v, o}, None{}, AtField{0n, n} <> q), pick_why(Bool.not(key_once(name, RKey{k, v, o})), at_end(RepeatedKey{name}, q), guard(String.eq(n, name), defect(~rule, vs, lookup(name, RKey{k, v, o}), None{}, q))))
1276    case SVariant{+name, +vs, +rest} RKey{+k, +v, +o} AtField{1n+j, +n} <> +q:
1277      pick_why(is_missing(lookup(name, RKey{k, v, o})), defect(~rule, rest, RKey{k, v, o}, None{}, AtField{j, n} <> q), guard(conforms(~rule, vs, lookup(name, RKey{k, v, o}), None{}), dup_defect(rest, RKey{k, v, o}, AtField{j, n} <> q)))
1278    case SVariant{+name, +vs, +rest} RKey{+k, +v, +o} +q:
1279      pick_why(is_missing(lookup(name, RKey{k, v, o})), defect(~rule, rest, RKey{k, v, o}, None{}, q), None{})
1280    case SVariant{+name, +vs, +rest} x q:
1281      not_object(x, q)
1282    case SVEnd{} REnd{} q:
1283      no_variant(q)
1284    case SVEnd{} RKey{k, v, o} q:
1285      no_variant(q)
1286    case SVEnd{} x q:
1287      not_object(x, q)
1288    case STuple{ts, rest} RCons{h, t} AtIndex{0n} <> q:
1289      defect(~rule, ts, h, None{}, q)
1290    case STuple{+ts, rest} RCons{h, t} AtIndex{1n+j} <> q:
1291      guard(conforms(~rule, ts, h, None{}), defect(~rule, rest, t, None{}, AtIndex{j} <> q))
1292    case STuple{+ts, rest} RCons{h, t} q:
1293      guard(conforms(~rule, ts, h, None{}), defect(~rule, rest, t, None{}, q))
1294    case STuple{ts, rest} RNil{} q:
1295      at_end(TooShort{}, q)
1296    case STuple{ts, rest} x q:
1297      not_list(x, q)
1298    case STEnd{} RNil{} q:
1299      None{}
1300    case STEnd{} RCons{h, t} q:
1301      at_end(TooLong{}, q)
1302    case STEnd{} x q:
1303      not_list(x, q)
1304    case SEither{+l, +r} +x +q:
1305      pick_why(has_kind(l, kind_of(x)), defect(~rule, l, x, prev, q), pick_why(has_kind(r, kind_of(x)), defect(~rule, r, x, prev, q), at_end(missing_or(x, no_alt(SEither{l, r})), q)))