Better support for Definition[].

expreduce/builtin_system.go

@@ -277,14 +277,11 @@ func GetSystemDefinitions() (defs []Definition) {
 				return this
 			}
 
-			toReturn := NewExpression([]Ex{NewSymbol("System`List")})
 			def, isDef := es.defined[sym.Name]
 			if isDef {
-				for _, s := range def.attributes.toStrings() {
-					toReturn.Parts = append(toReturn.Parts, NewSymbol("System`"+s))
-				}
+				return def.attributes.toSymList()
 			}
-			return toReturn
+			return NewExpression([]Ex{NewSymbol("System`List")})
 		},
 	})
 	defs = append(defs, Definition{
@@ -321,7 +318,6 @@ func GetSystemDefinitions() (defs []Definition) {
 	})
 	defs = append(defs, Definition{
 		Name:              "Definition",
-		OmitDocumentation: true,
 		toString: func(this *Expression, params ToStringParams) (bool, string) {
 			if len(this.Parts) != 2 {
 				return false, ""
@@ -341,7 +337,8 @@ func GetSystemDefinitions() (defs []Definition) {
 			stringParams := params
 			stringParams.context, stringParams.contextPath =
 				DefinitionComplexityStringFormArgs()
-			return true, def.StringForm(stringParams)
+			stringParams.previousHead = "<TOPLEVEL>"
+			return true, def.StringForm(sym, stringParams)
 		},
 	})
 	defs = append(defs, Definition{
@@ -382,7 +379,7 @@ func GetSystemDefinitions() (defs []Definition) {
 			if len(this.Parts) != 3 {
 				return false, ""
 			}
-			return ToStringInfixAdvanced(this.Parts[1:], " = ", "System`Set", false, "(", ")", params)
+			return ToStringInfixAdvanced(this.Parts[1:], " = ", "System`Set", false, "", "", params)
 		},
 		Bootstrap: true,
 		legacyEvalFn: func(this *Expression, es *EvalState) Ex {

expreduce/definition.go

@@ -1,6 +1,6 @@
 package expreduce
 
-import "bytes"
+import "strings"
 
 type DownValue struct {
 	rule        *Expression
@@ -32,28 +32,41 @@ func CopyDefs(in map[string]Def) map[string]Def {
 	return out
 }
 
-func (this *Def) String() string {
-	var buffer bytes.Buffer
-	buffer.WriteString("{")
-	for i, dv := range this.downvalues {
-		buffer.WriteString(dv.rule.String())
-		if i != len(this.downvalues)-1 {
-			buffer.WriteString("\n")
-		}
+func (def *Def) StringForm(defSym *Symbol, params ToStringParams) string {
+	var buffer []string
+
+	attrs := def.attributes.toStrings()
+	if len(attrs) > 0 {
+		e := E(
+			S("Set"),
+			E(
+				S("Attributes"),
+				defSym,
+			),
+			def.attributes.toSymList(),
+		)
+		buffer = append(buffer, e.StringForm(params))
 	}
-	buffer.WriteString("}")
-	return buffer.String()
-}
 
-func (def *Def) StringForm(params ToStringParams) string {
-	var buffer bytes.Buffer
-	buffer.WriteString("{")
-	for i, dv := range def.downvalues {
-		buffer.WriteString(dv.rule.StringForm(params))
-		if i != len(def.downvalues)-1 {
-			buffer.WriteString("\n")
-		}
+	for _, dv := range def.downvalues {
+		e := E(
+			S("SetDelayed"),
+			dv.rule.Parts[1].(*Expression).Parts[1],
+			dv.rule.Parts[2],
+		)
+		buffer = append(buffer, e.StringForm(params))
+	}
+
+	if def.defaultExpr != nil {
+		e := E(
+			S("Set"),
+			E(
+				S("Default"),
+				defSym,
+			),
+			def.defaultExpr,
+		)
+		buffer = append(buffer, e.StringForm(params))
 	}
-	buffer.WriteString("}")
-	return buffer.String()
+	return strings.Join(buffer[:], "\n")
 }

expreduce/evalstate.go

@@ -1,12 +1,10 @@
 package expreduce
 
 import (
-	"bytes"
 	"fmt"
 	"log"
 	"os"
 	"os/signal"
-	"sort"
 	"strings"
 	"time"
 )
@@ -540,30 +538,6 @@ func (this *EvalState) GetDefinedSnapshot() map[string]Def {
 	return CopyDefs(this.defined)
 }
 
-func (this *EvalState) String() string {
-	var buffer bytes.Buffer
-	buffer.WriteString("{")
-	// We sort the keys here such that converting identical EvalStates always
-	// produces the same string.
-	keys := []string{}
-	for k := range this.defined {
-		keys = append(keys, k)
-	}
-	sort.Strings(keys)
-	for _, k := range keys {
-		v := this.defined[k]
-		buffer.WriteString(k)
-		buffer.WriteString(": ")
-		buffer.WriteString(v.String())
-		buffer.WriteString(", ")
-	}
-	if strings.HasSuffix(buffer.String(), ", ") {
-		buffer.Truncate(buffer.Len() - 2)
-	}
-	buffer.WriteString("}")
-	return buffer.String()
-}
-
 func (this *EvalState) IsFrozen() bool {
 	return this.freeze
 }

expreduce/ex_symbol.go

@@ -248,6 +248,14 @@ func (this *Attributes) toStrings() []string {
 	return strings
 }
 
+func (this *Attributes) toSymList() *Expression {
+	toReturn := E(S("List"))
+	for _, s := range this.toStrings() {
+		toReturn.appendEx(S(s))
+	}
+	return toReturn
+}
+
 func (this *Symbol) NeedsEval() bool {
 	return false
 }

expreduce/interp_test.go

@@ -67,6 +67,6 @@ func TestInterp(t *testing.T) {
 	// Test newline handling
 	assert.Equal(t, "CompoundExpression[a, b]", Interp("a;b\n", es).String())
 	//assert.Equal(t, "Sequence[a, b]", Interp("a\nb\n", es).String())
-	assert.Equal(t, "((c = a*b))", Interp("c = (a\nb)\n", es).String())
-	assert.Equal(t, "((c = a*b))", Interp("c = (a\n\nb)\n", es).String())
+	assert.Equal(t, "(c = a*b)", Interp("c = (a\nb)\n", es).String())
+	assert.Equal(t, "(c = a*b)", Interp("c = (a\n\nb)\n", es).String())
 }

expreduce/resources/system.m

@@ -322,3 +322,6 @@
 
 Reap::usage = "`Reap[expr]` returns the result of `expr` and a list of all the sown values during evaluation.";
 Attributes[Reap] = {HoldFirst, Protected};
+
+Definition::usage = "`Definition[sym]` renders the attributes, downvalues, and default value of `sym`.";
+Attributes[Definition] = {HoldAll, Protected};

expreduce/string.go

@@ -68,6 +68,7 @@ func (this *Expression) ToStringInfix(p ToStringParams) (bool, string) {
 	return ToStringInfix(expr.Parts[1:], delim.Val, "", p)
 }
 
+// TODO(corywalker): Remove start, end. No users of these values.
 func ToStringInfixAdvanced(parts []Ex, delim string, thisHead string, surroundEachArg bool, start string, end string, params ToStringParams) (bool, string) {
 	if params.form != "InputForm" && params.form != "OutputForm" {
 		return false, ""