diff --git a/cmd/cue/cmd/eval.go b/cmd/cue/cmd/eval.go
index 938456c..76a7b96 100644
--- a/cmd/cue/cmd/eval.go
+++ b/cmd/cue/cmd/eval.go
@@ -17,6 +17,7 @@
 import (
 	"fmt"
 
+	"cuelang.org/go/cue"
 	"cuelang.org/go/cue/ast"
 	"cuelang.org/go/cue/format"
 	"cuelang.org/go/cue/parser"
@@ -62,16 +63,26 @@
 		for _, inst := range instances {
 			// TODO: use ImportPath or some other sanitized path.
 			fmt.Fprintf(w, "// %s\n", inst.Dir)
+			syn := []cue.Option{
+				cue.Attributes(*attrs),
+				cue.Optional(*all || *optional),
+			}
+			if *compile {
+				syn = append(syn, cue.RequireConcrete())
+			}
+			if *hidden || *all {
+				syn = append(syn, cue.Hidden(true))
+			}
 			opts := []format.Option{
 				format.UseSpaces(4),
 				format.TabIndent(false),
 			}
 			if exprs == nil {
-				format.Node(w, inst.Value().Syntax(), opts...)
+				format.Node(w, inst.Value().Syntax(syn...), opts...)
 				fmt.Fprintln(w)
 			}
 			for _, e := range exprs {
-				format.Node(w, inst.Eval(e).Syntax(), opts...)
+				format.Node(w, inst.Eval(e).Syntax(syn...), opts...)
 				fmt.Fprintln(w)
 			}
 		}
@@ -84,8 +95,29 @@
 
 	expressions = evalCmd.Flags().StringArrayP("expression", "e", nil, "evaluate this expression only")
 
+	compile = evalCmd.Flags().BoolP("concrete", "c", false,
+		"require the evaluation to be concrete")
+
+	hidden = evalCmd.Flags().BoolP("show-hidden", "H", false,
+		"display hidden attributes")
+
+	optional = evalCmd.Flags().BoolP("show-optional", "O", false,
+		"display hidden attributes")
+
+	attrs = evalCmd.Flags().BoolP("attributes", "l", false,
+		"display field attributes")
+
+	all = evalCmd.Flags().BoolP("all", "a", false,
+		"show optional and hidden fields")
+
+	// TODO: Option to include comments in output.
 }
 
 var (
 	expressions *[]string
+	compile     *bool
+	attrs       *bool
+	all         *bool
+	hidden      *bool
+	optional    *bool
 )
diff --git a/cmd/cue/cmd/trim.go b/cmd/cue/cmd/trim.go
index f6484cc..1da1dce 100644
--- a/cmd/cue/cmd/trim.go
+++ b/cmd/cue/cmd/trim.go
@@ -352,7 +352,7 @@
 
 		// Build map of mixin fields.
 		valueMap := map[key]cue.Value{}
-		for mIter, _ := in.AllFields(); mIter.Next(); {
+		for mIter, _ := in.Fields(cue.All()); mIter.Next(); {
 			valueMap[iterKey(mIter)] = mIter.Value()
 		}
 
@@ -360,7 +360,7 @@
 
 		// Process fields.
 		rm := []ast.Node{}
-		for iter, _ := v.AllFields(); iter.Next(); {
+		for iter, _ := v.Fields(cue.All()); iter.Next(); {
 			mSub := valueMap[iterKey(iter)]
 			if fn != nil {
 				mSub = mSub.Unify(fn(iter.Label()))
diff --git a/cue/export.go b/cue/export.go
index 3622e4c..cd4e63c 100644
--- a/cue/export.go
+++ b/cue/export.go
@@ -26,22 +26,18 @@
 	"cuelang.org/go/cue/token"
 )
 
-type exportMode int
+func doEval(m options) bool {
+	return !m.raw
+}
 
-const (
-	exportEval exportMode = 1 << iota
-	exportAttrs
-	exportRaw exportMode = 0
-)
-
-func export(ctx *context, v value, m exportMode) ast.Expr {
+func export(ctx *context, v value, m options) ast.Expr {
 	e := exporter{ctx, m, nil}
 	return e.expr(v)
 }
 
 type exporter struct {
 	ctx   *context
-	mode  exportMode
+	mode  options
 	stack []remap
 }
 
@@ -112,10 +108,10 @@
 }
 
 func (p *exporter) expr(v value) ast.Expr {
-	if p.mode == exportEval {
+	if doEval(p.mode) {
 		x := p.ctx.manifest(v)
 		if isIncomplete(x) {
-			p = &exporter{p.ctx, exportRaw, p.stack}
+			p = &exporter{p.ctx, options{raw: true}, p.stack}
 			return p.expr(v)
 		}
 		v = x
@@ -228,7 +224,7 @@
 
 	case *structLit:
 		obj := &ast.StructLit{}
-		if p.mode == exportEval {
+		if doEval(p.mode) {
 			for _, a := range x.arcs {
 				p.stack = append(p.stack, remap{
 					key:  x,
@@ -242,7 +238,7 @@
 		if x.emit != nil {
 			obj.Elts = append(obj.Elts, &ast.EmitDecl{Expr: p.expr(x.emit)})
 		}
-		if p.mode != exportEval && x.template != nil {
+		if !doEval(p.mode) && x.template != nil {
 			l, ok := x.template.evalPartial(p.ctx).(*lambdaExpr)
 			if ok {
 				obj.Elts = append(obj.Elts, &ast.Field{
@@ -257,15 +253,30 @@
 			f := &ast.Field{
 				Label: p.label(a.feature),
 			}
-			if p.mode != exportEval {
+			// 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 = 1
+			}
+			if a.feature&hidden != 0 && p.mode.concrete && p.mode.omitHidden {
+				continue
+			}
+			if !doEval(p.mode) {
 				f.Value = p.expr(a.v)
-			} else if v := p.ctx.manifest(x.at(p.ctx, i)); isIncomplete(v) {
-				p := &exporter{p.ctx, exportRaw, p.stack}
+			} else if v := p.ctx.manifest(x.at(p.ctx, i)); isIncomplete(v) && !p.mode.concrete {
+				p := &exporter{p.ctx, options{raw: true}, p.stack}
 				f.Value = p.expr(a.v)
 			} else {
 				f.Value = p.expr(v)
 			}
-			if a.attrs != nil { // TODO: && p.mode&exportAttrs != 0 {
+			if a.attrs != nil && !p.mode.omitAttrs {
 				for _, at := range a.attrs.attr {
 					f.Attrs = append(f.Attrs, &ast.Attribute{Text: at.text})
 				}
diff --git a/cue/export_test.go b/cue/export_test.go
index c77f59a..dad7d3a 100644
--- a/cue/export_test.go
+++ b/cue/export_test.go
@@ -26,8 +26,8 @@
 
 func TestExport(t *testing.T) {
 	testCases := []struct {
-		raw     bool
-		mode    exportMode
+		raw     bool // skip evaluation the root, fully raw
+		eval    bool // evaluate the full export
 		in, out string
 	}{{
 		in:  `"hello"`,
@@ -164,7 +164,7 @@
 				}`),
 	}, {
 		raw:  true,
-		mode: exportEval,
+		eval: true,
 		in: `{
 			b: {
 				idx: a[str]
@@ -186,7 +186,7 @@
 		}`),
 	}, {
 		raw:  true,
-		mode: exportEval,
+		eval: true,
 		in: `{
 			job <Name>: {
 				name:     Name
@@ -218,7 +218,7 @@
 		}`),
 	}, {
 		raw:  true,
-		mode: exportEval,
+		eval: true,
 		in: `{
 				b: [{
 					<X>: int
@@ -252,7 +252,8 @@
 			v := newValueRoot(ctx, n)
 
 			buf := &bytes.Buffer{}
-			err := format.Node(buf, export(ctx, v.eval(ctx), tc.mode))
+			opts := options{raw: !tc.eval}
+			err := format.Node(buf, export(ctx, v.eval(ctx), opts))
 			if err != nil {
 				log.Fatal(err)
 			}
diff --git a/cue/types.go b/cue/types.go
index c11fb73..df76119 100644
--- a/cue/types.go
+++ b/cue/types.go
@@ -170,12 +170,16 @@
 	return i.ctx.labelStr(i.f)
 }
 
-// IsHidden reports if a field is hidden from the data model. This may only
-// be true if the field was obtained using AllFields.
+// IsHidden reports if a field is hidden from the data model.
 func (i *Iterator) IsHidden() bool {
 	return i.f&hidden != 0
 }
 
+// IsOptional reports if a field is optional.
+func (i *Iterator) IsOptional() bool {
+	return i.cur.path.arc.optional
+}
+
 // marshalJSON iterates over the list and generates JSON output. HasNext
 // will return false after this operation.
 func marshalList(l *Iterator) (b []byte, err error) {
@@ -481,7 +485,8 @@
 
 // Label reports he label used to obtain this value from the enclosing struct.
 //
-// TODO: get rid of this somehow. Maybe by passing it to walk
+// TODO: get rid of this somehow. Probably by including a FieldInfo struct
+// or the like.
 func (v Value) Label() (string, bool) {
 	if v.path.feature == 0 {
 		return "", false
@@ -583,12 +588,12 @@
 
 // Syntax converts the possibly partially evaluated value into syntax. This
 // can use used to print the value with package format.
-func (v Value) Syntax() ast.Expr {
+func (v Value) Syntax(opts ...Option) ast.Expr {
 	if v.path == nil || v.path.cache == nil {
 		return nil
 	}
 	ctx := v.ctx()
-	return export(ctx, v.eval(ctx), exportEval)
+	return export(ctx, v.eval(ctx), getOptions(opts))
 }
 
 // Decode initializes x with Value v. If x is a struct, it will validate the
@@ -791,6 +796,14 @@
 
 // structVal returns an structVal or an error if v is not a struct.
 func (v Value) structVal(ctx *context) (structValue, error) {
+	return v.structValOpts(ctx, options{
+		omitHidden:   true,
+		omitOptional: true,
+	})
+}
+
+// structVal returns an structVal or an error if v is not a struct.
+func (v Value) structValOpts(ctx *context, o options) (structValue, error) {
 	if err := v.checkKind(ctx, structKind); err != nil {
 		return structValue{}, err
 	}
@@ -799,15 +812,20 @@
 	// TODO: This is expansion appropriate?
 	obj = obj.expandFields(ctx) // expand comprehensions
 
-	// check if any labels are hidden
-	hasOptional := false
-	f := label(0)
-	for _, a := range obj.arcs {
-		f |= a.feature
-		hasOptional = hasOptional || a.optional
+	// check if any fields can be omitted
+	needFilter := false
+	if o.omitHidden || o.omitOptional {
+		f := label(0)
+		for _, a := range obj.arcs {
+			f |= a.feature
+			if o.omitOptional && a.optional {
+				needFilter = true
+			}
+		}
+		needFilter = needFilter || f&hidden != 0
 	}
 
-	if f&hidden != 0 || hasOptional {
+	if needFilter {
 		arcs := make([]arc, len(obj.arcs))
 		k := 0
 		for _, a := range obj.arcs {
@@ -829,32 +847,13 @@
 	return structValue{ctx, v.path, obj}, nil
 }
 
-func (v Value) structValWithHidden(ctx *context) (structValue, error) {
-	if err := v.checkKind(ctx, structKind); err != nil {
-		return structValue{}, err
-	}
-	obj := v.eval(ctx).(*structLit)
-	obj = obj.expandFields(ctx)
-
-	return structValue{ctx, v.path, obj}, nil
-}
-
 // Fields creates an iterator over v's fields if v is a struct or an error
 // otherwise.
-func (v Value) Fields() (Iterator, error) {
+func (v Value) Fields(opts ...Option) (Iterator, error) {
+	o := options{omitHidden: true, omitOptional: true}
+	o.updateOptions(opts)
 	ctx := v.ctx()
-	obj, err := v.structVal(ctx)
-	if err != nil {
-		return Iterator{ctx: ctx}, err
-	}
-	return Iterator{ctx: ctx, val: v, iter: obj.n, len: len(obj.n.arcs)}, nil
-}
-
-// AllFields creates an iterator over all of v's fields, including the hidden
-// ones, if v is a struct or an error otherwise.
-func (v Value) AllFields() (Iterator, error) {
-	ctx := v.ctx()
-	obj, err := v.structValWithHidden(ctx)
+	obj, err := v.structValOpts(ctx, o)
 	if err != nil {
 		return Iterator{ctx: ctx}, err
 	}
@@ -989,32 +988,83 @@
 }
 
 type options struct {
-	concrete bool
+	concrete     bool // enforce that values are concrete
+	raw          bool // show original values
+	hasHidden    bool
+	omitHidden   bool
+	omitOptional bool
+	omitAttrs    bool
 }
 
 // An Option defines modes of evaluation.
-type Option func(p *options)
+type Option option
 
-// Used in Validate, Subsume?, Fields()
+type option func(p *options)
+
+// Used in Iter, Validate, Subsume?, Fields() Syntax, Export
 
 // TODO: could also be used for subsumption.
 
-// RequireConcrete verifies that all values in a tree are concrete.
+// RequireConcrete ensures that all values are concrete.
+//
+// For Validate this means it returns an error if this is not the case.
+// In other cases a non-concrete value will be replaced with an error.
 func RequireConcrete() Option {
-	return func(p *options) { p.concrete = true }
+	return func(p *options) {
+		p.concrete = true
+		if !p.hasHidden {
+			p.omitHidden = true
+		}
+	}
 }
 
-// VisitHidden(visit bool)
+// All indicates that all fields and values should be included in processing
+// even if they can be elided or omitted.
+func All() Option {
+	return func(p *options) {
+		p.omitAttrs = false
+		p.omitHidden = false
+		p.omitOptional = false
+	}
+}
+
+// Hidden indicates that hidden fields should be included.
 //
+// Hidden fields may still be included if include is false,
+// even if a value is not concrete.
+func Hidden(include bool) Option {
+	return func(p *options) {
+		p.hasHidden = true
+		p.omitHidden = !include
+	}
+}
+
+// Optional indicates that optional fields should be included.
+func Optional(include bool) Option {
+	return func(p *options) { p.omitOptional = !include }
+}
+
+// Attributes indicates that attributes should be included.
+func Attributes(include bool) Option {
+	return func(p *options) { p.omitAttrs = !include }
+}
+
+func getOptions(opts []Option) (o options) {
+	o.updateOptions(opts)
+	return
+}
+
+func (o *options) updateOptions(opts []Option) {
+	for _, fn := range opts {
+		fn(o)
+	}
+}
 
 // Validate reports any errors, recursively. The returned error may be an
 // errors.List reporting multiple errors, where the total number of errors
 // reported may be less than the actual number.
 func (v Value) Validate(opts ...Option) error {
-	var o options
-	for _, fn := range opts {
-		fn(&o)
-	}
+	o := getOptions(opts)
 	list := errors.List{}
 	v.Walk(func(v Value) bool {
 		if err := v.Err(); err != nil {
diff --git a/cue/types_test.go b/cue/types_test.go
index bb33193..93fe468 100644
--- a/cue/types_test.go
+++ b/cue/types_test.go
@@ -630,7 +630,7 @@
 		t.Run(tc.value, func(t *testing.T) {
 			obj := getInstance(t, tc.value).Value()
 
-			iter, err := obj.AllFields()
+			iter, err := obj.Fields(All())
 			checkFatal(t, err, tc.err, "init")
 
 			buf := []byte{'{'}
diff --git a/cue/value.go b/cue/value.go
index f15d7cf..976cd40 100644
--- a/cue/value.go
+++ b/cue/value.go
@@ -15,7 +15,6 @@
 package cue
 
 import (
-	"fmt"
 	"math/big"
 	"sort"
 	"strconv"