Merge pull request #55 from philandstuff/release-6.0.0

Release 6.0.0

Author: philandstuff

CHANGELOG.md

@@ -1,10 +1,53 @@
 # Changelog
 
 ## [Unreleased]
-[Unreleased]: https://github.com/philandstuff/dhall-golang/compare/v5.0.0...HEAD
+[Unreleased]: https://github.com/philandstuff/dhall-golang/compare/v6.0.0...HEAD
+
+## [6.0.0] - 2020-10-04
+[6.0.0]: https://github.com/philandstuff/dhall-golang/compare/v5.0.0...v6.0.0
+
+This brings dhall-golang up to version 19.0.0 of the Dhall standard.
+
+### Added
+
+ * From Dhall 19.0.0: add `Text/replace` builtin
+ * Add `dhall-golang json` command
+
+The new `dhall-golang json` command takes some Dhall and outputs it as
+JSON, similar to dhall-haskell's `dhall json`.  One key difference is
+that it also supports Prelude.JSON types.  For example, the following
+command:
+
+    dhall-golang json <<EOF
+    let JSON = https://prelude.dhall-lang.org/JSON/package.dhall
+
+    in  { x = JSON.natural 4
+        , y =
+            JSON.array
+              [ JSON.string "foo", JSON.natural 4, JSON.null, JSON.bool True ]
+        }
+    EOF
+
+will output:
+
+    {
+      "x": 4,
+      "y": [
+        "foo",
+        4,
+        null,
+        true
+      ]
+    }
+
+### Changed
+
+ * From Dhall 19.0.0: implement `with` as first-class expression
+ * Allow unmarshalling Dhall values into `interface{}`; dhall-golang
+   will select appropriate Go types for Dhall values when doing this.
 
 ## [5.0.0] - 2020-09-20
-[5.0.0]: https://github.com/philandstuff/dhall-golang/compare/v4.1.0...v5.1.0
+[5.0.0]: https://github.com/philandstuff/dhall-golang/compare/v4.1.0...v5.0.0
 
 This brings dhall-golang up to version 18.0.0 of the Dhall standard.
 

binary/cbor.go

@@ -41,7 +41,8 @@ var nameToBuiltin = map[string]Term{
 
 	"Double/show": DoubleShow,
 
-	"Text/show": TextShow,
+	"Text/show":    TextShow,
+	"Text/replace": TextReplace,
 
 	"List/build":   ListBuild,
 	"List/fold":    ListFold,

core/ast.go

@@ -79,7 +79,12 @@ type (
 	optional struct{}
 	none     struct{}
 
-	textShow struct{}
+	textShow    struct{}
+	textReplace struct {
+		needle      Value
+		replacement Value
+		// haystack Value
+	}
 
 	list      struct{}
 	listBuild struct {
@@ -119,7 +124,8 @@ func (doubleShow) isValue() {}
 func (optional) isValue() {}
 func (none) isValue()     {}
 
-func (textShow) isValue() {}
+func (textShow) isValue()    {}
+func (textReplace) isValue() {}
 
 func (list) isValue()        {}
 func (listBuild) isValue()   {}
@@ -334,6 +340,12 @@ type (
 		FieldNames []string
 	}
 
+	with struct {
+		Record Value
+		Path   []string
+		Value  Value
+	}
+
 	// no projectType because it cannot be in a normal form so cannot
 	// be a Value
 
@@ -396,6 +408,7 @@ func (RecordLit) isValue()        {}
 func (toMap) isValue()            {}
 func (field) isValue()            {}
 func (project) isValue()          {}
+func (with) isValue()             {}
 func (UnionType) isValue()        {}
 func (unionConstructor) isValue() {}
 func (unionVal) isValue()         {}

core/builtins.go

@@ -234,6 +234,36 @@ func (textShow) Call(a0 Value) Value {
 
 func (textShow) ArgType() Value { return Text }
 
+func (r textReplace) Call(a Value) Value {
+	if r.needle == nil {
+		return textReplace{needle: a}
+	}
+	if r.replacement == nil {
+		return textReplace{needle: r.needle, replacement: a}
+	}
+	needle, ok := r.needle.(PlainTextLit)
+	if !ok {
+		return nil
+	}
+	if needle == "" {
+		return a
+	}
+	haystack, ok := a.(PlainTextLit)
+	if !ok {
+		return nil
+	}
+	text := &textValBuilder{}
+	strs := strings.Split(string(haystack), string(needle))
+	text.appendStr(strs[0])
+	for _, s := range strs[1:] {
+		text.appendValue(r.replacement)
+		text.appendStr(s)
+	}
+	return text.value()
+}
+
+func (textReplace) ArgType() Value { return Text }
+
 func (list) Call(x Value) Value { return ListOf{x} }
 func (list) ArgType() Value     { return Type }
 
@@ -456,7 +486,8 @@ var (
 	Optional Callable = optional{}
 	None     Callable = none{}
 
-	TextShow Callable = textShow{}
+	TextShow    Callable = textShow{}
+	TextReplace Callable = textReplace{}
 
 	List        Callable = list{}
 	ListBuild   Callable = listBuild{}

core/equivalence.go

@@ -21,7 +21,7 @@ func alphaEquivalentWith(level int, v1 Value, v2 Value) bool {
 		integerShow, integerClamp, integerNegate, integerToDouble,
 		doubleShow,
 		optional, none,
-		textShow,
+		textShow, textReplace,
 		list, listBuild, listFold, listHead, listIndexed,
 		listLength, listLast, listReverse,
 		freeVar, localVar, quoteVar,
@@ -197,6 +197,21 @@ func alphaEquivalentWith(level int, v1 Value, v2 Value) bool {
 			}
 		}
 		return alphaEquivalentWith(level, v1.Record, v2.Record)
+	case with:
+		v2, ok := v2.(with)
+		if !ok {
+			return false
+		}
+		if len(v1.Path) != len(v2.Path) {
+			return false
+		}
+		for i := range v1.Path {
+			if v1.Path[i] != v2.Path[i] {
+				return false
+			}
+		}
+		return alphaEquivalentWith(level, v1.Record, v2.Record) &&
+			alphaEquivalentWith(level, v1.Value, v2.Value)
 	case UnionType:
 		v2, ok := v2.(UnionType)
 		if !ok {

core/eval.go

@@ -4,7 +4,6 @@ import (
 	"errors"
 	"fmt"
 	"sort"
-	"strings"
 
 	"github.com/philandstuff/dhall-golang/v5/term"
 )
@@ -64,6 +63,8 @@ func evalWith(t term.Term, e env) Value {
 			return Text
 		case term.TextShow:
 			return TextShow
+		case term.TextReplace:
+			return TextReplace
 		case term.List:
 			return List
 		case term.ListBuild:
@@ -135,41 +136,15 @@ func evalWith(t term.Term, e env) Value {
 	case term.DoubleLit:
 		return DoubleLit(t)
 	case term.TextLit:
-		var str strings.Builder
-		var newChunks chunks
+		text := &textValBuilder{}
 		for _, chk := range t.Chunks {
-			str.WriteString(chk.Prefix)
+			text.appendStr(chk.Prefix)
 			normExpr := evalWith(chk.Expr, e)
-			if text, ok := normExpr.(PlainTextLit); ok {
-				str.WriteString(string(text))
-			} else if text, ok := normExpr.(interpolatedText); ok {
-				// first chunk gets the rest of str
-				str.WriteString(text.Chunks[0].Prefix)
-				newChunks = append(newChunks,
-					chunk{Prefix: str.String(), Expr: text.Chunks[0].Expr})
-				newChunks = append(newChunks,
-					text.Chunks[1:]...)
-				str.Reset()
-				str.WriteString(text.Suffix)
-			} else {
-				newChunks = append(newChunks, chunk{Prefix: str.String(), Expr: normExpr})
-				str.Reset()
-			}
-		}
-		str.WriteString(t.Suffix)
-		newSuffix := str.String()
-
-		// Special case: "${<expr>}" → <expr>
-		if len(newChunks) == 1 && newChunks[0].Prefix == "" && newSuffix == "" {
-			return newChunks[0].Expr
-		}
-
-		// Special case: no chunks -> PlainTextLit
-		if len(newChunks) == 0 {
-			return PlainTextLit(newSuffix)
+			text.appendValue(normExpr)
 		}
+		text.appendStr(t.Suffix)
 
-		return interpolatedText{Chunks: newChunks, Suffix: newSuffix}
+		return text.value()
 	case term.BoolLit:
 		return BoolLit(t)
 	case term.If:
@@ -615,46 +590,33 @@ func evalWith(t term.Term, e env) Value {
 	case term.With:
 		record := evalWith(t.Record, e)
 		value := evalWith(t.Value, e)
-		output := record
-		here := record
-		var recordLit RecordLit
-		depth := 0
-		for _, component := range t.Path {
-			var ok bool
-			recordLit, ok = here.(RecordLit)
-			if !ok {
-				break
-			}
-			here = recordLit[component]
-			depth = depth + 1
-		}
-		desugared := desugarWith(here, t.Path[depth:], value)
-		if depth == 0 {
-			return desugared
-		}
-		recordLit[t.Path[depth-1]] = desugared
-		return output
+
+		return withRule(record, t.Path, value)
 	default:
 		panic(fmt.Sprint("unknown term type", t))
 	}
 }
 
-// desugarWith converts a `r with a.b...c = v` term to the equivalent,
-// defined by desugar-with() in the Dhall standard.  Note that path
-// may be of length 0, in which case value is returned.
-func desugarWith(abstractRecord Value, path []string, value Value) Value {
-	if len(path) == 0 {
-		return value
+// withRule implements evaluation of `with` expressions.  It was too
+// hard to express using for loops, so I finally did actual functional
+// style
+//
+// withRule may modify its parameters, you have been warned
+func withRule(record Value, path []string, value Value) Value {
+	recordLit, ok := record.(RecordLit)
+	if !ok {
+		return with{Record: record, Path: path, Value: value}
+	}
+	if len(path) == 1 {
+		recordLit[path[0]] = value
+		return recordLit
 	}
-	return oper{
-		OpCode: term.RightBiasedRecordMergeOp,
-		L:      abstractRecord,
-		R: RecordLit{path[0]: desugarWith(
-			field{abstractRecord, path[0]},
-			path[1:],
-			value,
-		)},
+	var subrecord Value = RecordLit{}
+	if recordLit[path[0]] != nil {
+		subrecord = recordLit[path[0]]
 	}
+	recordLit[path[0]] = withRule(subrecord, path[1:], value)
+	return recordLit
 }
 
 func apply(fn Value, args ...Value) Value {

core/quote.go

@@ -82,6 +82,17 @@ func quoteWith(ctx quoteContext, shouldAlphaNormalize bool, v Value) term.Term {
 		return term.None
 	case textShow:
 		return term.TextShow
+	case textReplace:
+		var result term.Term = term.TextReplace
+		if v.needle == nil {
+			return result
+		}
+		result = term.App{result, quoteWith(ctx, shouldAlphaNormalize, v.needle)}
+		if v.replacement == nil {
+			return result
+		}
+		result = term.App{result, quoteWith(ctx, shouldAlphaNormalize, v.replacement)}
+		return result
 	case list:
 		return term.List
 	case listBuild:
@@ -246,6 +257,12 @@ func quoteWith(ctx quoteContext, shouldAlphaNormalize bool, v Value) term.Term {
 			Record:     quoteWith(ctx, shouldAlphaNormalize, v.Record),
 			FieldNames: v.FieldNames,
 		}
+	case with:
+		return term.With{
+			Record: quoteWith(ctx, shouldAlphaNormalize, v.Record),
+			Path:   v.Path,
+			Value:  quoteWith(ctx, shouldAlphaNormalize, v.Value),
+		}
 	case UnionType:
 		result := term.UnionType{}
 		for k, v := range v {

core/text.go

@@ -0,0 +1,36 @@
+package core
+
+type textValBuilder struct {
+	Chunks chunks
+	Suffix string
+}
+
+func (t *textValBuilder) appendStr(s string) {
+	t.Suffix += s
+}
+
+func (t *textValBuilder) appendValue(v Value) {
+	if plainText, ok := v.(PlainTextLit); ok {
+		t.Suffix += string(plainText)
+	} else if interpolatedText, ok := v.(interpolatedText); ok {
+		t.Chunks = append(t.Chunks, chunk{
+			Prefix: t.Suffix + interpolatedText.Chunks[0].Prefix,
+			Expr:   interpolatedText.Chunks[0].Expr,
+		})
+		t.Chunks = append(t.Chunks, interpolatedText.Chunks[1:]...)
+		t.Suffix = interpolatedText.Suffix
+	} else {
+		t.Chunks = append(t.Chunks, chunk{Prefix: t.Suffix, Expr: v})
+		t.Suffix = ""
+	}
+}
+
+func (t *textValBuilder) value() Value {
+	if len(t.Chunks) == 0 {
+		return PlainTextLit(t.Suffix)
+	} else if len(t.Chunks) == 1 && t.Chunks[0].Prefix == "" && t.Suffix == "" {
+		// special case: "${x}" -> x
+		return t.Chunks[0].Expr
+	}
+	return interpolatedText(*t)
+}