Address aa's comments

- Return factory methods to privacy
- use tighter syntax inside Chunks() methods
- Rename Futures() -> Chunks()

types/blob.go

@@ -32,7 +32,7 @@ func (fb Blob) Equals(other Value) bool {
 	}
 }
 
-func (fb Blob) Futures() []Future {
+func (fb Blob) Chunks() []Future {
 	return nil
 }
 

types/future_test.go

@@ -11,7 +11,7 @@ import (
 func TestResolvedFuture(t *testing.T) {
 	assert := assert.New(t)
 	v := Int32(42)
-	f := FutureFromValue(v)
+	f := futureFromValue(v)
 	v2, err := f.Deref(nil)
 	assert.NoError(err)
 	assert.True(v.Equals(v2))
@@ -24,7 +24,7 @@ func TestUnresolvedFuture(t *testing.T) {
 	v := NewString("hello")
 	r, _ := WriteValue(v, cs)
 
-	f := FutureFromRef(r)
+	f := futureFromRef(r)
 	v2, err := f.Deref(cs)
 	assert.Equal(1, cs.Reads)
 	assert.NoError(err)
@@ -44,8 +44,8 @@ func TestEqualsFastPath(t *testing.T) {
 	r, err := WriteValue(v, cs)
 	assert.NoError(err)
 
-	fv := FutureFromValue(v)
-	fr := FutureFromRef(r)
+	fv := futureFromValue(v)
+	fr := futureFromRef(r)
 
 	count := 0
 	getRefOverride = func(val Value) ref.Ref {

types/gen/primitive.tmpl

@@ -12,7 +12,7 @@ func (v {{.NomsType}}) Ref() ref.Ref {
 	return getRef(v)
 }
 
-func (v {{.NomsType}}) Futures() []Future {
+func (v {{.NomsType}}) Chunks() []Future {
 	return nil
 }
 

types/json_decode.go

@@ -42,9 +42,9 @@ func jsonDecode(reader io.Reader, s chunks.ChunkSource) (Value, error) {
 func jsonDecodeValue(v interface{}, s chunks.ChunkSource) (Future, error) {
 	switch v := v.(type) {
 	case bool:
-		return FutureFromValue(Bool(v)), nil
+		return futureFromValue(Bool(v)), nil
 	case string:
-		return FutureFromValue(NewString(v)), nil
+		return futureFromValue(NewString(v)), nil
 	case map[string]interface{}:
 		return jsonDecodeTaggedValue(v, s)
 	default:
@@ -61,21 +61,21 @@ func jsonDecodeTaggedValue(m map[string]interface{}, s chunks.ChunkSource) (Futu
 			if v, ok := v.(float64); ok {
 				switch k {
 				case "int16":
-					return FutureFromValue(Int16(int16(v))), nil
+					return futureFromValue(Int16(int16(v))), nil
 				case "int32":
-					return FutureFromValue(Int32(int32(v))), nil
+					return futureFromValue(Int32(int32(v))), nil
 				case "int64":
-					return FutureFromValue(Int64(int64(v))), nil
+					return futureFromValue(Int64(int64(v))), nil
 				case "uint16":
-					return FutureFromValue(UInt16(uint16(v))), nil
+					return futureFromValue(UInt16(uint16(v))), nil
 				case "uint32":
-					return FutureFromValue(UInt32(uint32(v))), nil
+					return futureFromValue(UInt32(uint32(v))), nil
 				case "uint64":
-					return FutureFromValue(UInt64(uint64(v))), nil
+					return futureFromValue(UInt64(uint64(v))), nil
 				case "float32":
-					return FutureFromValue(Float32(float32(v))), nil
+					return futureFromValue(Float32(float32(v))), nil
 				case "float64":
-					return FutureFromValue(Float64(float64(v))), nil
+					return futureFromValue(Float64(float64(v))), nil
 				}
 			}
 		case "list":
@@ -109,7 +109,7 @@ func jsonDecodeList(input []interface{}, s chunks.ChunkSource) (Future, error) {
 		}
 		output = append(output, outVal)
 	}
-	return FutureFromValue(listFromFutures(output, s)), nil
+	return futureFromValue(listFromFutures(output, s)), nil
 }
 
 func jsonDecodeSet(input []interface{}, s chunks.ChunkSource) (Future, error) {
@@ -121,7 +121,7 @@ func jsonDecodeSet(input []interface{}, s chunks.ChunkSource) (Future, error) {
 		}
 		output = append(output, f)
 	}
-	return FutureFromValue(setFromFutures(output, s)), nil
+	return futureFromValue(setFromFutures(output, s)), nil
 }
 
 func jsonDecodeMap(input []interface{}, s chunks.ChunkSource) (Future, error) {
@@ -136,7 +136,7 @@ func jsonDecodeMap(input []interface{}, s chunks.ChunkSource) (Future, error) {
 		output = append(output, f)
 	}
 
-	return FutureFromValue(mapFromFutures(output, s)), nil
+	return futureFromValue(mapFromFutures(output, s)), nil
 }
 
 func jsonDecodeRef(refStr string, s chunks.ChunkSource) (Future, error) {
@@ -144,5 +144,5 @@ func jsonDecodeRef(refStr string, s chunks.ChunkSource) (Future, error) {
 	if err != nil {
 		return nil, err
 	}
-	return FutureFromRef(ref), nil
+	return futureFromRef(ref), nil
 }

types/json_encode_test.go

@@ -92,7 +92,7 @@ func TestGetJSONChildResolvedFuture(t *testing.T) {
 	assert := assert.New(t)
 	cs := &chunks.TestStore{}
 	v := NewString("abc")
-	f := FutureFromValue(v)
+	f := futureFromValue(v)
 	o, err := getChildJSON(f, cs)
 	assert.NoError(err)
 	assert.Equal("abc", o)
@@ -104,7 +104,7 @@ func TestGetJSONChildUnresolvedFuture(t *testing.T) {
 	cs := &chunks.TestStore{}
 	s := "sha1-a9993e364706816aba3e25717850c26c9cd0d89d"
 	r := ref.MustParse(s)
-	f := FutureFromRef(r)
+	f := futureFromRef(r)
 	m, err := getChildJSON(f, cs)
 	assert.NoError(err)
 	assert.Equal(s, m.(map[string]interface{})["ref"].(string))
@@ -116,10 +116,10 @@ func TestFutureCompound(t *testing.T) {
 	cs := &chunks.TestStore{}
 
 	v := NewString("abc")
-	resolved := FutureFromValue(v)
+	resolved := futureFromValue(v)
 	s := "sha1-a9993e364706816aba3e25717850c26c9cd0d89d"
 	r := ref.MustParse(s)
-	unresolved := FutureFromRef(r)
+	unresolved := futureFromRef(r)
 	futures := []Future{resolved, unresolved}
 
 	list := listFromFutures(futures, cs)

types/list.go

@@ -19,7 +19,7 @@ func NewList(v ...Value) List {
 func valuesToFutures(list []Value) []Future {
 	f := []Future{}
 	for _, v := range list {
-		f = append(f, FutureFromValue(v))
+		f = append(f, futureFromValue(v))
 	}
 	return f
 }
@@ -50,7 +50,7 @@ func (l List) Slice(start uint64, end uint64) List {
 func (l List) Set(idx uint64, v Value) List {
 	b := make([]Future, len(l.list))
 	copy(b, l.list)
-	b[idx] = FutureFromValue(v)
+	b[idx] = futureFromValue(v)
 	return listFromFutures(b, l.cs)
 }
 
@@ -89,12 +89,10 @@ func (l List) Equals(other Value) bool {
 	}
 }
 
-func (l List) Futures() (futures []Future) {
+func (l List) Chunks() (futures []Future) {
 	for _, f := range l.list {
-		switch f.(type) {
-		case *unresolvedFuture:
+		if f, ok := f.(*unresolvedFuture); ok {
 			futures = append(futures, f)
-		default:
 		}
 	}
 	return

types/list_test.go

@@ -166,10 +166,10 @@ func TestListFutures(t *testing.T) {
 	cs := &chunks.TestStore{}
 	v := NewString("hello")
 	r, _ := WriteValue(v, cs)
-	f := FutureFromRef(r)
+	f := futureFromRef(r)
 
-	l := listFromFutures([]Future{f, FutureFromValue(Int64(0xbeefcafe))}, cs)
+	l := listFromFutures([]Future{f, futureFromValue(Int64(0xbeefcafe))}, cs)
 
-	assert.Len(l.Futures(), 1)
-	assert.EqualValues(r, l.Futures()[0].Ref())
+	assert.Len(l.Chunks(), 1)
+	assert.EqualValues(r, l.Chunks()[0].Ref())
 }

types/map.go

@@ -96,12 +96,10 @@ func (fm Map) Equals(other Value) (res bool) {
 	}
 }
 
-func (fm Map) Futures() (futures []Future) {
+func (fm Map) Chunks() (futures []Future) {
 	appendIfUnresolved := func(f Future) {
-		switch f.(type) {
-		case *unresolvedFuture:
+		if f, ok := f.(*unresolvedFuture); ok {
 			futures = append(futures, f)
-		default:
 		}
 	}
 	for _, entry := range fm.m {

types/map_test.go

@@ -174,10 +174,10 @@ func TestMapFutures(t *testing.T) {
 	cs := &chunks.TestStore{}
 	k := NewString("hello")
 	kRef, _ := WriteValue(k, cs)
-	f := FutureFromRef(kRef)
+	f := futureFromRef(kRef)
 
-	m := mapFromFutures([]Future{f, FutureFromValue(Int64(0xbeefcafe))}, cs)
+	m := mapFromFutures([]Future{f, futureFromValue(Int64(0xbeefcafe))}, cs)
 
-	assert.Len(m.Futures(), 1)
-	assert.EqualValues(kRef, m.Futures()[0].Ref())
+	assert.Len(m.Chunks(), 1)
+	assert.EqualValues(kRef, m.Chunks()[0].Ref())
 }

types/primitives.go

@@ -21,7 +21,7 @@ func (v Bool) Ref() ref.Ref {
 	return getRef(v)
 }
 
-func (v Bool) Futures() []Future {
+func (v Bool) Chunks() []Future {
 	return nil
 }
 
@@ -43,7 +43,7 @@ func (v Int16) Ref() ref.Ref {
 	return getRef(v)
 }
 
-func (v Int16) Futures() []Future {
+func (v Int16) Chunks() []Future {
 	return nil
 }
 
@@ -65,7 +65,7 @@ func (v Int32) Ref() ref.Ref {
 	return getRef(v)
 }
 
-func (v Int32) Futures() []Future {
+func (v Int32) Chunks() []Future {
 	return nil
 }
 
@@ -87,7 +87,7 @@ func (v Int64) Ref() ref.Ref {
 	return getRef(v)
 }
 
-func (v Int64) Futures() []Future {
+func (v Int64) Chunks() []Future {
 	return nil
 }
 
@@ -109,7 +109,7 @@ func (v UInt16) Ref() ref.Ref {
 	return getRef(v)
 }
 
-func (v UInt16) Futures() []Future {
+func (v UInt16) Chunks() []Future {
 	return nil
 }
 
@@ -131,7 +131,7 @@ func (v UInt32) Ref() ref.Ref {
 	return getRef(v)
 }
 
-func (v UInt32) Futures() []Future {
+func (v UInt32) Chunks() []Future {
 	return nil
 }
 
@@ -153,7 +153,7 @@ func (v UInt64) Ref() ref.Ref {
 	return getRef(v)
 }
 
-func (v UInt64) Futures() []Future {
+func (v UInt64) Chunks() []Future {
 	return nil
 }
 
@@ -175,7 +175,7 @@ func (v Float32) Ref() ref.Ref {
 	return getRef(v)
 }
 
-func (v Float32) Futures() []Future {
+func (v Float32) Chunks() []Future {
 	return nil
 }
 
@@ -197,7 +197,7 @@ func (v Float64) Ref() ref.Ref {
 	return getRef(v)
 }
 
-func (v Float64) Futures() []Future {
+func (v Float64) Chunks() []Future {
 	return nil
 }
 

types/resolved_future.go

@@ -5,7 +5,7 @@ import (
 	"github.com/attic-labs/noms/ref"
 )
 
-func FutureFromValue(v Value) Future {
+func futureFromValue(v Value) Future {
 	return resolvedFuture{v}
 }
 

types/set.go

@@ -110,12 +110,10 @@ func (fs Set) Equals(other Value) bool {
 	}
 }
 
-func (fs Set) Futures() (futures []Future) {
+func (fs Set) Chunks() (futures []Future) {
 	for _, f := range fs.m {
-		switch f.(type) {
-		case *unresolvedFuture:
+		if f, ok := f.(*unresolvedFuture); ok {
 			futures = append(futures, f)
-		default:
 		}
 	}
 	return

types/set_test.go

@@ -131,10 +131,10 @@ func TestSetFutures(t *testing.T) {
 	cs := &chunks.TestStore{}
 	v := NewString("hello")
 	r, _ := WriteValue(v, cs)
-	f := FutureFromRef(r)
+	f := futureFromRef(r)
 
-	s := listFromFutures([]Future{f, FutureFromValue(Int64(0xbeefcafe))}, cs)
+	s := listFromFutures([]Future{f, futureFromValue(Int64(0xbeefcafe))}, cs)
 
-	assert.Len(s.Futures(), 1)
-	assert.EqualValues(r, s.Futures()[0].Ref())
+	assert.Len(s.Chunks(), 1)
+	assert.EqualValues(r, s.Chunks()[0].Ref())
 }

types/string.go

@@ -33,7 +33,7 @@ func (fs String) Equals(other Value) bool {
 	}
 }
 
-func (fs String) Futures() []Future {
+func (fs String) Chunks() []Future {
 	return nil
 }
 

types/unresolved_future.go

@@ -5,7 +5,7 @@ import (
 	"github.com/attic-labs/noms/ref"
 )
 
-func FutureFromRef(ref ref.Ref) Future {
+func futureFromRef(ref ref.Ref) Future {
 	return &unresolvedFuture{ref: ref}
 }
 

types/value.go

@@ -8,5 +8,5 @@ import (
 type Value interface {
 	Equals(other Value) bool
 	Ref() ref.Ref
-	Futures() []Future
+	Chunks() []Future
 }