working

Author: andrew-johnson-4

SRC/infer-global-terms.lsts

@@ -3,32 +3,25 @@ let infer-global-terms(term: AST): AST = (
    match term {
       Seq{} => (
          let seqs = mk-vector(type(AST));
-         while term.is-seq { match term {
+         while non-zero(term) { match term {
             Seq{l=left, r=right} => (
                seqs = seqs.push(r);
-               if l.is-seq
-               then term = l
-               else (term = ASTEOF; seqs = seqs.push(l));
+               term = l;
             );
          }};
-         let is-diff = false as U64;
-         let def-i = seqs.length - 1;
+         let def-i = seqs.length;
          while def-i > 0 {
+            def-i = def-i - 1;
             let r = seqs[def-i];
             let new-r = infer-global-terms(r);
-            if not(is(r,new-r)) then { is-diff = true; seqs[def-i] = new-r; };
-            def-i = def-i - 1;
+            if not(is(r,new-r)) then { seqs[def-i] = new-r; };
+         };
+         term = ASTEOF;
+         let def-order-i = seqs.length;
+         while def-order-i > 0 {
+            def-order-i = def-order-i - 1;
+            term = term + seqs[def-order-i];
          };
-         if is-diff {
-            term = ASTEOF;
-            let def-order-i = seqs.length - 1;
-            while def-order-i > 0 {
-               if non-zero(term)
-               then term = mk-seq(term, seqs[def-order-i])
-               else term = seqs[def-order-i];
-               def-order-i = def-order-i - 1;
-            };
-         }
       );
       Glb{val:Abs{}} => ();
       Glb{k=key, rhs=val} => (
@@ -56,10 +49,10 @@ let infer-global-context(term: AST): Nil = (
                else (term = ASTEOF; seqs = seqs.push(l));
             );
          }};
-         let def-i = seqs.length - 1;
+         let def-i = seqs.length;
          while def-i > 0 {
-            infer-global-context(seqs[def-i]);
             def-i = def-i - 1;
+            infer-global-context(seqs[def-i]);
          };
       );
       Typedef{ lhs:Lit{base-type=key}, case-constructors=rhs } => (

SRC/specialize.lm

@@ -16,6 +16,7 @@ specialize := λ(: key String)(: ft Type)(: unify-ctx Maybe<TContext>)(: result-
          (let special-term (substitute( unify-ctx term )))
          (infer-global-context( special-term ))
          (let tctx-special (std-infer-expr( (: None Maybe<TContext>) special-term false Used TAny )))
+         (set special-term (.second tctx-special))
          (set global-type-context (.bind( global-type-context key (typeof special-term) special-term )))
          (set ast-parsed-program (Seq(
             (close ast-parsed-program)

SRC/std-apply-macro.lsts

@@ -19,7 +19,7 @@ let std-apply-macro(tctx: Maybe<TContext>, mname: CString, margs: AST): (TContex
          peeped = mtype;
       };
    };
-   (let peeped-type, _) = std-infer-peeped-arguments(tctx, margs, peep-holes);
+   (let peeped-type, margs) = std-infer-peeped-arguments(tctx, margs, peep-holes);
 
    let matched = [] :: List<(Type,AST)>;
    for Tuple{mtype=first, mterm=third} in row {

SRC/std-infer-expr.lsts

@@ -88,32 +88,25 @@ let std-infer-expr(tctx: Maybe<TContext>, term: AST, is-scoped: Bool, used: IsUs
       AType{tt=tt} => ascript-normal(term, tt);
       Seq{} => (
          let seqs = mk-vector(type(AST));
-         while term.is-seq { match term {
+         while non-zero(term) { match term {
             Seq{l=left, r=right} => (
                seqs = seqs.push(r);
-               if l.is-seq
-               then term = l
-               else (term = ASTEOF; seqs = seqs.push(l));
+               term = l
             );
          }};
-         let is-diff = false as U64;
-         let def-i = seqs.length - 1;
+         let def-i = seqs.length;
          while def-i > 0 {
+            def-i = def-i - 1;
             let r = seqs[def-i];
             (_, let new-r) = std-infer-expr(tctx, seqs[def-i], false, Used, hint);
-            if not(is(r,new-r)) then { is-diff = true; seqs[def-i] = new-r; };
-            def-i = def-i - 1;
+            if not(is(r,new-r)) then { seqs[def-i] = new-r; };
+         };
+         term = ASTEOF;
+         let def-order-i = seqs.length;
+         while def-order-i > 0 {
+            def-order-i = def-order-i - 1;
+            term = term + seqs[def-order-i]
          };
-         if is-diff {
-            term = ASTEOF;
-            let def-order-i = seqs.length - 1;
-            while def-order-i > 0 {
-               if non-zero(term)
-               then term = mk-seq(term, seqs[def-order-i])
-               else term = seqs[def-order-i];
-               def-order-i = def-order-i - 1;
-            };
-         }
       );
       Glb{key=key, val=val} => (
          let rough-tt = typeof(term);