Reverse order of args in ValueOut, TupleOut, and AddValueIn

The order of these methods now matches the order of edge/value in every other context.
2021-12-30 11:38:36 -07:00 · 2021-12-30 11:38:36 -07:00 · 2a96e9a593
commit 2a96e9a593
parent 9c48232ac1
6 changed files with 106 additions and 110 deletions
--- a/gg/decoder.go
+++ b/gg/decoder.go
@ -124,7 +124,7 @@ func (d *decoder) parseOpenEdge(
 	}

 	if termed {
-		return graph.ValueOut[Value](val, ZeroValue), toks, nil
+		return graph.ValueOut[Value](ZeroValue, val), toks, nil
 	}

 	opTok, toks := toks[0], toks[1:]
@ -143,7 +143,7 @@ func (d *decoder) parseOpenEdge(
 		return nil, nil, err
 	}

-	oe = graph.TupleOut[Value]([]*OpenEdge{oe}, val)
+	oe = graph.TupleOut[Value](val, oe)

 	return oe, toks, nil
 }
@ -189,7 +189,7 @@ func (d *decoder) parseTuple(
 		toks = toks[1:]
 	}

-	return graph.TupleOut[Value](edges, ZeroValue), toks, nil
+	return graph.TupleOut[Value](ZeroValue, edges...), toks, nil
 }

 // returned boolean value indicates if the token following the graph is a term.
@ -288,7 +288,7 @@ func (d *decoder) parseValIn(into *Graph, toks []LexerToken) (*Graph, []LexerTok

 	dstVal := Value{Name: &dst.Value, LexerToken: &dst}

-	return into.AddValueIn(oe, dstVal), toks, nil
+	return into.AddValueIn(dstVal, oe), toks, nil
 }

 func (d *decoder) decode(lexer Lexer) (*Graph, error) {
--- a/gg/decoder_test.go
+++ b/gg/decoder_test.go
@ -21,12 +21,12 @@ func TestDecoder(t *testing.T) {
 		return Value{Name: &n}
 	}

-	vOut := func(val, edgeVal Value) *OpenEdge {
-		return graph.ValueOut(val, edgeVal)
+	vOut := func(edgeVal, val Value) *OpenEdge {
+		return graph.ValueOut(edgeVal, val)
 	}

-	tOut := func(ins []*OpenEdge, edgeVal Value) *OpenEdge {
-		return graph.TupleOut(ins, edgeVal)
+	tOut := func(edgeVal Value, ins ...*OpenEdge) *OpenEdge {
+		return graph.TupleOut(edgeVal, ins...)
 	}

 	tests := []struct {
@ -39,107 +39,98 @@ func TestDecoder(t *testing.T) {
 		},
 		{
 			in:  "out = 1;",
-			exp: zeroGraph.AddValueIn(vOut(i(1), ZeroValue), n("out")),
+			exp: zeroGraph.AddValueIn(n("out"), vOut(ZeroValue, i(1))),
 		},
 		{
 			in:  "out = incr < 1;",
-			exp: zeroGraph.AddValueIn(vOut(i(1), n("incr")), n("out")),
+			exp: zeroGraph.AddValueIn(n("out"), vOut(n("incr"), i(1))),
 		},
 		{
 			in: "out = a < b < 1;",
 			exp: zeroGraph.AddValueIn(
-				tOut(
-					[]*OpenEdge{vOut(i(1), n("b"))},
-					n("a"),
-				),
 				n("out"),
+				tOut(
+					n("a"),
+					vOut(n("b"),
+					i(1)),
+				),
 			),
 		},
 		{
 			in: "out = a < b < (1; c < 2; d < e < 3;);",
 			exp: zeroGraph.AddValueIn(
-				tOut(
-					[]*OpenEdge{tOut(
-						[]*OpenEdge{
-							vOut(i(1), ZeroValue),
-							vOut(i(2), n("c")),
-							tOut(
-								[]*OpenEdge{vOut(i(3), n("e"))},
-								n("d"),
-							),
-						},
-						n("b"),
-					)},
-					n("a"),
-				),
 				n("out"),
+				tOut(
+					n("a"),
+					tOut(
+						n("b"),
+						vOut(ZeroValue, i(1)),
+						vOut(n("c"), i(2)),
+						tOut(
+							n("d"),
+							vOut(n("e"), i(3)),
+						),
+					),
+				),
 			),
 		},
 		{
 			in: "out = a < b < (1; c < (d < 2; 3;); );",
 			exp: zeroGraph.AddValueIn(
-				tOut(
-					[]*OpenEdge{tOut(
-						[]*OpenEdge{
-							vOut(i(1), ZeroValue),
-							tOut(
-								[]*OpenEdge{
-									vOut(i(2), n("d")),
-									vOut(i(3), ZeroValue),
-								},
-								n("c"),
-							),
-						},
-						n("b"),
-					)},
-					n("a"),
-				),
 				n("out"),
+				tOut(
+					n("a"),
+					tOut(
+						n("b"),
+						vOut(ZeroValue, i(1)),
+						tOut(
+							n("c"),
+							vOut(n("d"), i(2)),
+							vOut(ZeroValue, i(3)),
+						),
+					),
+				),
 			),
 		},
 		{
 			in: "out = { a = 1; b = c < d < 2; };",
 			exp: zeroGraph.AddValueIn(
+				n("out"),
 				vOut(
+					ZeroValue,
 					Value{Graph: zeroGraph.
-						AddValueIn(vOut(i(1), ZeroValue), n("a")).
+						AddValueIn(n("a"), vOut(ZeroValue, i(1))).
 						AddValueIn(
-							tOut(
-								[]*OpenEdge{
-									vOut(i(2), n("d")),
-								},
-								n("c"),
-							),
 							n("b"),
+							tOut(
+								n("c"),
+								vOut(n("d"), i(2)),
+							),
 						),
 					},
-					ZeroValue,
 				),
-				n("out"),
 			),
 		},
 		{
 			in: "out = a < { b = 1; } < 2;",
 			exp: zeroGraph.AddValueIn(
-				tOut(
-					[]*OpenEdge{
-						vOut(
-							i(2),
-							Value{Graph: zeroGraph.
-								AddValueIn(vOut(i(1), ZeroValue), n("b")),
-							},
-						),
-					},
-					n("a"),
-				),
 				n("out"),
+				tOut(
+					n("a"),
+					vOut(
+						Value{Graph: zeroGraph.
+							AddValueIn(n("b"), vOut(ZeroValue, i(1))),
+						},
+						i(2),
+					),
+				),
 			),
 		},
 		{
 			in: "a = 1; b = 2;",
 			exp: zeroGraph.
-				AddValueIn(vOut(i(1), ZeroValue), n("a")).
-				AddValueIn(vOut(i(2), ZeroValue), n("b")),
+				AddValueIn(n("a"), vOut(ZeroValue, i(1))).
+				AddValueIn(n("b"), vOut(ZeroValue, i(2))),
 		},
 	}

--- a/graph/graph.go
+++ b/graph/graph.go
@ -111,7 +111,7 @@ func (oe OpenEdge[E, V]) FromTuple() ([]*OpenEdge[E, V], bool) {

 // ValueOut creates a OpenEdge which, when used to construct a Graph, represents
 // an edge (with edgeVal attached to it) coming from the vertex containing val.
-func ValueOut[E, V Value](val V, edgeVal E) *OpenEdge[E, V] {
+func ValueOut[E, V Value](edgeVal E, val V) *OpenEdge[E, V] {
 	return &OpenEdge[E, V]{
 		val: &val,
 		edgeVal: edgeVal,
@ -121,7 +121,7 @@ func ValueOut[E, V Value](val V, edgeVal E) *OpenEdge[E, V] {
 // TupleOut creates an OpenEdge which, when used to construct a Graph,
 // represents an edge (with edgeVal attached to it) coming from the vertex
 // comprised of the given ordered-set of input edges.
-func TupleOut[E, V Value](ins []*OpenEdge[E, V], edgeVal E) *OpenEdge[E, V] {
+func TupleOut[E, V Value](edgeVal E, ins ...*OpenEdge[E, V]) *OpenEdge[E, V] {

 	if len(ins) == 1 {

@ -218,7 +218,7 @@ func (g *Graph[E, V]) dedupeEdge(edge *OpenEdge[E, V]) *OpenEdge[E, V] {
 		tupEdges[i] = g.dedupeEdge(edge.tup[i])
 	}

-	return TupleOut(tupEdges, edge.EdgeValue())
+	return TupleOut(edge.EdgeValue(), tupEdges...)
 }

 // ValueIns returns, if any, all OpenEdges which lead to the given Value in the
@ -240,7 +240,7 @@ func (g *Graph[E, V]) ValueIns(val Value) []*OpenEdge[E, V] {

 // AddValueIn takes a OpenEdge and connects it to the Value vertex containing
 // val, returning the new Graph which reflects that connection.
-func (g *Graph[E, V]) AddValueIn(oe *OpenEdge[E, V], val V) *Graph[E, V] {
+func (g *Graph[E, V]) AddValueIn(val V, oe *OpenEdge[E, V]) *Graph[E, V] {

 	valIn := graphValueIn[E, V]{
 		val: val,
--- a/graph/graph_test.go
+++ b/graph/graph_test.go
@ -31,78 +31,83 @@ func TestEqual(t *testing.T) {
 		},
 		{
 			a:   zeroGraph,
-			b:   zeroGraph.AddValueIn(ValueOut[S, S]("in", "incr"), "out"),
+			b:   zeroGraph.AddValueIn("out", ValueOut[S, S]("incr", "in")),
 			exp: false,
 		},
 		{
-			a:   zeroGraph.AddValueIn(ValueOut[S, S]("in", "incr"), "out"),
-			b:   zeroGraph.AddValueIn(ValueOut[S, S]("in", "incr"), "out"),
+			a:   zeroGraph.AddValueIn("out", ValueOut[S, S]("incr", "in")),
+			b:   zeroGraph.AddValueIn("out", ValueOut[S, S]("incr", "in")),
 			exp: true,
 		},
 		{
-			a: zeroGraph.AddValueIn(ValueOut[S, S]("in", "incr"), "out"),
-			b: zeroGraph.AddValueIn(TupleOut[S, S]([]*OpenEdge[S, S]{
-				ValueOut[S, S]("in", "ident"),
-				ValueOut[S, S]("1", "ident"),
-			}, "add"), "out"),
+			a: zeroGraph.AddValueIn("out", ValueOut[S, S]("incr", "in")),
+			b: zeroGraph.AddValueIn("out", TupleOut[S, S](
+				"add",
+				ValueOut[S, S]("ident", "in"),
+				ValueOut[S, S]("ident", "1"),
+			)),
 			exp: false,
 		},
 		{
 			// tuples are different order
-			a: zeroGraph.AddValueIn(TupleOut[S, S]([]*OpenEdge[S, S]{
-				ValueOut[S, S]("1", "ident"),
-				ValueOut[S, S]("in", "ident"),
-			}, "add"), "out"),
-			b: zeroGraph.AddValueIn(TupleOut[S, S]([]*OpenEdge[S, S]{
-				ValueOut[S, S]("in", "ident"),
-				ValueOut[S, S]("1", "ident"),
-			}, "add"), "out"),
+			a: zeroGraph.AddValueIn("out", TupleOut[S, S](
+				"add",
+				ValueOut[S, S]("ident", "1"),
+				ValueOut[S, S]("ident", "in"),
+			)),
+			b: zeroGraph.AddValueIn("out", TupleOut[S, S](
+				"add",
+				ValueOut[S, S]("ident", "in"),
+				ValueOut[S, S]("ident", "1"),
+			)),
 			exp: false,
 		},
 		{
 			// tuple with no edge value and just a single input edge should be
 			// equivalent to just that edge.
-			a: zeroGraph.AddValueIn(TupleOut[S, S]([]*OpenEdge[S, S]{
-				ValueOut[S, S]("1", "ident"),
-			}, zeroValue), "out"),
-			b:   zeroGraph.AddValueIn(ValueOut[S, S]("1", "ident"), "out"),
+			a: zeroGraph.AddValueIn("out", TupleOut[S, S](
+				zeroValue,
+				ValueOut[S, S]("ident", "1"),
+			)),
+			b:   zeroGraph.AddValueIn("out", ValueOut[S, S]("ident", "1")),
 			exp: true,
 		},
 		{
 			// tuple with an edge value and just a single input edge that has no
 			// edgeVal should be equivalent to just that edge with the tuple's
 			// edge value.
-			a: zeroGraph.AddValueIn(TupleOut[S, S]([]*OpenEdge[S, S]{
-				ValueOut[S, S]("1", zeroValue),
-			}, "ident"), "out"),
-			b:   zeroGraph.AddValueIn(ValueOut[S, S]("1", "ident"), "out"),
+			a: zeroGraph.AddValueIn("out", TupleOut[S, S](
+				"ident",
+				ValueOut[S, S](zeroValue, "1"),
+			)),
+			b:   zeroGraph.AddValueIn("out", ValueOut[S, S]("ident", "1")),
 			exp: true,
 		},
 		{
 			a: zeroGraph.
-				AddValueIn(ValueOut[S, S]("in", "incr"), "out").
-				AddValueIn(ValueOut[S, S]("in2", "incr2"), "out2"),
+				AddValueIn("out", ValueOut[S, S]("incr", "in")).
+				AddValueIn("out2", ValueOut[S, S]("incr2", "in2")),
 			b: zeroGraph.
-				AddValueIn(ValueOut[S, S]("in", "incr"), "out"),
+				AddValueIn("out", ValueOut[S, S]("incr", "in")),
 			exp: false,
 		},
 		{
 			a: zeroGraph.
-				AddValueIn(ValueOut[S, S]("in", "incr"), "out").
-				AddValueIn(ValueOut[S, S]("in2", "incr2"), "out2"),
+				AddValueIn("out", ValueOut[S, S]("incr", "in")).
+				AddValueIn("out2", ValueOut[S, S]("incr2", "in2")),
 			b: zeroGraph.
-				AddValueIn(ValueOut[S, S]("in", "incr"), "out").
-				AddValueIn(ValueOut[S, S]("in2", "incr2"), "out2"),
+				AddValueIn("out", ValueOut[S, S]("incr", "in")).
+				AddValueIn("out2", ValueOut[S, S]("incr2", "in2")),
 			exp: true,
 		},
 		{
 			// order of value ins shouldn't matter
 			a: zeroGraph.
-				AddValueIn(ValueOut[S, S]("in", "incr"), "out").
-				AddValueIn(ValueOut[S, S]("in2", "incr2"), "out2"),
+				AddValueIn("out", ValueOut[S, S]("incr", "in")).
+				AddValueIn("out2", ValueOut[S, S]("incr2", "in2")),
 			b: zeroGraph.
-				AddValueIn(ValueOut[S, S]("in2", "incr2"), "out2").
-				AddValueIn(ValueOut[S, S]("in", "incr"), "out"),
+				AddValueIn("out2", ValueOut[S, S]("incr2", "in2")).
+				AddValueIn("out", ValueOut[S, S]("incr", "in")),
 			exp: true,
 		},
 	}
--- a/vm/op.go
+++ b/vm/op.go
@ -52,14 +52,14 @@ func preEvalEdgeOp(fn func(*gg.OpenEdge) (Value, error)) Operation {
 			tupEdges := make([]*gg.OpenEdge, len(val.Tuple))

 			for i := range val.Tuple {
-				tupEdges[i] = graph.ValueOut[gg.Value](val.Tuple[i].Value, gg.ZeroValue)
+				tupEdges[i] = graph.ValueOut[gg.Value](gg.ZeroValue, val.Tuple[i].Value)
 			}

-			edge = graph.TupleOut[gg.Value](tupEdges, gg.ZeroValue)
+			edge = graph.TupleOut[gg.Value](gg.ZeroValue, tupEdges...)

 		} else {

-			edge = graph.ValueOut[gg.Value](val.Value, gg.ZeroValue)
+			edge = graph.ValueOut[gg.Value](gg.ZeroValue, val.Value)

 		}

@ -92,7 +92,7 @@ func (g *graphOp) Perform(edge *gg.OpenEdge, scope Scope) (Value, error) {
 	return preEvalEdgeOp(func(edge *gg.OpenEdge) (Value, error) {

 		scope = ScopeFromGraph(
-			g.Graph.AddValueIn(edge, inVal.Value),
+			g.Graph.AddValueIn(inVal.Value, edge),
 			g.scope,
 		)

--- a/vm/vm.go
+++ b/vm/vm.go
@ -115,5 +115,5 @@ func EvaluateSource(opSrc io.Reader, input gg.Value, scope Scope) (Value, error)

 	op := OperationFromGraph(g, scope.NewScope())

-	return op.Perform(graph.ValueOut[gg.Value](input, gg.ZeroValue), scope)
+	return op.Perform(graph.ValueOut[gg.Value](gg.ZeroValue, input), scope)
 }