extract [Maybe]TransformSubexprs

Makes a bunch of other code quite a bit simpler

Author: philandstuff

imports/imports.go

@@ -96,109 +96,6 @@ func LoadWith(cache DhallCache, e Term, ancestors ...Fetchable) (Term, error) {
 			cache.Save(actualHash, core.QuoteAlphaNormal(exprVal))
 		}
 		return expr, nil
-	case Lambda:
-		resolvedType, err := LoadWith(cache, e.Type, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		resolvedBody, err := LoadWith(cache, e.Body, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		return Lambda{
-			Label: e.Label,
-			Type:  resolvedType,
-			Body:  resolvedBody,
-		}, nil
-	case Pi:
-		resolvedType, err := LoadWith(cache, e.Type, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		resolvedBody, err := LoadWith(cache, e.Body, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		return Pi{
-			Label: e.Label,
-			Type:  resolvedType,
-			Body:  resolvedBody,
-		}, nil
-	case App:
-		resolvedFn, err := LoadWith(cache, e.Fn, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		resolvedArg, err := LoadWith(cache, e.Arg, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		return Apply(
-			resolvedFn,
-			resolvedArg,
-		), nil
-	case Let:
-		newBindings := make([]Binding, len(e.Bindings))
-		for i, binding := range e.Bindings {
-			var err error
-			newBindings[i].Variable = binding.Variable
-			if binding.Annotation != nil {
-				newBindings[i].Annotation, err = LoadWith(cache, binding.Annotation, ancestors...)
-				if err != nil {
-					return nil, err
-				}
-			}
-			newBindings[i].Value, err = LoadWith(cache, binding.Value, ancestors...)
-			if err != nil {
-				return nil, err
-			}
-		}
-		resolvedBody, err := LoadWith(cache, e.Body, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		return Let{Bindings: newBindings, Body: resolvedBody}, nil
-	case Annot:
-		resolvedExpr, err := LoadWith(cache, e.Expr, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		resolvedAnnotation, err := LoadWith(cache, e.Annotation, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		return Annot{Expr: resolvedExpr, Annotation: resolvedAnnotation}, nil
-	case TextLit:
-		var newChunks Chunks
-		for _, chunk := range e.Chunks {
-			resolvedExpr, err := LoadWith(cache, chunk.Expr, ancestors...)
-			if err != nil {
-				return nil, err
-			}
-			newChunks = append(newChunks, Chunk{
-				Prefix: chunk.Prefix,
-				Expr:   resolvedExpr,
-			})
-		}
-		return TextLit{newChunks, e.Suffix}, nil
-	case If:
-		resolvedCond, err := LoadWith(cache, e.Cond, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		resolvedT, err := LoadWith(cache, e.T, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		resolvedF, err := LoadWith(cache, e.F, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		return If{
-			Cond: resolvedCond,
-			T:    resolvedT,
-			F:    resolvedF,
-		}, nil
 	case Op:
 		if e.OpCode == ImportAltOp {
 			resolvedL, err := LoadWith(cache, e.L, ancestors...)
@@ -220,112 +117,10 @@ func LoadWith(cache DhallCache, e Term, ancestors ...Fetchable) (Term, error) {
 			return nil, err
 		}
 		return Op{OpCode: e.OpCode, L: resolvedL, R: resolvedR}, nil
-	case EmptyList:
-		resolvedType, err := LoadWith(cache, e.Type, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		return EmptyList{Type: resolvedType}, nil
-	case NonEmptyList:
-		newList := make(NonEmptyList, len(e))
-		for i, item := range e {
-			var err error
-			newList[i], err = LoadWith(cache, item, ancestors...)
-			if err != nil {
-				return nil, err
-			}
-		}
-		return newList, nil
-	case Some:
-		val, err := LoadWith(cache, e.Val, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		return Some{val}, nil
-	case RecordType:
-		newRecord := make(RecordType, len(e))
-		for k, v := range e {
-			var err error
-			newRecord[k], err = LoadWith(cache, v, ancestors...)
-			if err != nil {
-				return nil, err
-			}
-		}
-		return newRecord, nil
-	case RecordLit:
-		newRecord := make(RecordLit, len(e))
-		for k, v := range e {
-			var err error
-			newRecord[k], err = LoadWith(cache, v, ancestors...)
-			if err != nil {
-				return nil, err
-			}
-		}
-		return newRecord, nil
-	case ToMap:
-		record, err := LoadWith(cache, e.Record, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		typ, err := LoadWith(cache, e.Type, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		return ToMap{Record: record, Type: typ}, nil
-	case Field:
-		newRecord, err := LoadWith(cache, e.Record, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		return Field{Record: newRecord, FieldName: e.FieldName}, nil
-	case Project:
-		newRecord, err := LoadWith(cache, e.Record, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		return Project{Record: newRecord, FieldNames: e.FieldNames}, nil
-	case ProjectType:
-		record, err := LoadWith(cache, e.Record, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		typ, err := LoadWith(cache, e.Selector, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		return ProjectType{Record: record, Selector: typ}, nil
-	case UnionType:
-		result := make(UnionType, len(e))
-		for k, v := range e {
-			var err error
-			if v == nil {
-				result[k] = nil
-				continue
-			}
-			result[k], err = LoadWith(cache, v, ancestors...)
-			if err != nil {
-				return nil, err
-			}
-		}
-		return result, nil
-	case Merge:
-		handler, err := LoadWith(cache, e.Handler, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		union, err := LoadWith(cache, e.Union, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		return Merge{Handler: handler, Union: union}, nil
-	case Assert:
-		annot, err := LoadWith(cache, e.Annotation, ancestors...)
-		if err != nil {
-			return nil, err
-		}
-		return Assert{Annotation: annot}, nil
 	default:
 		// Const, NaturalLit, etc
-		return e, nil
+		return term.MaybeTransformSubexprs(e, func(t Term) (Term, error) {
+			return LoadWith(cache, t, ancestors...)
+		})
 	}
 }

imports/imports_test.go

@@ -10,7 +10,6 @@ import (
 	. "github.com/philandstuff/dhall-golang/v4/term"
 
 	. "github.com/onsi/ginkgo"
-	. "github.com/onsi/ginkgo/extensions/table"
 	. "github.com/onsi/gomega"
 	"github.com/onsi/gomega/ghttp"
 )
@@ -48,13 +47,13 @@ var _ = Describe("Import resolution", func() {
 
 			Expect(err).To(HaveOccurred())
 		})
-		XIt("Performs import chaining", func() {
+		It("Performs import chaining", func() {
 			os.Setenv("CHAIN1", "env:CHAIN2")
 			os.Setenv("CHAIN2", "2 + 2")
 			actual, err := Load(NewEnvVarImport("CHAIN1", Code))
 
 			Expect(err).ToNot(HaveOccurred())
-			Expect(actual).To(Equal(NaturalPlus(NaturalLit(2), NaturalLit(2))))
+			Expect(actual).To(Equal(NaturalLit(4)))
 		})
 		It("Rejects import cycles", func() {
 			result := make(chan error)
@@ -196,11 +195,11 @@ var _ = Describe("Import resolution", func() {
 
 			Expect(err).To(HaveOccurred())
 		})
-		XIt("Performs import chaining", func() {
+		It("Performs import chaining", func() {
 			actual, err := Load(NewLocalImport("./testdata/chain1.dhall", Code))
 
 			Expect(err).ToNot(HaveOccurred())
-			Expect(actual).To(Equal(NaturalPlus(NaturalLit(2), NaturalLit(2))))
+			Expect(actual).To(Equal(NaturalLit(4)))
 		})
 		It("Rejects import cycles", func() {
 			result := make(chan error)
@@ -213,109 +212,4 @@ var _ = Describe("Import resolution", func() {
 			Eventually(result).Should(Receive())
 		})
 	})
-	DescribeTable("Other subexpressions", expectResolves,
-		Entry("Literal expression", NaturalLit(3), NaturalLit(3)),
-		Entry("Simple import", importFooAsText, resolvedFooAsText),
-		Entry("Import within lambda type",
-			Lambda{Type: importFooAsText},
-			Lambda{Type: resolvedFooAsText},
-		),
-		Entry("Import within lambda body",
-			Lambda{Body: importFooAsText},
-			Lambda{Body: resolvedFooAsText},
-		),
-		Entry("Import within pi type",
-			Pi{Type: importFooAsText},
-			Pi{Type: resolvedFooAsText},
-		),
-		Entry("Import within pi body",
-			Pi{Body: importFooAsText},
-			Pi{Body: resolvedFooAsText},
-		),
-		Entry("Import within app fn",
-			App{Fn: importFooAsText},
-			App{Fn: resolvedFooAsText},
-		),
-		Entry("Import within app arg",
-			App{Arg: importFooAsText},
-			App{Arg: resolvedFooAsText},
-		),
-		Entry("Import within let binding value",
-			NewLet(Natural, Binding{Value: importFooAsText}),
-			NewLet(Natural, Binding{Value: resolvedFooAsText}),
-		),
-		Entry("Import within let body",
-			NewLet(importFooAsText, Binding{}),
-			NewLet(resolvedFooAsText, Binding{}),
-		),
-		Entry("Import within annotated expression",
-			Annot{importFooAsText, Text},
-			Annot{resolvedFooAsText, Text},
-		),
-		Entry("Import within annotation",
-			// these don't typecheck but we're just
-			// checking the imports here
-			Annot{Natural, importFooAsText},
-			Annot{Natural, resolvedFooAsText},
-		),
-		Entry("Import within TextLit",
-			TextLit{
-				Chunks: Chunks{
-					{
-						Prefix: "foo",
-						Expr:   importFooAsText,
-					}},
-				Suffix: "baz",
-			},
-			TextLit{
-				Chunks: Chunks{
-					{
-						Prefix: "foo",
-						Expr:   resolvedFooAsText,
-					},
-				},
-				Suffix: "baz",
-			},
-		),
-		Entry("Import within if condition",
-			If{Cond: importFooAsText},
-			If{Cond: resolvedFooAsText},
-		),
-		Entry("Import within if true branch",
-			If{T: importFooAsText},
-			If{T: resolvedFooAsText},
-		),
-		Entry("Import within if false branch",
-			If{F: importFooAsText},
-			If{F: resolvedFooAsText},
-		),
-		Entry("Import within Operator (left side)",
-			Op{L: importFooAsText},
-			Op{L: resolvedFooAsText},
-		),
-		Entry("Import within natural plus (right side)",
-			Op{R: importFooAsText},
-			Op{R: resolvedFooAsText},
-		),
-		Entry("Import within empty list type",
-			EmptyList{Type: importFooAsText},
-			EmptyList{Type: resolvedFooAsText},
-		),
-		Entry("Import within list",
-			NewList(importFooAsText),
-			NewList(resolvedFooAsText),
-		),
-		Entry("Import within record type",
-			RecordType{"foo": importFooAsText},
-			RecordType{"foo": resolvedFooAsText},
-		),
-		Entry("Import within record literal",
-			RecordLit{"foo": importFooAsText},
-			RecordLit{"foo": resolvedFooAsText},
-		),
-		Entry("Import within field extract",
-			Field{Record: importFooAsText},
-			Field{Record: resolvedFooAsText},
-		),
-	)
 })