stuff

cli/src/gsc_test_ntree.erl

@@ -68,27 +68,38 @@ parse(Signal) ->
     % think)?
     F0 = Signal,
     F1 = f2f_parens(F0),
-    %F2 = f2f_op("=>", F1),
+    F2 = f2f_op("=>", F1),
-    Result = F1,
+    F3 = f2f_op("*", F2),
+    Result = F2,
     Result.
 
 
-%f2f_op(OpStr, Fst) ->
+f2f_op(OpStr, Fst) ->
-%    case f2f_op(OpStr, [], none, Fst) of
+    f2f_op(OpStr, [], Fst).
-%        % never saw it, no change
+
-%        ident -> Fst;
+
-%
+% never saw the op
-%
+f2f_op(_opstr, Stk, []) ->
-%% never saw the op
+    lists:reverse(Stk);
-%f2f_op(_, _, none, []) ->
+% see op
-%    ident;
+f2f_op(OpStr, LhsStk, [#tk{str = OpStr} = OpTk | Rest]) ->
-%% see op
+    Lhf = lists:reverse(LhsStk),
-%f2f_op(OpStr, LhsStk, none, [OpTk = #tk{str = OpStr} | Rest]) ->
+    Rhf = f2f_op(OpStr, Rest),
-%    Lhf = lists:reverse(LhsStk),
+    Lht = #ns{meta = none, kids = Lhf},
-%    Rhf = f2f_op(OpStr, Rest),
+    Rht = #ns{meta = none, kids = Rhf},
-%    Lht = #ns{meta = none, kids = Lhf},
+    ResultT = #ns{meta = {op, OpTk},
-%    Rht = #ns{meta = none, kids = Rhf},
+                  kids = [Lht, Rht]},
-%    Result = 
+    ResultF = [ResultT],
+    ResultF;
+% see stem, descend
+f2f_op(OpStr, LhsStk, [Ns = #ns{kids = NsKids} | Rest]) ->
+    NewNsKids = f2f_op(OpStr, NsKids),
+    NewNs = Ns#ns{kids = NewNsKids},
+    NewStk = [NewNs | LhsStk],
+    f2f_op(OpStr, NewStk, Rest);
+% see leaf, just add
+f2f_op(OpStr, Stk, [L | Rest]) ->
+    f2f_op(OpStr, [L | Stk], Rest).
 
 
 -spec f2f_parens(Forest) -> NewForest when

src/gsc_ntree.erl

@@ -51,7 +51,6 @@
 %% API: functions
 %%=====================================================
 
-
 -spec nstem(Root, Forest) -> Tree when
         Root   :: S,
         Forest :: nforest(S, L),
@@ -67,6 +66,7 @@ meta(#ns{meta = M}) -> M.
 kids(#ns{kids = K}) -> K.
 
 
+
 -spec flatten_tree(Tree) -> Leafs when
         Tree  :: ntree(_, L),
         Leafs :: [L],
@@ -76,6 +76,7 @@ flatten_tree(T) ->
     lists:flatten(ft(T)).
 
 
+
 -spec flatten_forest(Forest) -> Leafs when
         Forest :: nforest(_, L),
         Leafs  :: [L],
@@ -88,4 +89,6 @@ flatten_forest(F) ->
 ft(#ns{kids = F}) -> ff(F);
 ft(Leaf)          -> [Leaf].
 
-ff(F) -> [ft(T) || T <- F].
+ff(F) ->
+    [ft(T) || T <- F].
+