diff --git a/cue/binop.go b/cue/binop.go
index d83fb16..b52150c 100644
--- a/cue/binop.go
+++ b/cue/binop.go
@@ -34,15 +34,16 @@
 }
 
 func binOp(ctx *context, src source, op op, left, right evaluated) (result evaluated) {
+	_, isUnify := op.unifyType()
 	if b, ok := left.(*bottom); ok {
-		if op == opUnify && b.exprDepth == 0 && cycleError(b) != nil {
+		if isUnify && b.exprDepth == 0 && cycleError(b) != nil {
 			ctx.cycleErr = true
 			return right
 		}
 		return left
 	}
 	if b, ok := right.(*bottom); ok {
-		if op == opUnify && b.exprDepth == 0 && cycleError(b) != nil {
+		if isUnify && b.exprDepth == 0 && cycleError(b) != nil {
 			ctx.cycleErr = true
 			return left
 		}
@@ -82,7 +83,7 @@
 	if invert {
 		left, right = right, left
 	}
-	if op != opUnify {
+	if !isUnify {
 		// Any operation other than unification or disjunction must be on
 		// concrete types. Disjunction is handled separately.
 		if !leftKind.isGround() || !rightKind.isGround() {
@@ -94,7 +95,7 @@
 		return v
 	}
 
-	// op == opUnify
+	// isUnify
 
 	// TODO: unify type masks.
 	if left == right {
@@ -108,13 +109,13 @@
 	}
 
 	if dl, ok := left.(*disjunction); ok {
-		return distribute(ctx, src, dl, right)
+		return distribute(ctx, src, op, dl, right)
 	} else if dr, ok := right.(*disjunction); ok {
-		return distribute(ctx, src, dr, left)
+		return distribute(ctx, src, op, dr, left)
 	}
 
 	if _, ok := right.(*unification); ok {
-		return right.binOp(ctx, src, opUnify, left)
+		return right.binOp(ctx, src, op, left)
 	}
 
 	// TODO: value may be incomplete if there is a cycle. Instead of an error
@@ -141,13 +142,13 @@
 // TODO: this is an exponential algorithm. There is no reason to have to
 // resolve this early. Revise this to only do early pruning but not a full
 // evaluation.
-func distribute(ctx *context, src source, x, y evaluated) evaluated {
+func distribute(ctx *context, src source, op op, x, y evaluated) evaluated {
 	dn := &disjunction{baseValue: src.base()}
-	dist(ctx, dn, false, mVal{x, true}, mVal{y, true})
+	dist(ctx, dn, false, op, mVal{x, true}, mVal{y, true})
 	return dn.normalize(ctx, src).val
 }
 
-func dist(ctx *context, d *disjunction, mark bool, x, y mVal) {
+func dist(ctx *context, d *disjunction, mark bool, op op, x, y mVal) {
 	if dx, ok := x.val.(*disjunction); ok {
 		if dx.hasDefaults {
 			mark = true
@@ -155,7 +156,7 @@
 		}
 		for _, dxv := range dx.values {
 			m := dxv.marked || !dx.hasDefaults
-			dist(ctx, d, mark, mVal{dxv.val.evalPartial(ctx), m}, y)
+			dist(ctx, d, mark, op, mVal{dxv.val.evalPartial(ctx), m}, y)
 		}
 		return
 	}
@@ -166,12 +167,12 @@
 		}
 		for _, dxy := range dy.values {
 			m := dxy.marked || !dy.hasDefaults
-			dist(ctx, d, mark, x, mVal{dxy.val.evalPartial(ctx), m})
+			dist(ctx, d, mark, op, x, mVal{dxy.val.evalPartial(ctx), m})
 		}
 		return
 	}
-	src := binSrc(token.NoPos, opUnify, x.val, y.val)
-	d.add(ctx, binOp(ctx, src, opUnify, x.val, y.val), mark && x.mark && y.mark)
+	src := binSrc(token.NoPos, op, x.val, y.val)
+	d.add(ctx, binOp(ctx, src, op, x.val, y.val), mark && x.mark && y.mark)
 }
 
 func (x *disjunction) binOp(ctx *context, src source, op op, other evaluated) evaluated {
@@ -331,7 +332,6 @@
 		k, _, msg := matchBinOpKind(opUnify, x.kind(), other.kind())
 		if k == bottomKind {
 			return ctx.mkErr(src, msg, opUnify, ctx.str(x), ctx.str(other), x.kind(), other.kind())
-			break
 		}
 		switch y := other.(type) {
 		case *basicType:
@@ -582,7 +582,8 @@
 
 func (x *structLit) binOp(ctx *context, src source, op op, other evaluated) evaluated {
 	y, ok := other.(*structLit)
-	if !ok || op != opUnify {
+	_, isUnify := op.unifyType()
+	if !ok || !isUnify {
 		return ctx.mkIncompatible(src, op, x, other)
 	}
 
@@ -594,7 +595,14 @@
 		return x
 	}
 	arcs := make(arcs, 0, len(x.arcs)+len(y.arcs))
-	obj := &structLit{binSrc(src.Pos(), op, x, other), x.emit, nil, nil, arcs, nil}
+	obj := &structLit{
+		binSrc(src.Pos(), op, x, other), // baseValue
+		x.emit,                          // emit
+		nil,                             // template
+		nil,                             // comprehensions
+		arcs,                            // arcs
+		nil,                             // attributes
+	}
 	defer ctx.pushForwards(x, obj, y, obj).popForwards()
 
 	tx, ex := evalLambda(ctx, x.template)
diff --git a/cue/errors.go b/cue/errors.go
index 12342c9..b8f8436 100644
--- a/cue/errors.go
+++ b/cue/errors.go
@@ -147,7 +147,7 @@
 func appendPositions(pos []token.Pos, src source) []token.Pos {
 	if src != nil {
 		if b, ok := src.(*binaryExpr); ok {
-			if b.op == opUnify {
+			if _, isUnify := b.op.unifyType(); isUnify {
 				pos = appendPositions(pos, b.left)
 				pos = appendPositions(pos, b.right)
 			}
diff --git a/cue/eval.go b/cue/eval.go
index 1aa390f..f0f5cfb 100644
--- a/cue/eval.go
+++ b/cue/eval.go
@@ -365,7 +365,7 @@
 	}
 	var left, right evaluated
 
-	if x.op != opUnify {
+	if _, isUnify := x.op.unifyType(); !isUnify {
 		ctx.incEvalDepth()
 		left = ctx.manifest(x.left)
 		right = ctx.manifest(x.right)
diff --git a/cue/export.go b/cue/export.go
index 3e804a3..8f5a9c6 100644
--- a/cue/export.go
+++ b/cue/export.go
@@ -352,104 +352,7 @@
 		return bin
 
 	case *structLit:
-		obj := &ast.StructLit{}
-		if doEval(p.mode) {
-			x = x.expandFields(p.ctx)
-		}
-		for _, a := range x.arcs {
-			p.stack = append(p.stack, remap{
-				key:  x,
-				from: a.feature,
-				to:   nil,
-				syn:  obj,
-			})
-		}
-		if x.emit != nil {
-			obj.Elts = append(obj.Elts, &ast.EmbedDecl{Expr: p.expr(x.emit)})
-		}
-		if !doEval(p.mode) && x.template != nil {
-			l, ok := x.template.evalPartial(p.ctx).(*lambdaExpr)
-			if ok {
-				obj.Elts = append(obj.Elts, &ast.Field{
-					Label: &ast.TemplateLabel{
-						Ident: p.identifier(l.params.arcs[0].feature),
-					},
-					Value: p.expr(l.value),
-				})
-			} // TODO: else record error
-		}
-		for i, a := range x.arcs {
-			f := &ast.Field{
-				Label: p.label(a.feature),
-			}
-			// TODO: allow the removal of hidden fields. However, hidden fields
-			// that still used in incomplete expressions should not be removed
-			// (unless RequireConcrete is requested).
-			if a.optional {
-				// Optional fields are almost never concrete. We omit them in
-				// concrete mode to allow the user to use the -a option in eval
-				// without getting many errors.
-				if p.mode.omitOptional || p.mode.concrete {
-					continue
-				}
-				f.Optional = token.NoSpace.Pos()
-			}
-			if a.feature&hidden != 0 && p.mode.concrete && p.mode.omitHidden {
-				continue
-			}
-			if !doEval(p.mode) {
-				f.Value = p.expr(a.v)
-			} else {
-				e := x.at(p.ctx, i)
-				if v := p.ctx.manifest(e); isIncomplete(v) && !p.mode.concrete && isBottom(e) {
-					p := &exporter{p.ctx, options{raw: true}, p.stack, p.top, p.imports}
-					f.Value = p.expr(a.v)
-				} else {
-					f.Value = p.expr(e)
-				}
-			}
-			if a.attrs != nil && !p.mode.omitAttrs {
-				for _, at := range a.attrs.attr {
-					f.Attrs = append(f.Attrs, &ast.Attribute{Text: at.text})
-				}
-			}
-			obj.Elts = append(obj.Elts, f)
-		}
-
-		for _, c := range x.comprehensions {
-			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.ComprehensionDecl{Field: f, Clauses: clauses}
-					}
-					obj.Elts = append(obj.Elts, decl)
-					break
-				}
-
-				var y ast.Clause
-				y, next = p.clause(next)
-				clauses = append(clauses, y)
-			}
-		}
-		return obj
+		return p.structure(x)
 
 	case *fieldComprehension:
 		panic("should be handled in structLit")
@@ -607,6 +510,107 @@
 	}
 }
 
+func (p *exporter) structure(x *structLit) *ast.StructLit {
+	obj := &ast.StructLit{}
+	if doEval(p.mode) {
+		x = x.expandFields(p.ctx)
+	}
+	for _, a := range x.arcs {
+		p.stack = append(p.stack, remap{
+			key:  x,
+			from: a.feature,
+			to:   nil,
+			syn:  obj,
+		})
+	}
+	if x.emit != nil {
+		obj.Elts = append(obj.Elts, &ast.EmbedDecl{Expr: p.expr(x.emit)})
+	}
+	if !doEval(p.mode) && x.template != nil {
+		l, ok := x.template.evalPartial(p.ctx).(*lambdaExpr)
+		if ok {
+			obj.Elts = append(obj.Elts, &ast.Field{
+				Label: &ast.TemplateLabel{
+					Ident: p.identifier(l.params.arcs[0].feature),
+				},
+				Value: p.expr(l.value),
+			})
+		} // TODO: else record error
+	}
+	for i, a := range x.arcs {
+		f := &ast.Field{
+			Label: p.label(a.feature),
+		}
+		// TODO: allow the removal of hidden fields. However, hidden fields
+		// that still used in incomplete expressions should not be removed
+		// (unless RequireConcrete is requested).
+		if a.optional {
+			// Optional fields are almost never concrete. We omit them in
+			// concrete mode to allow the user to use the -a option in eval
+			// without getting many errors.
+			if p.mode.omitOptional || p.mode.concrete {
+				continue
+			}
+			f.Optional = token.NoSpace.Pos()
+		}
+		if a.feature&hidden != 0 && p.mode.concrete && p.mode.omitHidden {
+			continue
+		}
+		if !doEval(p.mode) {
+			f.Value = p.expr(a.v)
+		} else {
+			e := x.at(p.ctx, i)
+			if v := p.ctx.manifest(e); isIncomplete(v) && !p.mode.concrete && isBottom(e) {
+				p := &exporter{p.ctx, options{raw: true}, p.stack, p.top, p.imports}
+				f.Value = p.expr(a.v)
+			} else {
+				f.Value = p.expr(e)
+			}
+		}
+		if a.attrs != nil && !p.mode.omitAttrs {
+			for _, at := range a.attrs.attr {
+				f.Attrs = append(f.Attrs, &ast.Attribute{Text: at.text})
+			}
+		}
+		obj.Elts = append(obj.Elts, f)
+	}
+
+	for _, c := range x.comprehensions {
+		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.ComprehensionDecl{Field: f, Clauses: clauses}
+				}
+				obj.Elts = append(obj.Elts, decl)
+				break
+			}
+
+			var y ast.Clause
+			y, next = p.clause(next)
+			clauses = append(clauses, y)
+		}
+	}
+	return obj
+}
+
 // quote quotes the given string.
 func quote(str string, quote byte) string {
 	if strings.IndexByte(str, '\n') < 0 {
diff --git a/cue/op.go b/cue/op.go
index 8becafc..e13f965 100644
--- a/cue/op.go
+++ b/cue/op.go
@@ -133,6 +133,10 @@
 	return opEql <= op && op <= opGeq
 }
 
+func (op op) unifyType() (unchecked, ok bool) {
+	return false, op == opUnify
+}
+
 type op uint16
 
 const (
diff --git a/cue/value.go b/cue/value.go
index f8b6479..cfcee96 100644
--- a/cue/value.go
+++ b/cue/value.go
@@ -742,11 +742,9 @@
 	emit := x.emit
 	template := x.template
 	newArcs := []arc{}
-	optional := false
 
 	for _, c := range comprehensions {
 		result := c.clauses.yield(ctx, func(k, v evaluated, opt bool) *bottom {
-			optional = opt
 			if !k.kind().isAnyOf(stringKind) {
 				return ctx.mkErr(k, "key must be of type string")
 			}
@@ -767,7 +765,11 @@
 					return nil
 				}
 			}
-			newArcs = append(newArcs, arc{feature: f, v: v})
+			newArcs = append(newArcs, arc{
+				feature:  f,
+				optional: opt,
+				v:        v,
+			})
 			return nil
 		})
 		switch {
@@ -785,7 +787,14 @@
 	arcs := make([]arc, 0, len(x.arcs)+len(newArcs))
 	arcs = append(arcs, x.arcs...)
 	orig := x
-	x = &structLit{x.baseValue, emit, template, nil, arcs, nil}
+	x = &structLit{
+		x.baseValue, // baseValue
+		emit,        // emit
+		template,    // template
+		nil,         // comprehensions
+		arcs,        // arcs
+		nil,         // attributes
+	}
 	x.expanded = x
 	orig.expanded = x
 
@@ -799,13 +808,17 @@
 						ctx.labelStr(f))
 				} else {
 					x.arcs[i].v = mkBin(ctx, x.Pos(), opUnify, a.v, na.v)
-					x.arcs[i].optional = x.arcs[i].optional && optional
+					x.arcs[i].optional = x.arcs[i].optional && na.optional
 					x.arcs[i].docs = mergeDocs(na.docs, a.docs)
 				}
 				continue outer
 			}
 		}
-		x.arcs = append(x.arcs, arc{feature: f, optional: optional, v: na.v})
+		x.arcs = append(x.arcs, arc{
+			feature:  f,
+			optional: na.optional,
+			v:        na.v,
+		})
 	}
 	sort.Stable(x)
 	return x