mediocregopher/ginger
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Reverse order of args in ValueOut, TupleOut, and AddValueIn

Browse Source 
The order of these methods now matches the order of edge/value in every
other context.
This commit is contained in:
Brian Picciano 2021-12-30 11:38:36 -07:00
parent 9c48232ac1
commit 2a96e9a593
6 changed files with 106 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
gg/decoder.go
View File

@ -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) {

127
gg/decoder_test.go
View File

@ -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(
vOut(
Value{Graph: zeroGraph.
AddValueIn(vOut(i(1), ZeroValue), n("a")).
AddValueIn(
tOut(
[]*OpenEdge{
vOut(i(2), n("d")),
},
n("c"),
),
n("b"),
),
},
ZeroValue,
),
n("out"),
vOut(
ZeroValue,
Value{Graph: zeroGraph.
AddValueIn(n("a"), vOut(ZeroValue, i(1))).
AddValueIn(
n("b"),
tOut(
n("c"),
vOut(n("d"), i(2)),
),
),
},
),
),
},
{
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))),
},
}

8
graph/graph.go
View File

@ -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,

75
graph/graph_test.go
View File

@ -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,
},
}

8
vm/op.go
View File

@ -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,
)

2
vm/vm.go
View File

@ -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)
}