unexport serialize/deserialize
diff --git a/exec.go b/exec.go
index 689540b..31cd339 100644
--- a/exec.go
+++ b/exec.go
@@ -60,10 +60,10 @@
 func (v autoVar) AppendVar(*Evaluator, Value) Var {
 	panic("must not be called")
 }
-func (v autoVar) Serialize() SerializableVar {
+func (v autoVar) serialize() serializableVar {
 	panic(fmt.Sprintf("cannot serialize auto var: %q", v))
 }
-func (v autoVar) Dump(w io.Writer) {
+func (v autoVar) dump(w io.Writer) {
 	panic(fmt.Sprintf("cannot dump auto var: %q", v))
 }
 
diff --git a/expr.go b/expr.go
index d9fdb40..599a241 100644
--- a/expr.go
+++ b/expr.go
@@ -56,8 +56,8 @@
 type Value interface {
 	String() string
 	Eval(w io.Writer, ev *Evaluator)
-	Serialize() SerializableVar
-	Dump(w io.Writer)
+	serialize() serializableVar
+	dump(w io.Writer)
 }
 
 type Valuer interface {
@@ -71,10 +71,10 @@
 func (s literal) Eval(w io.Writer, ev *Evaluator) {
 	io.WriteString(w, string(s))
 }
-func (s literal) Serialize() SerializableVar {
-	return SerializableVar{Type: "literal", V: string(s)}
+func (s literal) serialize() serializableVar {
+	return serializableVar{Type: "literal", V: string(s)}
 }
-func (s literal) Dump(w io.Writer) {
+func (s literal) dump(w io.Writer) {
 	dumpByte(w, valueTypeLiteral)
 	dumpBytes(w, []byte(s))
 }
@@ -87,10 +87,10 @@
 	w.Write(t)
 }
 func (t tmpval) Value() []byte { return []byte(t) }
-func (t tmpval) Serialize() SerializableVar {
-	return SerializableVar{Type: "tmpval", V: string(t)}
+func (t tmpval) serialize() serializableVar {
+	return serializableVar{Type: "tmpval", V: string(t)}
 }
-func (t tmpval) Dump(w io.Writer) {
+func (t tmpval) dump(w io.Writer) {
 	dumpByte(w, valueTypeTmpval)
 	dumpBytes(w, t)
 }
@@ -112,18 +112,18 @@
 	}
 }
 
-func (e Expr) Serialize() SerializableVar {
-	r := SerializableVar{Type: "expr"}
+func (e Expr) serialize() serializableVar {
+	r := serializableVar{Type: "expr"}
 	for _, v := range e {
-		r.Children = append(r.Children, v.Serialize())
+		r.Children = append(r.Children, v.serialize())
 	}
 	return r
 }
-func (e Expr) Dump(w io.Writer) {
+func (e Expr) dump(w io.Writer) {
 	dumpByte(w, valueTypeExpr)
 	dumpInt(w, len(e))
 	for _, v := range e {
-		v.Dump(w)
+		v.dump(w)
 	}
 }
 
@@ -158,15 +158,15 @@
 	traceEvent.end(te)
 }
 
-func (v *varref) Serialize() SerializableVar {
-	return SerializableVar{
+func (v *varref) serialize() serializableVar {
+	return serializableVar{
 		Type:     "varref",
-		Children: []SerializableVar{v.varname.Serialize()},
+		Children: []serializableVar{v.varname.serialize()},
 	}
 }
-func (v *varref) Dump(w io.Writer) {
+func (v *varref) dump(w io.Writer) {
 	dumpByte(w, valueTypeVarref)
-	v.varname.Dump(w)
+	v.varname.dump(w)
 }
 
 // paramref is parameter reference e.g. $1.
@@ -188,11 +188,11 @@
 	traceEvent.end(te)
 }
 
-func (p paramref) Serialize() SerializableVar {
-	return SerializableVar{Type: "paramref", V: strconv.Itoa(int(p))}
+func (p paramref) serialize() serializableVar {
+	return serializableVar{Type: "paramref", V: strconv.Itoa(int(p))}
 }
 
-func (p paramref) Dump(w io.Writer) {
+func (p paramref) dump(w io.Writer) {
 	dumpByte(w, valueTypeParamref)
 	dumpInt(w, int(p))
 }
@@ -231,22 +231,22 @@
 	traceEvent.end(te)
 }
 
-func (v varsubst) Serialize() SerializableVar {
-	return SerializableVar{
+func (v varsubst) serialize() serializableVar {
+	return serializableVar{
 		Type: "varsubst",
-		Children: []SerializableVar{
-			v.varname.Serialize(),
-			v.pat.Serialize(),
-			v.subst.Serialize(),
+		Children: []serializableVar{
+			v.varname.serialize(),
+			v.pat.serialize(),
+			v.subst.serialize(),
 		},
 	}
 }
 
-func (v varsubst) Dump(w io.Writer) {
+func (v varsubst) dump(w io.Writer) {
 	dumpByte(w, valueTypeVarsubst)
-	v.varname.Dump(w)
-	v.pat.Dump(w)
-	v.subst.Dump(w)
+	v.varname.dump(w)
+	v.pat.dump(w)
+	v.subst.dump(w)
 }
 
 func str(buf []byte, alloc bool) Value {
@@ -621,8 +621,8 @@
 
 func (m matchVarref) String() string                  { return "$(match-any)" }
 func (m matchVarref) Eval(w io.Writer, ev *Evaluator) { panic("not implemented") }
-func (m matchVarref) Serialize() SerializableVar      { panic("not implemented") }
-func (m matchVarref) Dump(w io.Writer)                { panic("not implemented") }
+func (m matchVarref) serialize() serializableVar      { panic("not implemented") }
+func (m matchVarref) dump(w io.Writer)                { panic("not implemented") }
 
 type literalRE struct {
 	*regexp.Regexp
@@ -636,8 +636,8 @@
 
 func (r literalRE) String() string                  { return r.Regexp.String() }
 func (r literalRE) Eval(w io.Writer, ev *Evaluator) { panic("not implemented") }
-func (r literalRE) Serialize() SerializableVar      { panic("not implemented") }
-func (r literalRE) Dump(w io.Writer)                { panic("not implemented") }
+func (r literalRE) serialize() serializableVar      { panic("not implemented") }
+func (r literalRE) dump(w io.Writer)                { panic("not implemented") }
 
 func matchValue(expr, pat Value) bool {
 	switch pat := pat.(type) {
diff --git a/func.go b/func.go
index 790b5bc..6266a77 100644
--- a/func.go
+++ b/func.go
@@ -138,18 +138,18 @@
 	return fmt.Sprintf("$%s %s%c", arg0, strings.Join(args, ","), cp)
 }
 
-func (c *fclosure) Serialize() SerializableVar {
-	r := SerializableVar{Type: "func"}
+func (c *fclosure) serialize() serializableVar {
+	r := serializableVar{Type: "func"}
 	for _, a := range c.args {
-		r.Children = append(r.Children, a.Serialize())
+		r.Children = append(r.Children, a.serialize())
 	}
 	return r
 }
 
-func (c *fclosure) Dump(w io.Writer) {
+func (c *fclosure) dump(w io.Writer) {
 	dumpByte(w, valueTypeFunc)
 	for _, a := range c.args {
-		a.Dump(w)
+		a.dump(w)
 	}
 }
 
@@ -965,13 +965,13 @@
 
 func (f *funcNop) String() string             { return f.expr }
 func (f *funcNop) Eval(io.Writer, *Evaluator) {}
-func (f *funcNop) Serialize() SerializableVar {
-	return SerializableVar{
+func (f *funcNop) serialize() serializableVar {
+	return serializableVar{
 		Type: "funcNop",
 		V:    f.expr,
 	}
 }
-func (f *funcNop) Dump(w io.Writer) {
+func (f *funcNop) dump(w io.Writer) {
 	dumpByte(w, valueTypeNop)
 }
 
@@ -1046,22 +1046,22 @@
 	ev.outVars.Assign(f.lhs, rvalue)
 }
 
-func (f *funcEvalAssign) Serialize() SerializableVar {
-	return SerializableVar{
+func (f *funcEvalAssign) serialize() serializableVar {
+	return serializableVar{
 		Type: "funcEvalAssign",
-		Children: []SerializableVar{
-			SerializableVar{V: f.lhs},
-			SerializableVar{V: f.op},
-			f.rhs.Serialize(),
+		Children: []serializableVar{
+			serializableVar{V: f.lhs},
+			serializableVar{V: f.op},
+			f.rhs.serialize(),
 		},
 	}
 }
 
-func (f *funcEvalAssign) Dump(w io.Writer) {
+func (f *funcEvalAssign) dump(w io.Writer) {
 	dumpByte(w, valueTypeAssign)
 	dumpString(w, f.lhs)
 	dumpString(w, f.op)
-	f.rhs.Dump(w)
+	f.rhs.dump(w)
 }
 
 // http://www.gnu.org/software/make/manual/make.html#Origin-Function
diff --git a/serialize.go b/serialize.go
index a53d3e5..55889f6 100644
--- a/serialize.go
+++ b/serialize.go
@@ -77,14 +77,14 @@
 	}
 }
 
-type SerializableVar struct {
+type serializableVar struct {
 	Type     string
 	V        string
 	Origin   string
-	Children []SerializableVar
+	Children []serializableVar
 }
 
-type SerializableDepNode struct {
+type serializableDepNode struct {
 	Output             int
 	Cmds               []string
 	Deps               []int
@@ -98,15 +98,15 @@
 	Lineno             int
 }
 
-type SerializableTargetSpecificVar struct {
+type serializableTargetSpecificVar struct {
 	Name  string
-	Value SerializableVar
+	Value serializableVar
 }
 
-type SerializableGraph struct {
-	Nodes   []*SerializableDepNode
-	Vars    map[string]SerializableVar
-	Tsvs    []SerializableTargetSpecificVar
+type serializableGraph struct {
+	Nodes   []*serializableDepNode
+	Vars    map[string]serializableVar
+	Tsvs    []serializableTargetSpecificVar
 	Targets []string
 	Roots   []string
 	ReadMks []*ReadMakefile
@@ -126,28 +126,28 @@
 func encVar(k string, v Var) string {
 	var buf bytes.Buffer
 	dumpString(&buf, k)
-	v.Dump(&buf)
+	v.dump(&buf)
 	return buf.String()
 }
 
-type DepNodesSerializer struct {
-	nodes     []*SerializableDepNode
-	tsvs      []SerializableTargetSpecificVar
+type depNodesSerializer struct {
+	nodes     []*serializableDepNode
+	tsvs      []serializableTargetSpecificVar
 	tsvMap    map[string]int
 	targets   []string
 	targetMap map[string]int
 	done      map[string]bool
 }
 
-func NewDepNodesSerializer() *DepNodesSerializer {
-	return &DepNodesSerializer{
+func newDepNodesSerializer() *depNodesSerializer {
+	return &depNodesSerializer{
 		tsvMap:    make(map[string]int),
 		targetMap: make(map[string]int),
 		done:      make(map[string]bool),
 	}
 }
 
-func (ns *DepNodesSerializer) SerializeTarget(t string) int {
+func (ns *depNodesSerializer) serializeTarget(t string) int {
 	id, present := ns.targetMap[t]
 	if present {
 		return id
@@ -158,7 +158,7 @@
 	return id
 }
 
-func (ns *DepNodesSerializer) SerializeDepNodes(nodes []*DepNode) {
+func (ns *depNodesSerializer) serializeDepNodes(nodes []*DepNode) {
 	for _, n := range nodes {
 		if ns.done[n.Output] {
 			continue
@@ -167,15 +167,15 @@
 
 		var deps []int
 		for _, d := range n.Deps {
-			deps = append(deps, ns.SerializeTarget(d.Output))
+			deps = append(deps, ns.serializeTarget(d.Output))
 		}
 		var parents []int
 		for _, d := range n.Parents {
-			parents = append(parents, ns.SerializeTarget(d.Output))
+			parents = append(parents, ns.serializeTarget(d.Output))
 		}
 		var actualInputs []int
 		for _, i := range n.ActualInputs {
-			actualInputs = append(actualInputs, ns.SerializeTarget(i))
+			actualInputs = append(actualInputs, ns.serializeTarget(i))
 		}
 
 		// Sort keys for consistent serialization.
@@ -188,7 +188,7 @@
 		var vars []int
 		for _, k := range tsvKeys {
 			v := n.TargetSpecificVars[k]
-			sv := SerializableTargetSpecificVar{Name: k, Value: v.Serialize()}
+			sv := serializableTargetSpecificVar{Name: k, Value: v.serialize()}
 			//gob := encGob(sv)
 			gob := encVar(k, v)
 			id, present := ns.tsvMap[gob]
@@ -200,8 +200,8 @@
 			vars = append(vars, id)
 		}
 
-		ns.nodes = append(ns.nodes, &SerializableDepNode{
-			Output:             ns.SerializeTarget(n.Output),
+		ns.nodes = append(ns.nodes, &serializableDepNode{
+			Output:             ns.serializeTarget(n.Output),
 			Cmds:               n.Cmds,
 			Deps:               deps,
 			Parents:            parents,
@@ -213,23 +213,23 @@
 			Filename:           n.Filename,
 			Lineno:             n.Lineno,
 		})
-		ns.SerializeDepNodes(n.Deps)
+		ns.serializeDepNodes(n.Deps)
 	}
 }
 
-func MakeSerializableVars(vars Vars) (r map[string]SerializableVar) {
-	r = make(map[string]SerializableVar)
+func makeSerializableVars(vars Vars) (r map[string]serializableVar) {
+	r = make(map[string]serializableVar)
 	for k, v := range vars {
-		r[k] = v.Serialize()
+		r[k] = v.serialize()
 	}
 	return r
 }
 
-func MakeSerializableGraph(g *DepGraph, roots []string) SerializableGraph {
-	ns := NewDepNodesSerializer()
-	ns.SerializeDepNodes(g.nodes)
-	v := MakeSerializableVars(g.vars)
-	return SerializableGraph{
+func makeSerializableGraph(g *DepGraph, roots []string) serializableGraph {
+	ns := newDepNodesSerializer()
+	ns.serializeDepNodes(g.nodes)
+	v := makeSerializableVars(g.vars)
+	return serializableGraph{
 		Nodes:   ns.nodes,
 		Vars:    v,
 		Tsvs:    ns.tsvs,
@@ -241,7 +241,7 @@
 }
 
 func DumpDepGraphAsJSON(g *DepGraph, filename string, roots []string) {
-	sg := MakeSerializableGraph(g, roots)
+	sg := makeSerializableGraph(g, roots)
 	o, err := json.MarshalIndent(sg, " ", " ")
 	if err != nil {
 		panic(err)
@@ -264,7 +264,7 @@
 	}
 	e := gob.NewEncoder(f)
 	startTime := time.Now()
-	sg := MakeSerializableGraph(g, roots)
+	sg := makeSerializableGraph(g, roots)
 	LogStats("serialize prepare time: %q", time.Since(startTime))
 	startTime = time.Now()
 	e.Encode(sg)
@@ -275,7 +275,7 @@
 	}
 }
 
-func GetCacheFilename(mk string, roots []string) string {
+func cacheFilename(mk string, roots []string) string {
 	filename := ".kati_cache." + mk
 	for _, r := range roots {
 		filename += "." + r
@@ -287,7 +287,7 @@
 	if len(g.readMks) == 0 {
 		panic("No Makefile is read")
 	}
-	cacheFile := GetCacheFilename(g.readMks[0].Filename, roots)
+	cacheFile := cacheFilename(g.readMks[0].Filename, roots)
 	for _, mk := range g.readMks {
 		// Inconsistent, do not dump this result.
 		if mk.State == FileInconsistent {
@@ -300,14 +300,14 @@
 	DumpDepGraph(g, cacheFile, roots)
 }
 
-func DeserializeSingleChild(sv SerializableVar) Value {
+func deserializeSingleChild(sv serializableVar) Value {
 	if len(sv.Children) != 1 {
 		panic(fmt.Sprintf("unexpected number of children: %q", sv))
 	}
-	return DeserializeVar(sv.Children[0])
+	return deserializeVar(sv.Children[0])
 }
 
-func DeserializeVar(sv SerializableVar) (r Value) {
+func deserializeVar(sv serializableVar) (r Value) {
 	switch sv.Type {
 	case "literal":
 		return literal(sv.V)
@@ -316,11 +316,11 @@
 	case "expr":
 		var e Expr
 		for _, v := range sv.Children {
-			e = append(e, DeserializeVar(v))
+			e = append(e, deserializeVar(v))
 		}
 		return e
 	case "varref":
-		return &varref{varname: DeserializeSingleChild(sv)}
+		return &varref{varname: deserializeSingleChild(sv)}
 	case "paramref":
 		v, err := strconv.Atoi(sv.V)
 		if err != nil {
@@ -329,24 +329,24 @@
 		return paramref(v)
 	case "varsubst":
 		return varsubst{
-			varname: DeserializeVar(sv.Children[0]),
-			pat:     DeserializeVar(sv.Children[1]),
-			subst:   DeserializeVar(sv.Children[2]),
+			varname: deserializeVar(sv.Children[0]),
+			pat:     deserializeVar(sv.Children[1]),
+			subst:   deserializeVar(sv.Children[2]),
 		}
 
 	case "func":
-		name := DeserializeVar(sv.Children[0]).(literal)
+		name := deserializeVar(sv.Children[0]).(literal)
 		f := funcMap[string(name[1:])]()
 		f.AddArg(name)
 		for _, a := range sv.Children[1:] {
-			f.AddArg(DeserializeVar(a))
+			f.AddArg(deserializeVar(a))
 		}
 		return f
 	case "funcEvalAssign":
 		return &funcEvalAssign{
 			lhs: sv.Children[0].V,
 			op:  sv.Children[1].V,
-			rhs: DeserializeVar(sv.Children[2]),
+			rhs: deserializeVar(sv.Children[2]),
 		}
 	case "funcNop":
 		return &funcNop{expr: sv.V}
@@ -358,13 +358,13 @@
 		}
 	case "recursive":
 		return &recursiveVar{
-			expr:   DeserializeSingleChild(sv),
+			expr:   deserializeSingleChild(sv),
 			origin: sv.Origin,
 		}
 
 	case ":=", "=", "+=", "?=":
 		return &targetSpecificVar{
-			v:  DeserializeSingleChild(sv).(Var),
+			v:  deserializeSingleChild(sv).(Var),
 			op: sv.Type,
 		}
 
@@ -373,22 +373,22 @@
 	}
 }
 
-func DeserializeVars(vars map[string]SerializableVar) Vars {
+func deserializeVars(vars map[string]serializableVar) Vars {
 	r := make(Vars)
 	for k, v := range vars {
-		r[k] = DeserializeVar(v).(Var)
+		r[k] = deserializeVar(v).(Var)
 	}
 	return r
 }
 
-func DeserializeNodes(g SerializableGraph) (r []*DepNode) {
+func deserializeNodes(g serializableGraph) (r []*DepNode) {
 	nodes := g.Nodes
 	tsvs := g.Tsvs
 	targets := g.Targets
 	// Deserialize all TSVs first so that multiple rules can share memory.
 	var tsvValues []Var
 	for _, sv := range tsvs {
-		tsvValues = append(tsvValues, DeserializeVar(sv.Value).(Var))
+		tsvValues = append(tsvValues, deserializeVar(sv.Value).(Var))
 	}
 
 	nodeMap := make(map[string]*DepNode)
@@ -453,7 +453,7 @@
 	return fmt.Sprintf("%dB", n)
 }
 
-func showSerializedNodesStats(nodes []*SerializableDepNode) {
+func showSerializedNodesStats(nodes []*serializableDepNode) {
 	outputSize := 0
 	cmdSize := 0
 	depsSize := 0
@@ -489,7 +489,7 @@
 	LogStats(" lineno %s", human(linenoSize))
 }
 
-func (v SerializableVar) size() int {
+func (v serializableVar) size() int {
 	size := 0
 	size += len(v.Type)
 	size += len(v.V)
@@ -500,7 +500,7 @@
 	return size
 }
 
-func showSerializedVarsStats(vars map[string]SerializableVar) {
+func showSerializedVarsStats(vars map[string]serializableVar) {
 	nameSize := 0
 	valueSize := 0
 	for k, v := range vars {
@@ -513,7 +513,7 @@
 	LogStats(" value %s", human(valueSize))
 }
 
-func showSerializedTsvsStats(vars []SerializableTargetSpecificVar) {
+func showSerializedTsvsStats(vars []serializableTargetSpecificVar) {
 	nameSize := 0
 	valueSize := 0
 	for _, v := range vars {
@@ -542,7 +542,7 @@
 	LogStats("%d makefiles %s", len(readMks), human(size))
 }
 
-func showSerializedGraphStats(g SerializableGraph) {
+func showSerializedGraphStats(g serializableGraph) {
 	showSerializedNodesStats(g.Nodes)
 	showSerializedVarsStats(g.Vars)
 	showSerializedTsvsStats(g.Tsvs)
@@ -550,12 +550,12 @@
 	showSerializedReadMksStats(g.ReadMks)
 }
 
-func DeserializeGraph(g SerializableGraph) *DepGraph {
+func deserializeGraph(g serializableGraph) *DepGraph {
 	if LogFlag || StatsFlag {
 		showSerializedGraphStats(g)
 	}
-	nodes := DeserializeNodes(g)
-	vars := DeserializeVars(g.Vars)
+	nodes := deserializeNodes(g)
+	vars := deserializeVars(g.Vars)
 	return &DepGraph{
 		nodes:   nodes,
 		vars:    vars,
@@ -572,12 +572,12 @@
 	defer f.Close()
 
 	d := json.NewDecoder(f)
-	g := SerializableGraph{Vars: make(map[string]SerializableVar)}
+	g := serializableGraph{Vars: make(map[string]serializableVar)}
 	err = d.Decode(&g)
 	if err != nil {
 		panic(err)
 	}
-	return DeserializeGraph(g)
+	return deserializeGraph(g)
 }
 
 func LoadDepGraph(filename string) *DepGraph {
@@ -588,12 +588,12 @@
 	defer f.Close()
 
 	d := gob.NewDecoder(f)
-	g := SerializableGraph{Vars: make(map[string]SerializableVar)}
+	g := serializableGraph{Vars: make(map[string]serializableVar)}
 	err = d.Decode(&g)
 	if err != nil {
 		panic(err)
 	}
-	return DeserializeGraph(g)
+	return deserializeGraph(g)
 }
 
 func LoadDepGraphCache(makefile string, roots []string) *DepGraph {
@@ -602,7 +602,7 @@
 		LogStats("Cache lookup time: %q", time.Since(startTime))
 	}()
 
-	filename := GetCacheFilename(makefile, roots)
+	filename := cacheFilename(makefile, roots)
 	if !exists(filename) {
 		LogAlways("Cache not found")
 		return nil
diff --git a/var.go b/var.go
index 774a38a..f44a224 100644
--- a/var.go
+++ b/var.go
@@ -65,17 +65,17 @@
 	v.v.Eval(w, ev)
 }
 
-func (v *targetSpecificVar) Serialize() SerializableVar {
-	return SerializableVar{
+func (v *targetSpecificVar) serialize() serializableVar {
+	return serializableVar{
 		Type:     v.op,
-		Children: []SerializableVar{v.v.Serialize()},
+		Children: []serializableVar{v.v.serialize()},
 	}
 }
 
-func (v *targetSpecificVar) Dump(w io.Writer) {
+func (v *targetSpecificVar) dump(w io.Writer) {
 	dumpByte(w, valueTypeTSV)
 	dumpString(w, v.op)
-	v.v.Dump(w)
+	v.v.dump(w)
 }
 
 type simpleVar struct {
@@ -91,14 +91,14 @@
 func (v *simpleVar) Eval(w io.Writer, ev *Evaluator) {
 	io.WriteString(w, v.value)
 }
-func (v *simpleVar) Serialize() SerializableVar {
-	return SerializableVar{
+func (v *simpleVar) serialize() serializableVar {
+	return serializableVar{
 		Type:   "simple",
 		V:      v.value,
 		Origin: v.origin,
 	}
 }
-func (v *simpleVar) Dump(w io.Writer) {
+func (v *simpleVar) dump(w io.Writer) {
 	dumpByte(w, valueTypeSimple)
 	dumpString(w, v.value)
 	dumpString(w, v.origin)
@@ -140,10 +140,10 @@
 func (v *automaticVar) Eval(w io.Writer, ev *Evaluator) {
 	w.Write(v.value)
 }
-func (v *automaticVar) Serialize() SerializableVar {
+func (v *automaticVar) serialize() serializableVar {
 	panic(fmt.Sprintf("cannnot serialize automatic var:%s", v.value))
 }
-func (v *automaticVar) Dump(w io.Writer) {
+func (v *automaticVar) dump(w io.Writer) {
 	panic(fmt.Sprintf("cannnot dump automatic var:%s", v.value))
 }
 
@@ -180,16 +180,16 @@
 func (v *recursiveVar) Eval(w io.Writer, ev *Evaluator) {
 	v.expr.Eval(w, ev)
 }
-func (v *recursiveVar) Serialize() SerializableVar {
-	return SerializableVar{
+func (v *recursiveVar) serialize() serializableVar {
+	return serializableVar{
 		Type:     "recursive",
-		Children: []SerializableVar{v.expr.Serialize()},
+		Children: []serializableVar{v.expr.serialize()},
 		Origin:   v.origin,
 	}
 }
-func (v *recursiveVar) Dump(w io.Writer) {
+func (v *recursiveVar) dump(w io.Writer) {
 	dumpByte(w, valueTypeRecursive)
-	v.expr.Dump(w)
+	v.expr.dump(w)
 	dumpString(w, v.origin)
 }
 
@@ -234,10 +234,10 @@
 func (undefinedVar) String() string  { return "" }
 func (undefinedVar) Eval(_ io.Writer, _ *Evaluator) {
 }
-func (undefinedVar) Serialize() SerializableVar {
-	return SerializableVar{Type: "undefined"}
+func (undefinedVar) serialize() serializableVar {
+	return serializableVar{Type: "undefined"}
 }
-func (undefinedVar) Dump(w io.Writer) {
+func (undefinedVar) dump(w io.Writer) {
 	dumpByte(w, valueTypeUndefined)
 }