Make types.String not cache ref (#1836)

Fixes https://github.com/attic-labs/noms/issues/1542

cmd/noms-diff/diff/diff.go

@@ -134,11 +134,11 @@ func diffStructs(dq *diffQueue, w io.Writer, p types.Path, v1, v2 types.Struct)
 		f2 := v2.Get(field)
 		if canCompare(f1, f2) {
 			p1 := p.AddField(field)
-			dq.PushBack(diffInfo{path: p1, key: types.NewString(field), v1: f1, v2: f2})
+			dq.PushBack(diffInfo{path: p1, key: types.String(field), v1: f1, v2: f2})
 		} else {
 			wroteHeader = writeHeader(w, wroteHeader, p)
-			line(w, subPrefix, types.NewString(field), f1)
-			line(w, addPrefix, types.NewString(field), f2)
+			line(w, subPrefix, types.String(field), f1)
+			line(w, addPrefix, types.String(field), f2)
 		}
 	}
 }
@@ -148,7 +148,7 @@ func diffSets(dq *diffQueue, w io.Writer, p types.Path, v1, v2 types.Set) {
 	added, removed := v2.Diff(v1)
 	if len(added) == 1 && len(removed) == 1 && canCompare(added[0], removed[0]) {
 		p1 := p.AddField(added[0].Hash().String())
-		dq.PushBack(diffInfo{path: p1, key: types.NewString(""), v1: removed[0], v2: added[0]})
+		dq.PushBack(diffInfo{path: p1, key: types.String(""), v1: removed[0], v2: added[0]})
 	} else {
 		for _, value := range removed {
 			wroteHeader = writeHeader(w, wroteHeader, p)

cmd/noms-diff/diff/diff_test.go

@@ -27,7 +27,7 @@ func valToTypesValue(v interface{}) types.Value {
 	var v1 types.Value
 	switch t := v.(type) {
 	case string:
-		v1 = types.NewString(t)
+		v1 = types.String(t)
 	case int:
 		v1 = types.Number(t)
 	case types.Value:
@@ -108,7 +108,7 @@ func TestNomsStructDiff(t *testing.T) {
 		"field4", "field4-data",
 	}
 	s1 := createStruct("TestData", fieldData...)
-	s2 := s1.Set("field3", types.NewString("field3-data-diff"))
+	s2 := s1.Set("field3", types.String("field3-data-diff"))
 
 	m1 := createMap("one", 1, "two", 2, "three", s1, "four", "four")
 	m2 := createMap("one", 1, "two", 2, "three", s2, "four", "four-diff")

cmd/noms-ds/noms_ds_test.go

@@ -44,12 +44,12 @@ func (s *testSuite) TestNomsDs() {
 
 	id := "testdataset"
 	set := dataset.NewDataset(ds, id)
-	set, err := set.Commit(types.NewString("Commit Value"))
+	set, err := set.Commit(types.String("Commit Value"))
 	s.NoError(err)
 
 	id2 := "testdataset2"
 	set2 := dataset.NewDataset(ds, id2)
-	set2, err = set2.Commit(types.NewString("Commit Value2"))
+	set2, err = set2.Commit(types.String("Commit Value2"))
 	s.NoError(err)
 
 	err = ds.Close()

cmd/noms-log/noms_log_test.go

@@ -67,7 +67,7 @@ func (s *nomsShowTestSuite) TestNomsLog() {
 }
 
 func addCommit(ds dataset.Dataset, v string) (dataset.Dataset, error) {
-	return ds.Commit(types.NewString(v))
+	return ds.Commit(types.String(v))
 }
 
 func addCommitWithValue(ds dataset.Dataset, v types.Value) (dataset.Dataset, error) {
@@ -75,11 +75,11 @@ func addCommitWithValue(ds dataset.Dataset, v types.Value) (dataset.Dataset, err
 }
 
 func addBranchedDataset(newDs, parentDs dataset.Dataset, v string) (dataset.Dataset, error) {
-	return newDs.CommitWithParents(types.NewString(v), types.NewSet().Insert(parentDs.HeadRef()))
+	return newDs.CommitWithParents(types.String(v), types.NewSet().Insert(parentDs.HeadRef()))
 }
 
 func mergeDatasets(ds1, ds2 dataset.Dataset, v string) (dataset.Dataset, error) {
-	return ds1.CommitWithParents(types.NewString(v), types.NewSet(ds1.HeadRef(), ds2.HeadRef()))
+	return ds1.CommitWithParents(types.String(v), types.NewSet(ds1.HeadRef(), ds2.HeadRef()))
 }
 
 func (s *nomsShowTestSuite) TestNArg() {
@@ -247,7 +247,7 @@ func (s *nomsShowTestSuite) TestTruncation() {
 	toNomsList := func(l []string) types.List {
 		nv := []types.Value{}
 		for _, v := range l {
-			nv = append(nv, types.NewString(v))
+			nv = append(nv, types.String(v))
 		}
 		return types.NewList(nv...)
 	}

cmd/noms-show/noms_show_test.go

@@ -49,7 +49,7 @@ func (s *nomsShowTestSuite) TestNomsShow() {
 	ds, err := sp.Dataset()
 	d.Chk.NoError(err)
 
-	s1 := types.NewString("test string")
+	s1 := types.String("test string")
 	r := writeTestData(ds, s1)
 	s.Equal(res1, s.Run(main, []string{str}))
 
@@ -57,7 +57,7 @@ func (s *nomsShowTestSuite) TestNomsShow() {
 	s.Equal(res2, s.Run(main, []string{spec1}))
 
 	ds, err = sp.Dataset()
-	list := types.NewList(types.NewString("elem1"), types.Number(2), types.NewString("elem3"))
+	list := types.NewList(types.String("elem1"), types.Number(2), types.String("elem3"))
 	r = writeTestData(ds, list)
 	s.Equal(res3, s.Run(main, []string{str}))
 

go/datas/commit.go

@@ -33,7 +33,7 @@ func init() {
 
 func NewCommit() types.Struct {
 	initialFields := map[string]types.Value{
-		ValueField:   types.NewString(""),
+		ValueField:   types.String(""),
 		ParentsField: types.NewSet(),
 	}
 

go/datas/database_common.go

@@ -38,7 +38,7 @@ func (ds *databaseCommon) MaybeHead(datasetID string) (types.Struct, bool) {
 }
 
 func (ds *databaseCommon) MaybeHeadRef(datasetID string) (types.Ref, bool) {
-	if r, ok := ds.Datasets().MaybeGet(types.NewString(datasetID)); ok {
+	if r, ok := ds.Datasets().MaybeGet(types.String(datasetID)); ok {
 		return r.(types.Ref), true
 	}
 	return types.Ref{}, false
@@ -103,7 +103,7 @@ func (ds *databaseCommon) doCommit(datasetID string, commit types.Struct) error
 
 	// First commit in store is always fast-foward.
 	if !currentRootRef.IsEmpty() {
-		r, hasHead := currentDatasets.MaybeGet(types.NewString(datasetID))
+		r, hasHead := currentDatasets.MaybeGet(types.String(datasetID))
 
 		// First commit in dataset is always fast-foward.
 		if hasHead {
@@ -117,14 +117,14 @@ func (ds *databaseCommon) doCommit(datasetID string, commit types.Struct) error
 			}
 		}
 	}
-	currentDatasets = currentDatasets.Set(types.NewString(datasetID), commitRef)
+	currentDatasets = currentDatasets.Set(types.String(datasetID), commitRef)
 	return ds.tryUpdateRoot(currentDatasets, currentRootRef)
 }
 
 // doDelete manages concurrent access the single logical piece of mutable state: the current Root. doDelete is optimistic in that it is attempting to update head making the assumption that currentRootRef is the hash of the current head. The call to UpdateRoot below will return an 'ErrOptimisticLockFailed' error if that assumption fails (e.g. because of a race with another writer) and the entire algorithm must be tried again.
 func (ds *databaseCommon) doDelete(datasetID string) error {
 	currentRootRef, currentDatasets := ds.getRootAndDatasets()
-	currentDatasets = currentDatasets.Remove(types.NewString(datasetID))
+	currentDatasets = currentDatasets.Remove(types.String(datasetID))
 	return ds.tryUpdateRoot(currentDatasets, currentRootRef)
 }
 

go/datas/database_test.go

@@ -101,7 +101,7 @@ func (suite *DatabaseSuite) TestDatabaseCommit() {
 	suite.Zero(datasets.Len())
 
 	// |a|
-	a := types.NewString("a")
+	a := types.String("a")
 	aCommit := NewCommit().Set(ValueField, a)
 	ds2, err := suite.ds.Commit(datasetID, aCommit)
 	suite.NoError(err)
@@ -121,7 +121,7 @@ func (suite *DatabaseSuite) TestDatabaseCommit() {
 	suite.ds = ds2
 
 	// |a| <- |b|
-	b := types.NewString("b")
+	b := types.String("b")
 	bCommit := NewCommit().Set(ValueField, b).Set(ParentsField, types.NewSet(types.NewRef(aCommit)))
 	suite.ds, err = suite.ds.Commit(datasetID, bCommit)
 	suite.NoError(err)
@@ -131,14 +131,14 @@ func (suite *DatabaseSuite) TestDatabaseCommit() {
 	// |a| <- |b|
 	//   \----|c|
 	// Should be disallowed.
-	c := types.NewString("c")
+	c := types.String("c")
 	cCommit := NewCommit().Set(ValueField, c).Set(ParentsField, types.NewSet(types.NewRef(aCommit)))
 	suite.ds, err = suite.ds.Commit(datasetID, cCommit)
 	suite.Error(err)
 	suite.True(suite.ds.Head(datasetID).Get(ValueField).Equals(b))
 
 	// |a| <- |b| <- |d|
-	d := types.NewString("d")
+	d := types.String("d")
 	dCommit := NewCommit().Set(ValueField, d).Set(ParentsField, types.NewSet(types.NewRef(bCommit)))
 	suite.ds, err = suite.ds.Commit(datasetID, dCommit)
 	suite.NoError(err)
@@ -169,13 +169,13 @@ func (suite *DatabaseSuite) TestDatabaseDelete() {
 
 	// |a|
 	var err error
-	a := types.NewString("a")
+	a := types.String("a")
 	suite.ds, err = suite.ds.Commit(datasetID1, NewCommit().Set(ValueField, a))
 	suite.NoError(err)
 	suite.True(suite.ds.Head(datasetID1).Get(ValueField).Equals(a))
 
 	// ds1; |a|, ds2: |b|
-	b := types.NewString("b")
+	b := types.String("b")
 	suite.ds, err = suite.ds.Commit(datasetID2, NewCommit().Set(ValueField, b))
 	suite.NoError(err)
 	suite.True(suite.ds.Head(datasetID2).Get(ValueField).Equals(b))
@@ -201,13 +201,13 @@ func (suite *DatabaseSuite) TestDatabaseDeleteConcurrent() {
 	var err error
 
 	// |a|
-	a := types.NewString("a")
+	a := types.String("a")
 	aCommit := NewCommit().Set(ValueField, a)
 	suite.ds, err = suite.ds.Commit(datasetID, aCommit)
 	suite.NoError(err)
 
 	// |a| <- |b|
-	b := types.NewString("b")
+	b := types.String("b")
 	bCommit := NewCommit().Set(ValueField, b).Set(ParentsField, types.NewSet(types.NewRef(aCommit)))
 	ds2, err := suite.ds.Commit(datasetID, bCommit)
 	suite.NoError(err)
@@ -233,10 +233,10 @@ func (suite *DatabaseSuite) TestDatabaseConcurrency() {
 
 	// Setup:
 	// |a| <- |b|
-	a := types.NewString("a")
+	a := types.String("a")
 	aCommit := NewCommit().Set(ValueField, a)
 	suite.ds, err = suite.ds.Commit(datasetID, aCommit)
-	b := types.NewString("b")
+	b := types.String("b")
 	bCommit := NewCommit().Set(ValueField, b).Set(ParentsField, types.NewSet(types.NewRef(aCommit)))
 	suite.ds, err = suite.ds.Commit(datasetID, bCommit)
 	suite.NoError(err)
@@ -247,7 +247,7 @@ func (suite *DatabaseSuite) TestDatabaseConcurrency() {
 
 	// Change 1:
 	// |a| <- |b| <- |c|
-	c := types.NewString("c")
+	c := types.String("c")
 	cCommit := NewCommit().Set(ValueField, c).Set(ParentsField, types.NewSet(types.NewRef(bCommit)))
 	suite.ds, err = suite.ds.Commit(datasetID, cCommit)
 	suite.NoError(err)
@@ -256,7 +256,7 @@ func (suite *DatabaseSuite) TestDatabaseConcurrency() {
 	// Change 2:
 	// |a| <- |b| <- |e|
 	// Should be disallowed, Database returned by Commit() should have |c| as Head.
-	e := types.NewString("e")
+	e := types.String("e")
 	eCommit := NewCommit().Set(ValueField, e).Set(ParentsField, types.NewSet(types.NewRef(bCommit)))
 	ds2, err = ds2.Commit(datasetID, eCommit)
 	suite.Error(err)
@@ -264,7 +264,7 @@ func (suite *DatabaseSuite) TestDatabaseConcurrency() {
 }
 
 func (suite *DatabaseSuite) TestDatabaseHeightOfRefs() {
-	r1 := suite.ds.WriteValue(types.NewString("hello"))
+	r1 := suite.ds.WriteValue(types.String("hello"))
 	suite.Equal(uint64(1), r1.Height())
 
 	r2 := suite.ds.WriteValue(r1)
@@ -277,8 +277,8 @@ func (suite *DatabaseSuite) TestDatabaseHeightOfCollections() {
 	setOfRefOfStringType := types.MakeSetType(types.MakeRefType(types.StringType))
 
 	// Set<String>
-	v1 := types.NewString("hello")
-	v2 := types.NewString("world")
+	v1 := types.String("hello")
+	v2 := types.String("world")
 	s1 := types.NewSet(v1, v2)
 	suite.Equal(uint64(1), suite.ds.WriteValue(s1).Height())
 
@@ -287,8 +287,8 @@ func (suite *DatabaseSuite) TestDatabaseHeightOfCollections() {
 	suite.Equal(uint64(2), suite.ds.WriteValue(s2).Height())
 
 	// List<Set<String>>
-	v3 := types.NewString("foo")
-	v4 := types.NewString("bar")
+	v3 := types.String("foo")
+	v4 := types.String("bar")
 	s3 := types.NewSet(v3, v4)
 	l1 := types.NewList(s1, s3)
 	suite.Equal(uint64(1), suite.ds.WriteValue(l1).Height())

go/datas/http_batch_store_test.go

@@ -113,7 +113,7 @@ func (suite *HTTPBatchStoreSuite) TearDownTest() {
 }
 
 func (suite *HTTPBatchStoreSuite) TestPutChunk() {
-	c := types.EncodeValue(types.NewString("abc"), nil)
+	c := types.EncodeValue(types.String("abc"), nil)
 	suite.store.SchedulePut(c, 1, types.Hints{})
 	suite.store.Flush()
 
@@ -122,8 +122,8 @@ func (suite *HTTPBatchStoreSuite) TestPutChunk() {
 
 func (suite *HTTPBatchStoreSuite) TestPutChunksInOrder() {
 	vals := []types.Value{
-		types.NewString("abc"),
-		types.NewString("def"),
+		types.String("abc"),
+		types.String("def"),
 	}
 	l := types.NewList()
 	for _, val := range vals {
@@ -138,8 +138,8 @@ func (suite *HTTPBatchStoreSuite) TestPutChunksInOrder() {
 
 func (suite *HTTPBatchStoreSuite) TestPutChunkWithHints() {
 	vals := []types.Value{
-		types.NewString("abc"),
-		types.NewString("def"),
+		types.String("abc"),
+		types.String("def"),
 	}
 	chnx := []chunks.Chunk{
 		types.EncodeValue(vals[0], nil),
@@ -189,8 +189,8 @@ func (suite *HTTPBatchStoreSuite) TestPutChunksBackpressure() {
 	defer bpcs.Close()
 
 	vals := []types.Value{
-		types.NewString("abc"),
-		types.NewString("def"),
+		types.String("abc"),
+		types.String("def"),
 	}
 	l := types.NewList()
 	for _, v := range vals {

go/datas/pull_test.go

@@ -189,7 +189,7 @@ func (suite *PullSuite) TestPullDivergentHistory() {
 	srcL := buildListOfHeight(3, suite.source)
 	sourceRef := suite.commitToSource(srcL, types.NewSet())
 
-	sinkL = sinkL.Append(types.NewString("oy!"))
+	sinkL = sinkL.Append(types.String("oy!"))
 	sinkRef = suite.commitToSink(sinkL, types.NewSet(sinkRef))
 	srcL = srcL.Set(1, buildListOfHeight(5, suite.source))
 	sourceRef = suite.commitToSource(srcL, types.NewSet(sourceRef))
@@ -231,7 +231,7 @@ func (suite *PullSuite) TestPullUpdates() {
 	sourceRef := suite.commitToSource(srcL, types.NewSet())
 	L3 := srcL.Get(1).(types.Ref).TargetValue(suite.source).(types.List)
 	L2 := L3.Get(1).(types.Ref).TargetValue(suite.source).(types.List)
-	L2 = L2.Append(suite.source.WriteValue(types.NewString("oy!")))
+	L2 = L2.Append(suite.source.WriteValue(types.String("oy!")))
 	L3 = L3.Set(1, suite.source.WriteValue(L2))
 	srcL = srcL.Set(1, suite.source.WriteValue(L3))
 	sourceRef = suite.commitToSource(srcL, types.NewSet(sourceRef))

go/datas/put_cache_test.go

@@ -31,11 +31,11 @@ type LevelDBPutCacheSuite struct {
 func (suite *LevelDBPutCacheSuite) SetupTest() {
 	suite.cache = newOrderedChunkCache()
 	suite.values = []types.Value{
-		types.NewString("abc"),
-		types.NewString("def"),
-		types.NewString("ghi"),
-		types.NewString("jkl"),
-		types.NewString("mno"),
+		types.String("abc"),
+		types.String("def"),
+		types.String("ghi"),
+		types.String("jkl"),
+		types.String("mno"),
 	}
 	suite.chnx = map[hash.Hash]chunks.Chunk{}
 	for _, v := range suite.values {

go/dataset/dataset_test.go

@@ -20,12 +20,12 @@ func TestDatasetCommitTracker(t *testing.T) {
 	cs := chunks.NewMemoryStore()
 
 	ds1 := NewDataset(datas.NewDatabase(cs), id1)
-	ds1Commit := types.NewString("Commit value for " + id1)
+	ds1Commit := types.String("Commit value for " + id1)
 	ds1, err := ds1.Commit(ds1Commit)
 	assert.NoError(err)
 
 	ds2 := NewDataset(datas.NewDatabase(cs), id2)
-	ds2Commit := types.NewString("Commit value for " + id2)
+	ds2Commit := types.String("Commit value for " + id2)
 	ds2, err = ds2.Commit(ds2Commit)
 	assert.NoError(err)
 
@@ -51,7 +51,7 @@ func TestExplicitBranchUsingDatasets(t *testing.T) {
 	ds1 := newDS(id1, cs)
 
 	// ds1: |a|
-	a := types.NewString("a")
+	a := types.String("a")
 	ds1, err := ds1.Commit(a)
 	assert.NoError(err)
 	assert.True(ds1.Head().Get(datas.ValueField).Equals(a))
@@ -64,14 +64,14 @@ func TestExplicitBranchUsingDatasets(t *testing.T) {
 	assert.True(ds2.Head().Get(datas.ValueField).Equals(a))
 
 	// ds1: |a| <- |b|
-	b := types.NewString("b")
+	b := types.String("b")
 	ds1, err = ds1.Commit(b)
 	assert.NoError(err)
 	assert.True(ds1.Head().Get(datas.ValueField).Equals(b))
 
 	// ds1: |a|    <- |b|
 	//        \ds2 <- |c|
-	c := types.NewString("c")
+	c := types.String("c")
 	ds2, err = ds2.Commit(c)
 	assert.NoError(err)
 	assert.True(ds2.Head().Get(datas.ValueField).Equals(c))
@@ -79,7 +79,7 @@ func TestExplicitBranchUsingDatasets(t *testing.T) {
 	// ds1: |a|    <- |b| <--|d|
 	//        \ds2 <- |c| <--/
 	mergeParents := types.NewSet(types.NewRef(ds1.Head()), types.NewRef(ds2.Head()))
-	d := types.NewString("d")
+	d := types.String("d")
 	ds2, err = ds2.CommitWithParents(d, mergeParents)
 	assert.NoError(err)
 	assert.True(ds2.Head().Get(datas.ValueField).Equals(d))
@@ -98,7 +98,7 @@ func TestTwoClientsWithEmptyDataset(t *testing.T) {
 	dsy := newDS(id1, cs)
 
 	// dsx: || -> |a|
-	a := types.NewString("a")
+	a := types.String("a")
 	dsx, err := dsx.Commit(a)
 	assert.NoError(err)
 	assert.True(dsx.Head().Get(datas.ValueField).Equals(a))
@@ -106,7 +106,7 @@ func TestTwoClientsWithEmptyDataset(t *testing.T) {
 	// dsy: || -> |b|
 	_, ok := dsy.MaybeHead()
 	assert.False(ok)
-	b := types.NewString("b")
+	b := types.String("b")
 	dsy, err = dsy.Commit(b)
 	assert.Error(err)
 	// Commit failed, but ds1 now has latest head, so we should be able to just try again.
@@ -121,7 +121,7 @@ func TestTwoClientsWithNonEmptyDataset(t *testing.T) {
 	id1 := "testdataset"
 	cs := chunks.NewMemoryStore()
 
-	a := types.NewString("a")
+	a := types.String("a")
 	{
 		// ds1: || -> |a|
 		ds1 := newDS(id1, cs)
@@ -135,14 +135,14 @@ func TestTwoClientsWithNonEmptyDataset(t *testing.T) {
 
 	// dsx: |a| -> |b|
 	assert.True(dsx.Head().Get(datas.ValueField).Equals(a))
-	b := types.NewString("b")
+	b := types.String("b")
 	dsx, err := dsx.Commit(b)
 	assert.NoError(err)
 	assert.True(dsx.Head().Get(datas.ValueField).Equals(b))
 
 	// dsy: |a| -> |c|
 	assert.True(dsy.Head().Get(datas.ValueField).Equals(a))
-	c := types.NewString("c")
+	c := types.String("c")
 	dsy, err = dsy.Commit(c)
 	assert.Error(err)
 	assert.True(dsy.Head().Get(datas.ValueField).Equals(b))
@@ -175,7 +175,7 @@ func TestHeadValueFunctions(t *testing.T) {
 	ds1 := newDS(id1, cs)
 
 	// ds1: |a|
-	a := types.NewString("a")
+	a := types.String("a")
 	ds1, err := ds1.Commit(a)
 	assert.NoError(err)
 

go/dataset/pull_test.go

@@ -49,11 +49,11 @@ func TestPullTopDown(t *testing.T) {
 
 	// Give sink and source some initial shared context.
 	sourceInitialValue := types.NewMap(
-		types.NewString("first"), NewList(source),
-		types.NewString("second"), NewList(source, types.Number(2)))
+		types.String("first"), NewList(source),
+		types.String("second"), NewList(source, types.Number(2)))
 	sinkInitialValue := types.NewMap(
-		types.NewString("first"), NewList(sink),
-		types.NewString("second"), NewList(sink, types.Number(2)))
+		types.String("first"), NewList(sink),
+		types.String("second"), NewList(sink, types.Number(2)))
 
 	var err error
 	source, err = source.Commit(sourceInitialValue)
@@ -63,13 +63,13 @@ func TestPullTopDown(t *testing.T) {
 
 	// Add some new stuff to source.
 	updatedValue := sourceInitialValue.Set(
-		types.NewString("third"), NewList(source, types.Number(3)))
+		types.String("third"), NewList(source, types.Number(3)))
 	source, err = source.Commit(updatedValue)
 	assert.NoError(err)
 
 	// Add some more stuff, so that source isn't directly ahead of sink.
 	updatedValue = updatedValue.Set(
-		types.NewString("fourth"), NewList(source, types.Number(4)))
+		types.String("fourth"), NewList(source, types.Number(4)))
 	source, err = source.Commit(updatedValue)
 	assert.NoError(err)
 
@@ -85,8 +85,8 @@ func TestPullFirstCommitTopDown(t *testing.T) {
 	source := createTestDataset("source")
 
 	sourceInitialValue := types.NewMap(
-		types.NewString("first"), NewList(source),
-		types.NewString("second"), NewList(source, types.Number(2)))
+		types.String("first"), NewList(source),
+		types.String("second"), NewList(source, types.Number(2)))
 
 	NewList(sink)
 	NewList(sink, types.Number(2))

go/spec/dataspec_test.go

@@ -31,7 +31,7 @@ func TestLDBDatabase(t *testing.T) {
 	cs := chunks.NewLevelDBStoreUseFlags(ldbDir, "")
 	ds := datas.NewDatabase(cs)
 
-	s1 := types.NewString("A String")
+	s1 := types.String("A String")
 	s1Ref := ds.WriteValue(s1)
 	ds.Commit("testDs", datas.NewCommit().Set(datas.ValueField, s1Ref))
 	ds.Close()
@@ -40,7 +40,7 @@ func TestLDBDatabase(t *testing.T) {
 	assert.NoError(errRead)
 	store, err := sp.Database()
 	assert.NoError(err)
-	assert.Equal(s1.String(), store.ReadValue(s1.Hash()).(types.String).String())
+	assert.Equal(s1, store.ReadValue(s1.Hash()))
 	store.Close()
 	os.Remove(dir)
 }
@@ -67,7 +67,7 @@ func TestMemDataset(t *testing.T) {
 	assert.NoError(err)
 	dataset1, err := sp1.Dataset()
 	assert.NoError(err)
-	commit := types.NewString("Commit Value")
+	commit := types.String("Commit Value")
 	dsTest, err := dataset1.Commit(commit)
 	assert.NoError(err)
 	assert.EqualValues(commit, dsTest.HeadValue())
@@ -84,7 +84,7 @@ func TestLDBDataset(t *testing.T) {
 	id := "dsName"
 
 	set := dataset.NewDataset(ds, id)
-	commit := types.NewString("Commit Value")
+	commit := types.String("Commit Value")
 	set, err = set.Commit(commit)
 	assert.NoError(err)
 	ds.Close()
@@ -109,7 +109,7 @@ func TestLDBObject(t *testing.T) {
 	cs1 := chunks.NewLevelDBStoreUseFlags(ldbpath, "")
 	store1 := datas.NewDatabase(cs1)
 	dataset1 := dataset.NewDataset(store1, dsId)
-	s1 := types.NewString("Commit Value")
+	s1 := types.String("Commit Value")
 	r1 := store1.WriteValue(s1)
 	_, err = dataset1.Commit(r1)
 	assert.NoError(err)
@@ -123,13 +123,13 @@ func TestLDBObject(t *testing.T) {
 	assert.NoError(err)
 	r2 := dataset2.HeadValue()
 	s2 := r2.(types.Ref).TargetValue(dataset2.Database())
-	assert.Equal(s1.String(), s2.(types.String).String())
+	assert.Equal(s1, s2)
 	dataset2.Database().Close()
 
 	spec3 := fmt.Sprintf("ldb:%s::%s", ldbpath, s1.Hash().String())
 	sp3, err := ParsePathSpec(spec3)
 	database, v3, err := sp3.Value()
-	assert.Equal(s1.String(), v3.(types.String).String())
+	assert.Equal(s1, v3)
 	database.Close()
 }
 
@@ -144,7 +144,7 @@ func TestReadRef(t *testing.T) {
 	cs1 := chunks.NewLevelDBStoreUseFlags(ldbPath, "")
 	database1 := datas.NewDatabase(cs1)
 	dataset1 := dataset.NewDataset(database1, datasetId)
-	commit := types.NewString("Commit Value")
+	commit := types.String("Commit Value")
 	dataset1, err = dataset1.Commit(commit)
 	assert.NoError(err)
 	r1 := dataset1.Head().Hash()

go/types/assert_type_test.go

@@ -41,10 +41,10 @@ func TestAssertTypePrimitives(t *testing.T) {
 	assertSubtype(BoolType, Bool(true))
 	assertSubtype(BoolType, Bool(false))
 	assertSubtype(NumberType, Number(42))
-	assertSubtype(StringType, NewString("abc"))
+	assertSubtype(StringType, String("abc"))
 
 	assertInvalid(t, BoolType, Number(1))
-	assertInvalid(t, BoolType, NewString("abc"))
+	assertInvalid(t, BoolType, String("abc"))
 	assertInvalid(t, NumberType, Bool(true))
 	assertInvalid(t, StringType, Number(42))
 }
@@ -52,7 +52,7 @@ func TestAssertTypePrimitives(t *testing.T) {
 func TestAssertTypeValue(t *testing.T) {
 	assertSubtype(ValueType, Bool(true))
 	assertSubtype(ValueType, Number(1))
-	assertSubtype(ValueType, NewString("abc"))
+	assertSubtype(ValueType, String("abc"))
 	l := NewList(Number(0), Number(1), Number(2), Number(3))
 	assertSubtype(ValueType, l)
 }
@@ -72,7 +72,7 @@ func TestAssertTypeList(tt *testing.T) {
 
 func TestAssertTypeMap(tt *testing.T) {
 	mapOfNumberToStringType := MakeMapType(NumberType, StringType)
-	m := NewMap(Number(0), NewString("a"), Number(2), NewString("b"))
+	m := NewMap(Number(0), String("a"), Number(2), String("b"))
 	assertSubtype(mapOfNumberToStringType, m)
 	assertAll(tt, mapOfNumberToStringType, m)
 	assertSubtype(MakeMapType(ValueType, ValueType), m)
@@ -107,17 +107,17 @@ func TestAssertTypeStruct(tt *testing.T) {
 func TestAssertTypeUnion(tt *testing.T) {
 	assertSubtype(MakeUnionType(NumberType), Number(42))
 	assertSubtype(MakeUnionType(NumberType, StringType), Number(42))
-	assertSubtype(MakeUnionType(NumberType, StringType), NewString("hi"))
+	assertSubtype(MakeUnionType(NumberType, StringType), String("hi"))
 	assertSubtype(MakeUnionType(NumberType, StringType, BoolType), Number(555))
-	assertSubtype(MakeUnionType(NumberType, StringType, BoolType), NewString("hi"))
+	assertSubtype(MakeUnionType(NumberType, StringType, BoolType), String("hi"))
 	assertSubtype(MakeUnionType(NumberType, StringType, BoolType), Bool(true))
 
 	lt := MakeListType(MakeUnionType(NumberType, StringType))
-	assertSubtype(lt, NewList(Number(1), NewString("hi"), Number(2), NewString("bye")))
+	assertSubtype(lt, NewList(Number(1), String("hi"), Number(2), String("bye")))
 
 	st := MakeSetType(StringType)
 	assertSubtype(MakeUnionType(st, NumberType), Number(42))
-	assertSubtype(MakeUnionType(st, NumberType), NewSet(NewString("a"), NewString("b")))
+	assertSubtype(MakeUnionType(st, NumberType), NewSet(String("a"), String("b")))
 
 	assertInvalid(tt, MakeUnionType(), Number(42))
 	assertInvalid(tt, MakeUnionType(StringType), Number(42))
@@ -177,7 +177,7 @@ func TestAssertTypeStructSubtypeExtraFields(tt *testing.T) {
 	ct := MakeStructType("", TypeMap{"x": NumberType, "s": StringType})
 	av := NewStruct("", structData{})
 	bv := NewStruct("", structData{"x": Number(1)})
-	cv := NewStruct("", structData{"x": Number(2), "s": NewString("hi")})
+	cv := NewStruct("", structData{"x": Number(2), "s": String("hi")})
 
 	assertSubtype(at, av)
 	assertInvalid(tt, bt, av)

go/types/compare_test.go

@@ -17,7 +17,7 @@ func TestTotalOrdering(t *testing.T) {
 	values := []Value{
 		Bool(false), Bool(true),
 		Number(-10), Number(0), Number(10),
-		NewString("a"), NewString("b"), NewString("c"),
+		String("a"), String("b"), String("c"),
 
 		// The order of these are done by the hash.
 		BoolType,

go/types/encode_human_readable.go

@@ -62,7 +62,7 @@ func (w *hrsWriter) Write(v Value) {
 		w.write(strconv.FormatFloat(float64(v.(Number)), 'g', -1, 64))
 
 	case StringKind:
-		w.write(strconv.Quote(v.(String).String()))
+		w.write(strconv.Quote(string(v.(String))))
 
 	case BlobKind:
 		w.maybeWriteIndentation()

go/types/encode_human_readable_test.go

@@ -41,20 +41,20 @@ func TestWriteHumanReadablePrimitiveValues(t *testing.T) {
 	assertWriteHRSEqual(t, "314159.26535", Number(3.1415926535e5))
 	assertWriteHRSEqual(t, "3.1415926535e+20", Number(3.1415926535e20))
 
-	assertWriteHRSEqual(t, `"abc"`, NewString("abc"))
-	assertWriteHRSEqual(t, `" "`, NewString(" "))
-	assertWriteHRSEqual(t, `"\t"`, NewString("\t"))
-	assertWriteHRSEqual(t, `"\t"`, NewString("	"))
-	assertWriteHRSEqual(t, `"\n"`, NewString("\n"))
-	assertWriteHRSEqual(t, `"\n"`, NewString(`
+	assertWriteHRSEqual(t, `"abc"`, String("abc"))
+	assertWriteHRSEqual(t, `" "`, String(" "))
+	assertWriteHRSEqual(t, `"\t"`, String("\t"))
+	assertWriteHRSEqual(t, `"\t"`, String("	"))
+	assertWriteHRSEqual(t, `"\n"`, String("\n"))
+	assertWriteHRSEqual(t, `"\n"`, String(`
 `))
-	assertWriteHRSEqual(t, `"\r"`, NewString("\r"))
-	assertWriteHRSEqual(t, `"\r\n"`, NewString("\r\n"))
-	assertWriteHRSEqual(t, `"\xff"`, NewString("\xff"))
-	assertWriteHRSEqual(t, `"💩"`, NewString("\xf0\x9f\x92\xa9"))
-	assertWriteHRSEqual(t, `"💩"`, NewString("💩"))
-	assertWriteHRSEqual(t, `"\a"`, NewString("\007"))
-	assertWriteHRSEqual(t, `"☺"`, NewString("\u263a"))
+	assertWriteHRSEqual(t, `"\r"`, String("\r"))
+	assertWriteHRSEqual(t, `"\r\n"`, String("\r\n"))
+	assertWriteHRSEqual(t, `"\xff"`, String("\xff"))
+	assertWriteHRSEqual(t, `"💩"`, String("\xf0\x9f\x92\xa9"))
+	assertWriteHRSEqual(t, `"💩"`, String("💩"))
+	assertWriteHRSEqual(t, `"\a"`, String("\007"))
+	assertWriteHRSEqual(t, `"☺"`, String("\u263a"))
 }
 
 func TestWriteHumanReadableRef(t *testing.T) {
@@ -84,8 +84,8 @@ func TestWriteHumanReadableNested(t *testing.T) {
 	l := NewList(Number(0), Number(1))
 	l2 := NewList(Number(2), Number(3))
 
-	s := NewSet(NewString("a"), NewString("b"))
-	s2 := NewSet(NewString("c"), NewString("d"))
+	s := NewSet(String("a"), String("b"))
+	s2 := NewSet(String("c"), String("d"))
 
 	m := NewMap(s, l, s2, l2)
 	assertWriteHRSEqual(t, `{
@@ -232,20 +232,20 @@ func TestWriteHumanReadableTaggedPrimitiveValues(t *testing.T) {
 
 	assertWriteTaggedHRSEqual(t, "3.1415926535e+20", Number(3.1415926535e20))
 
-	assertWriteTaggedHRSEqual(t, `"abc"`, NewString("abc"))
-	assertWriteTaggedHRSEqual(t, `" "`, NewString(" "))
-	assertWriteTaggedHRSEqual(t, `"\t"`, NewString("\t"))
-	assertWriteTaggedHRSEqual(t, `"\t"`, NewString("	"))
-	assertWriteTaggedHRSEqual(t, `"\n"`, NewString("\n"))
-	assertWriteTaggedHRSEqual(t, `"\n"`, NewString(`
+	assertWriteTaggedHRSEqual(t, `"abc"`, String("abc"))
+	assertWriteTaggedHRSEqual(t, `" "`, String(" "))
+	assertWriteTaggedHRSEqual(t, `"\t"`, String("\t"))
+	assertWriteTaggedHRSEqual(t, `"\t"`, String("	"))
+	assertWriteTaggedHRSEqual(t, `"\n"`, String("\n"))
+	assertWriteTaggedHRSEqual(t, `"\n"`, String(`
 `))
-	assertWriteTaggedHRSEqual(t, `"\r"`, NewString("\r"))
-	assertWriteTaggedHRSEqual(t, `"\r\n"`, NewString("\r\n"))
-	assertWriteTaggedHRSEqual(t, `"\xff"`, NewString("\xff"))
-	assertWriteTaggedHRSEqual(t, `"💩"`, NewString("\xf0\x9f\x92\xa9"))
-	assertWriteTaggedHRSEqual(t, `"💩"`, NewString("💩"))
-	assertWriteTaggedHRSEqual(t, `"\a"`, NewString("\007"))
-	assertWriteTaggedHRSEqual(t, `"☺"`, NewString("\u263a"))
+	assertWriteTaggedHRSEqual(t, `"\r"`, String("\r"))
+	assertWriteTaggedHRSEqual(t, `"\r\n"`, String("\r\n"))
+	assertWriteTaggedHRSEqual(t, `"\xff"`, String("\xff"))
+	assertWriteTaggedHRSEqual(t, `"💩"`, String("\xf0\x9f\x92\xa9"))
+	assertWriteTaggedHRSEqual(t, `"💩"`, String("💩"))
+	assertWriteTaggedHRSEqual(t, `"\a"`, String("\007"))
+	assertWriteTaggedHRSEqual(t, `"☺"`, String("\u263a"))
 }
 
 func TestWriteHumanReadableTaggedType(t *testing.T) {

go/types/encoding_test.go

@@ -128,12 +128,12 @@ func TestRoundTrips(t *testing.T) {
 	assertRoundTrips(Number(0))
 	assertRoundTrips(Number(1))
 
-	assertRoundTrips(NewString(""))
-	assertRoundTrips(NewString("foo"))
-	assertRoundTrips(NewString("AINT NO THANG"))
-	assertRoundTrips(NewString("💩"))
+	assertRoundTrips(String(""))
+	assertRoundTrips(String("foo"))
+	assertRoundTrips(String("AINT NO THANG"))
+	assertRoundTrips(String("💩"))
 
-	assertRoundTrips(NewStruct("", structData{"a": Bool(true), "b": NewString("foo"), "c": Number(2.3)}))
+	assertRoundTrips(NewStruct("", structData{"a": Bool(true), "b": String("foo"), "c": Number(2.3)}))
 
 	listLeaf := newList(newListLeafSequence(nil, Number(4), Number(5), Number(6), Number(7)))
 	assertRoundTrips(listLeaf)
@@ -185,7 +185,7 @@ func TestWritePrimitives(t *testing.T) {
 		[]interface{}{
 			uint8(StringKind), "hi",
 		},
-		NewString("hi"))
+		String("hi"))
 }
 
 func TestWriteSimpleBlob(t *testing.T) {
@@ -244,7 +244,7 @@ func TestWriteMap(t *testing.T) {
 		[]interface{}{
 			uint8(MapKind), uint8(StringKind), uint8(BoolKind), false, uint32(2) /* len */, uint8(StringKind), "a", uint8(BoolKind), false, uint8(StringKind), "b", uint8(BoolKind), true,
 		},
-		NewMap(NewString("a"), Bool(false), NewString("b"), Bool(true)),
+		NewMap(String("a"), Bool(false), String("b"), Bool(true)),
 	)
 }
 
@@ -256,7 +256,7 @@ func TestWriteMapOfMap(t *testing.T) {
 			uint8(MapKind), uint8(StringKind), uint8(NumberKind), false, uint32(1) /* len */, uint8(StringKind), "a", uint8(NumberKind), float64(0),
 			uint8(SetKind), uint8(BoolKind), false, uint32(1) /* len */, uint8(BoolKind), true,
 		},
-		NewMap(NewMap(NewString("a"), Number(0)), NewSet(Bool(true))),
+		NewMap(NewMap(String("a"), Number(0)), NewSet(Bool(true))),
 	)
 }
 
@@ -307,7 +307,7 @@ func TestWriteStructWithList(t *testing.T) {
 			uint8(StructKind), "S", uint32(1) /* len */, "l", uint8(ListKind), uint8(StringKind),
 			uint8(ListKind), uint8(StringKind), false, uint32(2) /* len */, uint8(StringKind), "a", uint8(StringKind), "b",
 		},
-		NewStruct("S", structData{"l": NewList(NewString("a"), NewString("b"))}),
+		NewStruct("S", structData{"l": NewList(String("a"), String("b"))}),
 	)
 
 	// struct S {l: List<>}({l: []})
@@ -391,9 +391,9 @@ func TestWriteListOfUnion(t *testing.T) {
 			uint32(4) /* len */, uint8(StringKind), "0", uint8(NumberKind), float64(1), uint8(StringKind), "2", uint8(BoolKind), true,
 		},
 		NewList(
-			NewString("0"),
+			String("0"),
 			Number(1),
-			NewString("2"),
+			String("2"),
 			Bool(true),
 		),
 	)
@@ -484,7 +484,7 @@ func TestWriteUnionList(t *testing.T) {
 			uint8(ListKind), uint8(UnionKind), uint32(2) /* len */, uint8(StringKind), uint8(NumberKind),
 			false, uint32(2) /* len */, uint8(StringKind), "hi", uint8(NumberKind), float64(42),
 		},
-		NewList(NewString("hi"), Number(42)),
+		NewList(String("hi"), Number(42)),
 	)
 }
 

go/types/equals_test.go

@@ -21,9 +21,9 @@ func TestValueEquals(t *testing.T) {
 		func() Value { return Number(0) },
 		func() Value { return Number(-1) },
 		func() Value { return Number(1) },
-		func() Value { return NewString("") },
-		func() Value { return NewString("hi") },
-		func() Value { return NewString("bye") },
+		func() Value { return String("") },
+		func() Value { return String("hi") },
+		func() Value { return String("bye") },
 		func() Value {
 			return NewBlob(&bytes.Buffer{})
 		},
@@ -42,12 +42,12 @@ func TestValueEquals(t *testing.T) {
 			}, nil))
 		},
 		func() Value { return NewList() },
-		func() Value { return NewList(NewString("foo")) },
-		func() Value { return NewList(NewString("bar")) },
+		func() Value { return NewList(String("foo")) },
+		func() Value { return NewList(String("bar")) },
 		func() Value { return NewMap() },
-		func() Value { return NewMap(NewString("a"), NewString("a")) },
+		func() Value { return NewMap(String("a"), String("a")) },
 		func() Value { return NewSet() },
-		func() Value { return NewSet(NewString("hi")) },
+		func() Value { return NewSet(String("hi")) },
 
 		func() Value { return BoolType },
 		func() Value { return StringType },

go/types/get_hash_test.go

@@ -37,23 +37,22 @@ func TestEnsureHash(t *testing.T) {
 	bl := newBlob(newBlobLeafSequence(nil, []byte("hi")))
 	cb := newBlob(newBlobMetaSequence([]metaTuple{{Ref{}, Number(2), 2, bl}}, vs))
 
-	ll := newList(newListLeafSequence(nil, NewString("foo")))
+	ll := newList(newListLeafSequence(nil, String("foo")))
 	lt := MakeListType(StringType)
 	cl := newList(newIndexedMetaSequence([]metaTuple{{Ref{}, Number(1), 1, ll}}, lt, vs))
 
-	ml := newMap(newMapLeafSequence(nil, mapEntry{NewString("foo"), NewString("bar")}))
-	cm := newMap(newOrderedMetaSequence([]metaTuple{{Ref{}, NewString("foo"), 1, ml}}, MakeMapType(StringType, StringType), vs))
+	ml := newMap(newMapLeafSequence(nil, mapEntry{String("foo"), String("bar")}))
+	cm := newMap(newOrderedMetaSequence([]metaTuple{{Ref{}, String("foo"), 1, ml}}, MakeMapType(StringType, StringType), vs))
 
-	sl := newSet(newSetLeafSequence(nil, NewString("foo")))
-	cps := newSet(newOrderedMetaSequence([]metaTuple{{Ref{}, NewString("foo"), 1, sl}}, MakeSetType(StringType), vs))
+	sl := newSet(newSetLeafSequence(nil, String("foo")))
+	cps := newSet(newOrderedMetaSequence([]metaTuple{{Ref{}, String("foo"), 1, sl}}, MakeSetType(StringType), vs))
 
 	count = byte(1)
 	values := []Value{
 		newBlob(newBlobLeafSequence(nil, []byte{})),
 		cb,
-		newList(newListLeafSequence(nil, NewString("bar"))),
+		newList(newListLeafSequence(nil, String("bar"))),
 		cl,
-		NewString(""),
 		cm,
 		newMap(newMapLeafSequence(nil)),
 		cps,
@@ -75,6 +74,7 @@ func TestEnsureHash(t *testing.T) {
 	values = []Value{
 		Bool(false),
 		Number(0),
+		String(""),
 	}
 	for i := 0; i < 2; i++ {
 		for j, v := range values {

go/types/incremental_test.go

@@ -16,12 +16,12 @@ var (
 	testVals = []Value{
 		Bool(true),
 		Number(1),
-		NewString("hi"),
+		String("hi"),
 		NewBlob(bytes.NewReader([]byte("hi"))),
 		// compoundBlob
-		NewSet(NewString("hi")),
-		NewList(NewString("hi")),
-		NewMap(NewString("hi"), NewString("hi")),
+		NewSet(String("hi")),
+		NewList(String("hi")),
+		NewMap(String("hi"), String("hi")),
 	}
 )
 

go/types/list_test.go

@@ -764,8 +764,8 @@ func TestListDiffReplaceReverse5x100(t *testing.T) {
 func TestListDiffString1(t *testing.T) {
 	t.Parallel()
 	assert := assert.New(t)
-	nums1 := []Value{NewString("one"), NewString("two"), NewString("three")}
-	nums2 := []Value{NewString("one"), NewString("two"), NewString("three")}
+	nums1 := []Value{String("one"), String("two"), String("three")}
+	nums2 := []Value{String("one"), String("two"), String("three")}
 	l1 := NewList(nums1...)
 	l2 := NewList(nums2...)
 	diff := l2.Diff(l1)
@@ -775,8 +775,8 @@ func TestListDiffString1(t *testing.T) {
 func TestListDiffString2(t *testing.T) {
 	t.Parallel()
 	assert := assert.New(t)
-	nums1 := []Value{NewString("one"), NewString("two"), NewString("three")}
-	nums2 := []Value{NewString("one"), NewString("two"), NewString("three"), NewString("four")}
+	nums1 := []Value{String("one"), String("two"), String("three")}
+	nums2 := []Value{String("one"), String("two"), String("three"), String("four")}
 	l1 := NewList(nums1...)
 	l2 := NewList(nums2...)
 	diff := l2.Diff(l1)
@@ -790,8 +790,8 @@ func TestListDiffString2(t *testing.T) {
 func TestListDiffString3(t *testing.T) {
 	t.Parallel()
 	assert := assert.New(t)
-	nums1 := []Value{NewString("one"), NewString("two"), NewString("three")}
-	nums2 := []Value{NewString("one"), NewString("two"), NewString("four")}
+	nums1 := []Value{String("one"), String("two"), String("three")}
+	nums2 := []Value{String("one"), String("two"), String("four")}
 	l1 := NewList(nums1...)
 	l2 := NewList(nums2...)
 	diff := l2.Diff(l1)
@@ -852,7 +852,7 @@ func TestListTypeAfterMutations(t *testing.T) {
 		assert.IsType(c, l.sequence())
 		assert.True(l.Type().Equals(MakeListType(NumberType)))
 
-		l = l.Append(NewString("a"))
+		l = l.Append(String("a"))
 		assert.Equal(l.Len(), uint64(n+1))
 		assert.IsType(c, l.sequence())
 		assert.True(l.Type().Equals(MakeListType(MakeUnionType(NumberType, StringType))))

go/types/map_test.go

@@ -283,23 +283,23 @@ func TestNewMap(t *testing.T) {
 	assert := assert.New(t)
 	m := NewMap()
 	assert.Equal(uint64(0), m.Len())
-	m = NewMap(NewString("foo1"), NewString("bar1"), NewString("foo2"), NewString("bar2"))
+	m = NewMap(String("foo1"), String("bar1"), String("foo2"), String("bar2"))
 	assert.Equal(uint64(2), m.Len())
-	assert.True(NewString("bar1").Equals(m.Get(NewString("foo1"))))
-	assert.True(NewString("bar2").Equals(m.Get(NewString("foo2"))))
+	assert.True(String("bar1").Equals(m.Get(String("foo1"))))
+	assert.True(String("bar2").Equals(m.Get(String("foo2"))))
 }
 
 func TestMapUniqueKeysString(t *testing.T) {
 	assert := assert.New(t)
 	l := []Value{
-		NewString("hello"), NewString("world"),
-		NewString("foo"), NewString("bar"),
-		NewString("bar"), NewString("foo"),
-		NewString("hello"), NewString("foo"),
+		String("hello"), String("world"),
+		String("foo"), String("bar"),
+		String("bar"), String("foo"),
+		String("hello"), String("foo"),
 	}
 	m := NewMap(l...)
 	assert.Equal(uint64(3), m.Len())
-	assert.True(NewString("foo").Equals(m.Get(NewString("hello"))))
+	assert.True(String("foo").Equals(m.Get(String("hello"))))
 }
 
 func TestMapUniqueKeysNumber(t *testing.T) {
@@ -345,14 +345,14 @@ func TestMapHas(t *testing.T) {
 func TestMapHasRemove(t *testing.T) {
 	assert := assert.New(t)
 	m1 := NewMap()
-	assert.False(m1.Has(NewString("foo")))
-	m2 := m1.Set(NewString("foo"), NewString("foo"))
-	assert.False(m1.Has(NewString("foo")))
-	assert.True(m2.Has(NewString("foo")))
-	m3 := m1.Remove(NewString("foo"))
-	assert.False(m1.Has(NewString("foo")))
-	assert.True(m2.Has(NewString("foo")))
-	assert.False(m3.Has(NewString("foo")))
+	assert.False(m1.Has(String("foo")))
+	m2 := m1.Set(String("foo"), String("foo"))
+	assert.False(m1.Has(String("foo")))
+	assert.True(m2.Has(String("foo")))
+	m3 := m1.Remove(String("foo"))
+	assert.False(m1.Has(String("foo")))
+	assert.True(m2.Has(String("foo")))
+	assert.False(m3.Has(String("foo")))
 }
 
 func TestMapRemove(t *testing.T) {
@@ -401,8 +401,8 @@ func TestMapFirst(t *testing.T) {
 	assert.Nil(k)
 	assert.Nil(v)
 
-	m1 = m1.Set(NewString("foo"), NewString("bar"))
-	m1 = m1.Set(NewString("hot"), NewString("dog"))
+	m1 = m1.Set(String("foo"), String("bar"))
+	m1 = m1.Set(String("hot"), String("dog"))
 	ak, av := m1.First()
 	var ek, ev Value
 
@@ -438,19 +438,19 @@ func TestMapFirst2(t *testing.T) {
 func TestMapSetGet(t *testing.T) {
 	assert := assert.New(t)
 	m1 := NewMap()
-	assert.Nil(m1.Get(NewString("foo")))
-	m2 := m1.Set(NewString("foo"), Number(42))
-	assert.Nil(m1.Get(NewString("foo")))
-	assert.True(Number(42).Equals(m2.Get(NewString("foo"))))
-	m3 := m2.Set(NewString("foo"), Number(43))
-	assert.Nil(m1.Get(NewString("foo")))
-	assert.True(Number(42).Equals(m2.Get(NewString("foo"))))
-	assert.True(Number(43).Equals(m3.Get(NewString("foo"))))
-	m4 := m3.Remove(NewString("foo"))
-	assert.Nil(m1.Get(NewString("foo")))
-	assert.True(Number(42).Equals(m2.Get(NewString("foo"))))
-	assert.True(Number(43).Equals(m3.Get(NewString("foo"))))
-	assert.Nil(m4.Get(NewString("foo")))
+	assert.Nil(m1.Get(String("foo")))
+	m2 := m1.Set(String("foo"), Number(42))
+	assert.Nil(m1.Get(String("foo")))
+	assert.True(Number(42).Equals(m2.Get(String("foo"))))
+	m3 := m2.Set(String("foo"), Number(43))
+	assert.Nil(m1.Get(String("foo")))
+	assert.True(Number(42).Equals(m2.Get(String("foo"))))
+	assert.True(Number(43).Equals(m3.Get(String("foo"))))
+	m4 := m3.Remove(String("foo"))
+	assert.Nil(m1.Get(String("foo")))
+	assert.True(Number(42).Equals(m2.Get(String("foo"))))
+	assert.True(Number(43).Equals(m3.Get(String("foo"))))
+	assert.Nil(m4.Get(String("foo")))
 }
 
 func validateMapInsertion(t *testing.T, tm testMap) {
@@ -526,11 +526,11 @@ func TestMapSetM(t *testing.T) {
 	m1 := NewMap()
 	m2 := m1.SetM()
 	assert.True(m1.Equals(m2))
-	m3 := m2.SetM(NewString("foo"), NewString("bar"), NewString("hot"), NewString("dog"))
+	m3 := m2.SetM(String("foo"), String("bar"), String("hot"), String("dog"))
 	assert.Equal(uint64(2), m3.Len())
-	assert.True(NewString("bar").Equals(m3.Get(NewString("foo"))))
-	assert.True(NewString("dog").Equals(m3.Get(NewString("hot"))))
-	m4 := m3.SetM(NewString("mon"), NewString("key"))
+	assert.True(String("bar").Equals(m3.Get(String("foo"))))
+	assert.True(String("dog").Equals(m3.Get(String("hot"))))
+	m4 := m3.SetM(String("mon"), String("key"))
 	assert.Equal(uint64(2), m3.Len())
 	assert.Equal(uint64(3), m4.Len())
 }
@@ -595,18 +595,18 @@ func TestMapIter(t *testing.T) {
 	m.Iter(cb)
 	assert.Equal(0, len(results))
 
-	m = m.SetM(NewString("a"), Number(0), NewString("b"), Number(1))
+	m = m.SetM(String("a"), Number(0), String("b"), Number(1))
 	m.Iter(cb)
 	assert.Equal(2, len(results))
-	assert.True(got(NewString("a"), Number(0)))
-	assert.True(got(NewString("b"), Number(1)))
+	assert.True(got(String("a"), Number(0)))
+	assert.True(got(String("b"), Number(1)))
 
 	results = resultList{}
 	stop = true
 	m.Iter(cb)
 	assert.Equal(1, len(results))
 	// Iteration order not guaranteed, but it has to be one of these.
-	assert.True(got(NewString("a"), Number(0)) || got(NewString("b"), Number(1)))
+	assert.True(got(String("a"), Number(0)) || got(String("b"), Number(1)))
 }
 
 func TestMapIter2(t *testing.T) {
@@ -679,8 +679,8 @@ func TestMapEquals(t *testing.T) {
 	diffMapTest(assert, m3, m1, 0, 0, 0)
 	diffMapTest(assert, m3, m2, 0, 0, 0)
 
-	m1 = NewMap(NewString("foo"), Number(0.0), NewString("bar"), NewList())
-	m2 = m2.SetM(NewString("foo"), Number(0.0), NewString("bar"), NewList())
+	m1 = NewMap(String("foo"), Number(0.0), String("bar"), NewList())
+	m2 = m2.SetM(String("foo"), Number(0.0), String("bar"), NewList())
 	assert.True(m1.Equals(m2))
 	assert.True(m2.Equals(m1))
 	assert.False(m2.Equals(m3))
@@ -699,18 +699,18 @@ func TestMapNotStringKeys(t *testing.T) {
 	b1 := NewBlob(bytes.NewBufferString("blob1"))
 	b2 := NewBlob(bytes.NewBufferString("blob2"))
 	l := []Value{
-		Bool(true), NewString("true"),
-		Bool(false), NewString("false"),
-		Number(1), NewString("Number: 1"),
-		Number(0), NewString("Number: 0"),
-		b1, NewString("blob1"),
-		b2, NewString("blob2"),
-		NewList(), NewString("empty list"),
-		NewList(NewList()), NewString("list of list"),
-		NewMap(), NewString("empty map"),
-		NewMap(NewMap(), NewMap()), NewString("map of map/map"),
-		NewSet(), NewString("empty set"),
-		NewSet(NewSet()), NewString("map of set/set"),
+		Bool(true), String("true"),
+		Bool(false), String("false"),
+		Number(1), String("Number: 1"),
+		Number(0), String("Number: 0"),
+		b1, String("blob1"),
+		b2, String("blob2"),
+		NewList(), String("empty list"),
+		NewList(NewList()), String("list of list"),
+		NewMap(), String("empty map"),
+		NewMap(NewMap(), NewMap()), String("map of map/map"),
+		NewSet(), String("empty set"),
+		NewSet(NewSet()), String("map of set/set"),
 	}
 	m1 := NewMap(l...)
 	assert.Equal(uint64(12), m1.Len())
@@ -735,32 +735,32 @@ func TestMapOrdering(t *testing.T) {
 	testMapOrder(assert,
 		StringType, StringType,
 		[]Value{
-			NewString("a"), NewString("unused"),
-			NewString("z"), NewString("unused"),
-			NewString("b"), NewString("unused"),
-			NewString("y"), NewString("unused"),
-			NewString("c"), NewString("unused"),
-			NewString("x"), NewString("unused"),
+			String("a"), String("unused"),
+			String("z"), String("unused"),
+			String("b"), String("unused"),
+			String("y"), String("unused"),
+			String("c"), String("unused"),
+			String("x"), String("unused"),
 		},
 		[]Value{
-			NewString("a"),
-			NewString("b"),
-			NewString("c"),
-			NewString("x"),
-			NewString("y"),
-			NewString("z"),
+			String("a"),
+			String("b"),
+			String("c"),
+			String("x"),
+			String("y"),
+			String("z"),
 		},
 	)
 
 	testMapOrder(assert,
 		NumberType, StringType,
 		[]Value{
-			Number(0), NewString("unused"),
-			Number(1000), NewString("unused"),
-			Number(1), NewString("unused"),
-			Number(100), NewString("unused"),
-			Number(2), NewString("unused"),
-			Number(10), NewString("unused"),
+			Number(0), String("unused"),
+			Number(1000), String("unused"),
+			Number(1), String("unused"),
+			Number(100), String("unused"),
+			Number(2), String("unused"),
+			Number(10), String("unused"),
 		},
 		[]Value{
 			Number(0),
@@ -775,12 +775,12 @@ func TestMapOrdering(t *testing.T) {
 	testMapOrder(assert,
 		NumberType, StringType,
 		[]Value{
-			Number(0), NewString("unused"),
-			Number(-30), NewString("unused"),
-			Number(25), NewString("unused"),
-			Number(1002), NewString("unused"),
-			Number(-5050), NewString("unused"),
-			Number(23), NewString("unused"),
+			Number(0), String("unused"),
+			Number(-30), String("unused"),
+			Number(25), String("unused"),
+			Number(1002), String("unused"),
+			Number(-5050), String("unused"),
+			Number(23), String("unused"),
 		},
 		[]Value{
 			Number(-5050),
@@ -795,12 +795,12 @@ func TestMapOrdering(t *testing.T) {
 	testMapOrder(assert,
 		NumberType, StringType,
 		[]Value{
-			Number(0.0001), NewString("unused"),
-			Number(0.000001), NewString("unused"),
-			Number(1), NewString("unused"),
-			Number(25.01e3), NewString("unused"),
-			Number(-32.231123e5), NewString("unused"),
-			Number(23), NewString("unused"),
+			Number(0.0001), String("unused"),
+			Number(0.000001), String("unused"),
+			Number(1), String("unused"),
+			Number(25.01e3), String("unused"),
+			Number(-32.231123e5), String("unused"),
+			Number(23), String("unused"),
 		},
 		[]Value{
 			Number(-32.231123e5),
@@ -815,28 +815,28 @@ func TestMapOrdering(t *testing.T) {
 	testMapOrder(assert,
 		ValueType, StringType,
 		[]Value{
-			NewString("a"), NewString("unused"),
-			NewString("z"), NewString("unused"),
-			NewString("b"), NewString("unused"),
-			NewString("y"), NewString("unused"),
-			NewString("c"), NewString("unused"),
-			NewString("x"), NewString("unused"),
+			String("a"), String("unused"),
+			String("z"), String("unused"),
+			String("b"), String("unused"),
+			String("y"), String("unused"),
+			String("c"), String("unused"),
+			String("x"), String("unused"),
 		},
 		[]Value{
-			NewString("a"),
-			NewString("b"),
-			NewString("c"),
-			NewString("x"),
-			NewString("y"),
-			NewString("z"),
+			String("a"),
+			String("b"),
+			String("c"),
+			String("x"),
+			String("y"),
+			String("z"),
 		},
 	)
 
 	testMapOrder(assert,
 		BoolType, StringType,
 		[]Value{
-			Bool(true), NewString("unused"),
-			Bool(false), NewString("unused"),
+			Bool(true), String("unused"),
+			Bool(false), String("unused"),
 		},
 		[]Value{
 			Bool(false),
@@ -850,7 +850,7 @@ func TestMapEmpty(t *testing.T) {
 
 	m := NewMap()
 	assert.True(m.Empty())
-	m = m.Set(Bool(false), NewString("hi"))
+	m = m.Set(Bool(false), String("hi"))
 	assert.False(m.Empty())
 	m = m.Set(NewList(), NewMap())
 	assert.False(m.Empty())
@@ -863,17 +863,17 @@ func TestMapType(t *testing.T) {
 	m := NewMap()
 	assert.True(m.Type().Equals(emptyMapType))
 
-	m2 := m.Remove(NewString("B"))
+	m2 := m.Remove(String("B"))
 	assert.True(emptyMapType.Equals(m2.Type()))
 
 	tr := MakeMapType(StringType, NumberType)
-	m2 = m.Set(NewString("A"), Number(1))
+	m2 = m.Set(String("A"), Number(1))
 	assert.True(tr.Equals(m2.Type()))
 
-	m2 = m.SetM(NewString("B"), Number(2), NewString("C"), Number(2))
+	m2 = m.SetM(String("B"), Number(2), String("C"), Number(2))
 	assert.True(tr.Equals(m2.Type()))
 
-	m3 := m2.Set(NewString("A"), Bool(true))
+	m3 := m2.Set(String("A"), Bool(true))
 	assert.True(MakeMapType(StringType, MakeUnionType(BoolType, NumberType)).Equals(m3.Type()), m3.Type().Describe())
 	m4 := m3.Set(Bool(true), Number(1))
 	assert.True(MakeMapType(MakeUnionType(BoolType, StringType), MakeUnionType(BoolType, NumberType)).Equals(m4.Type()))
@@ -966,12 +966,12 @@ func TestMapTypeAfterMutations(t *testing.T) {
 		assert.IsType(c, m.sequence())
 		assert.True(m.Type().Equals(MakeMapType(NumberType, NumberType)))
 
-		m = m.Set(NewString("a"), NewString("a"))
+		m = m.Set(String("a"), String("a"))
 		assert.Equal(m.Len(), uint64(n+1))
 		assert.IsType(c, m.sequence())
 		assert.True(m.Type().Equals(MakeMapType(MakeUnionType(NumberType, StringType), MakeUnionType(NumberType, StringType))))
 
-		m = m.Remove(NewString("a"))
+		m = m.Remove(String("a"))
 		assert.Equal(m.Len(), uint64(n))
 		assert.IsType(c, m.sequence())
 		assert.True(m.Type().Equals(MakeMapType(NumberType, NumberType)))

go/types/path.go

@@ -186,7 +186,7 @@ Switch:
 		if i == len(str) {
 			err = errors.New("[ is missing closing ]")
 		} else {
-			idx = NewString(stringBuf.String())
+			idx = String(stringBuf.String())
 			rem = str[i+2:]
 		}
 

go/types/path_test.go

@@ -29,13 +29,13 @@ func TestPathStruct(t *testing.T) {
 	assert := assert.New(t)
 
 	v := NewStruct("", structData{
-		"foo": NewString("foo"),
+		"foo": String("foo"),
 		"bar": Bool(false),
 		"baz": Number(203),
 	})
 
-	assertPathResolvesTo(assert, NewString("foo"), v, NewPath().AddField("foo"))
-	assertPathStringResolvesTo(assert, NewString("foo"), v, `.foo`)
+	assertPathResolvesTo(assert, String("foo"), v, NewPath().AddField("foo"))
+	assertPathStringResolvesTo(assert, String("foo"), v, `.foo`)
 	assertPathResolvesTo(assert, Bool(false), v, NewPath().AddField("bar"))
 	assertPathStringResolvesTo(assert, Bool(false), v, `.bar`)
 	assertPathResolvesTo(assert, Number(203), v, NewPath().AddField("baz"))
@@ -47,14 +47,14 @@ func TestPathStruct(t *testing.T) {
 func TestPathList(t *testing.T) {
 	assert := assert.New(t)
 
-	v := NewList(Number(1), Number(3), NewString("foo"), Bool(false))
+	v := NewList(Number(1), Number(3), String("foo"), Bool(false))
 
 	assertPathResolvesTo(assert, Number(1), v, NewPath().AddIndex(Number(0)))
 	assertPathStringResolvesTo(assert, Number(1), v, `[0]`)
 	assertPathResolvesTo(assert, Number(3), v, NewPath().AddIndex(Number(1)))
 	assertPathStringResolvesTo(assert, Number(3), v, `[1]`)
-	assertPathResolvesTo(assert, NewString("foo"), v, NewPath().AddIndex(Number(2)))
-	assertPathStringResolvesTo(assert, NewString("foo"), v, `[2]`)
+	assertPathResolvesTo(assert, String("foo"), v, NewPath().AddIndex(Number(2)))
+	assertPathStringResolvesTo(assert, String("foo"), v, `[2]`)
 	assertPathResolvesTo(assert, Bool(false), v, NewPath().AddIndex(Number(3)))
 	assertPathStringResolvesTo(assert, Bool(false), v, `[3]`)
 	assertPathResolvesTo(assert, nil, v, NewPath().AddIndex(Number(4)))
@@ -67,16 +67,16 @@ func TestPathMap(t *testing.T) {
 	assert := assert.New(t)
 
 	v := NewMap(
-		Number(1), NewString("foo"),
-		NewString("two"), NewString("bar"),
+		Number(1), String("foo"),
+		String("two"), String("bar"),
 		Bool(false), Number(23),
 		Number(2.3), Number(4.5),
 	)
 
-	assertPathResolvesTo(assert, NewString("foo"), v, NewPath().AddIndex(Number(1)))
-	assertPathStringResolvesTo(assert, NewString("foo"), v, `[1]`)
-	assertPathResolvesTo(assert, NewString("bar"), v, NewPath().AddIndex(NewString("two")))
-	assertPathStringResolvesTo(assert, NewString("bar"), v, `["two"]`)
+	assertPathResolvesTo(assert, String("foo"), v, NewPath().AddIndex(Number(1)))
+	assertPathStringResolvesTo(assert, String("foo"), v, `[1]`)
+	assertPathResolvesTo(assert, String("bar"), v, NewPath().AddIndex(String("two")))
+	assertPathStringResolvesTo(assert, String("bar"), v, `["two"]`)
 	assertPathResolvesTo(assert, Number(23), v, NewPath().AddIndex(Bool(false)))
 	assertPathStringResolvesTo(assert, Number(23), v, `[false]`)
 	assertPathResolvesTo(assert, Number(4.5), v, NewPath().AddIndex(Number(2.3)))
@@ -89,14 +89,14 @@ func TestPathMulti(t *testing.T) {
 	assert := assert.New(t)
 
 	m1 := NewMap(
-		NewString("a"), NewString("foo"),
-		NewString("b"), NewString("bar"),
-		NewString("c"), NewString("car"),
+		String("a"), String("foo"),
+		String("b"), String("bar"),
+		String("c"), String("car"),
 	)
 
 	m2 := NewMap(
-		NewString("d"), NewString("dar"),
-		Bool(false), NewString("earth"),
+		String("d"), String("dar"),
+		Bool(false), String("earth"),
 	)
 
 	l := NewList(m1, m2)
@@ -109,24 +109,24 @@ func TestPathMulti(t *testing.T) {
 	assertPathStringResolvesTo(assert, l, s, `.foo`)
 	assertPathResolvesTo(assert, m1, s, NewPath().AddField("foo").AddIndex(Number(0)))
 	assertPathStringResolvesTo(assert, m1, s, `.foo[0]`)
-	assertPathResolvesTo(assert, NewString("foo"), s, NewPath().AddField("foo").AddIndex(Number(0)).AddIndex(NewString("a")))
-	assertPathStringResolvesTo(assert, NewString("foo"), s, `.foo[0]["a"]`)
-	assertPathResolvesTo(assert, NewString("bar"), s, NewPath().AddField("foo").AddIndex(Number(0)).AddIndex(NewString("b")))
-	assertPathStringResolvesTo(assert, NewString("bar"), s, `.foo[0]["b"]`)
-	assertPathResolvesTo(assert, NewString("car"), s, NewPath().AddField("foo").AddIndex(Number(0)).AddIndex(NewString("c")))
-	assertPathStringResolvesTo(assert, NewString("car"), s, `.foo[0]["c"]`)
-	assertPathResolvesTo(assert, nil, s, NewPath().AddField("foo").AddIndex(Number(0)).AddIndex(NewString("x")))
+	assertPathResolvesTo(assert, String("foo"), s, NewPath().AddField("foo").AddIndex(Number(0)).AddIndex(String("a")))
+	assertPathStringResolvesTo(assert, String("foo"), s, `.foo[0]["a"]`)
+	assertPathResolvesTo(assert, String("bar"), s, NewPath().AddField("foo").AddIndex(Number(0)).AddIndex(String("b")))
+	assertPathStringResolvesTo(assert, String("bar"), s, `.foo[0]["b"]`)
+	assertPathResolvesTo(assert, String("car"), s, NewPath().AddField("foo").AddIndex(Number(0)).AddIndex(String("c")))
+	assertPathStringResolvesTo(assert, String("car"), s, `.foo[0]["c"]`)
+	assertPathResolvesTo(assert, nil, s, NewPath().AddField("foo").AddIndex(Number(0)).AddIndex(String("x")))
 	assertPathStringResolvesTo(assert, nil, s, `.foo[0]["x"]`)
-	assertPathResolvesTo(assert, nil, s, NewPath().AddField("foo").AddIndex(Number(2)).AddIndex(NewString("c")))
+	assertPathResolvesTo(assert, nil, s, NewPath().AddField("foo").AddIndex(Number(2)).AddIndex(String("c")))
 	assertPathStringResolvesTo(assert, nil, s, `.foo[2]["c"]`)
-	assertPathResolvesTo(assert, nil, s, NewPath().AddField("notHere").AddIndex(Number(0)).AddIndex(NewString("c")))
+	assertPathResolvesTo(assert, nil, s, NewPath().AddField("notHere").AddIndex(Number(0)).AddIndex(String("c")))
 	assertPathStringResolvesTo(assert, nil, s, `.notHere[0]["c"]`)
 	assertPathResolvesTo(assert, m2, s, NewPath().AddField("foo").AddIndex(Number(1)))
 	assertPathStringResolvesTo(assert, m2, s, `.foo[1]`)
-	assertPathResolvesTo(assert, NewString("dar"), s, NewPath().AddField("foo").AddIndex(Number(1)).AddIndex(NewString("d")))
-	assertPathStringResolvesTo(assert, NewString("dar"), s, `.foo[1]["d"]`)
-	assertPathResolvesTo(assert, NewString("earth"), s, NewPath().AddField("foo").AddIndex(Number(1)).AddIndex(Bool(false)))
-	assertPathStringResolvesTo(assert, NewString("earth"), s, `.foo[1][false]`)
+	assertPathResolvesTo(assert, String("dar"), s, NewPath().AddField("foo").AddIndex(Number(1)).AddIndex(String("d")))
+	assertPathStringResolvesTo(assert, String("dar"), s, `.foo[1]["d"]`)
+	assertPathResolvesTo(assert, String("earth"), s, NewPath().AddField("foo").AddIndex(Number(1)).AddIndex(Bool(false)))
+	assertPathStringResolvesTo(assert, String("earth"), s, `.foo[1][false]`)
 }
 
 func TestPathToAndFromString(t *testing.T) {
@@ -140,7 +140,7 @@ func TestPathToAndFromString(t *testing.T) {
 	}
 
 	test("[0]", NewPath().AddIndex(Number(0)))
-	test("[\"0\"][\"1\"][\"100\"]", NewPath().AddIndex(NewString("0")).AddIndex(NewString("1")).AddIndex(NewString("100")))
+	test("[\"0\"][\"1\"][\"100\"]", NewPath().AddIndex(String("0")).AddIndex(String("1")).AddIndex(String("100")))
 	test(".foo[0].bar[4.5][false]", NewPath().AddField("foo").AddIndex(Number(0)).AddField("bar").AddIndex(Number(4.5)).AddIndex(Bool(false)))
 }
 
@@ -174,14 +174,14 @@ func TestPathParseSuccess(t *testing.T) {
 	test("[1e4]", NewPath().AddIndex(Number(1e4)))
 	test("[1.]", NewPath().AddIndex(Number(1.)))
 	test("[1.345]", NewPath().AddIndex(Number(1.345)))
-	test(`[""]`, NewPath().AddIndex(NewString("")))
-	test(`["42"]`, NewPath().AddIndex(NewString("42")))
-	test("[\"line\nbreak\rreturn\"]", NewPath().AddIndex(NewString("line\nbreak\rreturn")))
-	test(`["qu\\ote\""]`, NewPath().AddIndex(NewString(`qu\ote"`)))
-	test(`["π"]`, NewPath().AddIndex(NewString("π")))
-	test(`["[[br][]acke]]ts"]`, NewPath().AddIndex(NewString("[[br][]acke]]ts")))
-	test(`["xπy✌z"]`, NewPath().AddIndex(NewString("xπy✌z")))
-	test(`["ಠ_ಠ"]`, NewPath().AddIndex(NewString("ಠ_ಠ")))
+	test(`[""]`, NewPath().AddIndex(String("")))
+	test(`["42"]`, NewPath().AddIndex(String("42")))
+	test("[\"line\nbreak\rreturn\"]", NewPath().AddIndex(String("line\nbreak\rreturn")))
+	test(`["qu\\ote\""]`, NewPath().AddIndex(String(`qu\ote"`)))
+	test(`["π"]`, NewPath().AddIndex(String("π")))
+	test(`["[[br][]acke]]ts"]`, NewPath().AddIndex(String("[[br][]acke]]ts")))
+	test(`["xπy✌z"]`, NewPath().AddIndex(String("xπy✌z")))
+	test(`["ಠ_ಠ"]`, NewPath().AddIndex(String("ಠ_ಠ")))
 }
 
 func TestPathParseErrors(t *testing.T) {

go/types/set_test.go

@@ -228,7 +228,7 @@ func TestSetLen(t *testing.T) {
 	assert := assert.New(t)
 	s0 := NewSet()
 	assert.Equal(uint64(0), s0.Len())
-	s1 := NewSet(Bool(true), Number(1), NewString("hi"))
+	s1 := NewSet(Bool(true), Number(1), String("hi"))
 	assert.Equal(uint64(3), s1.Len())
 	diffSetTest(assert, s0, s1, 0, 3)
 	diffSetTest(assert, s1, s0, 3, 0)
@@ -283,11 +283,11 @@ func TestSetDuplicateInsert(t *testing.T) {
 
 func TestSetUniqueKeysString(t *testing.T) {
 	assert := assert.New(t)
-	s1 := NewSet(NewString("hello"), NewString("world"), NewString("hello"))
+	s1 := NewSet(String("hello"), String("world"), String("hello"))
 	assert.Equal(uint64(2), s1.Len())
-	assert.True(s1.Has(NewString("hello")))
-	assert.True(s1.Has(NewString("world")))
-	assert.False(s1.Has(NewString("foo")))
+	assert.True(s1.Has(String("hello")))
+	assert.True(s1.Has(String("world")))
+	assert.False(s1.Has(String("foo")))
 }
 
 func TestSetUniqueKeysNumber(t *testing.T) {
@@ -303,13 +303,13 @@ func TestSetUniqueKeysNumber(t *testing.T) {
 
 func TestSetHas(t *testing.T) {
 	assert := assert.New(t)
-	s1 := NewSet(Bool(true), Number(1), NewString("hi"))
+	s1 := NewSet(Bool(true), Number(1), String("hi"))
 	assert.True(s1.Has(Bool(true)))
 	assert.False(s1.Has(Bool(false)))
 	assert.True(s1.Has(Number(1)))
 	assert.False(s1.Has(Number(0)))
-	assert.True(s1.Has(NewString("hi")))
-	assert.False(s1.Has(NewString("ho")))
+	assert.True(s1.Has(String("hi")))
+	assert.False(s1.Has(String("ho")))
 
 	s2 := s1.Insert(Bool(false))
 	assert.True(s2.Has(Bool(false)))
@@ -606,20 +606,20 @@ func TestSetOrdering(t *testing.T) {
 	testSetOrder(assert,
 		StringType,
 		[]Value{
-			NewString("a"),
-			NewString("z"),
-			NewString("b"),
-			NewString("y"),
-			NewString("c"),
-			NewString("x"),
+			String("a"),
+			String("z"),
+			String("b"),
+			String("y"),
+			String("c"),
+			String("x"),
 		},
 		[]Value{
-			NewString("a"),
-			NewString("b"),
-			NewString("c"),
-			NewString("x"),
-			NewString("y"),
-			NewString("z"),
+			String("a"),
+			String("b"),
+			String("c"),
+			String("x"),
+			String("y"),
+			String("z"),
 		},
 	)
 
@@ -686,21 +686,21 @@ func TestSetOrdering(t *testing.T) {
 	testSetOrder(assert,
 		ValueType,
 		[]Value{
-			NewString("a"),
-			NewString("z"),
-			NewString("b"),
-			NewString("y"),
-			NewString("c"),
-			NewString("x"),
+			String("a"),
+			String("z"),
+			String("b"),
+			String("y"),
+			String("c"),
+			String("x"),
 		},
 		// Ordered by value
 		[]Value{
-			NewString("a"),
-			NewString("b"),
-			NewString("c"),
-			NewString("x"),
-			NewString("y"),
-			NewString("z"),
+			String("a"),
+			String("b"),
+			String("c"),
+			String("x"),
+			String("y"),
+			String("z"),
 		},
 	)
 
@@ -817,12 +817,12 @@ func TestSetTypeAfterMutations(t *testing.T) {
 		assert.IsType(c, s.sequence())
 		assert.True(s.Type().Equals(MakeSetType(NumberType)))
 
-		s = s.Insert(NewString("a"))
+		s = s.Insert(String("a"))
 		assert.Equal(s.Len(), uint64(n+1))
 		assert.IsType(c, s.sequence())
 		assert.True(s.Type().Equals(MakeSetType(MakeUnionType(NumberType, StringType))))
 
-		s = s.Remove(NewString("a"))
+		s = s.Remove(String("a"))
 		assert.Equal(s.Len(), uint64(n))
 		assert.IsType(c, s.sequence())
 		assert.True(s.Type().Equals(MakeSetType(NumberType)))

go/types/string.go

@@ -6,40 +6,22 @@ package types
 
 import "github.com/attic-labs/noms/go/hash"
 
-type String struct {
-	s string
-	h *hash.Hash
-}
-
-func NewString(s string) String {
-	return String{s, &hash.Hash{}}
-}
-
-func (fs String) String() string {
-	return fs.s
-}
-
-func (s String) hashPointer() *hash.Hash {
-	return s.h
-}
+type String string
 
 // Value interface
 func (s String) Equals(other Value) bool {
-	if other, ok := other.(String); ok {
-		return s.s == other.s
-	}
-	return false
+	return s == other
 }
 
 func (s String) Less(other Value) bool {
 	if s2, ok := other.(String); ok {
-		return s.s < s2.s
+		return s < s2
 	}
 	return StringKind < other.Type().Kind()
 }
 
-func (fs String) Hash() hash.Hash {
-	return EnsureHash(fs.h, fs)
+func (s String) Hash() hash.Hash {
+	return getHash(s)
 }
 
 func (fs String) ChildValues() []Value {

go/types/string_test.go

@@ -12,10 +12,10 @@ import (
 
 func TestStringEquals(t *testing.T) {
 	assert := assert.New(t)
-	s1 := NewString("foo")
-	s2 := NewString("foo")
+	s1 := String("foo")
+	s2 := String("foo")
 	s3 := s2
-	s4 := NewString("bar")
+	s4 := String("bar")
 	assert.True(s1.Equals(s2))
 	assert.True(s2.Equals(s1))
 	assert.True(s1.Equals(s3))
@@ -26,12 +26,12 @@ func TestStringEquals(t *testing.T) {
 
 func TestStringString(t *testing.T) {
 	assert := assert.New(t)
-	s1 := NewString("")
-	s2 := NewString("foo")
-	assert.Equal("", s1.String())
-	assert.Equal("foo", s2.String())
+	s1 := String("")
+	s2 := String("foo")
+	assert.Equal("", string(s1))
+	assert.Equal("foo", string(s2))
 }
 
 func TestStringType(t *testing.T) {
-	assert.True(t, NewString("hi").Type().Equals(StringType))
+	assert.True(t, String("hi").Type().Equals(StringType))
 }

go/types/struct_test.go

@@ -18,9 +18,9 @@ func TestGenericStructEquals(t *testing.T) {
 		"s": StringType,
 	})
 
-	data1 := structData{"x": Bool(true), "s": NewString("hi")}
+	data1 := structData{"x": Bool(true), "s": String("hi")}
 	s1 := newStructFromData(data1, typ)
-	data2 := structData{"x": Bool(true), "s": NewString("hi")}
+	data2 := structData{"x": Bool(true), "s": String("hi")}
 	s2 := newStructFromData(data2, typ)
 
 	assert.True(s1.Equals(s2))
@@ -46,29 +46,29 @@ func TestGenericStructChunks(t *testing.T) {
 func TestGenericStructNew(t *testing.T) {
 	assert := assert.New(t)
 
-	s := NewStruct("S2", map[string]Value{"b": Bool(true), "o": NewString("hi")})
+	s := NewStruct("S2", map[string]Value{"b": Bool(true), "o": String("hi")})
 	assert.True(s.Get("b").Equals(Bool(true)))
 	_, ok := s.MaybeGet("missing")
 	assert.False(ok)
 
-	s2 := NewStruct("S2", map[string]Value{"b": Bool(false), "o": NewString("hi")})
+	s2 := NewStruct("S2", map[string]Value{"b": Bool(false), "o": String("hi")})
 	assert.True(s2.Get("b").Equals(Bool(false)))
 	o, ok := s2.MaybeGet("o")
 	assert.True(ok)
-	assert.True(NewString("hi").Equals(o))
+	assert.True(String("hi").Equals(o))
 
 	typ := MakeStructType("S2", TypeMap{
 		"b": BoolType,
 		"o": StringType,
 	})
 	assert.Panics(func() { NewStructWithType(typ, nil) })
-	assert.Panics(func() { NewStructWithType(typ, map[string]Value{"o": NewString("hi")}) })
+	assert.Panics(func() { NewStructWithType(typ, map[string]Value{"o": String("hi")}) })
 }
 
 func TestGenericStructSet(t *testing.T) {
 	assert := assert.New(t)
 
-	s := NewStruct("S3", map[string]Value{"b": Bool(true), "o": NewString("hi")})
+	s := NewStruct("S3", map[string]Value{"b": Bool(true), "o": String("hi")})
 	s2 := s.Set("b", Bool(false))
 
 	assert.Panics(func() { s.Set("b", Number(1)) })
@@ -89,52 +89,52 @@ func TestStructDiff(t *testing.T) {
 		}
 	}
 
-	s1 := NewStruct("", map[string]Value{"a": Bool(true), "b": NewString("hi"), "c": Number(4)})
+	s1 := NewStruct("", map[string]Value{"a": Bool(true), "b": String("hi"), "c": Number(4)})
 
 	assertDiff([]string{}, s1,
-		NewStruct("", map[string]Value{"a": Bool(true), "b": NewString("hi"), "c": Number(4)}))
+		NewStruct("", map[string]Value{"a": Bool(true), "b": String("hi"), "c": Number(4)}))
 
 	assertDiff([]string{"a", "b"}, s1,
-		NewStruct("", map[string]Value{"a": Bool(false), "b": NewString("bye"), "c": Number(4)}))
+		NewStruct("", map[string]Value{"a": Bool(false), "b": String("bye"), "c": Number(4)}))
 
 	assertDiff([]string{"b", "c"}, s1,
-		NewStruct("", map[string]Value{"a": Bool(true), "b": NewString("bye"), "c": Number(5)}))
+		NewStruct("", map[string]Value{"a": Bool(true), "b": String("bye"), "c": Number(5)}))
 
 	assertDiff([]string{"a", "c"}, s1,
-		NewStruct("", map[string]Value{"a": Bool(false), "b": NewString("hi"), "c": Number(10)}))
+		NewStruct("", map[string]Value{"a": Bool(false), "b": String("hi"), "c": Number(10)}))
 
 	s2 := NewStruct("", map[string]Value{
 		"a": NewList(Number(0), Number(1)),
-		"b": NewMap(NewString("foo"), Bool(false), NewString("bar"), Bool(true)),
-		"c": NewSet(Number(0), Number(1), NewString("foo")),
+		"b": NewMap(String("foo"), Bool(false), String("bar"), Bool(true)),
+		"c": NewSet(Number(0), Number(1), String("foo")),
 	})
 
 	assertDiff([]string{}, s2,
 		NewStruct("", map[string]Value{
 			"a": NewList(Number(0), Number(1)),
-			"b": NewMap(NewString("foo"), Bool(false), NewString("bar"), Bool(true)),
-			"c": NewSet(Number(0), Number(1), NewString("foo")),
+			"b": NewMap(String("foo"), Bool(false), String("bar"), Bool(true)),
+			"c": NewSet(Number(0), Number(1), String("foo")),
 		}))
 
 	assertDiff([]string{"a", "b"}, s2,
 		NewStruct("", map[string]Value{
 			"a": NewList(Number(1), Number(1)),
-			"b": NewMap(NewString("foo"), Bool(true), NewString("bar"), Bool(true)),
-			"c": NewSet(Number(0), Number(1), NewString("foo")),
+			"b": NewMap(String("foo"), Bool(true), String("bar"), Bool(true)),
+			"c": NewSet(Number(0), Number(1), String("foo")),
 		}))
 
 	assertDiff([]string{"a", "c"}, s2,
 		NewStruct("", map[string]Value{
 			"a": NewList(Number(0)),
-			"b": NewMap(NewString("foo"), Bool(false), NewString("bar"), Bool(true)),
-			"c": NewSet(Number(0), Number(2), NewString("foo")),
+			"b": NewMap(String("foo"), Bool(false), String("bar"), Bool(true)),
+			"c": NewSet(Number(0), Number(2), String("foo")),
 		}))
 
 	assertDiff([]string{"b", "c"}, s2,
 		NewStruct("", map[string]Value{
 			"a": NewList(Number(0), Number(1)),
-			"b": NewMap(NewString("boo"), Bool(false), NewString("bar"), Bool(true)),
-			"c": NewSet(Number(0), Number(1), NewString("bar")),
+			"b": NewMap(String("boo"), Bool(false), String("bar"), Bool(true)),
+			"c": NewSet(Number(0), Number(1), String("bar")),
 		}))
 }
 

go/types/value_decoder.go

@@ -136,7 +136,7 @@ func (r *valueDecoder) readValue() Value {
 	case NumberKind:
 		return Number(r.readFloat64())
 	case StringKind:
-		return NewString(r.readString())
+		return String(r.readString())
 	case ListKind:
 		isMeta := r.readBool()
 		if isMeta {

go/types/value_encoder.go

@@ -148,7 +148,7 @@ func (w *valueEncoder) writeValue(v Value) {
 
 		w.writeSetLeafSequence(seq.(setLeafSequence))
 	case StringKind:
-		w.writeString(v.(String).String())
+		w.writeString(string(v.(String)))
 	case TypeKind:
 		vt := v.(*Type)
 		w.writeType(vt, nil)

go/types/value_store_test.go

@@ -43,7 +43,7 @@ func TestEnsureChunksInCache(t *testing.T) {
 	cvs := newLocalValueStore(cs)
 
 	b := NewEmptyBlob()
-	s := NewString("oy")
+	s := String("oy")
 	bref := NewRef(b)
 	sref := NewRef(s)
 	l := NewList(bref, sref)
@@ -65,7 +65,7 @@ func TestEnsureChunksFails(t *testing.T) {
 	bref := NewRef(b)
 	assert.Panics(func() { cvs.ensureChunksInCache(bref) })
 
-	s := NewString("oy")
+	s := String("oy")
 	cs.Put(EncodeValue(b, nil))
 	cs.Put(EncodeValue(s, nil))
 

go/types/xp_test.go

@@ -29,9 +29,9 @@ func newTestSuite() *testSuite {
 		&testValue{Number(-1), "sha1-cd243416f913f4a81d020a866266316b30200e34", "num - -1"},
 		&testValue{Number(0), "sha1-80e331473af6cb0cd7ae6f75793070cfbc4d642b", "num - 0"},
 		&testValue{Number(1), "sha1-9f34f68652a49c4b7cc5e25951311e92c61d46d0", "num - 1"},
-		&testValue{NewString(""), "sha1-e1bc1dae59f116abb43f9dafbb2acc9b141aa6b0", "str - empty"},
-		&testValue{NewString("0"), "sha1-a1c90c71d1ffdb51138677c578e6f2e8a011070d", "str - 0"},
-		&testValue{NewString("false"), "sha1-e15d53dc6c9d3aa6eca4eea28382c9c45ba8fd9e", "str - false"},
+		&testValue{String(""), "sha1-e1bc1dae59f116abb43f9dafbb2acc9b141aa6b0", "str - empty"},
+		&testValue{String("0"), "sha1-a1c90c71d1ffdb51138677c578e6f2e8a011070d", "str - 0"},
+		&testValue{String("false"), "sha1-e15d53dc6c9d3aa6eca4eea28382c9c45ba8fd9e", "str - false"},
 	}
 
 	// TODO: add these types too

go/walk/walk_test.go

@@ -40,7 +40,7 @@ func (suite *WalkAllTestSuite) storeAndRef(v types.Value) types.Ref {
 
 func (suite *WalkAllTestSuite) TestWalkPrimitives() {
 	suite.walkWorker(suite.storeAndRef(types.Number(0.0)), 2)
-	suite.walkWorker(suite.storeAndRef(types.NewString("hello")), 2)
+	suite.walkWorker(suite.storeAndRef(types.String("hello")), 2)
 }
 
 func (suite *WalkAllTestSuite) TestWalkComposites() {
@@ -79,12 +79,12 @@ func (suite *WalkAllTestSuite) TestWalkNestedComposites() {
 	//  []: "wow"
 	// }
 	nested := types.NewMap(
-		types.NewString("string"), types.NewString("string"),
-		types.NewString("list"), suite.NewList(cs, types.Bool(false), types.Bool(true)),
-		types.NewString("map"), suite.NewMap(cs, types.NewString("nested"), types.NewString("string")),
-		types.NewString("mtlist"), suite.NewList(cs),
-		types.NewString("set"), suite.NewSet(cs, types.Number(5), types.Number(7), types.Number(8)),
-		suite.NewList(cs), types.NewString("wow"), // note that the dupe list chunk is skipped
+		types.String("string"), types.String("string"),
+		types.String("list"), suite.NewList(cs, types.Bool(false), types.Bool(true)),
+		types.String("map"), suite.NewMap(cs, types.String("nested"), types.String("string")),
+		types.String("mtlist"), suite.NewList(cs),
+		types.String("set"), suite.NewSet(cs, types.Number(5), types.Number(7), types.Number(8)),
+		suite.NewList(cs), types.String("wow"), // note that the dupe list chunk is skipped
 	)
 	suite.walkWorker(suite.storeAndRef(nested), 25)
 }
@@ -99,7 +99,7 @@ type WalkTestSuite struct {
 
 func (suite *WalkTestSuite) SetupTest() {
 	suite.vs = types.NewTestValueStore()
-	suite.shouldSeeItem = types.NewString("zzz")
+	suite.shouldSeeItem = types.String("zzz")
 	suite.shouldSee = types.NewList(suite.shouldSeeItem)
 	suite.deadValue = types.Number(0xDEADBEEF)
 	suite.mustSkip = types.NewList(suite.deadValue)
@@ -143,7 +143,7 @@ func (suite *WalkTestSuite) SkipTestSkipSetElement() {
 }
 
 func (suite *WalkTestSuite) SkipTestSkipMapValue() {
-	shouldAlsoSeeItem := types.NewString("Also good")
+	shouldAlsoSeeItem := types.String("Also good")
 	shouldAlsoSee := types.NewSet(shouldAlsoSeeItem)
 	wholeMap := types.NewMap(suite.shouldSee, suite.mustSkip, shouldAlsoSee, suite.shouldSee)
 	reached := suite.skipWorker(wholeMap)

samples/go/codec-perf-rig/main.go

@@ -125,7 +125,7 @@ func makeBlobBytes(byteLength uint64) []byte {
 }
 
 func createString(i uint64) types.Value {
-	return types.NewString(fmt.Sprintf("%s%d", strPrefix, i))
+	return types.String(fmt.Sprintf("%s%d", strPrefix, i))
 }
 
 func createNumber(i uint64) types.Value {
@@ -140,7 +140,7 @@ var structType = types.MakeStructType("S1", map[string]*types.Type{
 
 func createStruct(i uint64) types.Value {
 	return types.NewStructWithType(structType, map[string]types.Value{
-		"str":  types.NewString(fmt.Sprintf("i am a 55 bytes............................%12d", i)),
+		"str":  types.String(fmt.Sprintf("i am a 55 bytes............................%12d", i)),
 		"num":  types.Number(i),
 		"bool": types.Bool(i%2 == 0),
 	})

samples/go/csv/csv-export/exporter_test.go

@@ -56,7 +56,7 @@ func (s *testSuite) TestCSVExporter() {
 		fields := make(map[string]types.Value)
 		for j, v := range row {
 			name := header[j]
-			fields[name] = types.NewString(v)
+			fields[name] = types.String(v)
 		}
 		structs[i] = types.NewStructWithType(typ, fields)
 	}

samples/go/csv/csv-import/importer_test.go

@@ -59,7 +59,7 @@ func (s *testSuite) TestCSVImporter() {
 	l.IterAll(func(v types.Value, j uint64) {
 		s.Equal(i, j)
 		st := v.(types.Struct)
-		s.Equal(types.NewString(fmt.Sprintf("a%d", i)), st.Get("a"))
+		s.Equal(types.String(fmt.Sprintf("a%d", i)), st.Get("a"))
 		s.Equal(types.Number(i), st.Get("b"))
 		i++
 	})
@@ -95,7 +95,7 @@ func (s *testSuite) TestCSVImporterToMap() {
 
 	for i := 0; i < 20; i++ {
 		m.Get(types.Number(i)).(types.Struct).Equals(types.NewStruct("", map[string]types.Value{
-			"a": types.NewString(fmt.Sprintf("a%d", i)),
+			"a": types.String(fmt.Sprintf("a%d", i)),
 			"c": types.Number(i * 2),
 		}))
 	}
@@ -124,7 +124,7 @@ func (s *testSuite) TestCSVImporterWithPipe() {
 	s.Equal(uint64(1), l.Len())
 	v := l.Get(0)
 	st := v.(types.Struct)
-	s.Equal(types.NewString("1"), st.Get("a"))
+	s.Equal(types.String("1"), st.Get("a"))
 	s.Equal(types.Number(2), st.Get("b"))
 }
 
@@ -151,6 +151,6 @@ func (s *testSuite) TestCSVImporterWithExternalHeader() {
 	s.Equal(uint64(1), l.Len())
 	v := l.Get(0)
 	st := v.(types.Struct)
-	s.Equal(types.NewString("7"), st.Get("x"))
+	s.Equal(types.String("7"), st.Get("x"))
 	s.Equal(types.Number(8), st.Get("y"))
 }

samples/go/csv/read_test.go

@@ -39,8 +39,8 @@ b,2,false
 	assert.Equal(types.NumberKind, desc.Field("B").Kind())
 	assert.Equal(types.BoolKind, desc.Field("C").Kind())
 
-	assert.True(l.Get(0).(types.Struct).Get("A").Equals(types.NewString("a")))
-	assert.True(l.Get(1).(types.Struct).Get("A").Equals(types.NewString("b")))
+	assert.True(l.Get(0).(types.Struct).Get("A").Equals(types.String("a")))
+	assert.True(l.Get(1).(types.Struct).Get("A").Equals(types.String("b")))
 
 	assert.True(l.Get(0).(types.Struct).Get("B").Equals(types.Number(1)))
 	assert.True(l.Get(1).(types.Struct).Get("B").Equals(types.Number(2)))
@@ -69,11 +69,11 @@ b,2,false
 			"C": types.BoolType,
 		}))))
 
-	assert.True(m.Get(types.NewString("a")).Equals(types.NewStruct("", map[string]types.Value{
+	assert.True(m.Get(types.String("a")).Equals(types.NewStruct("", map[string]types.Value{
 		"B": types.Number(1),
 		"C": types.Bool(true),
 	})))
-	assert.True(m.Get(types.NewString("b")).Equals(types.NewStruct("", map[string]types.Value{
+	assert.True(m.Get(types.String("b")).Equals(types.NewStruct("", map[string]types.Value{
 		"B": types.Number(2),
 		"C": types.Bool(false),
 	})))

samples/go/csv/schema.go

@@ -97,7 +97,7 @@ func StringToType(s string, k types.NomsKind) types.Value {
 		d.Chk.NoError(err)
 		return types.Bool(bval)
 	case types.StringKind:
-		return types.NewString(s)
+		return types.String(s)
 	default:
 		d.Exp.Fail("Invalid column type kind:", k)
 	}

samples/go/demo-server/main.go

@@ -8,9 +8,9 @@ import (
 )
 
 var (
-	portFlag = flag.Int("port", 8000, "port to listen on")
-	ldbDir   = flag.String("ldb-dir", "", "directory for ldb database")
-	authKeyFlag   = flag.String("authkey", "", "directory for ldb database")
+	portFlag    = flag.Int("port", 8000, "port to listen on")
+	ldbDir      = flag.String("ldb-dir", "", "directory for ldb database")
+	authKeyFlag = flag.String("authkey", "", "directory for ldb database")
 )
 
 func usage() {
@@ -42,6 +42,5 @@ func main() {
 	}
 	defer factory.Shutter()
 
-    
 	startWebServer(factory, *authKeyFlag)
 }

samples/go/demo-server/web_server.go

@@ -25,7 +25,7 @@ const (
 var (
 	authRegexp = regexp.MustCompile("^Bearer\\s+(\\S*)$")
 	router     *httprouter.Router
-    authKey    = ""
+	authKey    = ""
 )
 
 func setupWebServer(factory chunks.Factory) *httprouter.Router {
@@ -59,8 +59,8 @@ func setupWebServer(factory chunks.Factory) *httprouter.Router {
 }
 
 func startWebServer(factory chunks.Factory, key string) {
-    d.Chk.NotEmpty(key, "No auth key was provided to startWebServer")
-    authKey = key
+	d.Chk.NotEmpty(key, "No auth key was provided to startWebServer")
+	authKey = key
 	router = setupWebServer(factory)
 
 	fmt.Printf("Listening on http://localhost:%d/...\n", *portFlag)
@@ -71,7 +71,7 @@ func startWebServer(factory chunks.Factory, key string) {
 			router.ServeHTTP(w, req)
 		}),
 	}
-    
+
 	log.Fatal(srv.Serve(l))
 }
 

samples/go/demo-server/web_server_test.go

@@ -72,7 +72,7 @@ func TestWriteValue(t *testing.T) {
 	assert.Equal(http.StatusOK, w.Code)
 
 	tval := types.Bool(true)
-	wval := types.NewString(testString)
+	wval := types.String(testString)
 	chunk1 := types.EncodeValue(tval, nil)
 	chunk2 := types.EncodeValue(wval, nil)
 	refList := types.NewList(types.NewRef(tval), types.NewRef(wval))
@@ -112,5 +112,5 @@ func TestWriteValue(t *testing.T) {
 	ms := chunks.NewMemoryStore()
 	chunks.Deserialize(w.Body, ms, nil)
 	v := types.DecodeValue(ms.Get(whash), datas.NewDatabase(ms))
-	assert.Equal(testString, v.(types.String).String())
+	assert.Equal(testString, string(v.(types.String)))
 }

samples/go/encode-perf-rig/main.go

@@ -48,7 +48,7 @@ func runTest(encoderDecoder EncoderDecoder, n *big.Float) (nBytes uint64) {
 
 func getEncoder(name string) EncoderDecoder {
 	if name == "string" {
-		return NewStringEncodedDecoder()
+		return StringEncodedDecoder()
 	} else if name == "binary" {
 		return NewBinaryEncoderDecoder()
 	} else if name == "binary-int" {

samples/go/encode-perf-rig/string-encoder.go

@@ -11,7 +11,7 @@ import (
 
 type StringEncoderDecoder struct{}
 
-func NewStringEncodedDecoder() StringEncoderDecoder {
+func StringEncodedDecoder() StringEncoderDecoder {
 	return StringEncoderDecoder{}
 }
 

samples/go/hr/main.go

@@ -70,8 +70,8 @@ func addPerson(ds dataset.Dataset) {
 
 	np := types.NewStruct("Person", map[string]types.Value{
 		"id":    types.Number(id),
-		"name":  types.NewString(flag.Arg(2)),
-		"title": types.NewString(flag.Arg(3)),
+		"name":  types.String(flag.Arg(2)),
+		"title": types.String(flag.Arg(3)),
 	})
 
 	ds.Commit(getPersons(ds).Set(types.Number(id), np))
@@ -87,9 +87,9 @@ func listPersons(ds dataset.Dataset) {
 	d.IterAll(func(k, v types.Value) {
 		s := v.(types.Struct)
 		fmt.Printf("%s (id: %d, title: %s)\n",
-			s.Get("name").(types.String).String(),
+			s.Get("name"),
 			uint64(s.Get("id").(types.Number)),
-			s.Get("title").(types.String).String())
+			s.Get("title"))
 	})
 }
 

samples/go/test_util/util_test.go

@@ -21,7 +21,7 @@ type LibTestSuite struct {
 }
 
 func (suite *LibTestSuite) TestPrimitiveTypes() {
-	suite.EqualValues(types.NewString("expected"), util.NomsValueFromDecodedJSON("expected", false))
+	suite.EqualValues(types.String("expected"), util.NomsValueFromDecodedJSON("expected", false))
 	suite.EqualValues(types.Bool(false), util.NomsValueFromDecodedJSON(false, false))
 	suite.EqualValues(types.Number(1.7), util.NomsValueFromDecodedJSON(1.7, false))
 	suite.False(util.NomsValueFromDecodedJSON(1.7, false).Equals(types.Bool(true)))
@@ -44,14 +44,14 @@ func (suite *LibTestSuite) TestCompositeTypes() {
 	//  "map": {"nested": "string"}
 	// }
 	m := types.NewMap(
-		types.NewString("string"),
-		types.NewString("string"),
-		types.NewString("list"),
+		types.String("string"),
+		types.String("string"),
+		types.String("list"),
 		types.NewList().Append(types.Bool(false)).Append(types.Bool(true)),
-		types.NewString("map"),
+		types.String("map"),
 		types.NewMap(
-			types.NewString("nested"),
-			types.NewString("string")))
+			types.String("nested"),
+			types.String("string")))
 	o := util.NomsValueFromDecodedJSON(map[string]interface{}{
 		"string": "string",
 		"list":   []interface{}{false, true},
@@ -67,10 +67,10 @@ func (suite *LibTestSuite) TestCompositeTypeWithStruct() {
 	//  "struct": {"nested": "string"}
 	// }
 	tstruct := types.NewStruct("", map[string]types.Value{
-		"string": types.NewString("string"),
+		"string": types.String("string"),
 		"list":   types.NewList().Append(types.Bool(false)).Append(types.Bool(true)),
 		"struct": types.NewStruct("", map[string]types.Value{
-			"nested": types.NewString("string"),
+			"nested": types.String("string"),
 		}),
 	})
 	o := util.NomsValueFromDecodedJSON(map[string]interface{}{

samples/go/util/util.go

@@ -28,7 +28,7 @@ import (
 func NomsValueFromDecodedJSON(o interface{}, useStruct bool) types.Value {
 	switch o := o.(type) {
 	case string:
-		return types.NewString(o)
+		return types.String(o)
 	case bool:
 		return types.Bool(o)
 	case float64:
@@ -61,7 +61,7 @@ func NomsValueFromDecodedJSON(o interface{}, useStruct bool) types.Value {
 			for k, v := range o {
 				nv := NomsValueFromDecodedJSON(v, useStruct)
 				if nv != nil {
-					kv = append(kv, types.NewString(k), nv)
+					kv = append(kv, types.String(k), nv)
 				}
 			}
 			v = types.NewMap(kv...)