Skip to content

Commit e93a7cc

Browse files
VictorystickVictorystick
committed
Enforce typing of lists and variants
1 parent 6adffd7 commit e93a7cc

File tree

5 files changed

+120
-33
lines changed

5 files changed

+120
-33
lines changed

‎eval/builtins.go‎

Lines changed: 7 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -43,14 +43,16 @@ func bindBuiltIns(reg *types.Registry) Variables {
4343
return nil, fmt.Errorf("expected list, but got %T", val)
4444
}
4545

46-
results := make(List, len(ls))
47-
for i, v := range ls {
48-
results[i], err = fn(v)
46+
results := List{elements: make([]Value, len(ls.elements))}
47+
for i, v := range ls.elements {
48+
val, err = fn(v)
4949
if err != nil {
5050
return nil, err
5151
}
52+
results.elements[i] = val
53+
// TODO: propagate the new type.
5254
}
53-
return List(results), nil
55+
return results, nil
5456
},
5557
}, nil
5658
})
@@ -73,7 +75,7 @@ func bindBuiltIns(reg *types.Registry) Variables {
7375
return nil, fmt.Errorf("expected list, but got %T", val)
7476
}
7577
var mid Value
76-
for _, v := range ls {
78+
for _, v := range ls.elements {
7779
mid, err = fn(acc)
7880
if err != nil {
7981
return nil, err

‎eval/eval.go‎

Lines changed: 67 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -178,7 +178,9 @@ func (c *context) binary(x *ast.BinaryExpr) (Value, error) {
178178
}
179179
return binop(x.Op, lf, rf)
180180
}
181-
return nil, fmt.Errorf("cannot perform addition on %s", reflect.TypeOf(l))
181+
return nil, c.error(x.Span(),
182+
fmt.Sprintf("cannot perform addition on %s",
183+
c.reg.String(l.Type())))
182184

183185
case token.APPEND:
184186
l, err := c.eval(x.Left)
@@ -199,7 +201,18 @@ func (c *context) binary(x *ast.BinaryExpr) (Value, error) {
199201
if err != nil {
200202
return nil, err
201203
}
202-
return append(ls, r), nil
204+
typ := c.reg.GetList(ls.typ)
205+
if r.Type() != typ {
206+
// Special-case empty lists, which have type never.
207+
if typ == types.NeverRef {
208+
typ = r.Type()
209+
} else {
210+
return nil, c.error(x.Right.Span(),
211+
fmt.Sprintf("cannot append %s to %s",
212+
c.reg.String(r.Type()), c.reg.String(ls.typ)))
213+
}
214+
}
215+
return List{c.reg.List(typ), append(ls.elements, r)}, nil
203216
}
204217

205218
return nil, fmt.Errorf("cannot append to non-list %s", reflect.TypeOf(l))
@@ -223,7 +236,18 @@ func (c *context) binary(x *ast.BinaryExpr) (Value, error) {
223236
if err != nil {
224237
return nil, err
225238
}
226-
return append(List{l}, ls...), nil
239+
typ := c.reg.GetList(ls.typ)
240+
if l.Type() != typ {
241+
// Special-case empty lists, which have type never.
242+
if typ == types.NeverRef {
243+
typ = r.Type()
244+
} else {
245+
return nil, c.error(x.Left.Span(),
246+
fmt.Sprintf("cannot prepend %s to %s",
247+
c.reg.String(l.Type()), c.reg.String(ls.typ)))
248+
}
249+
}
250+
return List{c.reg.List(typ), append([]Value{l}, ls.elements...)}, nil
227251
}
228252

229253
return nil, fmt.Errorf("cannot prepend to non-list %s", reflect.TypeOf(r))
@@ -247,7 +271,17 @@ func (c *context) binary(x *ast.BinaryExpr) (Value, error) {
247271
if err != nil {
248272
return nil, err
249273
}
250-
return append(ls, r...), nil
274+
275+
// Special-case empty lists.
276+
typ := ls.typ // a list type
277+
if typ != r.typ {
278+
if c.reg.GetList(typ) == types.NeverRef {
279+
typ = r.typ
280+
} else if c.reg.GetList(r.typ) != types.NeverRef {
281+
return nil, c.error(x.Left.Span(), fmt.Sprintf("cannot concat %s to %s", c.reg.String(ls.typ), c.reg.String(r.typ)))
282+
}
283+
}
284+
return List{typ, append(ls.elements, r.elements...)}, nil
251285
}
252286

253287
if tx, ok := l.(Text); ok {
@@ -419,17 +453,27 @@ func (c *context) access(x *ast.AccessExpr) (Value, error) {
419453
return val, nil
420454
}
421455

422-
func (c *context) listExpr(x *ast.ListExpr) (List, error) {
423-
list := make(List, len(x.Elements))
456+
func (c *context) listExpr(x *ast.ListExpr) (ls List, err error) {
457+
elements := make([]Value, len(x.Elements))
458+
typ := types.NeverRef
424459
for i, x := range x.Elements {
425-
val, err := c.eval(x)
460+
var val Value
461+
val, err = c.eval(x)
426462
if err != nil {
427-
return nil, err
463+
return
428464
}
429465

430-
list[i] = val
466+
elements[i] = val
467+
if val.Type() != typ {
468+
if typ == types.NeverRef {
469+
typ = val.Type()
470+
} else {
471+
err = c.error(x.Span(), fmt.Sprintf("list elements must all be of type %s, got %s", c.reg.String(typ), c.reg.String(val.Type())))
472+
return
473+
}
474+
}
431475
}
432-
return list, nil
476+
return List{c.reg.List(typ), elements}, nil
433477
}
434478

435479
func (c *context) pick(pick *ast.BinaryExpr, x ast.Expr) (Value, error) {
@@ -447,7 +491,7 @@ func (c *context) pick(pick *ast.BinaryExpr, x ast.Expr) (Value, error) {
447491
if tagTyp, ok := enum[tag]; ok {
448492
if tagTyp == types.NeverRef {
449493
if x == nil {
450-
return Variant{Type(ref), tag, nil}, nil
494+
return Variant{ref, tag, nil}, nil
451495
} else {
452496
return nil, c.error(x.Span(), fmt.Sprintf("#%s does not take a value", tag))
453497
}
@@ -459,8 +503,12 @@ func (c *context) pick(pick *ast.BinaryExpr, x ast.Expr) (Value, error) {
459503
if err != nil {
460504
return nil, err
461505
}
462-
// TODO verify type.
463-
return Variant{Type(ref), tag, val}, nil
506+
if val.Type() != tagTyp {
507+
return nil, c.error(pick.Right.Span(),
508+
fmt.Sprintf("#%s requires a value of type %s, got %s",
509+
tag, c.reg.String(tagTyp), c.reg.String(val.Type())))
510+
}
511+
return Variant{ref, tag, val}, nil
464512
}
465513
}
466514
}
@@ -582,15 +630,17 @@ func (c *context) bytes(x ast.Node) (Bytes, error) {
582630
return nil, c.error(x.Span(), fmt.Sprintf("non-bytes value %s", val))
583631
}
584632

585-
func (c *context) list(x ast.Node) (List, error) {
586-
val, err := c.eval(x)
633+
func (c *context) list(x ast.Node) (l List, err error) {
634+
var val Value
635+
val, err = c.eval(x)
587636
if err != nil {
588-
return nil, err
637+
return
589638
}
590639
if i, ok := val.(List); ok {
591640
return i, nil
592641
}
593-
return nil, c.error(x.Span(), fmt.Sprintf("non-list value %s", val))
642+
err = c.error(x.Span(), fmt.Sprintf("non-list value %s", val))
643+
return
594644
}
595645

596646
func (c *context) record(x ast.Node) (Record, error) {

‎eval/eval_test.go‎

Lines changed: 9 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -58,7 +58,8 @@ var expressions = []struct {
5858
// | "hello " ++ name -> name
5959
// | _ -> "<empty>" <| "hello Oseg"`, Text("Oseg")},
6060
{`box::empty ; box : #empty`, `#empty`},
61-
{`typ::fun (n -> x * 2) ; typ : #fun (int -> int)`, `#fun n -> x * 2`},
61+
// TODO: Cannot infer type of `n -> x * 2`.
62+
// {`typ::fun (n -> x * 2) ; typ : #fun (int -> int)`, `#fun n -> x * 2`},
6263

6364
// Destructuring.
6465
{`{ a = 1, b = 2 } |> | { a = c, b = d } -> c + d`, `3`},
@@ -85,6 +86,9 @@ var failures = []struct {
8586
{`1::a`, `1 does not evaluate to a type`},
8687
{`box::empty 1 ; box : #empty`, `#empty does not take a value`},
8788
{`box::with ; box : #with int`, `#with requires a value of type int`},
89+
{`["a"] +< ~be`, `cannot append byte to list text`},
90+
{`1 >+ [~~abcd]`, `cannot prepend int to list bytes`},
91+
{`[1, 1.2]`, `list elements must all be of type int, got float`},
8892
}
8993

9094
func TestEval(t *testing.T) {
@@ -102,6 +106,10 @@ var exp2str = []struct{ source, result string }{
102106
{`bytes/from-utf8-text "hello world"`, `~~aGVsbG8gd29ybGQ=`},
103107

104108
{`1 >+ [2, 3] +< 4`, `[ 1, 2, 3, 4 ]`},
109+
{`1 >+ []`, `[ 1 ]`},
110+
{`[] +< 2`, `[ 2 ]`},
111+
{`[ 3 ] ++ []`, `[ 3 ]`},
112+
{`[] ++ [ 4 ]`, `[ 4 ]`},
105113
{`["prefix"] ++ ["in" ++ "fix"] +< "postfix"`, `[ "prefix", "infix", "postfix" ]`},
106114
// Records
107115
{`rec.a ; rec = { a = 1, b = "x" }`, `1`},

‎eval/match.go‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -117,14 +117,14 @@ func (m *matcher) match(x ast.Expr, val Value) {
117117

118118
case *ast.ListExpr:
119119
if list, ok := val.(List); ok {
120-
if len(x.Elements) != len(list) {
120+
if len(x.Elements) != len(list.elements) {
121121
m.err = ErrNoMatch
122122
return
123123
}
124124

125125
for index, x := range x.Elements {
126126
// Recursively match further.
127-
m.match(x, list[index])
127+
m.match(x, list.elements[index])
128128
}
129129
return
130130
}

‎eval/values.go‎

Lines changed: 35 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,7 @@ import (
1414
// Values
1515

1616
type Value interface {
17+
Type() types.TypeRef
1718
String() string
1819
eq(other Value) bool
1920
}
@@ -30,10 +31,13 @@ type Type types.TypeRef
3031

3132
type Record map[string]Value
3233

33-
type List []Value
34+
type List struct {
35+
typ types.TypeRef
36+
elements []Value
37+
}
3438

3539
type Variant struct {
36-
typ Type
40+
typ types.TypeRef
3741
tag string
3842
value Value
3943
}
@@ -108,17 +112,17 @@ func (bs Bytes) eq(other Value) bool {
108112
o, ok := other.(Bytes)
109113
return ok && bytes.Equal(bs, o)
110114
}
111-
func (i Type) eq(other Value) bool {
115+
func (t Type) eq(other Value) bool {
112116
o, ok := other.(Type)
113-
return ok && i == o
117+
return ok && t == o
114118
}
115119
func (i Record) eq(other Value) bool {
116120
o, ok := other.(Record)
117121
return ok && maps.EqualFunc(i, o, Equals)
118122
}
119123
func (l List) eq(other Value) bool {
120124
o, ok := other.(List)
121-
return ok && slices.EqualFunc(l, o, Equals)
125+
return ok && slices.EqualFunc(l.elements, o.elements, Equals)
122126
}
123127
func (v Variant) eq(other Value) bool {
124128
o, ok := other.(Variant)
@@ -134,6 +138,29 @@ func (sf ScriptFunc) eq(other Value) bool {
134138
return ok && sf.source == o.source
135139
}
136140

141+
// Type
142+
func (h Hole) Type() types.TypeRef { return types.HoleRef }
143+
func (i Int) Type() types.TypeRef { return types.IntRef }
144+
func (f Float) Type() types.TypeRef { return types.FloatRef }
145+
func (t Text) Type() types.TypeRef { return types.TextRef }
146+
func (b Byte) Type() types.TypeRef { return types.ByteRef }
147+
func (bs Bytes) Type() types.TypeRef { return types.BytesRef }
148+
func (t Type) Type() types.TypeRef {
149+
// TODO: Should a type return itself, or a special type?
150+
return types.NeverRef
151+
}
152+
func (i Record) Type() types.TypeRef {
153+
// TODO: implement
154+
return types.NeverRef
155+
}
156+
func (l List) Type() types.TypeRef { return l.typ }
157+
func (v Variant) Type() types.TypeRef { return v.typ }
158+
func (bf BuiltInFunc) Type() types.TypeRef { return bf.typ }
159+
func (sf ScriptFunc) Type() types.TypeRef {
160+
// TODO: implement
161+
return types.NeverRef
162+
}
163+
137164
// String
138165

139166
func (h Hole) String() string {
@@ -182,14 +209,14 @@ func (r Record) String() string {
182209
return b.String()
183210
}
184211
func (l List) String() string {
185-
if len(l) == 0 {
212+
if len(l.elements) == 0 {
186213
return "[]"
187214
}
188215

189216
var b strings.Builder
190217
b.WriteString("[ ")
191-
comma := len(l) - 1
192-
for _, val := range l {
218+
comma := len(l.elements) - 1
219+
for _, val := range l.elements {
193220
b.WriteString(val.String())
194221

195222
if comma > 0 {

0 commit comments

Comments
 (0)