WIP: clean up locatable stuff

gg/v2/gg.bnf

@@ -5,20 +5,19 @@
 
 <name> ::= (<letter> | <mark>) (<letter> | <mark> | <digit>)*
 
-<value> ::= <name> | <number> | <tuple> | <graph>
+<tuple>                ::= "(" <tuple-tail>
+<tuple-tail>           ::= ")" | <tuple-open-edge>
+<tuple-open-edge>      ::= <value> <tuple-open-edge-tail>
+<tuple-open-edge-tail> ::= ")"
+                         | "," <tuple-tail>
+                         | "<" <tuple-open-edge>
 
-<tuple>            ::= "(" <tuple-tail>
+<graph>                      ::= "{" <graph-tail>
-<tuple-tail>       ::= ")" | <value> <tuple-post-value>
+<graph-tail>                 ::= "}" | <name> "=" <graph-open-edge>
-<tuple-post-value> ::= ")"
+<graph-open-edge>            ::= <value> <graph-open-edge-value-tail>
-                     | "," <tuple-tail>
+                               | <tuple> <graph-open-edge-tail>
-                     | "<" <value> <tuple-post-value>
+<graph-open-edge-tail>       ::= "}" | ";" <graph-tail>
+<graph-open-edge-value-tail>  ::= <graph-open-edge-tail> | "<" <graph-open-edge>
 
-<graph>                ::= "{" <graph-tail>
+<value> ::= <name> | <number> | <graph>
-<graph-tail>           ::= "}" | <name> "=" <graph-open-edge>
+<gg>              ::= <eof> | <value> <gg>
-<graph-open-edge>      ::= <value> <graph-open-edge-tail>
-<graph-open-edge-tail> ::= "}"
-                         | ";" <graph-tail>
-                         | "<" <graph-open-edge>
-
-<top-level-value> ::= <name> | <number> | <graph>
-<gg>              ::= <eof> | <top-level-value> <gg>

gg/v2/location.go

@@ -25,10 +25,6 @@ func (e LocatedError) Error() string {
 	return fmt.Sprintf("%d:%d: %v", e.Row, e.Col, e.Err)
 }
 
-type locatable interface {
-	locate() Location
-}
-
 type locatableRune struct {
 	Location
 	r rune
@@ -38,12 +34,3 @@ type locatableString struct {
 	Location
 	str string
 }
-
-type locatableSlice[T locatable] []T
-
-func (s locatableSlice[T]) locate() Location {
-	if len(s) == 0 {
-		panic("can't locate empty locatableSlice")
-	}
-	return s[0].locate()
-}

gg/v2/term.go

@@ -9,6 +9,7 @@ import (
 	"unicode"
 
 	"github.com/mediocregopher/ginger/graph"
+	"golang.org/x/exp/slices"
 )
 
 var (
@@ -27,7 +28,7 @@ func (str stringerStr) String() string {
 	return string(str)
 }
 
-type term[T locatable] struct {
+type term[T any] struct {
 	name     fmt.Stringer
 	decodeFn func(d *Decoder) (T, error)
 }
@@ -36,7 +37,7 @@ func (t term[T]) String() string {
 	return t.name.String()
 }
 
-func firstOf[T locatable](terms ...*term[T]) *term[T] {
+func firstOf[T any](terms ...*term[T]) *term[T] {
 	if len(terms) < 2 {
 		panic("firstOfTerms requires at least 2 terms")
 	}
@@ -67,11 +68,11 @@ func firstOf[T locatable](terms ...*term[T]) *term[T] {
 	}
 }
 
-func seq[Ta, Tb, Tc locatable](
+func seq[Ta, Tb, Tc any](
 	name fmt.Stringer,
 	termA *term[Ta],
 	termB *term[Tb],
-	fn func(Ta, Tb) (Tc, error),
+	fn func(Ta, Tb) Tc,
 ) *term[Tc] {
 	return &term[Tc]{
 		name: name,
@@ -90,30 +91,25 @@ func seq[Ta, Tb, Tc locatable](
 				return zero, err
 			}
 
-			vc, err := fn(va, vb)
+			return fn(va, vb), nil
-			if err != nil {
-				return zero, err
-			}
-
-			return vc, nil
 		},
 	}
 }
 
-func matchAndSkip[Ta, Tb locatable](
+func matchAndSkip[Ta, Tb any](
 	termA *term[Ta], termB *term[Tb],
 ) *term[Tb] {
-	return seq(termA, termA, termB, func(_ Ta, b Tb) (Tb, error) {
+	return seq(termA, termA, termB, func(_ Ta, b Tb) Tb {
-		return b, nil
+		return b
 	})
 }
 
-func oneOrMore[T locatable](t *term[T]) *term[locatableSlice[T]] {
+func oneOrMore[T any](t *term[T]) *term[[]T] {
-	return &term[locatableSlice[T]]{
+	return &term[[]T]{
 		name: stringerFn(func() string {
 			return fmt.Sprintf("one or more %v", t)
 		}),
-		decodeFn: func(d *Decoder) (locatableSlice[T], error) {
+		decodeFn: func(d *Decoder) ([]T, error) {
 			var vv []T
 			for {
 				v, err := t.decodeFn(d)
@@ -135,12 +131,12 @@ func oneOrMore[T locatable](t *term[T]) *term[locatableSlice[T]] {
 	}
 }
 
-func zeroOrMore[T locatable](t *term[T]) *term[locatableSlice[T]] {
+func zeroOrMore[T any](t *term[T]) *term[[]T] {
-	return &term[locatableSlice[T]]{
+	return &term[[]T]{
 		name: stringerFn(func() string {
 			return fmt.Sprintf("zero or more %v", t)
 		}),
-		decodeFn: func(d *Decoder) (locatableSlice[T], error) {
+		decodeFn: func(d *Decoder) ([]T, error) {
 			var vv []T
 			for {
 				v, err := t.decodeFn(d)
@@ -158,7 +154,7 @@ func zeroOrMore[T locatable](t *term[T]) *term[locatableSlice[T]] {
 	}
 }
 
-func mapTerm[Ta locatable, Tb locatable](
+func mapTerm[Ta, Tb any](
 	name fmt.Stringer, t *term[Ta], fn func(Ta) Tb,
 ) *term[Tb] {
 	return &term[Tb]{
@@ -204,7 +200,7 @@ func runeTerm(r rune) *term[locatableRune] {
 	)
 }
 
-func locatableRunesToString(rr locatableSlice[locatableRune]) string {
+func locatableRunesToString(rr []locatableRune) string {
 	str := make([]rune, len(rr))
 	for i := range rr {
 		str[i] = rr[i].r
@@ -213,11 +209,11 @@ func locatableRunesToString(rr locatableSlice[locatableRune]) string {
 }
 
 func runesToStringTerm(
-	t *term[locatableSlice[locatableRune]],
+	t *term[[]locatableRune],
 ) *term[locatableString] {
 	return mapTerm(
-		t, t, func(rr locatableSlice[locatableRune]) locatableString {
+		t, t, func(rr []locatableRune) locatableString {
-			return locatableString{rr.locate(), locatableRunesToString(rr)}
+			return locatableString{rr[0].locate(), locatableRunesToString(rr)}
 		},
 	)
 }
@@ -234,10 +230,8 @@ var (
 		stringerStr("negative-number"),
 		runeTerm('-'),
 		positiveNumberTerm,
-		func(neg locatableRune, posNum locatableString) (locatableString, error) {
+		func(neg locatableRune, posNum locatableString) locatableString {
-			return locatableString{
+			return locatableString{neg.locate(), string(neg.r) + posNum.str}
-				neg.locate(), string(neg.r) + posNum.str,
-			}, nil
 		},
 	)
 
@@ -269,50 +263,125 @@ var (
 		stringerStr("name"),
 		letterTerm,
 		letterTailTerm,
-		func(head locatableRune, tail locatableSlice[locatableRune]) (Value, error) {
+		func(head locatableRune, tail []locatableRune) Value {
 			name := string(head.r) + locatableRunesToString(tail)
-			return Value{Name: &name, Location: head.locate()}, nil
+			return Value{Name: &name, Location: head.locate()}
 		},
 	)
 )
 
+func openEdgeIntoValue(val Value, oe *OpenEdge) *OpenEdge {
+	switch {
+	case oe == nil:
+		return graph.ValueOut(None, val)
+	case !oe.EdgeValue().Valid:
+		return oe.WithEdgeValue(Some(val))
+	default:
+		return graph.TupleOut(Some(val), oe)
+	}
+}
+
 var graphTerm = func() *term[Value] {
+	type tupleState struct {
+		ins []*OpenEdge
+		oe  *OpenEdge
+	}
+
 	type graphState struct {
-		Location // location of last place graphState was updated
+		g  *Graph
-		g        *Graph
+		oe *OpenEdge
-		oe       *OpenEdge
 	}
 
 	var (
-		// pre-define these, and then fill in the pointers after, in order to
+		rightParenthesis = runeTerm(')')
-		// deal with recursive dependencies between them.
+		tupleEndTerm     = mapTerm(
-		graphTerm             = new(term[Value])
+			rightParenthesis,
-		graphTailTerm         = new(term[graphState])
+			rightParenthesis,
-		graphOpenEdgeTerm     = new(term[graphState])
+			func(lr locatableRune) tupleState {
-		graphOpenEdgeTailTerm = new(term[graphState])
+				// if ')', then map that to an empty state. This acts as a
-		valueTerm             = new(term[Value])
+				// sentinel value to indicate "end of tuple".
+				return tupleState{}
+			},
+		)
 
 		rightCurlyBrace = runeTerm('}')
 		graphEndTerm    = mapTerm(
 			rightCurlyBrace,
-			rightCurlyBrace, func(lr locatableRune) graphState {
+			rightCurlyBrace,
+			func(lr locatableRune) graphState {
 				// if '}', then map that to an empty state. This acts as a
 				// sentinel value to indicate "end of graph".
-				return graphState{Location: lr.locate()}
+				return graphState{}
 			},
 		)
 	)
 
+	var (
+		// pre-define these, and then fill in the pointers after, in order to
+		// deal with recursive dependencies between them.
+		valueTerm = new(term[Value])
+
+		tupleTerm             = new(term[*OpenEdge])
+		tupleTailTerm         = new(term[tupleState])
+		tupleOpenEdgeTerm     = new(term[tupleState])
+		tupleOpenEdgeTailTerm = new(term[tupleState])
+
+		graphTerm                  = new(term[Value])
+		graphTailTerm              = new(term[graphState])
+		graphOpenEdgeTerm          = new(term[graphState])
+		graphOpenEdgeTailTerm      = new(term[graphState])
+		graphOpenEdgeValueTailTerm = new(term[graphState])
+	)
+
+	*tupleTerm = *seq(
+		stringerStr("tuple"),
+		runeTerm('('),
+		tupleTailTerm,
+		func(lr locatableRune, ts tupleState) *OpenEdge {
+			slices.Reverse(ts.ins)
+			return graph.TupleOut(None, ts.ins...)
+		},
+	)
+
+	*tupleTailTerm = *firstOf(
+		tupleEndTerm,
+		mapTerm(
+			tupleOpenEdgeTerm,
+			tupleOpenEdgeTerm,
+			func(ts tupleState) tupleState {
+				ts.ins = append(ts.ins, ts.oe)
+				ts.oe = nil
+				return ts
+			},
+		),
+	)
+
+	*tupleOpenEdgeTerm = *seq(
+		valueTerm,
+		valueTerm,
+		tupleOpenEdgeTailTerm,
+		func(val Value, ts tupleState) tupleState {
+			ts.oe = openEdgeIntoValue(val, ts.oe)
+			return ts
+		},
+	)
+
+	*tupleOpenEdgeTailTerm = *firstOf(
+		tupleEndTerm,
+		matchAndSkip(runeTerm(','), tupleTailTerm),
+		matchAndSkip(runeTerm('<'), tupleOpenEdgeTerm),
+	)
+
 	*graphTerm = *seq(
 		stringerStr("graph"),
 		runeTerm('{'),
 		graphTailTerm,
-		func(lr locatableRune, gs graphState) (Value, error) {
+		func(lr locatableRune, gs graphState) Value {
 			if gs.g == nil {
 				gs.g = new(Graph)
 			}
 
-			return Value{Graph: gs.g, Location: lr.locate()}, nil
+			return Value{Graph: gs.g, Location: lr.locate()}
 		},
 	)
 
@@ -321,42 +390,48 @@ var graphTerm = func() *term[Value] {
 		seq(
 			nameTerm,
 			nameTerm,
-			matchAndSkip(runeTerm('='), graphOpenEdgeTailTerm),
+			matchAndSkip(runeTerm('='), graphOpenEdgeTerm),
-			func(name Value, gs graphState) (graphState, error) {
+			func(name Value, gs graphState) graphState {
 				if gs.g == nil {
 					gs.g = new(Graph)
 				}
 
 				gs.g = gs.g.AddValueIn(name, gs.oe)
 				gs.oe = nil
-				gs.Location = name.locate()
+				return gs
-				return gs, nil
 			},
 		),
 	)
 
 	*graphOpenEdgeTerm = *firstOf(
-		graphEndTerm,
+		seq(
-		matchAndSkip(runeTerm(';'), graphTailTerm),
+			valueTerm,
-		matchAndSkip(runeTerm('<'), graphOpenEdgeTailTerm),
+			valueTerm,
+			graphOpenEdgeValueTailTerm,
+			func(val Value, gs graphState) graphState {
+				gs.oe = openEdgeIntoValue(val, gs.oe)
+				return gs
+			},
+		),
+		seq(
+			tupleTerm,
+			tupleTerm,
+			graphOpenEdgeTailTerm,
+			func(oe *OpenEdge, gs graphState) graphState {
+				gs.oe = oe
+				return gs
+			},
+		),
 	)
 
-	*graphOpenEdgeTailTerm = *seq(
+	*graphOpenEdgeTailTerm = *firstOf(
-		valueTerm,
+		graphEndTerm,
-		valueTerm,
+		matchAndSkip(runeTerm(';'), graphTailTerm),
-		graphOpenEdgeTerm,
+	)
-		func(val Value, gs graphState) (graphState, error) {
-			if gs.oe == nil {
-				gs.oe = graph.ValueOut(None, val)
-			} else if !gs.oe.EdgeValue().Valid {
-				gs.oe = gs.oe.WithEdgeValue(Some(val))
-			} else {
-				gs.oe = graph.TupleOut(Some(val), gs.oe)
-			}
 
-			gs.Location = val.locate()
+	*graphOpenEdgeValueTailTerm = *firstOf(
-			return gs, nil
+		graphOpenEdgeTailTerm,
-		},
+		matchAndSkip(runeTerm('<'), graphOpenEdgeTerm),
 	)
 
 	*valueTerm = *firstOf(nameTerm, numberTerm, graphTerm)

gg/v2/term_test.go

@@ -84,7 +84,7 @@ func TestTermDecoding(t *testing.T) {
 		{in: `{}`, exp: expGraph(1, 1, new(Graph))},
 		{in: `{`, expErr: `1:2: expected '}' or name`},
 		{in: `{a}`, expErr: `1:3: expected '='`},
-		{in: `{a=}`, expErr: `1:4: expected name or number or graph`},
+		{in: `{a=}`, expErr: `1:4: expected name or number or graph or tuple`},
 		{
 			in: `{foo=a}`,
 			exp: expGraph(
@@ -217,4 +217,89 @@ func TestTermDecoding(t *testing.T) {
 			),
 		},
 	})
+
+	runTests(t, "tuple", graphTerm, []test{
+		{
+			in: `{foo=(a)}`,
+			exp: expGraph(
+				1, 1, new(Graph).
+					AddValueIn(
+						expName(2, 1, "foo"),
+						graph.ValueOut(None, expName(6, 1, "a")),
+					),
+			),
+		},
+		{
+			in: `{foo=(a<b)}`,
+			exp: expGraph(
+				1, 1, new(Graph).
+					AddValueIn(
+						expName(2, 1, "foo"),
+						graph.ValueOut(
+							Some(expName(6, 1, "a")),
+							expName(8, 1, "b"),
+						),
+					),
+			),
+		},
+		{
+			in: `{foo=a<(b)}`,
+			exp: expGraph(
+				1, 1, new(Graph).
+					AddValueIn(
+						expName(2, 1, "foo"),
+						graph.ValueOut(
+							Some(expName(6, 1, "a")),
+							expName(8, 1, "b"),
+						),
+					),
+			),
+		},
+		{
+			in: `{foo=a<(b,c)}`,
+			exp: expGraph(
+				1, 1, new(Graph).
+					AddValueIn(
+						expName(2, 1, "foo"),
+						graph.TupleOut(
+							Some(expName(6, 1, "a")),
+							graph.ValueOut(None, expName(8, 1, "b")),
+							graph.ValueOut(None, expName(10, 1, "c")),
+						),
+					),
+			),
+		},
+		{
+			in: `{foo=a<(b<c)}`,
+			exp: expGraph(
+				1, 1, new(Graph).
+					AddValueIn(
+						expName(2, 1, "foo"),
+						graph.TupleOut(
+							Some(expName(6, 1, "a")),
+							graph.TupleOut(
+								Some(expName(6, 1, "b")),
+								graph.ValueOut(None, expName(8, 1, "c")),
+							),
+						),
+					),
+			),
+		},
+		//{
+		//	in: `{foo=a<(b<(c))}`,
+		//	exp: expGraph(
+		//		1, 1, new(Graph).
+		//			AddValueIn(
+		//				expName(2, 1, "foo"),
+		//				graph.TupleOut(
+		//					Some(expName(6, 1, "a")),
+		//					graph.TupleOut(
+		//						Some(expName(6, 1, "b")),
+		//						graph.ValueOut(None, expName(8, 1, "c")),
+		//					),
+		//				),
+		//			),
+		//	),
+		//},
+	})
 }

go.mod

@@ -7,5 +7,6 @@ require github.com/stretchr/testify v1.7.0
 require (
 	github.com/davecgh/go-spew v1.1.0 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
+	golang.org/x/exp v0.0.0-20231006140011-7918f672742d // indirect
 	gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect
 )

go.sum

@@ -5,6 +5,8 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.7.0 h1:nwc3DEeHmmLAfoZucVR881uASk0Mfjw8xYJ99tb5CcY=
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
+golang.org/x/exp v0.0.0-20231006140011-7918f672742d h1:jtJma62tbqLibJ5sFQz8bKtEM8rJBtfilJ2qTU199MI=
+golang.org/x/exp v0.0.0-20231006140011-7918f672742d/go.mod h1:ldy0pHrwJyGW56pPQzzkH36rKxoZW1tw7ZJpeKx+hdo=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=

graph/graph.go

@@ -126,7 +126,7 @@ func TupleOut[E, V Value](edgeVal E, ins ...*OpenEdge[E, V]) *OpenEdge[E, V] {
 	if len(ins) == 1 {
 
 		var (
-			zero V
+			zero E
 			in   = ins[0]
 		)
 
@@ -353,7 +353,6 @@ type reducedEdge[Ea, Va Value, Vb any] struct {
 // If a value or edge is connected to multiple times within the root OpenEdge it
 // will only be mapped/reduced a single time, and the result of that single
 // map/reduction will be passed to each dependant operation.
-//
 func MapReduce[Ea, Va Value, Vb any](
 	root *OpenEdge[Ea, Va],
 	mapVal func(Va) (Vb, error),