/
binding_map.go
107 lines (91 loc) · 2.53 KB
/
binding_map.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
package edit
import (
"errors"
"sort"
"github.com/markusbkk/elvish/pkg/eval"
"github.com/markusbkk/elvish/pkg/eval/vals"
"github.com/markusbkk/elvish/pkg/parse"
"github.com/markusbkk/elvish/pkg/ui"
)
var errValueShouldBeFn = errors.New("value should be function")
// A special Map that converts its key to ui.Key and ensures that its values
// satisfy eval.CallableValue.
type bindingsMap struct {
vals.Map
}
var emptyBindingsMap = bindingsMap{vals.EmptyMap}
// Repr returns the representation of the binding table as if it were an
// ordinary map keyed by strings.
func (bt bindingsMap) Repr(indent int) string {
var keys ui.Keys
for it := bt.Map.Iterator(); it.HasElem(); it.Next() {
k, _ := it.Elem()
keys = append(keys, k.(ui.Key))
}
sort.Sort(keys)
builder := vals.NewMapReprBuilder(indent)
for _, k := range keys {
v, _ := bt.Map.Index(k)
builder.WritePair(parse.Quote(k.String()), indent+2, vals.Repr(v, indent+2))
}
return builder.String()
}
// Index converts the index to ui.Key and uses the Index of the inner Map.
func (bt bindingsMap) Index(index interface{}) (interface{}, error) {
key, err := toKey(index)
if err != nil {
return nil, err
}
return vals.Index(bt.Map, key)
}
func (bt bindingsMap) HasKey(k interface{}) bool {
_, ok := bt.Map.Index(k)
return ok
}
func (bt bindingsMap) GetKey(k ui.Key) eval.Callable {
v, ok := bt.Map.Index(k)
if !ok {
panic("get called when key not present")
}
return v.(eval.Callable)
}
// Assoc converts the index to ui.Key, ensures that the value is CallableValue,
// uses the Assoc of the inner Map and converts the result to a BindingTable.
func (bt bindingsMap) Assoc(k, v interface{}) (interface{}, error) {
key, err := toKey(k)
if err != nil {
return nil, err
}
f, ok := v.(eval.Callable)
if !ok {
return nil, errValueShouldBeFn
}
map2 := bt.Map.Assoc(key, f)
return bindingsMap{map2}, nil
}
// Dissoc converts the key to ui.Key and calls the Dissoc method of the inner
// map.
func (bt bindingsMap) Dissoc(k interface{}) interface{} {
key, err := toKey(k)
if err != nil {
// Key is invalid; dissoc is no-op.
return bt
}
return bindingsMap{bt.Map.Dissoc(key)}
}
func makeBindingMap(raw vals.Map) (bindingsMap, error) {
converted := vals.EmptyMap
for it := raw.Iterator(); it.HasElem(); it.Next() {
k, v := it.Elem()
f, ok := v.(eval.Callable)
if !ok {
return emptyBindingsMap, errValueShouldBeFn
}
key, err := toKey(k)
if err != nil {
return bindingsMap{}, err
}
converted = converted.Assoc(key, f)
}
return bindingsMap{converted}, nil
}