core.bend
yaml-for-bend@0.1.0.0 · 146 lines · 0 definitions
1# The YAML 1.2 Core schema: how a scalar's text and tag become a value.
2#
3# An untagged plain scalar is null (null, Null, NULL, ~ or nothing), a
4# boolean (true/True/TRUE, false/False/FALSE), an integer (decimal, 0o
5# octal, 0x hex), a float (decimal, .inf, -.inf, .nan) or else a string.
6# A quoted or block scalar, or one tagged "!", is a string. A standard tag
7# (!!str, !!null, !!bool, !!int, !!float) reads the text as that type, and
8# fails when it can't; any other tag is kept as a Tagged value.
9
10import Base
11
12import yaml-for-bend@0.1.0.0/value.bend as V
13
14import yaml-for-bend@0.1.0.0/re.bend as R
15
16import yaml-for-bend@0.1.0.0/num.bend as N
17
18def yaml.tag(name: String) -> String:
19 "tag:yaml.org,2002:" ++ name
20
21def when(-A: Type, hit: Bool, yes: Unit -> A, no: Unit -> A) -> A:
22 match hit:
23 case True{}:
24 yes(Unit{})
25 case False{}:
26 no(Unit{})
27
28def is_null(+s: String) -> Bool:
29 Bool.or(Bool.or(String.is_empty(s), String.eq(s, "~")), Bool.or(String.eq(s, "null"), Bool.or(String.eq(s, "Null"), String.eq(s, "NULL"))))
30
31def is_true(+s: String) -> Bool:
32 Bool.or(String.eq(s, "true"), Bool.or(String.eq(s, "True"), String.eq(s, "TRUE")))
33
34def is_false(+s: String) -> Bool:
35 Bool.or(String.eq(s, "false"), Bool.or(String.eq(s, "False"), String.eq(s, "FALSE")))
36
37def dec.pat() -> List<&2, R.Pat>:
38 [R.sign(), R.digits()]
39
40def oct.pat() -> List<&2, R.Pat>:
41 [R.c('0'), R.c('o'), R.Plus{R.One{R.Range{'0', '7'}}}]
42
43def hex.pat() -> List<&2, R.Pat>:
44 [R.c('0'), R.c('x'), R.Plus{R.One{R.Hex{}}}]
45
46# [-+]?(\.[0-9]+|[0-9]+(\.[0-9]*)?)([eE][-+]?[0-9]+)?
47def float.pat() -> List<&2, R.Pat>:
48 [R.sign(), R.Alt{[[R.c('.'), R.digits()], [R.digits(), R.Opt{R.seq([R.c('.'), R.Star{R.digit()}])}]]},
49 R.Opt{R.seq([R.of("eE"), R.sign(), R.digits()])}]
50
51def is_inf(+s: String) -> Bool:
52 Bool.or(String.eq(s, ".inf"), Bool.or(String.eq(s, ".Inf"), String.eq(s, ".INF")))
53
54def is_nan(+s: String) -> Bool:
55 Bool.or(String.eq(s, ".nan"), Bool.or(String.eq(s, ".NaN"), String.eq(s, ".NAN")))
56
57def unsigned(s: String) -> String:
58 match s:
59 case SCon{c, t}:
60 match c:
61 case '-':
62 t
63 case '+':
64 t
65 case _:
66 SCon{c, t}
67 case SNil{}:
68 ""
69
70def is_neg(s: String) -> Bool:
71 String.starts_with(s, "-")
72
73# An integer's decimal text, if +s+ is one.
74def int.of(+s: String) -> Maybe<&2, String>:
75 when(Maybe<&2, String>, R.matches(dec.pat(), s), u => Some{N.int.text(is_neg(s), unsigned(s), 10n)},
76 u => when(Maybe<&2, String>, R.matches(oct.pat(), s), u => Some{N.int.text(False{}, String.drop(s, 2n), 8n)},
77 u => when(Maybe<&2, String>, R.matches(hex.pat(), s), u => Some{N.int.text(False{}, String.drop(s, 2n), 16n)}, u => None{})))
78
79# A float's text, if +s+ is one: as written, or ".inf", "-.inf", ".nan".
80def float.of(+s: String) -> Maybe<&2, String>:
81 +u = unsigned(s)
82 Bool.pick(Maybe<&2, String>, is_inf(u), Some{Bool.pick(String, is_neg(s), "-.inf", ".inf")},
83 Bool.pick(Maybe<&2, String>, is_nan(s), Some{".nan"},
84 Bool.pick(Maybe<&2, String>, R.matches(float.pat(), s), Some{s}, None{})))
85
86def or.int(m: Maybe<&2, String>, s: String, rest: Unit -> V.Yaml) -> V.Yaml:
87 match m:
88 case Some{t}:
89 V.Int{t}
90 case None{}:
91 rest(Unit{})
92
93def or.float(m: Maybe<&2, String>, rest: Unit -> V.Yaml) -> V.Yaml:
94 match m:
95 case Some{t}:
96 V.Float{t}
97 case None{}:
98 rest(Unit{})
99
100# An untagged plain scalar.
101def plain(+s: String) -> V.Yaml:
102 when(V.Yaml, is_null(s), u => V.Null{},
103 u => when(V.Yaml, is_true(s), u => V.Boolean{True{}},
104 u => when(V.Yaml, is_false(s), u => V.Boolean{False{}},
105 u => or.int(int.of(s), s, u => or.float(float.of(s), u => V.Str{s})))))
106
107def must(m: Maybe<&2, V.Yaml>, +tag: String, +s: String) -> Result<&2, &2, String, V.Yaml>:
108 match m:
109 case Some{v}:
110 Done{v}
111 case None{}:
112 Fail{"found a value that isn't a " ++ tag ++ ": " ++ s}
113
114def int.yaml(m: Maybe<&2, String>) -> Maybe<&2, V.Yaml>:
115 match m:
116 case Some{t}:
117 Some{V.Int{t}}
118 case None{}:
119 None{}
120
121# !!float: a float, or an integer written as one ("3" is 3.0).
122def float.yaml(m: Maybe<&2, String>, i: Maybe<&2, String>) -> Maybe<&2, V.Yaml>:
123 match m:
124 case Some{t}:
125 Some{V.Float{t}}
126 case None{}:
127 match i:
128 case Some{t}:
129 Some{V.Float{t ++ ".0"}}
130 case None{}:
131 None{}
132
133# A scalar with a tag: !!str, !!null, !!bool, !!int and !!float read the
134# text; "!" is a string; another tag is kept.
135def tagged(+tag: String, +s: String) -> Result<&2, &2, String, V.Yaml>:
136 when(Result<&2, &2, String, V.Yaml>, Bool.or(String.eq(tag, "!"), String.eq(tag, yaml.tag("str"))), u => Done{V.Str{s}},
137 u => when(Result<&2, &2, String, V.Yaml>, String.eq(tag, yaml.tag("null")), u => must(Bool.pick(Maybe<&2, V.Yaml>, is_null(s), Some{V.Null{}}, None{}), "!!null", s),
138 u => when(Result<&2, &2, String, V.Yaml>, String.eq(tag, yaml.tag("bool")),
139 u => must(Bool.pick(Maybe<&2, V.Yaml>, is_true(s), Some{V.Boolean{True{}}}, Bool.pick(Maybe<&2, V.Yaml>, is_false(s), Some{V.Boolean{False{}}}, None{})), "!!bool", s),
140 u => when(Result<&2, &2, String, V.Yaml>, String.eq(tag, yaml.tag("int")), u => must(int.yaml(int.of(s)), "!!int", s),
141 u => when(Result<&2, &2, String, V.Yaml>, String.eq(tag, yaml.tag("float")), u => must(float.yaml(float.of(s), int.of(s)), "!!float", s),
142 u => Done{V.Tagged{tag, V.Str{s}}})))))
143
144# A collection with a tag: "!", !!seq and !!map are plain; another is kept.
145def collection(+tag: String, +v: V.Yaml) -> V.Yaml:
146 Bool.pick(V.Yaml, Bool.or(String.eq(tag, "!"), Bool.or(String.eq(tag, yaml.tag("seq")), String.eq(tag, yaml.tag("map")))), v, V.Tagged{tag, v})