diff --git a/cue/ast.go b/cue/ast.go
index c1dec8a..8f72cb5 100644
--- a/cue/ast.go
+++ b/cue/ast.go
@@ -314,71 +314,20 @@
 		return v.errf(n, "ellipsis (...) only allowed at end of list or struct")
 
 	case *ast.Comprehension:
-		st, ok := n.Value.(*ast.StructLit)
-		if !ok || len(st.Elts) != 1 {
-			return v.errf(n, "invalid comprehension: %v", n)
+		yielder := &yield{baseValue: newExpr(n.Value)}
+		sc := &structComprehension{
+			newNode(n),
+			wrapClauses(v, yielder, n.Clauses),
 		}
-		field := st.Elts[0].(*ast.Field)
-		yielder := &yield{
-			baseValue: newExpr(n.Value),
-			opt:       field.Optional != token.NoPos,
-			def:       field.Token == token.ISA,
-		}
-		fc := &fieldComprehension{
-			baseValue: newDecl(n),
-			clauses:   wrapClauses(v, yielder, n.Clauses),
-		}
-		switch x := field.Label.(type) {
-		case *ast.Interpolation:
-			v.sel = "?"
-			yielder.key = v.walk(x)
-			yielder.value = v.walk(field.Value)
-
-		case *ast.TemplateLabel:
-			v.sel = "*"
-			f := v.label(v.ident(x.Ident), true)
-
-			sig := &params{}
-			sig.add(f, &basicType{newNode(field.Label), stringKind})
-			template := &lambdaExpr{newExpr(field.Value), sig, nil}
-
-			v.setScope(field, template)
-			template.value = v.walk(field.Value)
-			yielder.value = template
-			fc.isTemplate = true
-
-		case *ast.BasicLit, *ast.Ident:
-			name, ok := internal.LabelName(x)
-			if !ok {
-				return v.errf(x, "invalid field name: %v", x)
-			}
-			// TODO: is this correct? Just for info, so not very important.
-			v.sel = name
-
-			// TODO: if the clauses do not contain a guard, we know that this
-			// field will always be added and we can move the comprehension one
-			// level down. This, in turn, has the advantage that it is more
-			// likely that the cross-reference limitation for field
-			// comprehensions is not violated. To ensure compatibility between
-			// implementations, though, we should relax the spec as well.
-			// The cross-reference rule is simple and this relaxation seems a
-			// bit more complex.
-
-			// TODO: for now we can also consider making this an error if
-			// the list of clauses does not contain if and make a suggestion
-			// to rewrite it.
-
-			if name != "" {
-				yielder.key = &stringLit{newNode(x), name, nil}
-				yielder.value = v.walk(field.Value)
-			}
-
+		// we don't support key for lists (yet?)
+		switch n.Value.(type) {
+		case *ast.StructLit:
 		default:
-			panic("cue: unknown label type")
+			// Caught by parser, usually.
+			v.errf(n, "comprehension must be struct")
 		}
-		// yielder.key = v.walk(n.Field.Label)
-		// yielder.value = v.walk(n.Field.Value)
-		v.object.comprehensions = append(v.object.comprehensions, fc)
+		yielder.value = v.walk(n.Value)
+		v.object.comprehensions = append(v.object.comprehensions, sc)
 
 	case *ast.Field:
 		opt := n.Optional != token.NoPos
@@ -391,18 +340,31 @@
 			ctx.inDefinition++
 			defer func() { ctx.inDefinition-- }()
 		}
+		attrs, err := createAttrs(v.ctx(), newNode(n), n.Attrs)
+		if err != nil {
+			return v.errf(n, err.format, err.args)
+		}
+		var leftOverDoc *docNode
+		for _, c := range n.Comments() {
+			if c.Position == 0 {
+				leftOverDoc = v.doc
+				v.doc = &docNode{n: n}
+				break
+			}
+		}
 		switch x := n.Label.(type) {
 		case *ast.Interpolation:
 			v.sel = "?"
-			yielder := &yield{baseValue: newNode(x)}
+			// Must be struct comprehension.
 			fc := &fieldComprehension{
 				baseValue: newDecl(n),
-				clauses:   yielder,
+				key:       v.walk(x),
+				val:       v.walk(n.Value),
+				opt:       opt,
+				def:       isDef,
+				doc:       leftOverDoc,
+				attrs:     attrs,
 			}
-			yielder.key = v.walk(x)
-			yielder.value = v.walk(n.Value)
-			yielder.opt = opt
-			yielder.def = isDef
 			v.object.comprehensions = append(v.object.comprehensions, fc)
 
 		case *ast.TemplateLabel:
@@ -431,23 +393,11 @@
 					v.sel = "*"
 				}
 			}
-			attrs, err := createAttrs(v.ctx(), newNode(n), n.Attrs)
-			if err != nil {
-				return v.errf(n, err.format, err.args)
-			}
 			f, ok := v.nodeLabel(x)
 			if !ok {
 				return v.errf(n.Label, "invalid field name: %v", n.Label)
 			}
 			if f != 0 {
-				var leftOverDoc *docNode
-				for _, c := range n.Comments() {
-					if c.Position == 0 {
-						leftOverDoc = v.doc
-						v.doc = &docNode{n: n}
-						break
-					}
-				}
 				val := v.walk(n.Value)
 				v.object.insertValue(v.ctx(), f, opt, isDef, val, attrs, v.doc)
 				v.doc = leftOverDoc
diff --git a/cue/ast_test.go b/cue/ast_test.go
index 2663112..634cb05 100644
--- a/cue/ast_test.go
+++ b/cue/ast_test.go
@@ -31,7 +31,7 @@
 		in: `{
 		  foo: 1,
 		}`,
-		out: "<0>{}", // emitted value, but no top-level fields
+		out: "<0>{<1>{foo: 1}, }", // emitted value, but no top-level fields
 	}, {
 		in: `
 		foo: 1
@@ -224,19 +224,19 @@
 			c: 3
 		}
 		`,
-		out: `<0>{a: <1>{ <2>for k, v in <0>.b if (<0>.b.a < <2>.k) yield (""+<2>.k+""): <2>.v}, b: <3>{a: 1, b: 2, c: 3}}`,
+		out: `<0>{a: <1>{ <2>for k, v in <0>.b if (<0>.b.a < <2>.k) yield <3>{""+<2>.k+"": <2>.v}}, b: <4>{a: 1, b: 2, c: 3}}`,
 	}, {
 		in: `
 			a: { for k, v in b {"\(v)": v} }
 			b: { a: "aa", b: "bb", c: "cc" }
 			`,
-		out: `<0>{a: <1>{ <2>for k, v in <0>.b yield (""+<2>.v+""): <2>.v}, b: <3>{a: "aa", b: "bb", c: "cc"}}`,
+		out: `<0>{a: <1>{ <2>for k, v in <0>.b yield <3>{""+<2>.v+"": <2>.v}}, b: <4>{a: "aa", b: "bb", c: "cc"}}`,
 	}, {
 		in: `
 			a: [ v for _, v in b ]
 			b: { a: 1, b: 2, c: 3 }
 			`,
-		out: `<0>{a: [ <1>for _, v in <0>.b yield (*nil*): <1>.v ], b: <2>{a: 1, b: 2, c: 3}}`,
+		out: `<0>{a: [ <1>for _, v in <0>.b yield <1>.v ], b: <2>{a: 1, b: 2, c: 3}}`,
 	}, {
 		in: `
 			a: >=1 & <=2
diff --git a/cue/debug.go b/cue/debug.go
index 1db9eff..bb130bf 100644
--- a/cue/debug.go
+++ b/cue/debug.go
@@ -224,6 +224,12 @@
 		write(x.op)
 		p.str(x.x)
 	case *binaryExpr:
+		if x.op == opUnifyUnchecked {
+			p.str(x.left)
+			write(", ")
+			p.str(x.right)
+			break
+		}
 		write("(")
 		p.str(x.left)
 		writef(" %v ", x.op)
@@ -284,6 +290,10 @@
 			p.str(x.template)
 			write(", ")
 		}
+		if x.emit != nil {
+			p.str(x.emit)
+			write(", ")
+		}
 		p.str(x.arcs)
 		for i, c := range x.comprehensions {
 			p.str(c)
@@ -332,21 +342,20 @@
 		}
 
 	case *fieldComprehension:
-		p.str(x.clauses)
+		p.str(x.key)
+		writef(": ")
+		p.str(x.val)
 
 	case *listComprehension:
 		writef("[")
 		p.str(x.clauses)
 		write(" ]")
 
+	case *structComprehension:
+		p.str(x.clauses)
+
 	case *yield:
 		writef(" yield ")
-		writef("(")
-		p.str(x.key)
-		if x.opt {
-			writef("?")
-		}
-		writef("): ")
 		p.str(x.value)
 
 	case *feed:
diff --git a/cue/eval.go b/cue/eval.go
index bb4399f..ee66cba 100644
--- a/cue/eval.go
+++ b/cue/eval.go
@@ -258,10 +258,7 @@
 func (x *listComprehension) evalPartial(ctx *context) evaluated {
 	s := &structLit{baseValue: x.baseValue}
 	list := &list{baseValue: x.baseValue, elem: s}
-	err := x.clauses.yield(ctx, func(k, v evaluated, _, _ bool) *bottom {
-		if !k.kind().isAnyOf(intKind) {
-			return ctx.mkErr(k, "key must be of type int")
-		}
+	err := x.clauses.yield(ctx, func(v evaluated) *bottom {
 		list.elem.arcs = append(list.elem.arcs, arc{
 			feature: label(len(list.elem.arcs)),
 			v:       v.evalPartial(ctx),
@@ -275,11 +272,49 @@
 	return list
 }
 
+func (x *structComprehension) evalPartial(ctx *context) evaluated {
+	st := &structLit{baseValue: x.baseValue}
+	err := x.clauses.yield(ctx, func(v evaluated) *bottom {
+		embed := v.evalPartial(ctx).(*structLit)
+		embed, err := embed.expandFields(ctx)
+		if err != nil {
+			return err
+		}
+		res := binOp(ctx, x, opUnify, st, embed)
+		switch u := res.(type) {
+		case *bottom:
+			return u
+		case *structLit:
+			st = u
+		default:
+			panic("unreachable")
+		}
+		return nil
+	})
+	if err != nil {
+		return err
+	}
+	return st
+}
+
 func (x *feed) evalPartial(ctx *context) evaluated  { return x }
 func (x *guard) evalPartial(ctx *context) evaluated { return x }
 func (x *yield) evalPartial(ctx *context) evaluated { return x }
 
-func (x *fieldComprehension) evalPartial(ctx *context) evaluated { return x }
+func (x *fieldComprehension) evalPartial(ctx *context) evaluated {
+	k := x.key.evalPartial(ctx)
+	v := x.val.evalPartial(ctx)
+	if err := firstBottom(k, v); err != nil {
+		return err
+	}
+	if !k.kind().isAnyOf(stringKind) {
+		return ctx.mkErr(k, "key must be of type string")
+	}
+	f := ctx.label(k.strValue(), true)
+	st := &structLit{baseValue: x.baseValue}
+	st.insertValue(ctx, f, x.opt, x.def, v, x.attrs, x.doc)
+	return st
+}
 
 func (x *structLit) evalPartial(ctx *context) (result evaluated) {
 	if ctx.trace {
@@ -290,6 +325,9 @@
 
 	// TODO: Handle cycle?
 
+	// TODO: would be great to be able to expand fields here. But would need
+	// some careful consideration regarding dereferencing.
+
 	return x
 }
 
diff --git a/cue/export.go b/cue/export.go
index ec454b5..8035c94 100644
--- a/cue/export.go
+++ b/cue/export.go
@@ -659,35 +659,33 @@
 	for _, v := range x.comprehensions {
 		switch c := v.(type) {
 		case *fieldComprehension:
+			l := p.expr(c.key)
+			label, _ := l.(ast.Label)
+			opt := token.NoPos
+			if c.opt {
+				opt = token.NoSpace.Pos() // anything but token.NoPos
+			}
+			tok := token.COLON
+			if c.def {
+				tok = token.ISA
+			}
+			f := &ast.Field{
+				Label:    label,
+				Optional: opt,
+				Token:    tok,
+				Value:    p.expr(c.val),
+			}
+			obj.Elts = append(obj.Elts, f)
+
+		case *structComprehension:
 			var clauses []ast.Clause
 			next := c.clauses
 			for {
 				if yield, ok := next.(*yield); ok {
-					l := p.expr(yield.key)
-					label, ok := l.(ast.Label)
-					if !ok {
-						// TODO: add an invalid field instead?
-						continue
-					}
-					opt := token.NoPos
-					if yield.opt {
-						opt = token.NoSpace.Pos() // anything but token.NoPos
-					}
-					f := &ast.Field{
-						Label:    label,
-						Optional: opt,
-						Value:    p.expr(yield.value),
-					}
-					var decl ast.Decl = f
-					if len(clauses) > 0 {
-						decl = &ast.Comprehension{
-							Clauses: clauses,
-							Value: &ast.StructLit{
-								Elts: []ast.Decl{f},
-							},
-						}
-					}
-					obj.Elts = append(obj.Elts, decl)
+					obj.Elts = append(obj.Elts, &ast.Comprehension{
+						Clauses: clauses,
+						Value:   p.expr(yield.value),
+					})
 					break
 				}
 
diff --git a/cue/resolve_test.go b/cue/resolve_test.go
index 8a9b838..b1c776c 100644
--- a/cue/resolve_test.go
+++ b/cue/resolve_test.go
@@ -1324,10 +1324,11 @@
 		`,
 		out: `<0>{` +
 			`A :: <1>C{f1: int, f2: int}, ` +
-			`B :: <2>C{f1: int}, ` +
-			`C :: <3>C{f1: int}, ` +
-			`D :: <4>{f1: int, ...}, ` +
-			`a: <5>C{f1: int, f2: int, f3: int}}`,
+			`a: <2>C{f1: int, f2: int, f3: int}, ` +
+			`B :: <3>C{f1: int}, ` +
+			`C :: <4>C{f1: int}, ` +
+			`D :: <5>{f1: int, ...}` +
+			`}`,
 	}, {
 		desc: "reference to root",
 		in: `
@@ -1580,8 +1581,7 @@
 				}
 			}
 		`,
-		out: `<0>{obj: <1>{<>: <2>(Name: string)-><3>{a: (*"dummy" | string) if true yield ("sub"): <4>{as: <3>.a}}, ` +
-			`foo: <5>{a: "bar", sub: <6>{as: "bar"}}}}`,
+		out: `<0>{obj: <1>{<>: <2>(Name: string)-><3>{a: (*"dummy" | string) if true yield <4>{sub: <5>{as: <3>.a}}}, foo: <6>{a: "bar", sub: <7>{as: "bar"}}}}`,
 	}, {
 		desc: "builtins",
 		in: `
@@ -1911,7 +1911,7 @@
 				}
 			}
 		`,
-		out: `<0>{b: true, c: <1>{a: 3}, a: "foo", d: <2>{a: int if (<2>.a > 1) yield ("a"): 3}}`,
+		out: `<0>{b: true, a: "foo", c: <1>{a: 3}, d: <2>{a: int if (<2>.a > 1) yield <3>{a: 3}}}`,
 	}, {
 		desc: "referencing field in field comprehension",
 		in: `
@@ -2202,7 +2202,7 @@
 			`fibRec: <1>{` +
 			`nn: int, ` +
 			`out: (<2>.fib & <3>{n: <4>.nn}).out}, ` +
-			`fib: <5>{n: int if (<5>.n >= 2) yield ("out"): ((<2>.fibRec & <6>{nn: (<5>.n - 2)}).out + (<2>.fibRec & <7>{nn: (<5>.n - 1)}).out),  if (<5>.n < 2) yield ("out"): <5>.n}, ` +
+			`fib: <5>{n: int if (<5>.n >= 2) yield <6>{out: ((<2>.fibRec & <7>{nn: (<5>.n - 2)}).out + (<2>.fibRec & <8>{nn: (<5>.n - 1)}).out)},  if (<5>.n < 2) yield <9>{out: <5>.n}}, ` +
 			`fib2: 1, ` +
 			`fib7: 13, ` +
 			`fib12: 144}`,
@@ -2320,17 +2320,9 @@
 	// Don't remove. For debugging.
 	testCases := []testCase{{
 		in: `
-		fnRec: {nn: [...int], out: (fn & {arg: nn}).out}
-		fn: {
-			arg: [...int]
-
-			out: arg[0] + (fnRec & {nn: arg[1:]}).out if len(arg) > 0
-			out: 0 if len(arg) == 0
-		}
-		fn7: (fn & {arg: [1, 2, 3]}).out
-
-
-		`,
+		g1: 1
+		"g\(1)"?: 1
+	`,
 	}}
 	rewriteHelper(t, testCases, evalFull)
 }
diff --git a/cue/rewrite.go b/cue/rewrite.go
index ff4e7ba..6d13eaa 100644
--- a/cue/rewrite.go
+++ b/cue/rewrite.go
@@ -225,24 +225,29 @@
 	return &listComprehension{x.baseValue, clauses}
 }
 
-func (x *fieldComprehension) rewrite(ctx *context, fn rewriteFunc) value {
+func (x *structComprehension) rewrite(ctx *context, fn rewriteFunc) value {
 	clauses := rewrite(ctx, x.clauses, fn).(yielder)
 	if clauses == x.clauses {
 		return x
 	}
-	return &fieldComprehension{x.baseValue, clauses, x.isTemplate}
+	return &structComprehension{x.baseValue, clauses}
+}
+
+func (x *fieldComprehension) rewrite(ctx *context, fn rewriteFunc) value {
+	key := rewrite(ctx, x.key, fn)
+	val := rewrite(ctx, x.val, fn)
+	if key == x.key && val == x.val {
+		return x
+	}
+	return &fieldComprehension{x.baseValue, key, val, x.opt, x.def, x.doc, x.attrs}
 }
 
 func (x *yield) rewrite(ctx *context, fn rewriteFunc) value {
-	key := x.key
-	if key != nil {
-		key = rewrite(ctx, x.key, fn)
-	}
 	value := rewrite(ctx, x.value, fn)
-	if key == x.key && value == x.value {
+	if value == x.value {
 		return x
 	}
-	return &yield{x.baseValue, x.opt, x.def, key, value}
+	return &yield{x.baseValue, value}
 }
 
 func (x *guard) rewrite(ctx *context, fn rewriteFunc) value {
diff --git a/cue/subsume.go b/cue/subsume.go
index 0440e54..cacc6fa 100644
--- a/cue/subsume.go
+++ b/cue/subsume.go
@@ -90,6 +90,11 @@
 		if len(x.comprehensions) > 0 { //|| x.template != nil {
 			return false
 		}
+		if x.emit != nil {
+			if o.emit == nil || !subsumes(ctx, x.emit, o.emit, mode) {
+				return false
+			}
+		}
 
 		// all arcs in n must exist in v and its values must subsume.
 		for _, a := range x.arcs {
@@ -471,9 +476,20 @@
 }
 
 // structural equivalence
+func (x *structComprehension) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
+	if b, ok := v.(*structComprehension); ok {
+		return subsumes(ctx, x.clauses, b.clauses, 0)
+	}
+	return isBottom(v)
+}
+
+// structural equivalence
 func (x *fieldComprehension) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
 	if b, ok := v.(*fieldComprehension); ok {
-		return subsumes(ctx, x.clauses, b.clauses, 0)
+		return subsumes(ctx, x.key, b.key, 0) &&
+			subsumes(ctx, x.val, b.val, 0) &&
+			!x.opt && b.opt &&
+			x.def == b.def
 	}
 	return isBottom(v)
 }
@@ -481,8 +497,7 @@
 // structural equivalence
 func (x *yield) subsumesImpl(ctx *context, v value, mode subsumeMode) bool {
 	if b, ok := v.(*yield); ok {
-		return subsumes(ctx, x.key, b.key, 0) &&
-			subsumes(ctx, x.value, b.value, 0)
+		return subsumes(ctx, x.value, b.value, 0)
 	}
 	return isBottom(v)
 }
diff --git a/cue/value.go b/cue/value.go
index c24af45..6f5f659 100644
--- a/cue/value.go
+++ b/cue/value.go
@@ -803,71 +803,47 @@
 	x.expanded = x
 
 	comprehensions := x.comprehensions
-	emit := x.emit
-	template := x.template
-	newArcs := []arc{}
+
+	var n evaluated = &top{x.baseValue}
+	if x.emit != nil {
+		n = x.emit.evalPartial(ctx)
+	}
 
 	for _, x := range comprehensions {
-		switch c := x.(type) {
-		case *fieldComprehension:
-			err := c.clauses.yield(ctx, func(k, v evaluated, opt, def bool) *bottom {
-				if !k.kind().isAnyOf(stringKind) {
-					return ctx.mkErr(k, "key must be of type string")
-				}
+		v := x.evalPartial(ctx)
+		src := binSrc(x.Pos(), opUnify, x, v)
+		n = binOp(ctx, src, opUnifyUnchecked, n, v)
+	}
 
-				if c.isTemplate {
-					// TODO: disallow altogether or only when it refers to fields.
-					if template == nil {
-						template = v
-					} else {
-						template = mkBin(ctx, c.Pos(), opUnify, template, v)
-					}
-					return nil
-				}
-				// TODO(perf): improve big O
-				f := ctx.label(k.strValue(), true)
-				for i, a := range newArcs {
-					if a.feature == f {
-						newArcs[i].v = mkBin(ctx, x.Pos(), opUnify, a.v, v)
-						return nil
-					}
-				}
-				newArcs = append(newArcs, arc{
-					feature:    f,
-					optional:   opt,
-					definition: def,
-					v:          v,
-				})
-				return nil
-			})
-			if err != nil {
-				return nil, err
-			}
+	src := binSrc(x.Pos(), opUnify, x, n)
+	switch n.(type) {
+	case *bottom:
+	case *structLit:
+		orig := *x
+		orig.comprehensions = nil
+		orig.emit = nil
+		n = binOp(ctx, src, opUnifyUnchecked, &orig, n)
+
+	default:
+		if x.emit != nil {
+			v := x.emit.evalPartial(ctx)
+			n = binOp(ctx, src, opUnifyUnchecked, v, n)
 		}
+		return nil, ctx.mkErr(x, "invalid embedding")
 	}
 
-	// TODO: new arcs may be merged with old ones, but only if the old ones were
-	// not referred to in the evaluation of any of the arcs. Or should we relax
-	// the specs?
+	switch v := n.(type) {
+	case *bottom:
+		x.expanded = n
+		return nil, v
+	case *structLit:
+		x.expanded = n
+		return v, nil
 
-	orig := *x
-	orig.comprehensions = nil
-
-	res := orig.binOp(ctx, x, opUnifyUnchecked, &structLit{
-		x.baseValue, // baseValue
-		emit,        // emit
-		template,    // template
-		false,       // isClosed
-		nil,         // comprehensions
-		newArcs,     // arcs
-		nil,         // attributes
-	})
-
-	x.expanded = res
-	if isBottom(res) {
-		return nil, res.(*bottom)
+	default:
+		x.expanded = x
+		return x, nil
 	}
-	return x.expanded.(*structLit), nil
 }
 
 func (x *structLit) applyTemplate(ctx *context, i int, v evaluated) (evaluated, *ast.Field) {
@@ -1377,17 +1353,32 @@
 	return listKind | nonGround | referenceKind
 }
 
+type structComprehension struct {
+	baseValue
+	clauses yielder
+}
+
+func (x *structComprehension) kind() kind {
+	return structKind | nonGround | referenceKind
+}
+
+// TODO: rename to something better. No longer a comprehension.
+// Generated field, perhaps.
 type fieldComprehension struct {
 	baseValue
-	clauses    yielder
-	isTemplate bool
+	key   value
+	val   value
+	opt   bool
+	def   bool
+	doc   *docNode
+	attrs *attributes
 }
 
 func (x *fieldComprehension) kind() kind {
 	return structKind | nonGround
 }
 
-type yieldFunc func(k, v evaluated, optional, definition bool) *bottom
+type yieldFunc func(v evaluated) *bottom
 
 type yielder interface {
 	value
@@ -1396,29 +1387,17 @@
 
 type yield struct {
 	baseValue
-	opt   bool
-	def   bool
-	key   value
 	value value
 }
 
 func (x *yield) kind() kind { return topKind | referenceKind }
 
 func (x *yield) yield(ctx *context, fn yieldFunc) *bottom {
-	var k evaluated
-	if x.key != nil {
-		k = ctx.manifest(x.key)
-		if err, ok := k.(*bottom); ok {
-			return err
-		}
-	} else {
-		k = &top{}
-	}
 	v := x.value.evalPartial(ctx)
 	if err, ok := v.(*bottom); ok {
 		return err
 	}
-	if err := fn(k, v, x.opt, x.def); err != nil {
+	if err := fn(v); err != nil {
 		return err
 	}
 	return nil
diff --git a/doc/tutorial/kubernetes/testdata/manual.out b/doc/tutorial/kubernetes/testdata/manual.out
index 8e1b30f..6019a37 100644
--- a/doc/tutorial/kubernetes/testdata/manual.out
+++ b/doc/tutorial/kubernetes/testdata/manual.out
@@ -1559,11 +1559,11 @@
                                 name:          "peer"
                                 containerPort: 2380
                             }]
-                            command: ["/usr/local/bin/etcd"]
                             volumeMounts: [{
                                 name:      "etcd3"
                                 mountPath: "/data"
                             }]
+                            command: ["/usr/local/bin/etcd"]
                             livenessProbe: {
                                 httpGet: {
                                     path: "/health"
@@ -1650,11 +1650,11 @@
                 template: {
                     spec: {
                         containers: [{
-                            command: ["/usr/local/bin/etcd"]
                             volumeMounts: [{
                                 name:      "etcd3"
                                 mountPath: "/data"
                             }]
+                            command: ["/usr/local/bin/etcd"]
                             livenessProbe: {
                                 httpGet: {
                                     path: "/health"
@@ -1859,6 +1859,9 @@
                             }]
                             volumeMounts: [_|_ /* non-concrete value bool */]
                         }]
+                        volumes: [{
+                            name: "secret-volume"
+                        }]
                         affinity: {
                             podAntiAffinity: {
                                 requiredDuringSchedulingIgnoredDuringExecution: [{
@@ -1873,9 +1876,6 @@
                                 }]
                             }
                         }
-                        volumes: [{
-                            name: "secret-volume"
-                        }]
                     }
                     metadata: {
                         labels: {
@@ -4855,13 +4855,13 @@
                                 }
                             }
                         }]
-                        hostNetwork: true
-                        hostPID:     true
                         volumes: [{
                             name: "proc"
                         }, {
                             name: "sys"
                         }]
+                        hostNetwork: true
+                        hostPID:     true
                     }
                     metadata: {
                         labels: {