Speedup and cleanup vom encoder, some bugfixes. This brings the vom Encoder implementation into a reasonable state, performance-wise. The technique is the same as on the decoder side: https://vanadium-review.googlesource.com/#/q/topic:toddw-fastdec Also fixed a bug in the handling of bytes in vdl.newPipe. Added a bunch of comments in v.io/v23/vdl/pipe.go to describe the general mechanism. The important files to look at are under: v.io/v23/vdl v.io/v23/vom v.io/v23/verror v.io/x/ref/lib/vdl/codegen/golang Here are the encoding benchmarks. Note that there is higher variance for these numbers than the decoder numbers, since encoding requires allocations on the output buffer. Our solution to that will be chunked encoding, which isn't implemented here. benchmark old ns/op new ns/op delta Vom___Encode_____XNumber 6647 4216 -36.57% Vom___EncodeMany_XNumber 472 428 -9.32% Vom___Encode_____VNumber 6482 5542 -14.50% Vom___EncodeMany_VNumber 176 174 -1.14% Vom___Encode_____XStringSmall 6862 6531 -4.82% Vom___EncodeMany_XStringSmall 527 460 -12.71% Vom___Encode_____VStringSmall 6257 5685 -9.14% Vom___EncodeMany_VStringSmall 196 188 -4.08% Vom___Encode_____XStringLarge 133510 120660 -9.62% Vom___EncodeMany_XStringLarge 55130 52237 -5.25% Vom___Encode_____VStringLarge 130751 129680 -0.82% Vom___EncodeMany_VStringLarge 53851 51242 -4.84% Vom___Encode_____VEnum 7093 6172 -12.98% Vom___EncodeMany_VEnum 191 183 -4.19% Vom___Encode_____XByteListSmall 7351 6873 -6.50% Vom___EncodeMany_XByteListSmall 579 472 -18.48% Vom___Encode_____VByteListSmall 6623 6157 -7.04% Vom___EncodeMany_VByteListSmall 187 177 -5.35% Vom___Encode_____XByteListLarge 104355 104017 -0.32% Vom___EncodeMany_XByteListLarge 8676 8696 +0.23% Vom___Encode_____VByteListLarge 97597 100401 +2.87% Vom___EncodeMany_VByteListLarge 8052 8231 +2.22% Vom___Encode_____XByteArray 7364 7530 +2.25% Vom___EncodeMany_XByteArray 745 749 +0.54% Vom___Encode_____VByteArray 6595 6139 -6.91% Vom___EncodeMany_VByteArray 215 202 -6.05% Vom___Encode_____XArray 8624 7307 -15.27% Vom___EncodeMany_XArray 1266 630 -50.24% Vom___Encode_____VArray 7358 6523 -11.35% Vom___EncodeMany_VArray 370 274 -25.95% Vom___Encode_____XListSmall 8184 6991 -14.58% Vom___EncodeMany_XListSmall 1505 688 -54.29% Vom___Encode_____VListSmall 7000 6308 -9.89% Vom___EncodeMany_VListSmall 390 288 -26.15% Vom___Encode_____XListLarge 21629416 4103590 -81.03% Vom___EncodeMany_XListLarge 20971508 3440893 -83.59% Vom___Encode_____VListLarge 4816700 2821262 -41.43% Vom___EncodeMany_VListLarge 4226822 2257347 -46.59% Vom___Encode_____XListAnySmall 20538 20456 -0.40% Vom___EncodeMany_XListAnySmall 11473 10555 -8.00% Vom___Encode_____VListAnySmall 17542 13722 -21.78% Vom___EncodeMany_VListAnySmall 9502 5963 -37.24% Vom___Encode_____XListAnyLarge 242633472 186445853 -23.16% Vom___EncodeMany_XListAnyLarge 231676344 184135888 -20.52% Vom___Encode_____VListAnyLarge 243393646 232625450 -4.42% Vom___EncodeMany_VListAnyLarge 204297618 208020229 +1.82% Vom___Encode_____VSet 7379 6520 -11.64% Vom___EncodeMany_VSet 539 435 -19.29% Vom___Encode_____XMap 10599 9060 -14.52% Vom___EncodeMany_XMap 3338 2743 -17.83% Vom___Encode_____VMap 6516 7004 +7.49% Vom___EncodeMany_VMap 719 527 -26.70% Vom___Encode_____XSmallStruct 11613 10277 -11.50% Vom___EncodeMany_XSmallStruct 2094 1630 -22.16% Vom___Encode_____VSmallStruct 9404 8227 -12.52% Vom___EncodeMany_VSmallStruct 470 405 -13.83% Vom___Encode_____XLargeStruct 63816 51583 -19.17% Vom___EncodeMany_XLargeStruct 37361 28332 -24.17% Vom___Encode_____VLargeStruct 37287 32095 -13.92% Vom___EncodeMany_VLargeStruct 11101 9271 -16.49% Vom___Encode_____XLargeStructZero 43606 40770 -6.50% Vom___EncodeMany_XLargeStructZero 19131 17869 -6.60% Vom___Encode_____VLargeStructZero 23724 23690 -0.14% Vom___EncodeMany_VLargeStructZero 224 217 -3.12% Vom___Encode_____VSmallUnion 9225 7531 -18.36% Vom___EncodeMany_VSmallUnion 266 227 -14.66% Vom___Encode_____Time 9340 10026 +7.34% Vom___EncodeMany_Time 1794 1732 -3.46% Vom___Encode_____Blessings 41833 38908 -6.99% Vom___EncodeMany_Blessings 5743 5291 -7.87% Vom___Encode_____RPCRequestZero 50452 47035 -6.77% Vom___EncodeMany_RPCRequestZero 217 208 -4.15% Vom___Encode_____RPCRequestFull 63186 56772 -10.15% Vom___EncodeMany_RPCRequestFull 5448 4803 -11.84% Vom___Encode_____RPCResponseZero 51641 45973 -10.98% Vom___EncodeMany_RPCResponseZero 809 831 +2.72% Vom___Encode_____RPCResponseFull 101767 105144 +3.32% Vom___EncodeMany_RPCResponseFull 57135 55317 -3.18% MultiPart: 3/5 Change-Id: I2d407d1affa272083c9290dbd182b0c769fc2968

commit: 1eba705399f2b205790e7586496ef247ed5218d4 [log] [tgz]
author: Todd Wang <toddw@google.com> Tue May 24 17:57:25 2016 -0700
committer: Todd Wang <toddw@google.com> Wed May 25 20:32:45 2016 +0000
tree: 849272d64a47787e7f5fd72e42b0a34dbf22dcfe
parent: 19ad3429d134c1b9cfc7af9620cc94668bb4290c [diff]
diff --git a/cmd/sb/internal/demodb/demodb.vdl.go b/cmd/sb/internal/demodb/demodb.vdl.go
index 90e4370..a2c3940 100644
--- a/cmd/sb/internal/demodb/demodb.vdl.go
+++ b/cmd/sb/internal/demodb/demodb.vdl.go

@@ -41,58 +41,22 @@
 		return err
 	}
 	if x.Street != "" {
-		if err := enc.NextField("Street"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Street); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Street", vdl.StringType, x.Street); err != nil {
 			return err
 		}
 	}
 	if x.City != "" {
-		if err := enc.NextField("City"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.City); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("City", vdl.StringType, x.City); err != nil {
 			return err
 		}
 	}
 	if x.State != "" {
-		if err := enc.NextField("State"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.State); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("State", vdl.StringType, x.State); err != nil {
 			return err
 		}
 	}
 	if x.Zip != "" {
-		if err := enc.NextField("Zip"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Zip); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Zip", vdl.StringType, x.Zip); err != nil {
 			return err
 		}
 	}
@@ -209,13 +173,10 @@
 }
 
 func (x CreditAgency) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_enum_2); err != nil {
+	if err := enc.WriteValueString(__VDLType_enum_2, x.String()); err != nil {
 		return err
 	}
-	if err := enc.EncodeString(x.String()); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *CreditAgency) VDLRead(dec vdl.Decoder) error {
@@ -282,13 +243,10 @@
 }
 
 func (x ExperianRating) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_enum_3); err != nil {
+	if err := enc.WriteValueString(__VDLType_enum_3, x.String()); err != nil {
 		return err
 	}
-	if err := enc.EncodeString(x.String()); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *ExperianRating) VDLRead(dec vdl.Decoder) error {
@@ -321,16 +279,7 @@
 		return err
 	}
 	if x.Rating != 0 {
-		if err := enc.NextField("Rating"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.ByteType); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.Rating)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("Rating", vdl.ByteType, uint64(x.Rating)); err != nil {
 			return err
 		}
 	}
@@ -386,10 +335,7 @@
 		return err
 	}
 	if x.Rating != ExperianRatingGood {
-		if err := enc.NextField("Rating"); err != nil {
-			return err
-		}
-		if err := x.Rating.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueString("Rating", __VDLType_enum_3, x.Rating.String()); err != nil {
 			return err
 		}
 	}
@@ -447,16 +393,7 @@
 		return err
 	}
 	if x.Rating != 0 {
-		if err := enc.NextField("Rating"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int16Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(x.Rating)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("Rating", vdl.Int16Type, int64(x.Rating)); err != nil {
 			return err
 		}
 	}
@@ -667,10 +604,7 @@
 		return err
 	}
 	if x.Agency != CreditAgencyEquifax {
-		if err := enc.NextField("Agency"); err != nil {
-			return err
-		}
-		if err := x.Agency.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueString("Agency", __VDLType_enum_2, x.Agency.String()); err != nil {
 			return err
 		}
 	}
@@ -761,44 +695,17 @@
 		return err
 	}
 	if x.Name != "" {
-		if err := enc.NextField("Name"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Name); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Name", vdl.StringType, x.Name); err != nil {
 			return err
 		}
 	}
 	if x.Id != 0 {
-		if err := enc.NextField("Id"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(x.Id); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("Id", vdl.Int64Type, x.Id); err != nil {
 			return err
 		}
 	}
 	if x.Active {
-		if err := enc.NextField("Active"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.Active); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("Active", vdl.BoolType, x.Active); err != nil {
 			return err
 		}
 	}
@@ -899,44 +806,17 @@
 		return err
 	}
 	if x.CustId != 0 {
-		if err := enc.NextField("CustId"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(x.CustId); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("CustId", vdl.Int64Type, x.CustId); err != nil {
 			return err
 		}
 	}
 	if x.InvoiceNum != 0 {
-		if err := enc.NextField("InvoiceNum"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(x.InvoiceNum); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("InvoiceNum", vdl.Int64Type, x.InvoiceNum); err != nil {
 			return err
 		}
 	}
 	if x.Amount != 0 {
-		if err := enc.NextField("Amount"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(x.Amount); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("Amount", vdl.Int64Type, x.Amount); err != nil {
 			return err
 		}
 	}
@@ -1026,128 +906,47 @@
 		return err
 	}
 	if x.B != 0 {
-		if err := enc.NextField("B"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.ByteType); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.B)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("B", vdl.ByteType, uint64(x.B)); err != nil {
 			return err
 		}
 	}
 	if x.Ui16 != 0 {
-		if err := enc.NextField("Ui16"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint16Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.Ui16)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("Ui16", vdl.Uint16Type, uint64(x.Ui16)); err != nil {
 			return err
 		}
 	}
 	if x.Ui32 != 0 {
-		if err := enc.NextField("Ui32"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.Ui32)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("Ui32", vdl.Uint32Type, uint64(x.Ui32)); err != nil {
 			return err
 		}
 	}
 	if x.Ui64 != 0 {
-		if err := enc.NextField("Ui64"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.Ui64); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("Ui64", vdl.Uint64Type, x.Ui64); err != nil {
 			return err
 		}
 	}
 	if x.I16 != 0 {
-		if err := enc.NextField("I16"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int16Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(x.I16)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("I16", vdl.Int16Type, int64(x.I16)); err != nil {
 			return err
 		}
 	}
 	if x.I32 != 0 {
-		if err := enc.NextField("I32"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(x.I32)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("I32", vdl.Int32Type, int64(x.I32)); err != nil {
 			return err
 		}
 	}
 	if x.I64 != 0 {
-		if err := enc.NextField("I64"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(x.I64); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("I64", vdl.Int64Type, x.I64); err != nil {
 			return err
 		}
 	}
 	if x.F32 != 0 {
-		if err := enc.NextField("F32"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Float32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeFloat(float64(x.F32)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueFloat("F32", vdl.Float32Type, float64(x.F32)); err != nil {
 			return err
 		}
 	}
 	if x.F64 != 0 {
-		if err := enc.NextField("F64"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Float64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeFloat(x.F64); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueFloat("F64", vdl.Float64Type, x.F64); err != nil {
 			return err
 		}
 	}
@@ -1292,16 +1091,7 @@
 	if err := enc.StartValue(__VDLType_union_12); err != nil {
 		return err
 	}
-	if err := enc.NextField("Title"); err != nil {
-		return err
-	}
-	if err := enc.StartValue(vdl.StringType); err != nil {
-		return err
-	}
-	if err := enc.EncodeString(x.Value); err != nil {
-		return err
-	}
-	if err := enc.FinishValue(); err != nil {
+	if err := enc.NextFieldValueString("Title", vdl.StringType, x.Value); err != nil {
 		return err
 	}
 	if err := enc.NextField(""); err != nil {
@@ -1314,16 +1104,7 @@
 	if err := enc.StartValue(__VDLType_union_12); err != nil {
 		return err
 	}
-	if err := enc.NextField("Value"); err != nil {
-		return err
-	}
-	if err := enc.StartValue(vdl.Int64Type); err != nil {
-		return err
-	}
-	if err := enc.EncodeInt(x.Value); err != nil {
-		return err
-	}
-	if err := enc.FinishValue(); err != nil {
+	if err := enc.NextFieldValueInt("Value", vdl.Int64Type, x.Value); err != nil {
 		return err
 	}
 	if err := enc.NextField(""); err != nil {
@@ -1398,16 +1179,7 @@
 		return err
 	}
 	if x.Name != "" {
-		if err := enc.NextField("Name"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Name); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Name", vdl.StringType, x.Name); err != nil {
 			return err
 		}
 	}
@@ -1602,17 +1374,8 @@
 	if err := enc.StartValue(__VDLType_array_16); err != nil {
 		return err
 	}
-	for i := 0; i < 2; i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x[i]); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueString(vdl.StringType, elem); err != nil {
 			return err
 		}
 	}
@@ -1722,17 +1485,8 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(x[i])); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueInt(vdl.Int32Type, int64(elem)); err != nil {
 			return err
 		}
 	}
@@ -1750,16 +1504,7 @@
 		return err
 	}
 	for key := range x {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(key)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextEntryValueInt(vdl.Int32Type, int64(key)); err != nil {
 			return err
 		}
 	}
@@ -1777,25 +1522,10 @@
 		return err
 	}
 	for key, elem := range x {
-		if err := enc.NextEntry(false); err != nil {
+		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
 			return err
 		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(key); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(elem)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.WriteValueInt(vdl.Int32Type, int64(elem)); err != nil {
 			return err
 		}
 	}
@@ -2050,11 +1780,9 @@
 			return err
 		}
 		enc.SetNextStartValueIsOptional()
-
 		if err := x.Maybe.VDLWrite(enc); err != nil {
 			return err
 		}
-
 	}
 	if len(x.Rec) != 0 {
 		if err := enc.NextField("Rec"); err != nil {
@@ -2225,16 +1953,7 @@
 	if err := enc.StartValue(__VDLType_union_27); err != nil {
 		return err
 	}
-	if err := enc.NextField("ActScore"); err != nil {
-		return err
-	}
-	if err := enc.StartValue(vdl.Uint16Type); err != nil {
-		return err
-	}
-	if err := enc.EncodeUint(uint64(x.Value)); err != nil {
-		return err
-	}
-	if err := enc.FinishValue(); err != nil {
+	if err := enc.NextFieldValueUint("ActScore", vdl.Uint16Type, uint64(x.Value)); err != nil {
 		return err
 	}
 	if err := enc.NextField(""); err != nil {
@@ -2247,16 +1966,7 @@
 	if err := enc.StartValue(__VDLType_union_27); err != nil {
 		return err
 	}
-	if err := enc.NextField("SatScore"); err != nil {
-		return err
-	}
-	if err := enc.StartValue(vdl.Uint16Type); err != nil {
-		return err
-	}
-	if err := enc.EncodeUint(uint64(x.Value)); err != nil {
-		return err
-	}
-	if err := enc.FinishValue(); err != nil {
+	if err := enc.NextFieldValueUint("SatScore", vdl.Uint16Type, uint64(x.Value)); err != nil {
 		return err
 	}
 	if err := enc.NextField(""); err != nil {
@@ -2335,16 +2045,7 @@
 		return err
 	}
 	if x.Name != "" {
-		if err := enc.NextField("Name"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Name); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Name", vdl.StringType, x.Name); err != nil {
 			return err
 		}
 	}
@@ -2441,16 +2142,7 @@
 		return err
 	}
 	if x.NameOfType != "" {
-		if err := enc.NextField("NameOfType"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.NameOfType); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("NameOfType", vdl.StringType, x.NameOfType); err != nil {
 			return err
 		}
 	}

diff --git a/cmd/vom/main.vdl.go b/cmd/vom/main.vdl.go
index 5489c71..a94cc4e 100644
--- a/cmd/vom/main.vdl.go
+++ b/cmd/vom/main.vdl.go

@@ -69,13 +69,10 @@
 }
 
 func (x dataRep) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_enum_1); err != nil {
+	if err := enc.WriteValueString(__VDLType_enum_1, x.String()); err != nil {
 		return err
 	}
-	if err := enc.EncodeString(x.String()); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *dataRep) VDLRead(dec vdl.Decoder) error {

diff --git a/cmd/vrpc/internal/internal.vdl.go b/cmd/vrpc/internal/internal.vdl.go
index 0e9a5a6..dbe5a69 100644
--- a/cmd/vrpc/internal/internal.vdl.go
+++ b/cmd/vrpc/internal/internal.vdl.go

@@ -40,30 +40,12 @@
 		return err
 	}
 	if x.X != 0 {
-		if err := enc.NextField("X"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(x.X)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("X", vdl.Int32Type, int64(x.X)); err != nil {
 			return err
 		}
 	}
 	if x.Y != 0 {
-		if err := enc.NextField("Y"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(x.Y)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("Y", vdl.Int32Type, int64(x.Y)); err != nil {
 			return err
 		}
 	}
@@ -123,17 +105,8 @@
 	if err := enc.StartValue(__VDLType_array_2); err != nil {
 		return err
 	}
-	for i := 0; i < 2; i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(x[i])); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueInt(vdl.Int32Type, int64(elem)); err != nil {
 			return err
 		}
 	}

diff --git a/examples/rps/rps.vdl.go b/examples/rps/rps.vdl.go
index 66f0dad..760a8bf 100644
--- a/examples/rps/rps.vdl.go
+++ b/examples/rps/rps.vdl.go

@@ -59,16 +59,7 @@
 		return err
 	}
 	if x.Id != "" {
-		if err := enc.NextField("Id"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Id); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Id", vdl.StringType, x.Id); err != nil {
 			return err
 		}
 	}
@@ -118,13 +109,10 @@
 }
 
 func (x GameTypeTag) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_byte_2); err != nil {
+	if err := enc.WriteValueUint(__VDLType_byte_2, uint64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeUint(uint64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *GameTypeTag) VDLRead(dec vdl.Decoder) error {
@@ -157,24 +145,12 @@
 		return err
 	}
 	if x.NumRounds != 0 {
-		if err := enc.NextField("NumRounds"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(x.NumRounds)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("NumRounds", vdl.Int32Type, int64(x.NumRounds)); err != nil {
 			return err
 		}
 	}
 	if x.GameType != 0 {
-		if err := enc.NextField("GameType"); err != nil {
-			return err
-		}
-		if err := x.GameType.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueUint("GameType", __VDLType_byte_2, uint64(x.GameType)); err != nil {
 			return err
 		}
 	}
@@ -314,16 +290,7 @@
 	if err := enc.StartValue(__VDLType_union_5); err != nil {
 		return err
 	}
-	if err := enc.NextField("Move"); err != nil {
-		return err
-	}
-	if err := enc.StartValue(vdl.StringType); err != nil {
-		return err
-	}
-	if err := enc.EncodeString(x.Value); err != nil {
-		return err
-	}
-	if err := enc.FinishValue(); err != nil {
+	if err := enc.NextFieldValueString("Move", vdl.StringType, x.Value); err != nil {
 		return err
 	}
 	if err := enc.NextField(""); err != nil {
@@ -401,17 +368,8 @@
 	if err := enc.StartValue(__VDLType_array_6); err != nil {
 		return err
 	}
-	for i := 0; i < 2; i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x[i]); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueString(vdl.StringType, elem); err != nil {
 			return err
 		}
 	}
@@ -458,13 +416,10 @@
 }
 
 func (x WinnerTag) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_byte_7); err != nil {
+	if err := enc.WriteValueUint(__VDLType_byte_7, uint64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeUint(uint64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *WinnerTag) VDLRead(dec vdl.Decoder) error {
@@ -523,24 +478,12 @@
 		}
 	}
 	if x.Comment != "" {
-		if err := enc.NextField("Comment"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Comment); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Comment", vdl.StringType, x.Comment); err != nil {
 			return err
 		}
 	}
 	if x.Winner != 0 {
-		if err := enc.NextField("Winner"); err != nil {
-			return err
-		}
-		if err := x.Winner.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueUint("Winner", __VDLType_byte_7, uint64(x.Winner)); err != nil {
 			return err
 		}
 	}
@@ -682,16 +625,7 @@
 		}
 	}
 	if x.Judge != "" {
-		if err := enc.NextField("Judge"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Judge); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Judge", vdl.StringType, x.Judge); err != nil {
 			return err
 		}
 	}
@@ -736,10 +670,7 @@
 		}
 	}
 	if x.Winner != 0 {
-		if err := enc.NextField("Winner"); err != nil {
-			return err
-		}
-		if err := x.Winner.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueUint("Winner", __VDLType_byte_7, uint64(x.Winner)); err != nil {
 			return err
 		}
 	}
@@ -756,17 +687,8 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x[i]); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueString(vdl.StringType, elem); err != nil {
 			return err
 		}
 	}
@@ -783,11 +705,11 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
+	for _, elem := range x {
 		if err := enc.NextEntry(false); err != nil {
 			return err
 		}
-		if err := x[i].VDLWrite(enc); err != nil {
+		if err := elem.VDLWrite(enc); err != nil {
 			return err
 		}
 	}
@@ -993,16 +915,7 @@
 	if err := enc.StartValue(__VDLType_union_13); err != nil {
 		return err
 	}
-	if err := enc.NextField("PlayerNum"); err != nil {
-		return err
-	}
-	if err := enc.StartValue(vdl.Int32Type); err != nil {
-		return err
-	}
-	if err := enc.EncodeInt(int64(x.Value)); err != nil {
-		return err
-	}
-	if err := enc.FinishValue(); err != nil {
+	if err := enc.NextFieldValueInt("PlayerNum", vdl.Int32Type, int64(x.Value)); err != nil {
 		return err
 	}
 	if err := enc.NextField(""); err != nil {
@@ -1015,16 +928,7 @@
 	if err := enc.StartValue(__VDLType_union_13); err != nil {
 		return err
 	}
-	if err := enc.NextField("OpponentName"); err != nil {
-		return err
-	}
-	if err := enc.StartValue(vdl.StringType); err != nil {
-		return err
-	}
-	if err := enc.EncodeString(x.Value); err != nil {
-		return err
-	}
-	if err := enc.FinishValue(); err != nil {
+	if err := enc.NextFieldValueString("OpponentName", vdl.StringType, x.Value); err != nil {
 		return err
 	}
 	if err := enc.NextField(""); err != nil {
@@ -1159,16 +1063,7 @@
 		return err
 	}
 	if x.YouWon {
-		if err := enc.NextField("YouWon"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.YouWon); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("YouWon", vdl.BoolType, x.YouWon); err != nil {
 			return err
 		}
 	}

diff --git a/examples/tunnel/tunnel.vdl.go b/examples/tunnel/tunnel.vdl.go
index 64b600b..397c070 100644
--- a/examples/tunnel/tunnel.vdl.go
+++ b/examples/tunnel/tunnel.vdl.go

@@ -43,30 +43,12 @@
 		return err
 	}
 	if x.Rows != 0 {
-		if err := enc.NextField("Rows"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint16Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.Rows)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("Rows", vdl.Uint16Type, uint64(x.Rows)); err != nil {
 			return err
 		}
 	}
 	if x.Cols != 0 {
-		if err := enc.NextField("Cols"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint16Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.Cols)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("Cols", vdl.Uint16Type, uint64(x.Cols)); err != nil {
 			return err
 		}
 	}
@@ -140,16 +122,7 @@
 		return err
 	}
 	if x.UsePty {
-		if err := enc.NextField("UsePty"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.UsePty); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("UsePty", vdl.BoolType, x.UsePty); err != nil {
 			return err
 		}
 	}
@@ -182,17 +155,8 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x[i]); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueString(vdl.StringType, elem); err != nil {
 			return err
 		}
 	}
@@ -373,16 +337,7 @@
 	if err := enc.StartValue(__VDLType_union_6); err != nil {
 		return err
 	}
-	if err := enc.NextField("Stdin"); err != nil {
-		return err
-	}
-	if err := enc.StartValue(__VDLType_list_5); err != nil {
-		return err
-	}
-	if err := enc.EncodeBytes(x.Value); err != nil {
-		return err
-	}
-	if err := enc.FinishValue(); err != nil {
+	if err := enc.NextFieldValueBytes("Stdin", __VDLType_list_5, x.Value); err != nil {
 		return err
 	}
 	if err := enc.NextField(""); err != nil {
@@ -519,16 +474,7 @@
 	if err := enc.StartValue(__VDLType_union_7); err != nil {
 		return err
 	}
-	if err := enc.NextField("Stdout"); err != nil {
-		return err
-	}
-	if err := enc.StartValue(__VDLType_list_5); err != nil {
-		return err
-	}
-	if err := enc.EncodeBytes(x.Value); err != nil {
-		return err
-	}
-	if err := enc.FinishValue(); err != nil {
+	if err := enc.NextFieldValueBytes("Stdout", __VDLType_list_5, x.Value); err != nil {
 		return err
 	}
 	if err := enc.NextField(""); err != nil {
@@ -541,16 +487,7 @@
 	if err := enc.StartValue(__VDLType_union_7); err != nil {
 		return err
 	}
-	if err := enc.NextField("Stderr"); err != nil {
-		return err
-	}
-	if err := enc.StartValue(__VDLType_list_5); err != nil {
-		return err
-	}
-	if err := enc.EncodeBytes(x.Value); err != nil {
-		return err
-	}
-	if err := enc.FinishValue(); err != nil {
+	if err := enc.NextFieldValueBytes("Stderr", __VDLType_list_5, x.Value); err != nil {
 		return err
 	}
 	if err := enc.NextField(""); err != nil {

diff --git a/lib/discovery/discovery.vdl.go b/lib/discovery/discovery.vdl.go
index 3c99e3a..652a9fb 100644
--- a/lib/discovery/discovery.vdl.go
+++ b/lib/discovery/discovery.vdl.go

@@ -35,13 +35,10 @@
 }
 
 func (x Uuid) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_list_1); err != nil {
+	if err := enc.WriteValueBytes(__VDLType_list_1, []byte(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeBytes([]byte(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *Uuid) VDLRead(dec vdl.Decoder) error {
@@ -65,13 +62,10 @@
 }
 
 func (x EncryptionAlgorithm) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_int32_2); err != nil {
+	if err := enc.WriteValueInt(__VDLType_int32_2, int64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeInt(int64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *EncryptionAlgorithm) VDLRead(dec vdl.Decoder) error {
@@ -96,13 +90,10 @@
 }
 
 func (x EncryptionKey) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_list_3); err != nil {
+	if err := enc.WriteValueBytes(__VDLType_list_3, []byte(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeBytes([]byte(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *EncryptionKey) VDLRead(dec vdl.Decoder) error {
@@ -126,13 +117,10 @@
 }
 
 func (x AdStatus) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_byte_4); err != nil {
+	if err := enc.WriteValueUint(__VDLType_byte_4, uint64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeUint(uint64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *AdStatus) VDLRead(dec vdl.Decoder) error {
@@ -158,13 +146,10 @@
 }
 
 func (x AdHash) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_array_5); err != nil {
+	if err := enc.WriteValueBytes(__VDLType_array_5, x[:]); err != nil {
 		return err
 	}
-	if err := enc.EncodeBytes([]byte(x[:])); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *AdHash) VDLRead(dec vdl.Decoder) error {
@@ -244,10 +229,7 @@
 		}
 	}
 	if x.EncryptionAlgorithm != 0 {
-		if err := enc.NextField("EncryptionAlgorithm"); err != nil {
-			return err
-		}
-		if err := x.EncryptionAlgorithm.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueInt("EncryptionAlgorithm", __VDLType_int32_2, int64(x.EncryptionAlgorithm)); err != nil {
 			return err
 		}
 	}
@@ -260,24 +242,12 @@
 		}
 	}
 	if x.Hash != (AdHash{}) {
-		if err := enc.NextField("Hash"); err != nil {
-			return err
-		}
-		if err := x.Hash.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueBytes("Hash", __VDLType_array_5, x.Hash[:]); err != nil {
 			return err
 		}
 	}
 	if x.TimestampNs != 0 {
-		if err := enc.NextField("TimestampNs"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(x.TimestampNs); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("TimestampNs", vdl.Int64Type, x.TimestampNs); err != nil {
 			return err
 		}
 	}
@@ -290,24 +260,12 @@
 		}
 	}
 	if x.Status != 0 {
-		if err := enc.NextField("Status"); err != nil {
-			return err
-		}
-		if err := x.Status.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueUint("Status", __VDLType_byte_4, uint64(x.Status)); err != nil {
 			return err
 		}
 	}
 	if x.Lost {
-		if err := enc.NextField("Lost"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.Lost); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("Lost", vdl.BoolType, x.Lost); err != nil {
 			return err
 		}
 	}
@@ -324,11 +282,8 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := x[i].VDLWrite(enc); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueBytes(__VDLType_list_3, []byte(elem)); err != nil {
 			return err
 		}
 	}
@@ -345,17 +300,8 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x[i]); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueString(vdl.StringType, elem); err != nil {
 			return err
 		}
 	}

diff --git a/lib/discovery/testdata/testdata.vdl.go b/lib/discovery/testdata/testdata.vdl.go
index 29dd48a..7ad0f1d 100644
--- a/lib/discovery/testdata/testdata.vdl.go
+++ b/lib/discovery/testdata/testdata.vdl.go

@@ -53,16 +53,7 @@
 		}
 	}
 	if len(x.Packed) != 0 {
-		if err := enc.NextField("Packed"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(__VDLType_list_3); err != nil {
-			return err
-		}
-		if err := enc.EncodeBytes(x.Packed); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBytes("Packed", __VDLType_list_3, x.Packed); err != nil {
 			return err
 		}
 	}
@@ -79,17 +70,8 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x[i]); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueString(vdl.StringType, elem); err != nil {
 			return err
 		}
 	}
@@ -184,10 +166,7 @@
 		return err
 	}
 	if x.Algo != 0 {
-		if err := enc.NextField("Algo"); err != nil {
-			return err
-		}
-		if err := x.Algo.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueInt("Algo", __VDLType_int32_5, int64(x.Algo)); err != nil {
 			return err
 		}
 	}
@@ -200,16 +179,7 @@
 		}
 	}
 	if len(x.Packed) != 0 {
-		if err := enc.NextField("Packed"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(__VDLType_list_3); err != nil {
-			return err
-		}
-		if err := enc.EncodeBytes(x.Packed); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBytes("Packed", __VDLType_list_3, x.Packed); err != nil {
 			return err
 		}
 	}
@@ -226,11 +196,8 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := x[i].VDLWrite(enc); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueBytes(__VDLType_list_7, []byte(elem)); err != nil {
 			return err
 		}
 	}
@@ -325,30 +292,12 @@
 		return err
 	}
 	if x.In != "" {
-		if err := enc.NextField("In"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.In); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("In", vdl.StringType, x.In); err != nil {
 			return err
 		}
 	}
 	if x.Want != "" {
-		if err := enc.NextField("Want"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Want); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Want", vdl.StringType, x.Want); err != nil {
 			return err
 		}
 	}

diff --git a/lib/raft/raft.vdl.go b/lib/raft/raft.vdl.go
index 20f346f..0dddf77 100644
--- a/lib/raft/raft.vdl.go
+++ b/lib/raft/raft.vdl.go

@@ -34,13 +34,10 @@
 }
 
 func (x Term) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_uint64_1); err != nil {
+	if err := enc.WriteValueUint(__VDLType_uint64_1, uint64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeUint(uint64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *Term) VDLRead(dec vdl.Decoder) error {
@@ -69,13 +66,10 @@
 }
 
 func (x Index) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_uint64_2); err != nil {
+	if err := enc.WriteValueUint(__VDLType_uint64_2, uint64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeUint(uint64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *Index) VDLRead(dec vdl.Decoder) error {
@@ -124,46 +118,22 @@
 		return err
 	}
 	if x.Term != 0 {
-		if err := enc.NextField("Term"); err != nil {
-			return err
-		}
-		if err := x.Term.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueUint("Term", __VDLType_uint64_1, uint64(x.Term)); err != nil {
 			return err
 		}
 	}
 	if x.Index != 0 {
-		if err := enc.NextField("Index"); err != nil {
-			return err
-		}
-		if err := x.Index.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueUint("Index", __VDLType_uint64_2, uint64(x.Index)); err != nil {
 			return err
 		}
 	}
 	if len(x.Cmd) != 0 {
-		if err := enc.NextField("Cmd"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(__VDLType_list_4); err != nil {
-			return err
-		}
-		if err := enc.EncodeBytes(x.Cmd); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBytes("Cmd", __VDLType_list_4, x.Cmd); err != nil {
 			return err
 		}
 	}
 	if x.Type != 0 {
-		if err := enc.NextField("Type"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.ByteType); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.Type)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("Type", vdl.ByteType, uint64(x.Type)); err != nil {
 			return err
 		}
 	}

diff --git a/lib/security/bcrypter/bcrypter.vdl.go b/lib/security/bcrypter/bcrypter.vdl.go
index 140d792..ca7f9de 100644
--- a/lib/security/bcrypter/bcrypter.vdl.go
+++ b/lib/security/bcrypter/bcrypter.vdl.go

@@ -55,16 +55,7 @@
 		return err
 	}
 	if x.PatternId != "" {
-		if err := enc.NextField("PatternId"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.PatternId); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("PatternId", vdl.StringType, x.PatternId); err != nil {
 			return err
 		}
 	}
@@ -90,25 +81,10 @@
 		return err
 	}
 	for key, elem := range x {
-		if err := enc.NextEntry(false); err != nil {
+		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
 			return err
 		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(key); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
-			return err
-		}
-		if err := enc.StartValue(__VDLType_list_3); err != nil {
-			return err
-		}
-		if err := enc.EncodeBytes(elem); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.WriteValueBytes(__VDLType_list_3, elem); err != nil {
 			return err
 		}
 	}
@@ -210,30 +186,12 @@
 		return err
 	}
 	if x.Blessing != "" {
-		if err := enc.NextField("Blessing"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Blessing); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Blessing", vdl.StringType, x.Blessing); err != nil {
 			return err
 		}
 	}
 	if len(x.Params) != 0 {
-		if err := enc.NextField("Params"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(__VDLType_list_3); err != nil {
-			return err
-		}
-		if err := enc.EncodeBytes(x.Params); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBytes("Params", __VDLType_list_3, x.Params); err != nil {
 			return err
 		}
 	}
@@ -323,16 +281,7 @@
 		return err
 	}
 	if x.Blessing != "" {
-		if err := enc.NextField("Blessing"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Blessing); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Blessing", vdl.StringType, x.Blessing); err != nil {
 			return err
 		}
 	}
@@ -365,17 +314,8 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(__VDLType_list_3); err != nil {
-			return err
-		}
-		if err := enc.EncodeBytes(x[i]); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueBytes(__VDLType_list_3, elem); err != nil {
 			return err
 		}
 	}

diff --git a/lib/security/security.vdl.go b/lib/security/security.vdl.go
index a4388c9..a28624a 100644
--- a/lib/security/security.vdl.go
+++ b/lib/security/security.vdl.go

@@ -38,16 +38,7 @@
 		return err
 	}
 	for key, elem := range x {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(key); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
 			return err
 		}
 		if err := __VDLWriteAnon_list_1(enc, elem); err != nil {
@@ -67,11 +58,8 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := x[i].VDLWrite(enc); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueString(__VDLType_string_3, string(elem)); err != nil {
 			return err
 		}
 	}
@@ -142,13 +130,10 @@
 }
 
 func (x dischargeCacheKey) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_array_4); err != nil {
+	if err := enc.WriteValueBytes(__VDLType_array_4, x[:]); err != nil {
 		return err
 	}
-	if err := enc.EncodeBytes([]byte(x[:])); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *dischargeCacheKey) VDLRead(dec vdl.Decoder) error {
@@ -336,16 +321,7 @@
 		}
 	}
 	if x.CacheKeyFormat != 0 {
-		if err := enc.NextField("CacheKeyFormat"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.CacheKeyFormat)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("CacheKeyFormat", vdl.Uint32Type, uint64(x.CacheKeyFormat)); err != nil {
 			return err
 		}
 	}
@@ -363,10 +339,7 @@
 		return err
 	}
 	for key, elem := range x {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := key.VDLWrite(enc); err != nil {
+		if err := enc.NextEntryValueString(__VDLType_string_3, string(key)); err != nil {
 			return err
 		}
 		var wire security.WireBlessings
@@ -391,10 +364,7 @@
 		return err
 	}
 	for key, elem := range x {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := key.VDLWrite(enc); err != nil {
+		if err := enc.NextEntryValueBytes(__VDLType_array_4, key[:]); err != nil {
 			return err
 		}
 		var wire security.WireDischarge
@@ -427,10 +397,7 @@
 		return err
 	}
 	for key, elem := range x {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := key.VDLWrite(enc); err != nil {
+		if err := enc.NextEntryValueBytes(__VDLType_array_4, key[:]); err != nil {
 			return err
 		}
 		if err := elem.VDLWrite(enc); err != nil {

diff --git a/lib/security/serialization/serialization.vdl.go b/lib/security/serialization/serialization.vdl.go
index 804732c..93e6e32 100644
--- a/lib/security/serialization/serialization.vdl.go
+++ b/lib/security/serialization/serialization.vdl.go

@@ -36,16 +36,7 @@
 		return err
 	}
 	if x.ChunkSizeBytes != 0 {
-		if err := enc.NextField("ChunkSizeBytes"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(x.ChunkSizeBytes); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("ChunkSizeBytes", vdl.Int64Type, x.ChunkSizeBytes); err != nil {
 			return err
 		}
 	}
@@ -95,13 +86,10 @@
 }
 
 func (x HashCode) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_array_2); err != nil {
+	if err := enc.WriteValueBytes(__VDLType_array_2, x[:]); err != nil {
 		return err
 	}
-	if err := enc.EncodeBytes([]byte(x[:])); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *HashCode) VDLRead(dec vdl.Decoder) error {
@@ -181,10 +169,7 @@
 	if err := enc.StartValue(__VDLType_union_4); err != nil {
 		return err
 	}
-	if err := enc.NextField("Hash"); err != nil {
-		return err
-	}
-	if err := x.Value.VDLWrite(enc); err != nil {
+	if err := enc.NextFieldValueBytes("Hash", __VDLType_array_2, x.Value[:]); err != nil {
 		return err
 	}
 	if err := enc.NextField(""); err != nil {

diff --git a/lib/vdl/codegen/golang/reader.go b/lib/vdl/codegen/golang/reader.go
index 129bf47..89fbb04 100644
--- a/lib/vdl/codegen/golang/reader.go
+++ b/lib/vdl/codegen/golang/reader.go

@@ -133,7 +133,7 @@
 		// types to avoid an extra VDLRead method call, and appears before anonymous
 		// lists to avoid slow byte-at-a-time decoding.
 		return g.bodyBytes(tt, arg) + retnil
-	case !topLevel && tt.Name() != "" && !hasScalarInfo(tt):
+	case !topLevel && tt.Name() != "" && !g.hasScalarInfo(tt):
 		// Non-top-level named types call the VDLRead method defined on the arg.
 		// The top-level type is always named, and needs a real body generated.
 		// We let scalars drop through, to avoid the extra method call.
@@ -146,7 +146,7 @@
 		return g.bodyAnon(tt, arg)
 	}
 	// Handle each kind of type.
-	if hasScalarInfo(tt) {
+	if g.hasScalarInfo(tt) {
 		return g.bodyScalar(tt, arg) + retnil
 	}
 	switch kind {
@@ -216,12 +216,14 @@
 	}`, g.anonReaderName(tt), arg.Ptr())
 }
 
-func hasScalarInfo(tt *vdl.Type) bool {
-	_, _, exact := scalarInfo(tt)
+func (g *genRead) hasScalarInfo(tt *vdl.Type) bool {
+	_, _, exact := g.scalarInfo(tt)
 	return exact != nil
 }
 
-func scalarInfo(tt *vdl.Type) (method, params string, exact *vdl.Type) {
+// TODO(toddw): Change this to fastpathInfo and handle Bytes here as well, just
+// like the writer.  Also add Decoder.NextEntryValueBytes for symmetry.
+func (g *genRead) scalarInfo(tt *vdl.Type) (method, params string, exact *vdl.Type) {
 	bitlen := strconv.Itoa(tt.Kind().BitLen())
 	switch tt.Kind() {
 	case vdl.Bool:
@@ -240,7 +242,7 @@
 	return "", "", nil
 }
 
-func setEnum(argEnum, argLabel string) string {
+func (g *genRead) setEnum(argEnum, argLabel string) string {
 	return fmt.Sprintf(`
 	if err := %[1]s.Set(%[2]s); err != nil {
 		return err
@@ -248,7 +250,7 @@
 }
 
 func (g *genRead) bodyScalar(tt *vdl.Type, arg namedArg) string {
-	method, params, exact := scalarInfo(tt)
+	method, params, exact := g.scalarInfo(tt)
 	valueCast := "value"
 	if tt != exact {
 		// The types don't have an exact match, so we need a conversion.  This
@@ -271,7 +273,7 @@
 		return err
 	default:`, method, params)
 	if tt.Kind() == vdl.Enum {
-		s += setEnum(arg.Name, "value")
+		s += g.setEnum(arg.Name, "value")
 	} else {
 		s += fmt.Sprintf(`
 		%[1]s = %[2]s`, arg.Ref(), valueCast)
@@ -319,11 +321,12 @@
 	return s
 }
 
-func nextEntrySwitch(varName string, ttEntry *vdl.Type) (string, *vdl.Type) {
+func (g *genRead) nextEntrySwitch(varName string, ttEntry *vdl.Type) (string, *vdl.Type) {
 	s := `
 	switch done, err := dec.NextEntry(); {`
-	method, params, exact := scalarInfo(ttEntry)
-	if exact != nil {
+	method, params, exact := g.scalarInfo(ttEntry)
+	// TODO(toddw): Add fastpath support for native types with scalar wire types.
+	if exact != nil && !isNativeType(g.Env, ttEntry) {
 		s = fmt.Sprintf(`
 	switch done, %[1]s, err := dec.NextEntryValue%[2]s(%[3]s); {`, varName, method, params)
 	}
@@ -334,7 +337,7 @@
 	s := fmt.Sprintf(`
 	for index := 0; index < %[1]d; index++ {`, tt.Len())
 	elem := "elem"
-	switchLine, exact := nextEntrySwitch(elem, tt.Elem())
+	switchLine, exact := g.nextEntrySwitch(elem, tt.Elem())
 	s += switchLine + fmt.Sprintf(`
 		case err != nil:
 			return err
@@ -346,7 +349,7 @@
 	case exact == nil:
 		s += g.body(tt.Elem(), elemArg, false)
 	case tt.Elem().Kind() == vdl.Enum:
-		s += setEnum(elemArg.Name, elem)
+		s += g.setEnum(elemArg.Name, elem)
 	default:
 		if tt.Elem() != exact {
 			elem = typeGoWire(g.goData, tt.Elem()) + "(" + elem + ")"
@@ -374,7 +377,7 @@
 	}
 	for {`, arg.Ref(), typeGoWire(g.goData, tt))
 	elem := "elem"
-	switchLine, exact := nextEntrySwitch(elem, tt.Elem())
+	switchLine, exact := g.nextEntrySwitch(elem, tt.Elem())
 	s += switchLine + `
 		case err != nil:
 			return err
@@ -389,7 +392,7 @@
 			var %[1]s %[2]s%[3]s`, elem, typeGo(g.goData, tt.Elem()), elemBody)
 	case tt.Elem().Kind() == vdl.Enum:
 		s += fmt.Sprintf(`
-			var enum %[1]s%[2]s`, typeGo(g.goData, tt.Elem()), setEnum("enum", elem))
+			var enum %[1]s%[2]s`, typeGo(g.goData, tt.Elem()), g.setEnum("enum", elem))
 		elem = "enum"
 	case tt.Elem() != exact:
 		elem = typeGoWire(g.goData, tt.Elem()) + "(" + elem + ")"
@@ -408,7 +411,7 @@
   }
 	for {`, typeGoWire(g.goData, tt))
 	key := "key"
-	switchLine, exact := nextEntrySwitch(key, tt.Key())
+	switchLine, exact := g.nextEntrySwitch(key, tt.Key())
 	s += switchLine + fmt.Sprintf(`
 		case err != nil:
 			return err
@@ -424,7 +427,7 @@
 			var %[1]s %[2]s%[3]s`, key, typeGo(g.goData, tt.Key()), keyBody)
 	case tt.Key().Kind() == vdl.Enum:
 		s += fmt.Sprintf(`
-			var keyEnum %[1]s%[2]s`, typeGo(g.goData, tt.Key()), setEnum("keyEnum", key))
+			var keyEnum %[1]s%[2]s`, typeGo(g.goData, tt.Key()), g.setEnum("keyEnum", key))
 		key = "keyEnum"
 	case tt.Key() != exact:
 		key = typeGoWire(g.goData, tt.Key()) + "(" + key + ")"

diff --git a/lib/vdl/codegen/golang/writer.go b/lib/vdl/codegen/golang/writer.go
index 1191121..87ce8cc 100644
--- a/lib/vdl/codegen/golang/writer.go
+++ b/lib/vdl/codegen/golang/writer.go

@@ -6,6 +6,7 @@
 
 import (
 	"fmt"
+	"strings"
 
 	"v.io/v23/vdl"
 	"v.io/x/ref/lib/vdl/compile"
@@ -94,9 +95,12 @@
 	if err := enc.FinishValue(); err != nil {
 		return err
 	}`
+	retnil := ""
 	if topLevel {
 		fin = `
 	return enc.FinishValue()`
+		retnil = `
+	return nil`
 	}
 	// Handle special cases.  The ordering of the cases is very important.
 	switch {
@@ -115,16 +119,16 @@
 		// wire type.  Appears as early as possible, so that all subsequent cases
 		// have nativity handled correctly.
 		return g.bodyNative(tt, arg, skipNilCheck)
-	case !topLevel && tt.Name() != "":
+	case tt.IsBytes():
+		// Bytes call the fast Encoder.WriteValueBytes method.  Appears before named
+		// types to avoid an extra VDLWrite method call, and appears before
+		// anonymous lists to avoid slow byte-at-a-time encoding.
+		return g.bodyFastpath(tt, arg, false) + retnil
+	case !topLevel && tt.Name() != "" && !g.hasFastpath(tt, false):
 		// Non-top-level named types call the VDLWrite method defined on the arg.
 		// The top-level type is always named, and needs a real body generated.
-		// Appears before bytes, so that we use the defined method rather than
-		// re-generating extra code.
+		// We let fastpath types drop through, to avoid the extra method call.
 		return g.bodyCallVDLWrite(tt, arg, skipNilCheck)
-	case tt.IsBytes() && tt.Elem() == vdl.ByteType:
-		// Bytes use the special Encoder.EncodeBytes method.  Appears before
-		// anonymous types, to avoid processing bytes as a list or array.
-		return sta + g.bodyBytes(tt, arg) + fin
 	case !topLevel && (kind == vdl.List || kind == vdl.Set || kind == vdl.Map):
 		// Non-top-level anonymous types call the unexported __VDLWrite* functions
 		// generated in g.Gen, after the main VDLWrite method has been generated.
@@ -133,21 +137,12 @@
 		return g.bodyAnon(tt, arg)
 	}
 	// Handle each kind of type.
+	if g.hasFastpath(tt, false) {
+		// Don't perform native conversions, since they were already performed above.
+		// All scalar types have a fastpath.
+		return g.bodyFastpath(tt, arg, false) + retnil
+	}
 	switch kind {
-	case vdl.Bool:
-		return sta + g.bodyScalar(tt, vdl.BoolType, arg, "Bool") + fin
-	case vdl.String:
-		return sta + g.bodyScalar(tt, vdl.StringType, arg, "String") + fin
-	case vdl.Byte, vdl.Uint16, vdl.Uint32, vdl.Uint64:
-		return sta + g.bodyScalar(tt, vdl.Uint64Type, arg, "Uint") + fin
-	case vdl.Int8, vdl.Int16, vdl.Int32, vdl.Int64:
-		return sta + g.bodyScalar(tt, vdl.Int64Type, arg, "Int") + fin
-	case vdl.Float32, vdl.Float64:
-		return sta + g.bodyScalar(tt, vdl.Float64Type, arg, "Float") + fin
-	case vdl.TypeObject:
-		return g.bodyCallVDLWrite(tt, arg, skipNilCheck)
-	case vdl.Enum:
-		return sta + g.bodyEnum(tt, arg) + fin
 	case vdl.Array:
 		return sta + g.bodyArray(tt, arg) + fin
 	case vdl.List:
@@ -225,31 +220,89 @@
 	}`, g.anonWriterName(tt), arg.Ref())
 }
 
-func (g *genWrite) bodyScalar(tt, exact *vdl.Type, arg namedArg, method string) string {
-	param := arg.Ref()
+func (g *genWrite) hasFastpath(tt *vdl.Type, nativeConv bool) bool {
+	method, _, _ := g.fastpathInfo(tt, namedArg{}, nativeConv)
+	return method != ""
+}
+
+func (g *genWrite) fastpathInfo(tt *vdl.Type, arg namedArg, nativeConv bool) (method string, params []string, init string) {
+	kind := tt.Kind()
+	p1, p2 := "", ""
+	// When fastpathInfo is called in order to produce NextEntry* or NextField*
+	// methods, we must perform the native conversion if tt is a native type.
+	if nativeConv && isNativeType(g.Env, tt) {
+		init = fmt.Sprintf(`
+	var wire %[1]s
+	if err := %[1]sFromNative(&wire, %[2]s); err != nil {
+		return err
+	}`, typeGoWire(g.goData, tt), arg.Ref())
+		arg = typedArg("wire", tt)
+	}
+	// Handle bytes fastpath.  Go doesn't allow type conversions from []MyByte to
+	// []byte, but the reflect package does let us perform this conversion.
+	if tt.IsBytes() {
+		method, p1 = "Bytes", g.TypeOf(tt)
+		switch {
+		case tt.Elem() != vdl.ByteType:
+			slice := arg.Ref()
+			if kind == vdl.Array {
+				slice = arg.Name + "[:]"
+			}
+			p2 = fmt.Sprintf(`%sValueOf(%s).Bytes()`, g.Pkg("reflect"), slice)
+		case kind == vdl.Array:
+			p2 = arg.Name + "[:]"
+		default:
+			p2 = g.cast(arg.Ref(), tt, vdl.ListType(vdl.ByteType))
+		}
+	}
+	// Handle scalar fastpaths.
+	switch kind {
+	case vdl.Bool:
+		method, p1, p2 = "Bool", g.TypeOf(tt), g.cast(arg.Ref(), tt, vdl.BoolType)
+	case vdl.String:
+		method, p1, p2 = "String", g.TypeOf(tt), g.cast(arg.Ref(), tt, vdl.StringType)
+	case vdl.Enum:
+		method, p1, p2 = "String", g.TypeOf(tt), arg.Name+".String()"
+	case vdl.Byte, vdl.Uint16, vdl.Uint32, vdl.Uint64:
+		method, p1, p2 = "Uint", g.TypeOf(tt), g.cast(arg.Ref(), tt, vdl.Uint64Type)
+	case vdl.Int8, vdl.Int16, vdl.Int32, vdl.Int64:
+		method, p1, p2 = "Int", g.TypeOf(tt), g.cast(arg.Ref(), tt, vdl.Int64Type)
+	case vdl.Float32, vdl.Float64:
+		method, p1, p2 = "Float", g.TypeOf(tt), g.cast(arg.Ref(), tt, vdl.Float64Type)
+	case vdl.TypeObject:
+		method, p2 = "TypeObject", arg.Ref()
+	}
+	if method == "" {
+		return "", nil, ""
+	}
+	if p1 != "" {
+		params = append(params, p1)
+	}
+	params = append(params, p2)
+	return
+}
+
+func (g *genWrite) cast(value string, tt, exact *vdl.Type) string {
 	if tt != exact {
-		param = typeGo(g.goData, exact) + "(" + arg.Ref() + ")"
+		// The types don't have an exact match, so we need a conversion.  This
+		// occurs for all named types, as well as numeric types where the bitlen
+		// isn't exactly the same.  E.g.
+		//
+		//   type Foo uint16
+		//
+		//   x := Foo(123)
+		//   enc.WriteValueUint(tt, uint64(x))
+		return typeGoWire(g.goData, exact) + "(" + value + ")"
 	}
-	return fmt.Sprintf(`
-	if err := enc.Encode%[1]s(%[2]s); err != nil {
-		return err
-	}`, method, param)
+	return value
 }
 
-var ttBytes = vdl.ListType(vdl.ByteType)
-
-func (g *genWrite) bodyBytes(tt *vdl.Type, arg namedArg) string {
-	if tt.Kind() == vdl.Array {
-		arg = arg.ArrayIndex(":", ttBytes)
-	}
-	return g.bodyScalar(tt, ttBytes, arg, "Bytes")
-}
-
-func (g *genWrite) bodyEnum(tt *vdl.Type, arg namedArg) string {
-	return fmt.Sprintf(`
-	if err := enc.EncodeString(%[1]s.String()); err != nil {
+func (g *genWrite) bodyFastpath(tt *vdl.Type, arg namedArg, nativeConv bool) string {
+	method, params, init := g.fastpathInfo(tt, arg, nativeConv)
+	return fmt.Sprintf(`%[1]s
+	if err := enc.WriteValue%[2]s(%[3]s); err != nil {
 		return err
-	}`, arg.Name)
+	}`, init, method, strings.Join(params, ", "))
 }
 
 const (
@@ -268,25 +321,41 @@
 )
 
 func (g *genWrite) bodyArray(tt *vdl.Type, arg namedArg) string {
-	elemArg := arg.ArrayIndex("i", tt.Elem())
+	elemArg := typedArg("elem", tt.Elem())
 	s := fmt.Sprintf(`
-	for i := 0; i < %[1]d; i++ {`, tt.Len())
-	s += encNextEntry
-	s += g.body(tt.Elem(), elemArg, false, false)
+	for _, elem := range %[1]s {`, arg.Ref())
+	method, params, init := g.fastpathInfo(tt.Elem(), elemArg, true)
+	if method != "" {
+		s += fmt.Sprintf(`%[1]s
+	if err := enc.NextEntryValue%[2]s(%[3]s); err != nil {
+		return err
+	}`, init, method, strings.Join(params, ", "))
+	} else {
+		s += encNextEntry
+		s += g.body(tt.Elem(), elemArg, false, false)
+	}
 	s += `
 	}` + encNextEntryDone
 	return s
 }
 
 func (g *genWrite) bodyList(tt *vdl.Type, arg namedArg) string {
-	elemArg := arg.Index("i", tt.Elem())
+	elemArg := typedArg("elem", tt.Elem())
 	s := fmt.Sprintf(`
 	if err := enc.SetLenHint(len(%[1]s)); err != nil {
 		return err
 	}
-	for i := 0; i < len(%[1]s); i++ {`, arg.Ref())
-	s += encNextEntry
-	s += g.body(tt.Elem(), elemArg, false, false)
+	for _, elem := range %[1]s {`, arg.Ref())
+	method, params, init := g.fastpathInfo(tt.Elem(), elemArg, true)
+	if method != "" {
+		s += fmt.Sprintf(`%[1]s
+	if err := enc.NextEntryValue%[2]s(%[3]s); err != nil {
+		return err
+	}`, init, method, strings.Join(params, ", "))
+	} else {
+		s += encNextEntry
+		s += g.body(tt.Elem(), elemArg, false, false)
+	}
 	s += `
 	}` + encNextEntryDone
 	return s
@@ -299,8 +368,16 @@
 		return err
 	}
 	for key := range %[1]s {`, arg.Ref())
-	s += encNextEntry
-	s += g.body(tt.Key(), keyArg, false, false)
+	method, params, init := g.fastpathInfo(tt.Key(), keyArg, true)
+	if method != "" {
+		s += fmt.Sprintf(`%[1]s
+	if err := enc.NextEntryValue%[2]s(%[3]s); err != nil {
+		return err
+	}`, init, method, strings.Join(params, ", "))
+	} else {
+		s += encNextEntry
+		s += g.body(tt.Key(), keyArg, false, false)
+	}
 	s += `
 	}` + encNextEntryDone
 	return s
@@ -313,8 +390,16 @@
 		return err
 	}
 	for key, elem := range %[1]s {`, arg.Ref())
-	s += encNextEntry
-	s += g.body(tt.Key(), keyArg, false, false)
+	method, params, init := g.fastpathInfo(tt.Key(), keyArg, true)
+	if method != "" {
+		s += fmt.Sprintf(`%[1]s
+	if err := enc.NextEntryValue%[2]s(%[3]s); err != nil {
+		return err
+	}`, init, method, strings.Join(params, ", "))
+	} else {
+		s += encNextEntry
+		s += g.body(tt.Key(), keyArg, false, false)
+	}
 	s += g.body(tt.Elem(), elemArg, false, false)
 	s += `
 	}` + encNextEntryDone
@@ -328,37 +413,55 @@
 		fieldArg := arg.Field(field)
 		zero := genIsZero{g.goData}
 		expr := zero.Expr(ifNeZero, field.Type, fieldArg, field.Name)
-		// The second-to-last true parameter indicates that nil checks can be
-		// skipped, since we've already ensured the field isn't zero here.
-		fieldBody := g.body(field.Type, fieldArg, true, false)
 		s += fmt.Sprintf(`
-	if %[1]s {
-		if err := enc.NextField(%[2]q); err != nil {
+	if %[1]s {`, expr)
+		method, params, init := g.fastpathInfo(field.Type, fieldArg, true)
+		if method != "" {
+			params = append([]string{`"` + field.Name + `"`}, params...)
+			s += fmt.Sprintf(`%[1]s
+		if err := enc.NextFieldValue%[2]s(%[3]s); err != nil {
 			return err
-		}%[3]s
-	}`, expr, field.Name, fieldBody)
+		}`, init, method, strings.Join(params, ", "))
+		} else {
+			// The second-to-last true parameter indicates that nil checks can be
+			// skipped, since we've already ensured the field isn't zero here.
+			fieldBody := g.body(field.Type, fieldArg, true, false)
+			s += fmt.Sprintf(`
+		if err := enc.NextField(%[1]q); err != nil {
+			return err
+		}%[2]s`, field.Name, fieldBody)
+		}
+		s += `
+	}`
 	}
 	s += encNextFieldDone
 	return s
 }
 
 func (g *genWrite) bodyUnion(field vdl.Field, arg namedArg) string {
+	var s string
 	fieldArg := typedArg(arg.Name+".Value", field.Type)
-	s := fmt.Sprintf(`
+	method, params, init := g.fastpathInfo(field.Type, fieldArg, true)
+	if method != "" {
+		params = append([]string{`"` + field.Name + `"`}, params...)
+		s += fmt.Sprintf(`%[1]s
+	if err := enc.NextFieldValue%[2]s(%[3]s); err != nil {
+		return err
+	}`, init, method, strings.Join(params, ", "))
+	} else {
+		s += fmt.Sprintf(`
 	if err := enc.NextField(%[1]q); err != nil {
 			return err
 	}`, field.Name)
-	s += g.body(field.Type, fieldArg, false, false)
+		s += g.body(field.Type, fieldArg, false, false)
+	}
 	s += encNextFieldDone
 	return s
 }
 
 func (g *genWrite) bodyOptional(tt *vdl.Type, arg namedArg, skipNilCheck bool) string {
-	body := g.body(tt.Elem(), arg, false, false)
-	s := fmt.Sprintf(`
-	enc.SetNextStartValueIsOptional()
-	%[1]s
-	`, body)
+	s := `
+	enc.SetNextStartValueIsOptional()` + g.body(tt.Elem(), arg, false, false)
 	if !skipNilCheck {
 		s = fmt.Sprintf(`
 	if %[1]s == nil {

diff --git a/lib/vdl/testdata/base/base.vdl.go b/lib/vdl/testdata/base/base.vdl.go
index 46202d4..7d6160b 100644
--- a/lib/vdl/testdata/base/base.vdl.go
+++ b/lib/vdl/testdata/base/base.vdl.go

@@ -37,13 +37,10 @@
 }
 
 func (x NamedBool) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_bool_1); err != nil {
+	if err := enc.WriteValueBool(__VDLType_bool_1, bool(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeBool(bool(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *NamedBool) VDLRead(dec vdl.Decoder) error {
@@ -68,13 +65,10 @@
 }
 
 func (x NamedByte) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_byte_2); err != nil {
+	if err := enc.WriteValueUint(__VDLType_byte_2, uint64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeUint(uint64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *NamedByte) VDLRead(dec vdl.Decoder) error {
@@ -99,13 +93,10 @@
 }
 
 func (x NamedUint16) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_uint16_3); err != nil {
+	if err := enc.WriteValueUint(__VDLType_uint16_3, uint64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeUint(uint64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *NamedUint16) VDLRead(dec vdl.Decoder) error {
@@ -130,13 +121,10 @@
 }
 
 func (x NamedUint32) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_uint32_4); err != nil {
+	if err := enc.WriteValueUint(__VDLType_uint32_4, uint64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeUint(uint64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *NamedUint32) VDLRead(dec vdl.Decoder) error {
@@ -161,13 +149,10 @@
 }
 
 func (x NamedUint64) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_uint64_5); err != nil {
+	if err := enc.WriteValueUint(__VDLType_uint64_5, uint64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeUint(uint64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *NamedUint64) VDLRead(dec vdl.Decoder) error {
@@ -192,13 +177,10 @@
 }
 
 func (x NamedInt8) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_int8_6); err != nil {
+	if err := enc.WriteValueInt(__VDLType_int8_6, int64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeInt(int64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *NamedInt8) VDLRead(dec vdl.Decoder) error {
@@ -223,13 +205,10 @@
 }
 
 func (x NamedInt16) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_int16_7); err != nil {
+	if err := enc.WriteValueInt(__VDLType_int16_7, int64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeInt(int64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *NamedInt16) VDLRead(dec vdl.Decoder) error {
@@ -254,13 +233,10 @@
 }
 
 func (x NamedInt32) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_int32_8); err != nil {
+	if err := enc.WriteValueInt(__VDLType_int32_8, int64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeInt(int64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *NamedInt32) VDLRead(dec vdl.Decoder) error {
@@ -285,13 +261,10 @@
 }
 
 func (x NamedInt64) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_int64_9); err != nil {
+	if err := enc.WriteValueInt(__VDLType_int64_9, int64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeInt(int64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *NamedInt64) VDLRead(dec vdl.Decoder) error {
@@ -316,13 +289,10 @@
 }
 
 func (x NamedFloat32) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_float32_10); err != nil {
+	if err := enc.WriteValueFloat(__VDLType_float32_10, float64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeFloat(float64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *NamedFloat32) VDLRead(dec vdl.Decoder) error {
@@ -347,13 +317,10 @@
 }
 
 func (x NamedFloat64) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_float64_11); err != nil {
+	if err := enc.WriteValueFloat(__VDLType_float64_11, float64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeFloat(float64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *NamedFloat64) VDLRead(dec vdl.Decoder) error {
@@ -378,13 +345,10 @@
 }
 
 func (x NamedString) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_string_12); err != nil {
+	if err := enc.WriteValueString(__VDLType_string_12, string(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeString(string(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *NamedString) VDLRead(dec vdl.Decoder) error {
@@ -455,13 +419,10 @@
 }
 
 func (x NamedEnum) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_enum_13); err != nil {
+	if err := enc.WriteValueString(__VDLType_enum_13, x.String()); err != nil {
 		return err
 	}
-	if err := enc.EncodeString(x.String()); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *NamedEnum) VDLRead(dec vdl.Decoder) error {
@@ -491,17 +452,8 @@
 	if err := enc.StartValue(__VDLType_array_14); err != nil {
 		return err
 	}
-	for i := 0; i < 2; i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x[i]); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueBool(vdl.BoolType, elem); err != nil {
 			return err
 		}
 	}
@@ -552,17 +504,8 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x[i])); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueUint(vdl.Uint32Type, uint64(elem)); err != nil {
 			return err
 		}
 	}
@@ -612,16 +555,7 @@
 		return err
 	}
 	for key := range x {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(key); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
 			return err
 		}
 	}
@@ -674,25 +608,10 @@
 		return err
 	}
 	for key, elem := range x {
-		if err := enc.NextEntry(false); err != nil {
+		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
 			return err
 		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(key); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Float32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeFloat(float64(elem)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.WriteValueFloat(vdl.Float32Type, float64(elem)); err != nil {
 			return err
 		}
 	}
@@ -753,44 +672,17 @@
 		return err
 	}
 	if x.A {
-		if err := enc.NextField("A"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.A); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("A", vdl.BoolType, x.A); err != nil {
 			return err
 		}
 	}
 	if x.B != "" {
-		if err := enc.NextField("B"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.B); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("B", vdl.StringType, x.B); err != nil {
 			return err
 		}
 	}
 	if x.C != 0 {
-		if err := enc.NextField("C"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(x.C)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("C", vdl.Int32Type, int64(x.C)); err != nil {
 			return err
 		}
 	}
@@ -905,16 +797,7 @@
 	if err := enc.StartValue(__VDLType_union_19); err != nil {
 		return err
 	}
-	if err := enc.NextField("A"); err != nil {
-		return err
-	}
-	if err := enc.StartValue(vdl.BoolType); err != nil {
-		return err
-	}
-	if err := enc.EncodeBool(x.Value); err != nil {
-		return err
-	}
-	if err := enc.FinishValue(); err != nil {
+	if err := enc.NextFieldValueBool("A", vdl.BoolType, x.Value); err != nil {
 		return err
 	}
 	if err := enc.NextField(""); err != nil {
@@ -927,16 +810,7 @@
 	if err := enc.StartValue(__VDLType_union_19); err != nil {
 		return err
 	}
-	if err := enc.NextField("B"); err != nil {
-		return err
-	}
-	if err := enc.StartValue(vdl.StringType); err != nil {
-		return err
-	}
-	if err := enc.EncodeString(x.Value); err != nil {
-		return err
-	}
-	if err := enc.FinishValue(); err != nil {
+	if err := enc.NextFieldValueString("B", vdl.StringType, x.Value); err != nil {
 		return err
 	}
 	if err := enc.NextField(""); err != nil {
@@ -949,16 +823,7 @@
 	if err := enc.StartValue(__VDLType_union_19); err != nil {
 		return err
 	}
-	if err := enc.NextField("C"); err != nil {
-		return err
-	}
-	if err := enc.StartValue(vdl.Int32Type); err != nil {
-		return err
-	}
-	if err := enc.EncodeInt(int64(x.Value)); err != nil {
-		return err
-	}
-	if err := enc.FinishValue(); err != nil {
+	if err := enc.NextFieldValueInt("C", vdl.Int32Type, int64(x.Value)); err != nil {
 		return err
 	}
 	if err := enc.NextField(""); err != nil {
@@ -1150,170 +1015,62 @@
 		return err
 	}
 	if x.A0 {
-		if err := enc.NextField("A0"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.A0); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("A0", vdl.BoolType, x.A0); err != nil {
 			return err
 		}
 	}
 	if x.A1 != 0 {
-		if err := enc.NextField("A1"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.ByteType); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.A1)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("A1", vdl.ByteType, uint64(x.A1)); err != nil {
 			return err
 		}
 	}
 	if x.A2 != 0 {
-		if err := enc.NextField("A2"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint16Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.A2)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("A2", vdl.Uint16Type, uint64(x.A2)); err != nil {
 			return err
 		}
 	}
 	if x.A3 != 0 {
-		if err := enc.NextField("A3"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.A3)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("A3", vdl.Uint32Type, uint64(x.A3)); err != nil {
 			return err
 		}
 	}
 	if x.A4 != 0 {
-		if err := enc.NextField("A4"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.A4); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("A4", vdl.Uint64Type, x.A4); err != nil {
 			return err
 		}
 	}
 	if x.A5 != 0 {
-		if err := enc.NextField("A5"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int8Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(x.A5)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("A5", vdl.Int8Type, int64(x.A5)); err != nil {
 			return err
 		}
 	}
 	if x.A6 != 0 {
-		if err := enc.NextField("A6"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int16Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(x.A6)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("A6", vdl.Int16Type, int64(x.A6)); err != nil {
 			return err
 		}
 	}
 	if x.A7 != 0 {
-		if err := enc.NextField("A7"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(x.A7)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("A7", vdl.Int32Type, int64(x.A7)); err != nil {
 			return err
 		}
 	}
 	if x.A8 != 0 {
-		if err := enc.NextField("A8"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(x.A8); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("A8", vdl.Int64Type, x.A8); err != nil {
 			return err
 		}
 	}
 	if x.A9 != 0 {
-		if err := enc.NextField("A9"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Float32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeFloat(float64(x.A9)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueFloat("A9", vdl.Float32Type, float64(x.A9)); err != nil {
 			return err
 		}
 	}
 	if x.A10 != 0 {
-		if err := enc.NextField("A10"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Float64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeFloat(x.A10); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueFloat("A10", vdl.Float64Type, x.A10); err != nil {
 			return err
 		}
 	}
 	if x.A11 != "" {
-		if err := enc.NextField("A11"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.A11); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("A11", vdl.StringType, x.A11); err != nil {
 			return err
 		}
 	}
@@ -1334,114 +1091,72 @@
 		}
 	}
 	if x.A14 != nil && x.A14 != vdl.AnyType {
-		if err := enc.NextField("A14"); err != nil {
-			return err
-		}
-		if err := x.A14.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueTypeObject("A14", x.A14); err != nil {
 			return err
 		}
 	}
 	if x.B0 {
-		if err := enc.NextField("B0"); err != nil {
-			return err
-		}
-		if err := x.B0.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueBool("B0", __VDLType_bool_1, bool(x.B0)); err != nil {
 			return err
 		}
 	}
 	if x.B1 != 0 {
-		if err := enc.NextField("B1"); err != nil {
-			return err
-		}
-		if err := x.B1.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueUint("B1", __VDLType_byte_2, uint64(x.B1)); err != nil {
 			return err
 		}
 	}
 	if x.B2 != 0 {
-		if err := enc.NextField("B2"); err != nil {
-			return err
-		}
-		if err := x.B2.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueUint("B2", __VDLType_uint16_3, uint64(x.B2)); err != nil {
 			return err
 		}
 	}
 	if x.B3 != 0 {
-		if err := enc.NextField("B3"); err != nil {
-			return err
-		}
-		if err := x.B3.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueUint("B3", __VDLType_uint32_4, uint64(x.B3)); err != nil {
 			return err
 		}
 	}
 	if x.B4 != 0 {
-		if err := enc.NextField("B4"); err != nil {
-			return err
-		}
-		if err := x.B4.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueUint("B4", __VDLType_uint64_5, uint64(x.B4)); err != nil {
 			return err
 		}
 	}
 	if x.B5 != 0 {
-		if err := enc.NextField("B5"); err != nil {
-			return err
-		}
-		if err := x.B5.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueInt("B5", __VDLType_int8_6, int64(x.B5)); err != nil {
 			return err
 		}
 	}
 	if x.B6 != 0 {
-		if err := enc.NextField("B6"); err != nil {
-			return err
-		}
-		if err := x.B6.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueInt("B6", __VDLType_int16_7, int64(x.B6)); err != nil {
 			return err
 		}
 	}
 	if x.B7 != 0 {
-		if err := enc.NextField("B7"); err != nil {
-			return err
-		}
-		if err := x.B7.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueInt("B7", __VDLType_int32_8, int64(x.B7)); err != nil {
 			return err
 		}
 	}
 	if x.B8 != 0 {
-		if err := enc.NextField("B8"); err != nil {
-			return err
-		}
-		if err := x.B8.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueInt("B8", __VDLType_int64_9, int64(x.B8)); err != nil {
 			return err
 		}
 	}
 	if x.B9 != 0 {
-		if err := enc.NextField("B9"); err != nil {
-			return err
-		}
-		if err := x.B9.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueFloat("B9", __VDLType_float32_10, float64(x.B9)); err != nil {
 			return err
 		}
 	}
 	if x.B10 != 0 {
-		if err := enc.NextField("B10"); err != nil {
-			return err
-		}
-		if err := x.B10.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueFloat("B10", __VDLType_float64_11, float64(x.B10)); err != nil {
 			return err
 		}
 	}
 	if x.B11 != "" {
-		if err := enc.NextField("B11"); err != nil {
-			return err
-		}
-		if err := x.B11.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueString("B11", __VDLType_string_12, string(x.B11)); err != nil {
 			return err
 		}
 	}
 	if x.B12 != NamedEnumA {
-		if err := enc.NextField("B12"); err != nil {
-			return err
-		}
-		if err := x.B12.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueString("B12", __VDLType_enum_13, x.B12.String()); err != nil {
 			return err
 		}
 	}
@@ -1723,266 +1438,122 @@
 		return err
 	}
 	if x.A0 {
-		if err := enc.NextField("A0"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.A0); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("A0", vdl.BoolType, x.A0); err != nil {
 			return err
 		}
 	}
 	if x.A1 != 0 {
-		if err := enc.NextField("A1"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.ByteType); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.A1)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("A1", vdl.ByteType, uint64(x.A1)); err != nil {
 			return err
 		}
 	}
 	if x.A2 != 0 {
-		if err := enc.NextField("A2"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint16Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.A2)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("A2", vdl.Uint16Type, uint64(x.A2)); err != nil {
 			return err
 		}
 	}
 	if x.A3 != 0 {
-		if err := enc.NextField("A3"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.A3)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("A3", vdl.Uint32Type, uint64(x.A3)); err != nil {
 			return err
 		}
 	}
 	if x.A4 != 0 {
-		if err := enc.NextField("A4"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.A4); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("A4", vdl.Uint64Type, x.A4); err != nil {
 			return err
 		}
 	}
 	if x.A5 != 0 {
-		if err := enc.NextField("A5"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int8Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(x.A5)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("A5", vdl.Int8Type, int64(x.A5)); err != nil {
 			return err
 		}
 	}
 	if x.A6 != 0 {
-		if err := enc.NextField("A6"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int16Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(x.A6)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("A6", vdl.Int16Type, int64(x.A6)); err != nil {
 			return err
 		}
 	}
 	if x.A7 != 0 {
-		if err := enc.NextField("A7"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(x.A7)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("A7", vdl.Int32Type, int64(x.A7)); err != nil {
 			return err
 		}
 	}
 	if x.A8 != 0 {
-		if err := enc.NextField("A8"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(x.A8); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("A8", vdl.Int64Type, x.A8); err != nil {
 			return err
 		}
 	}
 	if x.A9 != 0 {
-		if err := enc.NextField("A9"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Float32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeFloat(float64(x.A9)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueFloat("A9", vdl.Float32Type, float64(x.A9)); err != nil {
 			return err
 		}
 	}
 	if x.A10 != 0 {
-		if err := enc.NextField("A10"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Float64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeFloat(x.A10); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueFloat("A10", vdl.Float64Type, x.A10); err != nil {
 			return err
 		}
 	}
 	if x.A11 != "" {
-		if err := enc.NextField("A11"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.A11); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("A11", vdl.StringType, x.A11); err != nil {
 			return err
 		}
 	}
 	if x.B0 {
-		if err := enc.NextField("B0"); err != nil {
-			return err
-		}
-		if err := x.B0.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueBool("B0", __VDLType_bool_1, bool(x.B0)); err != nil {
 			return err
 		}
 	}
 	if x.B1 != 0 {
-		if err := enc.NextField("B1"); err != nil {
-			return err
-		}
-		if err := x.B1.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueUint("B1", __VDLType_byte_2, uint64(x.B1)); err != nil {
 			return err
 		}
 	}
 	if x.B2 != 0 {
-		if err := enc.NextField("B2"); err != nil {
-			return err
-		}
-		if err := x.B2.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueUint("B2", __VDLType_uint16_3, uint64(x.B2)); err != nil {
 			return err
 		}
 	}
 	if x.B3 != 0 {
-		if err := enc.NextField("B3"); err != nil {
-			return err
-		}
-		if err := x.B3.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueUint("B3", __VDLType_uint32_4, uint64(x.B3)); err != nil {
 			return err
 		}
 	}
 	if x.B4 != 0 {
-		if err := enc.NextField("B4"); err != nil {
-			return err
-		}
-		if err := x.B4.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueUint("B4", __VDLType_uint64_5, uint64(x.B4)); err != nil {
 			return err
 		}
 	}
 	if x.B5 != 0 {
-		if err := enc.NextField("B5"); err != nil {
-			return err
-		}
-		if err := x.B5.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueInt("B5", __VDLType_int8_6, int64(x.B5)); err != nil {
 			return err
 		}
 	}
 	if x.B6 != 0 {
-		if err := enc.NextField("B6"); err != nil {
-			return err
-		}
-		if err := x.B6.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueInt("B6", __VDLType_int16_7, int64(x.B6)); err != nil {
 			return err
 		}
 	}
 	if x.B7 != 0 {
-		if err := enc.NextField("B7"); err != nil {
-			return err
-		}
-		if err := x.B7.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueInt("B7", __VDLType_int32_8, int64(x.B7)); err != nil {
 			return err
 		}
 	}
 	if x.B8 != 0 {
-		if err := enc.NextField("B8"); err != nil {
-			return err
-		}
-		if err := x.B8.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueInt("B8", __VDLType_int64_9, int64(x.B8)); err != nil {
 			return err
 		}
 	}
 	if x.B9 != 0 {
-		if err := enc.NextField("B9"); err != nil {
-			return err
-		}
-		if err := x.B9.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueFloat("B9", __VDLType_float32_10, float64(x.B9)); err != nil {
 			return err
 		}
 	}
 	if x.B10 != 0 {
-		if err := enc.NextField("B10"); err != nil {
-			return err
-		}
-		if err := x.B10.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueFloat("B10", __VDLType_float64_11, float64(x.B10)); err != nil {
 			return err
 		}
 	}
 	if x.B13 != "" {
-		if err := enc.NextField("B13"); err != nil {
-			return err
-		}
-		if err := x.B13.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueString("B13", __VDLType_string_12, string(x.B13)); err != nil {
 			return err
 		}
 	}
@@ -2201,11 +1772,11 @@
 	if err := enc.StartValue(__VDLType_array_22); err != nil {
 		return err
 	}
-	for i := 0; i < 2; i++ {
+	for _, elem := range x {
 		if err := enc.NextEntry(false); err != nil {
 			return err
 		}
-		if err := x[i].VDLWrite(enc); err != nil {
+		if err := elem.VDLWrite(enc); err != nil {
 			return err
 		}
 	}
@@ -2329,11 +1900,11 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
+	for _, elem := range x {
 		if err := enc.NextEntry(false); err != nil {
 			return err
 		}
-		if err := x[i].VDLWrite(enc); err != nil {
+		if err := elem.VDLWrite(enc); err != nil {
 			return err
 		}
 	}
@@ -2372,16 +1943,7 @@
 		return err
 	}
 	for key, elem := range x {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(key); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
 			return err
 		}
 		if err := elem.VDLWrite(enc); err != nil {
@@ -2554,11 +2116,11 @@
 	if err := enc.StartValue(__VDLType_array_27); err != nil {
 		return err
 	}
-	for i := 0; i < 2; i++ {
+	for _, elem := range x {
 		if err := enc.NextEntry(false); err != nil {
 			return err
 		}
-		if err := x[i].VDLWrite(enc); err != nil {
+		if err := elem.VDLWrite(enc); err != nil {
 			return err
 		}
 	}
@@ -2682,11 +2244,11 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
+	for _, elem := range x {
 		if err := enc.NextEntry(false); err != nil {
 			return err
 		}
-		if err := x[i].VDLWrite(enc); err != nil {
+		if err := elem.VDLWrite(enc); err != nil {
 			return err
 		}
 	}
@@ -2704,16 +2266,7 @@
 		return err
 	}
 	for key, elem := range x {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(key); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
 			return err
 		}
 		if err := elem.VDLWrite(enc); err != nil {
@@ -2757,11 +2310,11 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
+	for _, elem := range x {
 		if err := enc.NextEntry(false); err != nil {
 			return err
 		}
-		if err := __VDLWriteAnon_map_5(enc, x[i]); err != nil {
+		if err := __VDLWriteAnon_map_5(enc, elem); err != nil {
 			return err
 		}
 	}
@@ -3002,30 +2555,12 @@
 		return err
 	}
 	if x.A != 0 {
-		if err := enc.NextField("A"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(x.A)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("A", vdl.Int32Type, int64(x.A)); err != nil {
 			return err
 		}
 	}
 	if x.B != 0 {
-		if err := enc.NextField("B"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(x.B)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("B", vdl.Int32Type, int64(x.B)); err != nil {
 			return err
 		}
 	}

diff --git a/lib/vdl/testdata/nativedep/nativedep.vdl.go b/lib/vdl/testdata/nativedep/nativedep.vdl.go
index d918c24..7a82dd0 100644
--- a/lib/vdl/testdata/nativedep/nativedep.vdl.go
+++ b/lib/vdl/testdata/nativedep/nativedep.vdl.go

@@ -52,50 +52,38 @@
 		return err
 	}
 	if x.A != "" {
-		if err := enc.NextField("A"); err != nil {
-			return err
-		}
 		var wire nativetest_2.WireString
 		if err := nativetest_2.WireStringFromNative(&wire, x.A); err != nil {
 			return err
 		}
-		if err := wire.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueInt("A", __VDLType_int32_2, int64(wire)); err != nil {
 			return err
 		}
 	}
 	if !x.B.IsZero() {
-		if err := enc.NextField("B"); err != nil {
-			return err
-		}
 		var wire nativetest_2.WireTime
 		if err := nativetest_2.WireTimeFromNative(&wire, x.B); err != nil {
 			return err
 		}
-		if err := wire.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueInt("B", __VDLType_int32_3, int64(wire)); err != nil {
 			return err
 		}
 	}
 	if x.C != "" {
-		if err := enc.NextField("C"); err != nil {
-			return err
-		}
 		var wire nativetest_2.WireSamePkg
 		if err := nativetest_2.WireSamePkgFromNative(&wire, x.C); err != nil {
 			return err
 		}
-		if err := wire.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueInt("C", __VDLType_int32_4, int64(wire)); err != nil {
 			return err
 		}
 	}
 	if x.D != nil {
-		if err := enc.NextField("D"); err != nil {
-			return err
-		}
 		var wire nativetest_2.WireMultiImport
 		if err := nativetest_2.WireMultiImportFromNative(&wire, x.D); err != nil {
 			return err
 		}
-		if err := wire.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueInt("D", __VDLType_int32_5, int64(wire)); err != nil {
 			return err
 		}
 	}

diff --git a/lib/vdl/testdata/nativedep2/nativedep2.vdl.go b/lib/vdl/testdata/nativedep2/nativedep2.vdl.go
index 151041e..e54df92 100644
--- a/lib/vdl/testdata/nativedep2/nativedep2.vdl.go
+++ b/lib/vdl/testdata/nativedep2/nativedep2.vdl.go

@@ -30,13 +30,10 @@
 }
 
 func (x MyTime) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_int32_1); err != nil {
+	if err := enc.WriteValueInt(__VDLType_int32_1, int64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeInt(int64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *MyTime) VDLRead(dec vdl.Decoder) error {

diff --git a/lib/vdl/testdata/nativetest/nativetest.vdl.go b/lib/vdl/testdata/nativetest/nativetest.vdl.go
index 04b85fd..de68a53 100644
--- a/lib/vdl/testdata/nativetest/nativetest.vdl.go
+++ b/lib/vdl/testdata/nativetest/nativetest.vdl.go

@@ -31,13 +31,10 @@
 }
 
 func (x WireString) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_int32_1); err != nil {
+	if err := enc.WriteValueInt(__VDLType_int32_1, int64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeInt(int64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *WireString) VDLRead(dec vdl.Decoder) error {
@@ -62,13 +59,10 @@
 }
 
 func (x WireTime) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_int32_2); err != nil {
+	if err := enc.WriteValueInt(__VDLType_int32_2, int64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeInt(int64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *WireTime) VDLRead(dec vdl.Decoder) error {
@@ -93,13 +87,10 @@
 }
 
 func (x WireSamePkg) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_int32_3); err != nil {
+	if err := enc.WriteValueInt(__VDLType_int32_3, int64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeInt(int64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *WireSamePkg) VDLRead(dec vdl.Decoder) error {
@@ -124,13 +115,10 @@
 }
 
 func (x WireMultiImport) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_int32_4); err != nil {
+	if err := enc.WriteValueInt(__VDLType_int32_4, int64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeInt(int64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *WireMultiImport) VDLRead(dec vdl.Decoder) error {
@@ -155,13 +143,10 @@
 }
 
 func (x WireRenameMe) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_int32_5); err != nil {
+	if err := enc.WriteValueInt(__VDLType_int32_5, int64(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeInt(int64(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *WireRenameMe) VDLRead(dec vdl.Decoder) error {
@@ -211,58 +196,43 @@
 		return err
 	}
 	if x.A != "" {
-		if err := enc.NextField("A"); err != nil {
-			return err
-		}
 		var wire WireString
 		if err := WireStringFromNative(&wire, x.A); err != nil {
 			return err
 		}
-		if err := wire.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueInt("A", __VDLType_int32_1, int64(wire)); err != nil {
 			return err
 		}
 	}
 	if !x.B.IsZero() {
-		if err := enc.NextField("B"); err != nil {
-			return err
-		}
 		var wire WireTime
 		if err := WireTimeFromNative(&wire, x.B); err != nil {
 			return err
 		}
-		if err := wire.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueInt("B", __VDLType_int32_2, int64(wire)); err != nil {
 			return err
 		}
 	}
 	if x.C != "" {
-		if err := enc.NextField("C"); err != nil {
-			return err
-		}
 		var wire WireSamePkg
 		if err := WireSamePkgFromNative(&wire, x.C); err != nil {
 			return err
 		}
-		if err := wire.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueInt("C", __VDLType_int32_3, int64(wire)); err != nil {
 			return err
 		}
 	}
 	if x.D != nil {
-		if err := enc.NextField("D"); err != nil {
-			return err
-		}
 		var wire WireMultiImport
 		if err := WireMultiImportFromNative(&wire, x.D); err != nil {
 			return err
 		}
-		if err := wire.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueInt("D", __VDLType_int32_4, int64(wire)); err != nil {
 			return err
 		}
 	}
 	if x.E != 0 {
-		if err := enc.NextField("E"); err != nil {
-			return err
-		}
-		if err := x.E.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueInt("E", __VDLType_int32_5, int64(x.E)); err != nil {
 			return err
 		}
 	}
@@ -344,13 +314,10 @@
 }
 
 func (x ignoreme) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_string_7); err != nil {
+	if err := enc.WriteValueString(__VDLType_string_7, string(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeString(string(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *ignoreme) VDLRead(dec vdl.Decoder) error {

diff --git a/runtime/internal/flow/conn/conn.vdl.go b/runtime/internal/flow/conn/conn.vdl.go
index c116e01..9af7f6e 100644
--- a/runtime/internal/flow/conn/conn.vdl.go
+++ b/runtime/internal/flow/conn/conn.vdl.go

@@ -63,16 +63,7 @@
 		}
 	}
 	if x.BKey != 0 {
-		if err := enc.NextField("BKey"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.BKey); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("BKey", vdl.Uint64Type, x.BKey); err != nil {
 			return err
 		}
 	}
@@ -157,16 +148,7 @@
 		}
 	}
 	if x.BKey != 0 {
-		if err := enc.NextField("BKey"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.BKey); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("BKey", vdl.Uint64Type, x.BKey); err != nil {
 			return err
 		}
 	}
@@ -183,11 +165,11 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
+	for _, elem := range x {
 		if err := enc.NextEntry(false); err != nil {
 			return err
 		}
-		if err := x[i].VDLWrite(enc); err != nil {
+		if err := elem.VDLWrite(enc); err != nil {
 			return err
 		}
 	}
@@ -297,30 +279,12 @@
 		}
 	}
 	if x.DKey != 0 {
-		if err := enc.NextField("DKey"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.DKey); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("DKey", vdl.Uint64Type, x.DKey); err != nil {
 			return err
 		}
 	}
 	if x.BKey != 0 {
-		if err := enc.NextField("BKey"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.BKey); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("BKey", vdl.Uint64Type, x.BKey); err != nil {
 			return err
 		}
 	}
@@ -337,12 +301,12 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
+	for _, elem := range x {
 		if err := enc.NextEntry(false); err != nil {
 			return err
 		}
 		var wire security.WireDischarge
-		if err := security.WireDischargeFromNative(&wire, x[i]); err != nil {
+		if err := security.WireDischargeFromNative(&wire, elem); err != nil {
 			return err
 		}
 		switch {
@@ -476,30 +440,12 @@
 		}
 	}
 	if x.DKey != 0 {
-		if err := enc.NextField("DKey"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.DKey); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("DKey", vdl.Uint64Type, x.DKey); err != nil {
 			return err
 		}
 	}
 	if x.BKey != 0 {
-		if err := enc.NextField("BKey"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.BKey); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("BKey", vdl.Uint64Type, x.BKey); err != nil {
 			return err
 		}
 	}

diff --git a/runtime/internal/rpc/stress/stress.vdl.go b/runtime/internal/rpc/stress/stress.vdl.go
index 784129a..a49195f 100644
--- a/runtime/internal/rpc/stress/stress.vdl.go
+++ b/runtime/internal/rpc/stress/stress.vdl.go

@@ -50,44 +50,17 @@
 		return err
 	}
 	if x.ABool {
-		if err := enc.NextField("ABool"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.ABool); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("ABool", vdl.BoolType, x.ABool); err != nil {
 			return err
 		}
 	}
 	if x.AInt64 != 0 {
-		if err := enc.NextField("AInt64"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(x.AInt64); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("AInt64", vdl.Int64Type, x.AInt64); err != nil {
 			return err
 		}
 	}
 	if len(x.AListOfBytes) != 0 {
-		if err := enc.NextField("AListOfBytes"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(__VDLType_list_2); err != nil {
-			return err
-		}
-		if err := enc.EncodeBytes(x.AListOfBytes); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBytes("AListOfBytes", __VDLType_list_2, x.AListOfBytes); err != nil {
 			return err
 		}
 	}
@@ -157,58 +130,22 @@
 		return err
 	}
 	if x.SumCount != 0 {
-		if err := enc.NextField("SumCount"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.SumCount); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("SumCount", vdl.Uint64Type, x.SumCount); err != nil {
 			return err
 		}
 	}
 	if x.SumStreamCount != 0 {
-		if err := enc.NextField("SumStreamCount"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.SumStreamCount); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("SumStreamCount", vdl.Uint64Type, x.SumStreamCount); err != nil {
 			return err
 		}
 	}
 	if x.BytesRecv != 0 {
-		if err := enc.NextField("BytesRecv"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.BytesRecv); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("BytesRecv", vdl.Uint64Type, x.BytesRecv); err != nil {
 			return err
 		}
 	}
 	if x.BytesSent != 0 {
-		if err := enc.NextField("BytesSent"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.BytesSent); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("BytesSent", vdl.Uint64Type, x.BytesSent); err != nil {
 			return err
 		}
 	}

diff --git a/runtime/protocols/vine/vine.vdl.go b/runtime/protocols/vine/vine.vdl.go
index eb70949..8c066d8 100644
--- a/runtime/protocols/vine/vine.vdl.go
+++ b/runtime/protocols/vine/vine.vdl.go

@@ -41,30 +41,12 @@
 		return err
 	}
 	if x.Dialer != "" {
-		if err := enc.NextField("Dialer"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Dialer); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Dialer", vdl.StringType, x.Dialer); err != nil {
 			return err
 		}
 	}
 	if x.Acceptor != "" {
-		if err := enc.NextField("Acceptor"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Acceptor); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Acceptor", vdl.StringType, x.Acceptor); err != nil {
 			return err
 		}
 	}
@@ -136,30 +118,12 @@
 		return err
 	}
 	if x.Reachable {
-		if err := enc.NextField("Reachable"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.Reachable); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("Reachable", vdl.BoolType, x.Reachable); err != nil {
 			return err
 		}
 	}
 	if x.Discoverable {
-		if err := enc.NextField("Discoverable"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.Discoverable); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("Discoverable", vdl.BoolType, x.Discoverable); err != nil {
 			return err
 		}
 	}

diff --git a/services/agent/agent.vdl.go b/services/agent/agent.vdl.go
index 79e1556..be243ef 100644
--- a/services/agent/agent.vdl.go
+++ b/services/agent/agent.vdl.go

@@ -70,30 +70,12 @@
 		return err
 	}
 	if x.MinVersion != 0 {
-		if err := enc.NextField("MinVersion"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(x.MinVersion)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("MinVersion", vdl.Int32Type, int64(x.MinVersion)); err != nil {
 			return err
 		}
 	}
 	if x.MaxVersion != 0 {
-		if err := enc.NextField("MaxVersion"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(x.MaxVersion)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("MaxVersion", vdl.Int32Type, int64(x.MaxVersion)); err != nil {
 			return err
 		}
 	}
@@ -158,44 +140,17 @@
 		return err
 	}
 	if x.Id != 0 {
-		if err := enc.NextField("Id"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.Id); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("Id", vdl.Uint64Type, x.Id); err != nil {
 			return err
 		}
 	}
 	if x.Method != "" {
-		if err := enc.NextField("Method"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Method); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Method", vdl.StringType, x.Method); err != nil {
 			return err
 		}
 	}
 	if x.NumArgs != 0 {
-		if err := enc.NextField("NumArgs"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.NumArgs)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("NumArgs", vdl.Uint32Type, uint64(x.NumArgs)); err != nil {
 			return err
 		}
 	}
@@ -267,16 +222,7 @@
 		return err
 	}
 	if x.Id != 0 {
-		if err := enc.NextField("Id"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.Id); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("Id", vdl.Uint64Type, x.Id); err != nil {
 			return err
 		}
 	}
@@ -289,16 +235,7 @@
 		}
 	}
 	if x.NumArgs != 0 {
-		if err := enc.NextField("NumArgs"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.NumArgs)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("NumArgs", vdl.Uint32Type, uint64(x.NumArgs)); err != nil {
 			return err
 		}
 	}

diff --git a/services/ben/ben.vdl.go b/services/ben/ben.vdl.go
index 4914aee..74cc45a 100644
--- a/services/ben/ben.vdl.go
+++ b/services/ben/ben.vdl.go

@@ -41,44 +41,17 @@
 		return err
 	}
 	if x.Architecture != "" {
-		if err := enc.NextField("Architecture"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Architecture); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Architecture", vdl.StringType, x.Architecture); err != nil {
 			return err
 		}
 	}
 	if x.Description != "" {
-		if err := enc.NextField("Description"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Description); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Description", vdl.StringType, x.Description); err != nil {
 			return err
 		}
 	}
 	if x.ClockSpeedMhz != 0 {
-		if err := enc.NextField("ClockSpeedMhz"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.ClockSpeedMhz)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("ClockSpeedMhz", vdl.Uint32Type, uint64(x.ClockSpeedMhz)); err != nil {
 			return err
 		}
 	}
@@ -150,30 +123,12 @@
 		return err
 	}
 	if x.Name != "" {
-		if err := enc.NextField("Name"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Name); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Name", vdl.StringType, x.Name); err != nil {
 			return err
 		}
 	}
 	if x.Version != "" {
-		if err := enc.NextField("Version"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Version); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Version", vdl.StringType, x.Version); err != nil {
 			return err
 		}
 	}
@@ -255,16 +210,7 @@
 		}
 	}
 	if x.Label != "" {
-		if err := enc.NextField("Label"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Label); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Label", vdl.StringType, x.Label); err != nil {
 			return err
 		}
 	}
@@ -328,13 +274,10 @@
 }
 
 func (x SourceCode) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_string_4); err != nil {
+	if err := enc.WriteValueString(__VDLType_string_4, string(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeString(string(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *SourceCode) VDLRead(dec vdl.Decoder) error {
@@ -372,100 +315,37 @@
 		return err
 	}
 	if x.Name != "" {
-		if err := enc.NextField("Name"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Name); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Name", vdl.StringType, x.Name); err != nil {
 			return err
 		}
 	}
 	if x.Iterations != 0 {
-		if err := enc.NextField("Iterations"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.Iterations); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("Iterations", vdl.Uint64Type, x.Iterations); err != nil {
 			return err
 		}
 	}
 	if x.NanoSecsPerOp != 0 {
-		if err := enc.NextField("NanoSecsPerOp"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Float64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeFloat(x.NanoSecsPerOp); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueFloat("NanoSecsPerOp", vdl.Float64Type, x.NanoSecsPerOp); err != nil {
 			return err
 		}
 	}
 	if x.AllocsPerOp != 0 {
-		if err := enc.NextField("AllocsPerOp"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.AllocsPerOp); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("AllocsPerOp", vdl.Uint64Type, x.AllocsPerOp); err != nil {
 			return err
 		}
 	}
 	if x.AllocedBytesPerOp != 0 {
-		if err := enc.NextField("AllocedBytesPerOp"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.AllocedBytesPerOp); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("AllocedBytesPerOp", vdl.Uint64Type, x.AllocedBytesPerOp); err != nil {
 			return err
 		}
 	}
 	if x.MegaBytesPerSec != 0 {
-		if err := enc.NextField("MegaBytesPerSec"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Float64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeFloat(x.MegaBytesPerSec); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueFloat("MegaBytesPerSec", vdl.Float64Type, x.MegaBytesPerSec); err != nil {
 			return err
 		}
 	}
 	if x.Parallelism != 0 {
-		if err := enc.NextField("Parallelism"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.Parallelism)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("Parallelism", vdl.Uint32Type, uint64(x.Parallelism)); err != nil {
 			return err
 		}
 	}

diff --git a/services/groups/internal/server/server.vdl.go b/services/groups/internal/server/server.vdl.go
index 4703d82..bb8fbd9 100644
--- a/services/groups/internal/server/server.vdl.go
+++ b/services/groups/internal/server/server.vdl.go

@@ -74,10 +74,7 @@
 		return err
 	}
 	for key := range x {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := key.VDLWrite(enc); err != nil {
+		if err := enc.NextEntryValueString(__VDLType_string_4, string(key)); err != nil {
 			return err
 		}
 	}

diff --git a/services/identity/identity.vdl.go b/services/identity/identity.vdl.go
index 3f0e99b6..22150e1 100644
--- a/services/identity/identity.vdl.go
+++ b/services/identity/identity.vdl.go

@@ -58,16 +58,7 @@
 		}
 	}
 	if x.PublicKey != "" {
-		if err := enc.NextField("PublicKey"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.PublicKey); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("PublicKey", vdl.StringType, x.PublicKey); err != nil {
 			return err
 		}
 	}
@@ -84,17 +75,8 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x[i]); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueString(vdl.StringType, elem); err != nil {
 			return err
 		}
 	}

diff --git a/services/profile/profile.vdl.go b/services/profile/profile.vdl.go
index f22bcb2..c63ecfe 100644
--- a/services/profile/profile.vdl.go
+++ b/services/profile/profile.vdl.go

@@ -42,44 +42,17 @@
 		return err
 	}
 	if x.Name != "" {
-		if err := enc.NextField("Name"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Name); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Name", vdl.StringType, x.Name); err != nil {
 			return err
 		}
 	}
 	if x.MajorVersion != "" {
-		if err := enc.NextField("MajorVersion"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.MajorVersion); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("MajorVersion", vdl.StringType, x.MajorVersion); err != nil {
 			return err
 		}
 	}
 	if x.MinorVersion != "" {
-		if err := enc.NextField("MinorVersion"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.MinorVersion); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("MinorVersion", vdl.StringType, x.MinorVersion); err != nil {
 			return err
 		}
 	}
@@ -181,54 +154,27 @@
 		return err
 	}
 	if x.Label != "" {
-		if err := enc.NextField("Label"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Label); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Label", vdl.StringType, x.Label); err != nil {
 			return err
 		}
 	}
 	if x.Description != "" {
-		if err := enc.NextField("Description"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Description); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Description", vdl.StringType, x.Description); err != nil {
 			return err
 		}
 	}
 	if x.Arch != build.ArchitectureAmd64 {
-		if err := enc.NextField("Arch"); err != nil {
-			return err
-		}
-		if err := x.Arch.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueString("Arch", __VDLType_enum_3, x.Arch.String()); err != nil {
 			return err
 		}
 	}
 	if x.Os != build.OperatingSystemDarwin {
-		if err := enc.NextField("Os"); err != nil {
-			return err
-		}
-		if err := x.Os.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueString("Os", __VDLType_enum_4, x.Os.String()); err != nil {
 			return err
 		}
 	}
 	if x.Format != build.FormatElf {
-		if err := enc.NextField("Format"); err != nil {
-			return err
-		}
-		if err := x.Format.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueString("Format", __VDLType_enum_5, x.Format.String()); err != nil {
 			return err
 		}
 	}

diff --git a/services/role/roled/internal/internal.vdl.go b/services/role/roled/internal/internal.vdl.go
index 16f720c..f3334e3 100644
--- a/services/role/roled/internal/internal.vdl.go
+++ b/services/role/roled/internal/internal.vdl.go

@@ -94,44 +94,17 @@
 		}
 	}
 	if x.Extend {
-		if err := enc.NextField("Extend"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.Extend); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("Extend", vdl.BoolType, x.Extend); err != nil {
 			return err
 		}
 	}
 	if x.Audit {
-		if err := enc.NextField("Audit"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.Audit); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("Audit", vdl.BoolType, x.Audit); err != nil {
 			return err
 		}
 	}
 	if x.Expiry != "" {
-		if err := enc.NextField("Expiry"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Expiry); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Expiry", vdl.StringType, x.Expiry); err != nil {
 			return err
 		}
 	}
@@ -156,17 +129,8 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x[i]); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueString(vdl.StringType, elem); err != nil {
 			return err
 		}
 	}
@@ -183,11 +147,8 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := x[i].VDLWrite(enc); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueString(__VDLType_string_4, string(elem)); err != nil {
 			return err
 		}
 	}

diff --git a/services/stats/stats.vdl.go b/services/stats/stats.vdl.go
index 6378b82..fb699ec 100644
--- a/services/stats/stats.vdl.go
+++ b/services/stats/stats.vdl.go

@@ -39,30 +39,12 @@
 		return err
 	}
 	if x.LowBound != 0 {
-		if err := enc.NextField("LowBound"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(x.LowBound); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("LowBound", vdl.Int64Type, x.LowBound); err != nil {
 			return err
 		}
 	}
 	if x.Count != 0 {
-		if err := enc.NextField("Count"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(x.Count); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("Count", vdl.Int64Type, x.Count); err != nil {
 			return err
 		}
 	}
@@ -150,58 +132,22 @@
 		return err
 	}
 	if x.Count != 0 {
-		if err := enc.NextField("Count"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(x.Count); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("Count", vdl.Int64Type, x.Count); err != nil {
 			return err
 		}
 	}
 	if x.Sum != 0 {
-		if err := enc.NextField("Sum"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(x.Sum); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("Sum", vdl.Int64Type, x.Sum); err != nil {
 			return err
 		}
 	}
 	if x.Min != 0 {
-		if err := enc.NextField("Min"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(x.Min); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("Min", vdl.Int64Type, x.Min); err != nil {
 			return err
 		}
 	}
 	if x.Max != 0 {
-		if err := enc.NextField("Max"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(x.Max); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("Max", vdl.Int64Type, x.Max); err != nil {
 			return err
 		}
 	}
@@ -226,11 +172,11 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
+	for _, elem := range x {
 		if err := enc.NextEntry(false); err != nil {
 			return err
 		}
-		if err := x[i].VDLWrite(enc); err != nil {
+		if err := elem.VDLWrite(enc); err != nil {
 			return err
 		}
 	}

diff --git a/services/syncbase/server/interfaces/interfaces.vdl.go b/services/syncbase/server/interfaces/interfaces.vdl.go
index c1f7cb3..22bc11f 100644
--- a/services/syncbase/server/interfaces/interfaces.vdl.go
+++ b/services/syncbase/server/interfaces/interfaces.vdl.go

@@ -49,25 +49,10 @@
 		return err
 	}
 	for key, elem := range x {
-		if err := enc.NextEntry(false); err != nil {
+		if err := enc.NextEntryValueUint(vdl.Uint64Type, key); err != nil {
 			return err
 		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(key); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(elem); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.WriteValueUint(vdl.Uint64Type, elem); err != nil {
 			return err
 		}
 	}
@@ -130,16 +115,7 @@
 		return err
 	}
 	for key, elem := range x {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(key); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
 			return err
 		}
 		if err := elem.VDLWrite(enc); err != nil {
@@ -247,72 +223,27 @@
 		return err
 	}
 	if x.Id != 0 {
-		if err := enc.NextField("Id"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.Id); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("Id", vdl.Uint64Type, x.Id); err != nil {
 			return err
 		}
 	}
 	if x.Gen != 0 {
-		if err := enc.NextField("Gen"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.Gen); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("Gen", vdl.Uint64Type, x.Gen); err != nil {
 			return err
 		}
 	}
 	if x.RecType != 0 {
-		if err := enc.NextField("RecType"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.ByteType); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.RecType)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("RecType", vdl.ByteType, uint64(x.RecType)); err != nil {
 			return err
 		}
 	}
 	if x.ObjId != "" {
-		if err := enc.NextField("ObjId"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.ObjId); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("ObjId", vdl.StringType, x.ObjId); err != nil {
 			return err
 		}
 	}
 	if x.CurVers != "" {
-		if err := enc.NextField("CurVers"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.CurVers); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("CurVers", vdl.StringType, x.CurVers); err != nil {
 			return err
 		}
 	}
@@ -337,44 +268,17 @@
 		}
 	}
 	if x.Delete {
-		if err := enc.NextField("Delete"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.Delete); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("Delete", vdl.BoolType, x.Delete); err != nil {
 			return err
 		}
 	}
 	if x.BatchId != 0 {
-		if err := enc.NextField("BatchId"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.BatchId); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("BatchId", vdl.Uint64Type, x.BatchId); err != nil {
 			return err
 		}
 	}
 	if x.BatchCount != 0 {
-		if err := enc.NextField("BatchCount"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.BatchCount); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("BatchCount", vdl.Uint64Type, x.BatchCount); err != nil {
 			return err
 		}
 	}
@@ -391,17 +295,8 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x[i]); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueString(vdl.StringType, elem); err != nil {
 			return err
 		}
 	}
@@ -615,13 +510,10 @@
 }
 
 func (x GroupId) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_string_7); err != nil {
+	if err := enc.WriteValueString(__VDLType_string_7, string(x)); err != nil {
 		return err
 	}
-	if err := enc.EncodeString(string(x)); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *GroupId) VDLRead(dec vdl.Decoder) error {
@@ -693,13 +585,10 @@
 }
 
 func (x SyncgroupStatus) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_enum_8); err != nil {
+	if err := enc.WriteValueString(__VDLType_enum_8, x.String()); err != nil {
 		return err
 	}
-	if err := enc.EncodeString(x.String()); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *SyncgroupStatus) VDLRead(dec vdl.Decoder) error {
@@ -768,16 +657,7 @@
 		}
 	}
 	if x.SpecVersion != "" {
-		if err := enc.NextField("SpecVersion"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.SpecVersion); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("SpecVersion", vdl.StringType, x.SpecVersion); err != nil {
 			return err
 		}
 	}
@@ -790,16 +670,7 @@
 		}
 	}
 	if x.Creator != "" {
-		if err := enc.NextField("Creator"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Creator); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Creator", vdl.StringType, x.Creator); err != nil {
 			return err
 		}
 	}
@@ -812,10 +683,7 @@
 		}
 	}
 	if x.Status != SyncgroupStatusPublishPending {
-		if err := enc.NextField("Status"); err != nil {
-			return err
-		}
-		if err := x.Status.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueString("Status", __VDLType_enum_8, x.Status.String()); err != nil {
 			return err
 		}
 	}
@@ -841,16 +709,7 @@
 		return err
 	}
 	for key, elem := range x {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(key); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
 			return err
 		}
 		if err := elem.VDLWrite(enc); err != nil {
@@ -979,16 +838,7 @@
 		return err
 	}
 	for key, elem := range x {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(key); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
 			return err
 		}
 		if err := elem.VDLWrite(enc); err != nil {
@@ -1174,10 +1024,7 @@
 		return err
 	}
 	for key := range x {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := key.VDLWrite(enc); err != nil {
+		if err := enc.NextEntryValueString(__VDLType_string_7, string(key)); err != nil {
 			return err
 		}
 	}
@@ -1509,30 +1356,12 @@
 		return err
 	}
 	if x.DevType != 0 {
-		if err := enc.NextField("DevType"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(x.DevType)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("DevType", vdl.Int32Type, int64(x.DevType)); err != nil {
 			return err
 		}
 	}
 	if x.Distance != 0 {
-		if err := enc.NextField("Distance"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Float32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeFloat(float64(x.Distance)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueFloat("Distance", vdl.Float32Type, float64(x.Distance)); err != nil {
 			return err
 		}
 	}
@@ -1619,10 +1448,7 @@
 		return err
 	}
 	for key, elem := range x {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := key.VDLWrite(enc); err != nil {
+		if err := enc.NextEntryValueString(__VDLType_string_7, string(key)); err != nil {
 			return err
 		}
 		if err := elem.VDLWrite(enc); err != nil {
@@ -1745,16 +1571,7 @@
 		return err
 	}
 	if len(x.Hash) != 0 {
-		if err := enc.NextField("Hash"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(__VDLType_list_25); err != nil {
-			return err
-		}
-		if err := enc.EncodeBytes(x.Hash); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBytes("Hash", __VDLType_list_25, x.Hash); err != nil {
 			return err
 		}
 	}
@@ -1811,16 +1628,7 @@
 		return err
 	}
 	if len(x.Data) != 0 {
-		if err := enc.NextField("Data"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(__VDLType_list_25); err != nil {
-			return err
-		}
-		if err := enc.EncodeBytes(x.Data); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBytes("Data", __VDLType_list_25, x.Data); err != nil {
 			return err
 		}
 	}
@@ -2020,30 +1828,12 @@
 		}
 	}
 	if x.NumReboots != 0 {
-		if err := enc.NextField("NumReboots"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint16Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.NumReboots)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("NumReboots", vdl.Uint16Type, uint64(x.NumReboots)); err != nil {
 			return err
 		}
 	}
 	if x.NumHops != 0 {
-		if err := enc.NextField("NumHops"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint16Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.NumHops)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("NumHops", vdl.Uint16Type, uint64(x.NumHops)); err != nil {
 			return err
 		}
 	}
@@ -2141,19 +1931,10 @@
 		return err
 	}
 	for key, elem := range x {
-		if err := enc.NextEntry(false); err != nil {
+		if err := enc.NextEntryValueString(__VDLType_string_7, string(key)); err != nil {
 			return err
 		}
-		if err := key.VDLWrite(enc); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(int64(elem)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.WriteValueInt(vdl.Int32Type, int64(elem)); err != nil {
 			return err
 		}
 	}
@@ -2237,30 +2018,12 @@
 		}
 	}
 	if x.IsProxy {
-		if err := enc.NextField("IsProxy"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.IsProxy); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("IsProxy", vdl.BoolType, x.IsProxy); err != nil {
 			return err
 		}
 	}
 	if x.IsServer {
-		if err := enc.NextField("IsServer"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.IsServer); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("IsServer", vdl.BoolType, x.IsServer); err != nil {
 			return err
 		}
 	}
@@ -2333,16 +2096,7 @@
 		return err
 	}
 	for key, elem := range x {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(key); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
 			return err
 		}
 		if err := elem.VDLWrite(enc); err != nil {

diff --git a/services/syncbase/server/server.vdl.go b/services/syncbase/server/server.vdl.go
index 8eba6d5..6461580 100644
--- a/services/syncbase/server/server.vdl.go
+++ b/services/syncbase/server/server.vdl.go

@@ -44,16 +44,7 @@
 		return err
 	}
 	if x.Version != 0 {
-		if err := enc.NextField("Version"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.Version); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("Version", vdl.Uint64Type, x.Version); err != nil {
 			return err
 		}
 	}
@@ -135,30 +126,12 @@
 		}
 	}
 	if x.RootDir != "" {
-		if err := enc.NextField("RootDir"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.RootDir); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("RootDir", vdl.StringType, x.RootDir); err != nil {
 			return err
 		}
 	}
 	if x.Engine != "" {
-		if err := enc.NextField("Engine"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Engine); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Engine", vdl.StringType, x.Engine); err != nil {
 			return err
 		}
 	}
@@ -250,16 +223,7 @@
 		}
 	}
 	if x.Version != 0 {
-		if err := enc.NextField("Version"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.Version); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("Version", vdl.Uint64Type, x.Version); err != nil {
 			return err
 		}
 	}
@@ -276,11 +240,9 @@
 			return err
 		}
 		enc.SetNextStartValueIsOptional()
-
 		if err := x.SchemaMetadata.VDLWrite(enc); err != nil {
 			return err
 		}
-
 	}
 	if err := enc.NextField(""); err != nil {
 		return err

diff --git a/services/syncbase/signing/signing.vdl.go b/services/syncbase/signing/signing.vdl.go
index 40a8c7b..f8a1f94 100644
--- a/services/syncbase/signing/signing.vdl.go
+++ b/services/syncbase/signing/signing.vdl.go

@@ -81,16 +81,7 @@
 	if err := enc.StartValue(__VDLType_union_2); err != nil {
 		return err
 	}
-	if err := enc.NextField("Data"); err != nil {
-		return err
-	}
-	if err := enc.StartValue(__VDLType_list_1); err != nil {
-		return err
-	}
-	if err := enc.EncodeBytes(x.Value); err != nil {
-		return err
-	}
-	if err := enc.FinishValue(); err != nil {
+	if err := enc.NextFieldValueBytes("Data", __VDLType_list_1, x.Value); err != nil {
 		return err
 	}
 	if err := enc.NextField(""); err != nil {
@@ -103,16 +94,7 @@
 	if err := enc.StartValue(__VDLType_union_2); err != nil {
 		return err
 	}
-	if err := enc.NextField("Hash"); err != nil {
-		return err
-	}
-	if err := enc.StartValue(__VDLType_list_1); err != nil {
-		return err
-	}
-	if err := enc.EncodeBytes(x.Value); err != nil {
-		return err
-	}
-	if err := enc.FinishValue(); err != nil {
+	if err := enc.NextFieldValueBytes("Hash", __VDLType_list_1, x.Value); err != nil {
 		return err
 	}
 	if err := enc.NextField(""); err != nil {
@@ -236,16 +218,7 @@
 		}
 	}
 	if len(x.BlessingsHash) != 0 {
-		if err := enc.NextField("BlessingsHash"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(__VDLType_list_1); err != nil {
-			return err
-		}
-		if err := enc.EncodeBytes(x.BlessingsHash); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBytes("BlessingsHash", __VDLType_list_1, x.BlessingsHash); err != nil {
 			return err
 		}
 	}
@@ -258,30 +231,12 @@
 		}
 	}
 	if x.IsValidated {
-		if err := enc.NextField("IsValidated"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.IsValidated); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("IsValidated", vdl.BoolType, x.IsValidated); err != nil {
 			return err
 		}
 	}
 	if len(x.ValidatorDataHash) != 0 {
-		if err := enc.NextField("ValidatorDataHash"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(__VDLType_list_1); err != nil {
-			return err
-		}
-		if err := enc.EncodeBytes(x.ValidatorDataHash); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBytes("ValidatorDataHash", __VDLType_list_1, x.ValidatorDataHash); err != nil {
 			return err
 		}
 	}
@@ -306,18 +261,18 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
+	for _, elem := range x {
 		if err := enc.NextEntry(false); err != nil {
 			return err
 		}
 		switch {
-		case x[i] == nil:
+		case elem == nil:
 			// Write the zero value of the union type.
 			if err := vdl.ZeroValue(__VDLType_union_2).VDLWrite(enc); err != nil {
 				return err
 			}
 		default:
-			if err := x[i].VDLWrite(enc); err != nil {
+			if err := elem.VDLWrite(enc); err != nil {
 				return err
 			}
 		}
@@ -436,16 +391,7 @@
 		}
 	}
 	if len(x.MarshalledPublicKey) != 0 {
-		if err := enc.NextField("MarshalledPublicKey"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(__VDLType_list_1); err != nil {
-			return err
-		}
-		if err := enc.EncodeBytes(x.MarshalledPublicKey); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBytes("MarshalledPublicKey", __VDLType_list_1, x.MarshalledPublicKey); err != nil {
 			return err
 		}
 	}
@@ -462,17 +408,8 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x[i]); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueString(vdl.StringType, elem); err != nil {
 			return err
 		}
 	}

diff --git a/services/syncbase/store/watchable/watchable.vdl.go b/services/syncbase/store/watchable/watchable.vdl.go
index fd0ea26..a2b7b2a 100644
--- a/services/syncbase/store/watchable/watchable.vdl.go
+++ b/services/syncbase/store/watchable/watchable.vdl.go

@@ -39,16 +39,7 @@
 		return err
 	}
 	if len(x.Key) != 0 {
-		if err := enc.NextField("Key"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(__VDLType_list_2); err != nil {
-			return err
-		}
-		if err := enc.EncodeBytes(x.Key); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBytes("Key", __VDLType_list_2, x.Key); err != nil {
 			return err
 		}
 	}
@@ -109,30 +100,12 @@
 		return err
 	}
 	if len(x.Start) != 0 {
-		if err := enc.NextField("Start"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(__VDLType_list_2); err != nil {
-			return err
-		}
-		if err := enc.EncodeBytes(x.Start); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBytes("Start", __VDLType_list_2, x.Start); err != nil {
 			return err
 		}
 	}
 	if len(x.Limit) != 0 {
-		if err := enc.NextField("Limit"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(__VDLType_list_2); err != nil {
-			return err
-		}
-		if err := enc.EncodeBytes(x.Limit); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBytes("Limit", __VDLType_list_2, x.Limit); err != nil {
 			return err
 		}
 	}
@@ -199,30 +172,12 @@
 		return err
 	}
 	if len(x.Key) != 0 {
-		if err := enc.NextField("Key"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(__VDLType_list_2); err != nil {
-			return err
-		}
-		if err := enc.EncodeBytes(x.Key); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBytes("Key", __VDLType_list_2, x.Key); err != nil {
 			return err
 		}
 	}
 	if len(x.Version) != 0 {
-		if err := enc.NextField("Version"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(__VDLType_list_2); err != nil {
-			return err
-		}
-		if err := enc.EncodeBytes(x.Version); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBytes("Version", __VDLType_list_2, x.Version); err != nil {
 			return err
 		}
 	}
@@ -283,16 +238,7 @@
 		return err
 	}
 	if len(x.Key) != 0 {
-		if err := enc.NextField("Key"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(__VDLType_list_2); err != nil {
-			return err
-		}
-		if err := enc.EncodeBytes(x.Key); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBytes("Key", __VDLType_list_2, x.Key); err != nil {
 			return err
 		}
 	}
@@ -380,44 +326,17 @@
 		}
 	}
 	if x.CommitTimestamp != 0 {
-		if err := enc.NextField("CommitTimestamp"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Int64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeInt(x.CommitTimestamp); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueInt("CommitTimestamp", vdl.Int64Type, x.CommitTimestamp); err != nil {
 			return err
 		}
 	}
 	if x.FromSync {
-		if err := enc.NextField("FromSync"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.FromSync); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("FromSync", vdl.BoolType, x.FromSync); err != nil {
 			return err
 		}
 	}
 	if x.Continued {
-		if err := enc.NextField("Continued"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.Continued); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("Continued", vdl.BoolType, x.Continued); err != nil {
 			return err
 		}
 	}

diff --git a/services/syncbase/vclock/vclock.vdl.go b/services/syncbase/vclock/vclock.vdl.go
index 71cba63..c0d7430 100644
--- a/services/syncbase/vclock/vclock.vdl.go
+++ b/services/syncbase/vclock/vclock.vdl.go

@@ -119,30 +119,12 @@
 		}
 	}
 	if x.NumReboots != 0 {
-		if err := enc.NextField("NumReboots"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint16Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.NumReboots)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("NumReboots", vdl.Uint16Type, uint64(x.NumReboots)); err != nil {
 			return err
 		}
 	}
 	if x.NumHops != 0 {
-		if err := enc.NextField("NumHops"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint16Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.NumHops)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("NumHops", vdl.Uint16Type, uint64(x.NumHops)); err != nil {
 			return err
 		}
 	}

diff --git a/services/syncbase/vsync/testdata/blobtestsvdl.vdl.go b/services/syncbase/vsync/testdata/blobtestsvdl.vdl.go
index 835dee9..cf407e1 100644
--- a/services/syncbase/vsync/testdata/blobtestsvdl.vdl.go
+++ b/services/syncbase/vsync/testdata/blobtestsvdl.vdl.go

@@ -38,24 +38,12 @@
 		return err
 	}
 	if x.Info != "" {
-		if err := enc.NextField("Info"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Info); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Info", vdl.StringType, x.Info); err != nil {
 			return err
 		}
 	}
 	if x.Br != "" {
-		if err := enc.NextField("Br"); err != nil {
-			return err
-		}
-		if err := x.Br.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueString("Br", __VDLType_string_2, string(x.Br)); err != nil {
 			return err
 		}
 	}
@@ -151,16 +139,7 @@
 	if err := enc.StartValue(__VDLType_union_3); err != nil {
 		return err
 	}
-	if err := enc.NextField("Num"); err != nil {
-		return err
-	}
-	if err := enc.StartValue(vdl.Int32Type); err != nil {
-		return err
-	}
-	if err := enc.EncodeInt(int64(x.Value)); err != nil {
-		return err
-	}
-	if err := enc.FinishValue(); err != nil {
+	if err := enc.NextFieldValueInt("Num", vdl.Int32Type, int64(x.Value)); err != nil {
 		return err
 	}
 	if err := enc.NextField(""); err != nil {
@@ -248,16 +227,7 @@
 		return err
 	}
 	if x.Info != "" {
-		if err := enc.NextField("Info"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Info); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Info", vdl.StringType, x.Info); err != nil {
 			return err
 		}
 	}
@@ -283,10 +253,7 @@
 		return err
 	}
 	for key := range x {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := key.VDLWrite(enc); err != nil {
+		if err := enc.NextEntryValueString(__VDLType_string_2, string(key)); err != nil {
 			return err
 		}
 	}
@@ -377,16 +344,7 @@
 		return err
 	}
 	if x.Info != "" {
-		if err := enc.NextField("Info"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Info); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Info", vdl.StringType, x.Info); err != nil {
 			return err
 		}
 	}
@@ -411,16 +369,16 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
+	for _, elem := range x {
 		if err := enc.NextEntry(false); err != nil {
 			return err
 		}
-		if x[i] == nil {
+		if elem == nil {
 			if err := enc.NilValue(vdl.AnyType); err != nil {
 				return err
 			}
 		} else {
-			if err := x[i].VDLWrite(enc); err != nil {
+			if err := elem.VDLWrite(enc); err != nil {
 				return err
 			}
 		}
@@ -514,16 +472,7 @@
 		return err
 	}
 	if x.Info != "" {
-		if err := enc.NextField("Info"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Info); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Info", vdl.StringType, x.Info); err != nil {
 			return err
 		}
 	}
@@ -549,16 +498,7 @@
 		return err
 	}
 	for key := range x {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(key); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
 			return err
 		}
 	}
@@ -643,16 +583,7 @@
 		return err
 	}
 	if x.Info != "" {
-		if err := enc.NextField("Info"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Info); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Info", vdl.StringType, x.Info); err != nil {
 			return err
 		}
 	}
@@ -661,11 +592,9 @@
 			return err
 		}
 		enc.SetNextStartValueIsOptional()
-
 		if err := x.Bo.VDLWrite(enc); err != nil {
 			return err
 		}
-
 	}
 	if err := enc.NextField(""); err != nil {
 		return err

diff --git a/services/syncbase/vsync/vsync.vdl.go b/services/syncbase/vsync/vsync.vdl.go
index 9640dcd..f66c573 100644
--- a/services/syncbase/vsync/vsync.vdl.go
+++ b/services/syncbase/vsync/vsync.vdl.go

@@ -36,16 +36,7 @@
 		return err
 	}
 	if x.Id != 0 {
-		if err := enc.NextField("Id"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.Id); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("Id", vdl.Uint64Type, x.Id); err != nil {
 			return err
 		}
 	}
@@ -129,16 +120,7 @@
 		}
 	}
 	if x.IsPaused {
-		if err := enc.NextField("IsPaused"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.IsPaused); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("IsPaused", vdl.BoolType, x.IsPaused); err != nil {
 			return err
 		}
 	}
@@ -219,16 +201,7 @@
 		}
 	}
 	if x.Pos != 0 {
-		if err := enc.NextField("Pos"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.Pos); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("Pos", vdl.Uint64Type, x.Pos); err != nil {
 			return err
 		}
 	}
@@ -337,58 +310,22 @@
 		return err
 	}
 	if x.NumLocalJoiners != 0 {
-		if err := enc.NextField("NumLocalJoiners"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint32Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(uint64(x.NumLocalJoiners)); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("NumLocalJoiners", vdl.Uint32Type, uint64(x.NumLocalJoiners)); err != nil {
 			return err
 		}
 	}
 	if x.Watched {
-		if err := enc.NextField("Watched"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.Watched); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("Watched", vdl.BoolType, x.Watched); err != nil {
 			return err
 		}
 	}
 	if x.RemotePublisher != "" {
-		if err := enc.NextField("RemotePublisher"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.RemotePublisher); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("RemotePublisher", vdl.StringType, x.RemotePublisher); err != nil {
 			return err
 		}
 	}
 	if x.SyncPending {
-		if err := enc.NextField("SyncPending"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.SyncPending); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("SyncPending", vdl.BoolType, x.SyncPending); err != nil {
 			return err
 		}
 	}
@@ -508,16 +445,7 @@
 		return err
 	}
 	if x.Level != 0 {
-		if err := enc.NextField("Level"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.Level); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("Level", vdl.Uint64Type, x.Level); err != nil {
 			return err
 		}
 	}
@@ -530,72 +458,27 @@
 		}
 	}
 	if x.Logrec != "" {
-		if err := enc.NextField("Logrec"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.Logrec); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("Logrec", vdl.StringType, x.Logrec); err != nil {
 			return err
 		}
 	}
 	if x.BatchId != 0 {
-		if err := enc.NextField("BatchId"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.BatchId); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("BatchId", vdl.Uint64Type, x.BatchId); err != nil {
 			return err
 		}
 	}
 	if x.Deleted {
-		if err := enc.NextField("Deleted"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.Deleted); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("Deleted", vdl.BoolType, x.Deleted); err != nil {
 			return err
 		}
 	}
 	if x.PermId != "" {
-		if err := enc.NextField("PermId"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.PermId); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("PermId", vdl.StringType, x.PermId); err != nil {
 			return err
 		}
 	}
 	if x.PermVers != "" {
-		if err := enc.NextField("PermVers"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x.PermVers); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueString("PermVers", vdl.StringType, x.PermVers); err != nil {
 			return err
 		}
 	}
@@ -612,17 +495,8 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x[i]); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueString(vdl.StringType, elem); err != nil {
 			return err
 		}
 	}
@@ -776,16 +650,7 @@
 		}
 	}
 	if x.Count != 0 {
-		if err := enc.NextField("Count"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.Uint64Type); err != nil {
-			return err
-		}
-		if err := enc.EncodeUint(x.Count); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueUint("Count", vdl.Uint64Type, x.Count); err != nil {
 			return err
 		}
 	}
@@ -803,25 +668,10 @@
 		return err
 	}
 	for key, elem := range x {
-		if err := enc.NextEntry(false); err != nil {
+		if err := enc.NextEntryValueString(vdl.StringType, key); err != nil {
 			return err
 		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(key); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(elem); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.WriteValueString(vdl.StringType, elem); err != nil {
 			return err
 		}
 	}

diff --git a/services/syncbase/watchable/watchable.vdl.go b/services/syncbase/watchable/watchable.vdl.go
index 343d622..03b49b7 100644
--- a/services/syncbase/watchable/watchable.vdl.go
+++ b/services/syncbase/watchable/watchable.vdl.go

@@ -51,10 +51,7 @@
 		return err
 	}
 	if x.SgId != "" {
-		if err := enc.NextField("SgId"); err != nil {
-			return err
-		}
-		if err := x.SgId.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueString("SgId", __VDLType_string_2, string(x.SgId)); err != nil {
 			return err
 		}
 	}
@@ -67,16 +64,7 @@
 		}
 	}
 	if x.Remove {
-		if err := enc.NextField("Remove"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.BoolType); err != nil {
-			return err
-		}
-		if err := enc.EncodeBool(x.Remove); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBool("Remove", vdl.BoolType, x.Remove); err != nil {
 			return err
 		}
 	}
@@ -93,17 +81,8 @@
 	if err := enc.SetLenHint(len(x)); err != nil {
 		return err
 	}
-	for i := 0; i < len(x); i++ {
-		if err := enc.NextEntry(false); err != nil {
-			return err
-		}
-		if err := enc.StartValue(vdl.StringType); err != nil {
-			return err
-		}
-		if err := enc.EncodeString(x[i]); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+	for _, elem := range x {
+		if err := enc.NextEntryValueString(vdl.StringType, elem); err != nil {
 			return err
 		}
 	}
@@ -205,30 +184,12 @@
 		return err
 	}
 	if len(x.Key) != 0 {
-		if err := enc.NextField("Key"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(__VDLType_list_5); err != nil {
-			return err
-		}
-		if err := enc.EncodeBytes(x.Key); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBytes("Key", __VDLType_list_5, x.Key); err != nil {
 			return err
 		}
 	}
 	if len(x.Version) != 0 {
-		if err := enc.NextField("Version"); err != nil {
-			return err
-		}
-		if err := enc.StartValue(__VDLType_list_5); err != nil {
-			return err
-		}
-		if err := enc.EncodeBytes(x.Version); err != nil {
-			return err
-		}
-		if err := enc.FinishValue(); err != nil {
+		if err := enc.NextFieldValueBytes("Version", __VDLType_list_5, x.Version); err != nil {
 			return err
 		}
 	}
@@ -320,13 +281,10 @@
 }
 
 func (x StateChange) VDLWrite(enc vdl.Encoder) error {
-	if err := enc.StartValue(__VDLType_enum_6); err != nil {
+	if err := enc.WriteValueString(__VDLType_enum_6, x.String()); err != nil {
 		return err
 	}
-	if err := enc.EncodeString(x.String()); err != nil {
-		return err
-	}
-	return enc.FinishValue()
+	return nil
 }
 
 func (x *StateChange) VDLRead(dec vdl.Decoder) error {
@@ -364,10 +322,7 @@
 		return err
 	}
 	if x.RequestType != StateChangePauseSync {
-		if err := enc.NextField("RequestType"); err != nil {
-			return err
-		}
-		if err := x.RequestType.VDLWrite(enc); err != nil {
+		if err := enc.NextFieldValueString("RequestType", __VDLType_enum_6, x.RequestType.String()); err != nil {
 			return err
 		}
 	}
commit	1eba705399f2b205790e7586496ef247ed5218d4	[log] [tgz]
author	Todd Wang <toddw@google.com>	Tue May 24 17:57:25 2016 -0700
committer	Todd Wang <toddw@google.com>	Wed May 25 20:32:45 2016 +0000
tree	849272d64a47787e7f5fd72e42b0a34dbf22dcfe
parent	19ad3429d134c1b9cfc7af9620cc94668bb4290c [diff]