Reimplement edit.BindingTable with persistent hashmap.

edit/api.go

@@ -138,17 +138,12 @@ func installModules(modules map[string]eval.Namespace, ed *Editor) {
 		}
 	}
 
-	// Add $edit:xxx:binding variables.
-	// TODO Make binding specific to the Editor.
-	for _, mode := range []string{
-		modeInsert, modeCommand, modeCompletion, modeNavigation, modeHistory,
-		modeHistoryListing, modeLocation, modeLastCmd, modeListing, modeNarrow} {
-
+	// Add $edit:{mode}:binding variables.
+	for mode, bindingVar := range ed.bindings {
 		if modules["edit:"+mode] == nil {
 			modules["edit:"+mode] = make(eval.Namespace)
 		}
-		modules["edit:"+mode]["binding"] =
-			eval.NewRoVariable(BindingTable{keyBindings[mode]})
+		modules["edit:"+mode]["binding"] = bindingVar
 	}
 }
 

edit/binding_table.go

@@ -0,0 +1,57 @@
+package edit
+
+import (
+	"github.com/elves/elvish/edit/ui"
+	"github.com/elves/elvish/eval"
+	"github.com/elves/elvish/parse"
+)
+
+func getBinding(bindingVar eval.Variable, k ui.Key) eval.CallableValue {
+	binding := bindingVar.Get().(BindingTable)
+	switch {
+	case binding.HasKey(k):
+		return binding.IndexOne(k).(eval.CallableValue)
+	case binding.HasKey(ui.Default):
+		return binding.IndexOne(ui.Default).(eval.CallableValue)
+	default:
+		return nil
+	}
+}
+
+// BindingTable is a special Map that converts its key to ui.Key and ensures
+// that its values satisfy eval.CallableValue.
+type BindingTable struct {
+	eval.Map
+}
+
+// Repr returns the representation of the binding table as if it were an
+// ordinary map keyed by strings.
+func (bt BindingTable) Repr(indent int) string {
+	var builder eval.MapReprBuilder
+	builder.Indent = indent
+	bt.Map.IteratePair(func(k, v eval.Value) bool {
+		builder.WritePair(parse.Quote(k.(ui.Key).String()), indent+2, v.Repr(indent+2))
+		return true
+	})
+	return builder.String()
+}
+
+// IndexOne converts the index to ui.Key and uses the IndexOne of the inner Map.
+func (bt BindingTable) IndexOne(idx eval.Value) eval.Value {
+	return bt.Map.IndexOne(ui.ToKey(idx))
+}
+
+func (bt BindingTable) get(k ui.Key) eval.CallableValue {
+	return bt.Map.IndexOne(k).(eval.CallableValue)
+}
+
+// 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 BindingTable) Assoc(k, v eval.Value) eval.Value {
+	key := ui.ToKey(k)
+	f, ok := v.(eval.CallableValue)
+	if !ok {
+		throwf("want function, got %s", v.Kind())
+	}
+	return BindingTable{bt.Map.Assoc(key, f).(eval.Map)}
+}

edit/completion.go

@@ -56,8 +56,8 @@ type completion struct {
 	height          int
 }
 
-func (*completion) Binding(k ui.Key) eval.CallableValue {
-	return getBinding(modeCompletion, k)
+func (*completion) Binding(m map[string]eval.Variable, k ui.Key) eval.CallableValue {
+	return getBinding(m[modeCompletion], k)
 }
 
 func (c *completion) needScrollbar() bool {

edit/editor.go

@@ -38,6 +38,7 @@ type Editor struct {
 	evaler *eval.Evaler
 
 	variables map[string]eval.Variable
+	bindings  map[string]eval.Variable
 
 	active      bool
 	activeMutex sync.Mutex
@@ -92,6 +93,7 @@ func NewEditor(in *os.File, out *os.File, sigs chan os.Signal, ev *eval.Evaler,
 		daemon: daemon,
 		evaler: ev,
 
+		bindings:  makeBindings(),
 		variables: makeVariables(),
 	}
 	if daemon != nil {
@@ -437,7 +439,7 @@ MainLoop:
 			case tty.Key:
 				k := ui.Key(unit)
 			lookupKey:
-				fn := ed.mode.Binding(k)
+				fn := ed.mode.Binding(ed.bindings, k)
 				if fn == nil {
 					ed.addTip("Unbound and no default binding: %s", k)
 					continue MainLoop

edit/history.go

@@ -35,8 +35,8 @@ type hist struct {
 	*history.Walker
 }
 
-func (*hist) Binding(k ui.Key) eval.CallableValue {
-	return getBinding(modeHistory, k)
+func (*hist) Binding(m map[string]eval.Variable, k ui.Key) eval.CallableValue {
+	return getBinding(m[modeHistory], k)
 }
 
 func (h *hist) ModeLine() renderer {

edit/insert.go

@@ -132,8 +132,8 @@ func (ins *insert) ModeLine() renderer {
 	return nil
 }
 
-func (*insert) Binding(k ui.Key) eval.CallableValue {
-	return getBinding(modeInsert, k)
+func (*insert) Binding(m map[string]eval.Variable, k ui.Key) eval.CallableValue {
+	return getBinding(m[modeInsert], k)
 }
 
 type command struct{}
@@ -142,8 +142,8 @@ func (*command) ModeLine() renderer {
 	return modeLineRenderer{" COMMAND ", ""}
 }
 
-func (*command) Binding(k ui.Key) eval.CallableValue {
-	return getBinding(modeCommand, k)
+func (*command) Binding(m map[string]eval.Variable, k ui.Key) eval.CallableValue {
+	return getBinding(m[modeCommand], k)
 }
 
 func insertStart(ed *Editor) {

edit/listing.go

@@ -80,24 +80,26 @@ func newListing(t string, p listingProvider) listing {
 	return l
 }
 
-func (l *listing) Binding(k ui.Key) eval.CallableValue {
-	specificBindings := keyBindings[l.name]
-	if specificBindings == nil {
-		return getBinding(modeListing, k)
+func (l *listing) Binding(m map[string]eval.Variable, k ui.Key) eval.CallableValue {
+	if m[l.name] == nil {
+		return getBinding(m[modeListing], k)
 	}
-	listingBindings := keyBindings[modeListing]
+	specificBindings := m[l.name].Get().(BindingTable)
+	listingBindings := m[modeListing].Get().(BindingTable)
 	// mode-specific binding -> listing binding ->
 	// mode-specific default -> listing default
-	if v, ok := specificBindings[k]; ok {
-		return v
+	switch {
+	case specificBindings.HasKey(k):
+		return specificBindings.get(k)
+	case listingBindings.HasKey(k):
+		return listingBindings.get(k)
+	case specificBindings.HasKey(ui.Default):
+		return specificBindings.get(ui.Default)
+	case listingBindings.HasKey(ui.Default):
+		return listingBindings.get(ui.Default)
+	default:
+		return nil
 	}
-	if v, ok := listingBindings[k]; ok {
-		return v
-	}
-	if v, ok := specificBindings[ui.Default]; ok {
-		return v
-	}
-	return listingBindings[ui.Default]
 }
 
 func (l *listing) ModeLine() renderer {

edit/mode.go

@@ -24,7 +24,7 @@ const (
 // Mode is an editor mode.
 type Mode interface {
 	ModeLine() renderer
-	Binding(ui.Key) eval.CallableValue
+	Binding(map[string]eval.Variable, ui.Key) eval.CallableValue
 }
 
 // CursorOnModeLiner is an optional interface that modes can implement. If a

edit/narrow.go

@@ -59,19 +59,14 @@ type narrow struct {
 	opts      narrowOptions
 }
 
-func (l *narrow) Binding(k ui.Key) eval.CallableValue {
+func (l *narrow) Binding(m map[string]eval.Variable, k ui.Key) eval.CallableValue {
 	if l.opts.bindingMap != nil {
 		if f, ok := l.opts.bindingMap[k]; ok {
 			return f
 		}
 	}
 
-	bindings := keyBindings[modeNarrow]
-	if f, ok := bindings[k]; ok {
-		return f
-	}
-
-	return bindings[ui.Default]
+	return getBinding(m[modeNarrow], k)
 }
 
 func (l *narrow) ModeLine() renderer {

edit/navigation.go

@@ -60,8 +60,8 @@ type navigation struct {
 	chdir      func(string) error
 }
 
-func (*navigation) Binding(k ui.Key) eval.CallableValue {
-	return getBinding(modeNavigation, k)
+func (*navigation) Binding(m map[string]eval.Variable, k ui.Key) eval.CallableValue {
+	return getBinding(m[modeNavigation], k)
 }
 
 func (n *navigation) ModeLine() renderer {
@@ -141,7 +141,7 @@ func navDefault(ed *Editor) {
 			n.refreshDirPreview()
 		}
 	} else {
-		ed.CallFn(getBinding(modeInsert, k))
+		ed.CallFn(getBinding(ed.bindings[modeInsert], k))
 	}
 }
 

edit/raw_insert.go

@@ -23,7 +23,7 @@ func insertRaw(ed *Editor, r rune) {
 	ed.mode = &ed.insert
 }
 
-func (rawInsert) Binding(k ui.Key) eval.CallableValue {
+func (rawInsert) Binding(map[string]eval.Variable, ui.Key) eval.CallableValue {
 	// The raw insert mode does not handle keys.
 	return nil
 }

edit/registry.go

@@ -1,12 +1,14 @@
 package edit
 
 import (
+	"errors"
 	"fmt"
 	"os"
 	"strings"
 
 	"github.com/elves/elvish/edit/ui"
 	"github.com/elves/elvish/eval"
+	"github.com/xiaq/persistent/hashmap"
 )
 
 // This file contains several "registries", data structure that are written
@@ -97,3 +99,25 @@ func registerBindings(
 	}
 	return struct{}{}
 }
+
+func makeBindings() map[string]eval.Variable {
+	bindings := make(map[string]eval.Variable)
+	for mode, binding := range keyBindings {
+		bindingValue := hashmap.Empty
+		for key, fn := range binding {
+			bindingValue = bindingValue.Assoc(key, fn)
+		}
+		bindings[mode] = eval.NewPtrVariableWithValidator(
+			BindingTable{eval.NewMap(bindingValue)}, shouldBeBindingTable)
+	}
+	return bindings
+}
+
+var errShouldBeBindingTable = errors.New("should be binding table")
+
+func shouldBeBindingTable(v eval.Value) error {
+	if _, ok := v.(BindingTable); !ok {
+		return errShouldBeBindingTable
+	}
+	return nil
+}