very small improvement but improvement nonetheless

Author: andrew4328

BOOTSTRAP/cli.c

@@ -321,7 +321,7 @@ let lsts-parse-type-conjugate(tokens: List<Token>): Tuple<Type,List<Token>> = (
          tokens = tnext-rest.second;
       };
       lsts-parse-expect(c")", tokens); tokens = tail(tokens);
-      if args.length==0 then t0(c"Nil")
+      if args.length==0 then type-nil
       else if args.length==1 then head(args)
       else ts( c"Tuple", args );
    } else if lsts-parse-head(tokens)==c"?" {
@@ -1025,7 +1025,7 @@ let lsts-parse-function-signature(fname: CString, tokens: List<Token>, loc: Sour
    let out = LstsFnSignature ( mk-nil(), ta, ta );
 
    lsts-parse-expect(c"(", tokens); tokens = tail(tokens);
-   out.args-type = t0(c"Nil");
+   out.args-type = type-nil;
    while non-zero(tokens) and lsts-parse-head(tokens)!=c")" {
       lsts-parse-expect(c"Identifier", lsts-is-ident-head(lsts-parse-head(tokens)), tokens);
       let arg-name = head(tokens); tokens = tail(tokens);
@@ -1059,7 +1059,7 @@ let lsts-parse-function-signature(fname: CString, tokens: List<Token>, loc: Sour
        if fname!=c"phi" then out.return-type = phi-as-state(out.return-type);
        tokens = rtype-rest.second;
    } else if non-zero(out.args-type) {
-       out.return-type = t0(c"Nil");
+       out.return-type = type-nil;
    };
 
    Tuple ( out, tokens )

PLUGINS/FRONTEND/LSTS/lsts-parse.lsts

@@ -122,7 +122,7 @@ let unify-inner(fpt: Type, pt: Type, blame: AST): Maybe<TypeContext> = (
           second:rp1
       } => (
          if can-unify(lp1, rp1)
-         then { ctx = unify-inner(lp1,rp1,blame) && unify-inner(lpr, t0(c"Nil"), blame); }
+         then { ctx = unify-inner(lp1,rp1,blame) && unify-inner(lpr, type-nil, blame); }
          else { ctx = unify-inner(lpr,rp1,blame); }
       );
       Tuple{

SRC/tctx-unify.lsts

@@ -124,7 +124,7 @@ let can-unify(fpt: Type, pt: Type): Bool = (
           ]},
           second:rp1
       } => (
-         if can-unify(lp1,rp1) then can-unify(lpr,t0(c"Nil")) else can-unify(lpr,rp1)
+         if can-unify(lp1,rp1) then can-unify(lpr,type-nil) else can-unify(lpr,rp1)
       );
       Tuple{
           first:TGround{tag:c"...", parameters:[lp1..]},

SRC/type-can-unify.lsts

@@ -20,8 +20,14 @@ let t2(tag: CString, p1: Type, p2: Type): Type = TGround(tag, mk-vector(type(Typ
 # new allocations = 0
 let tv(name: CString): Type = TVar(name);
 
-# new allocations = 0
-let type-any-arrow = t2(c"Arrow", t0(c"Any"), t0(c"Any"));
+# new allocations = 0 (constant)
+let type-nil = t0(c"Nil");
+
+# new allocations = 0 (constant)
+let type-any = t0(c"Any");
+
+# new allocations = 0 (constant)
+let type-any-arrow = t2(c"Arrow", type-any, type-any);
 
 # new allocations = 0 if either argument is ?
 #                 | 1

SRC/type-constructor.lsts

@@ -18,7 +18,7 @@ let std-infer-expr(tctx: Maybe<TypeContext>, term: AST, is-scoped: Bool, used: I
          if not(is(rhs,new-rhs)) then { rhs = new-rhs; term = mk-app(mk-abs(def,mk-nil(),misc-tt),rhs); };
          (tctx, let tt) = std-bind-term(tctx, lname, rhs, def, term, hint);
          tctx = tctx.ascript(def, tt);
-         tctx = tctx.ascript(term, t0(c"Nil"));
+         tctx = tctx.ascript(term, type-nil);
       );
       App{o-t=left:Var{key:c"typeof"}, r=right} => (
          (tctx, let new-r) = std-infer-expr(tctx, r, is-scoped, Used, ta);
@@ -63,7 +63,7 @@ let std-infer-expr(tctx: Maybe<TypeContext>, term: AST, is-scoped: Bool, used: I
       App{asc=left:Lit{key:c":"}, right:App{inner=left:ASTNil{},right:AType{tt=tt}}} => (
          tt = tt.rewrite-type-alias;
          add-concrete-type-instance(tt, term);
-         tctx = tctx.ascript(inner, t0(c"Nil"));
+         tctx = tctx.ascript(inner, type-nil);
          tctx = tctx.ascript(term, tt);
       );
       App{asc=left:Lit{key:c":"}, right:App{t=left,right:AType{tt=tt}}} => (
@@ -88,7 +88,7 @@ let std-infer-expr(tctx: Maybe<TypeContext>, term: AST, is-scoped: Bool, used: I
             let is-nullary = false;
             if typeof-term(t).is-arrow and not(tt.is-arrow) and non-zero(var-name-if-var-or-lit(t)) {
                # This case exists for nullary constructors like TAny : Type
-               let ftype = tctx.find-callable( var-name-if-var-or-lit(t), t0(c"Nil"), term, tt ).direct-type;
+               let ftype = tctx.find-callable( var-name-if-var-or-lit(t), type-nil, term, tt ).direct-type;
                tctx = tctx.ascript(term, ftype);
                is-nullary = true;
             } else if typeof-term(t) == type-any-arrow {
@@ -175,7 +175,7 @@ let std-infer-expr(tctx: Maybe<TypeContext>, term: AST, is-scoped: Bool, used: I
             };
             let lub = if typeof-term(f).is-t(c"Never",0) then typeof-term(t)
             else if typeof-term(t).is-t(c"Never",0) then typeof-term(f)
-            else if typeof-term(f).is-t(c"Nil",0) or typeof-term(t).is-t(c"Nil",0) then t0(c"Nil")
+            else if typeof-term(f).is-t(c"Nil",0) or typeof-term(t).is-t(c"Nil",0) then type-nil
             else { (tctx, let lub) = tctx.least-upper-bound(typeof-term(t), typeof-term(f), term); lub };
             tctx = tctx.ascript(term, lub);
             let term-phi-id = typeof-term(term).slot(c"Phi::Id",1).l1.simple-id;
@@ -189,9 +189,9 @@ let std-infer-expr(tctx: Maybe<TypeContext>, term: AST, is-scoped: Bool, used: I
             if non-zero(term-phi-id) and term-phi-id != f-phi-id then tctx = tctx.phi-move(typeof-term(f), f);
          }
       );
-      ASTEOF{} => tctx = tctx.ascript(term, t0(c"Nil"));
-      ASTNil{} => tctx = tctx.ascript(term, t0(c"Nil"));
-      Meta{} => tctx = tctx.ascript(term, t0(c"Nil"));
+      ASTEOF{} => tctx = tctx.ascript(term, type-nil);
+      ASTNil{} => tctx = tctx.ascript(term, type-nil);
+      Meta{} => tctx = tctx.ascript(term, type-nil);
       Typedef{} => ();
       AType{tt:TGround{tag:c"Type",parameters:[p1..]}} => tctx = tctx.ascript(term, t1(c"Type",p1.sanitize-phi));
       AType{tt=tt} => tctx = tctx.ascript(term, tt.sanitize-phi);
@@ -274,7 +274,7 @@ let std-infer-expr(tctx: Maybe<TypeContext>, term: AST, is-scoped: Bool, used: I
             } else if not(non-zero(typeof-term(term))) {
                if hint.is-t(c"HashtableEq",2) and hint.is-datatype and key3==c"HashtableEqEOF"
                then {
-                  (tctx, let lit-tt) = tctx.apply-callable(key3, t0(c"Nil"), term, hint);
+                  (tctx, let lit-tt) = tctx.apply-callable(key3, type-nil, term, hint);
                   tctx = tctx.ascript(term, lit-tt);
                } else {
                   tctx = tctx.ascript(term, type-any-arrow);
@@ -340,7 +340,7 @@ let std-infer-expr(tctx: Maybe<TypeContext>, term: AST, is-scoped: Bool, used: I
                   let pre-retain-tctx = tctx;
                   (tctx, let new-r) = std-infer-call-arg(tctx, r, var-name-if-var-or-lit(l), rr-args-hint);
                   let ftype = tctx.find-callable( var-name-if-var-or-lit(l), typeof-term(new-r), term, direct-hint ).direct-type;
-                  if typeof-term(l) == t2(c"Arrow",t0(c"Any"),t0(c"Any")) {
+                  if typeof-term(l) == type-any-arrow {
                      tctx = tctx.ascript(l, ftype);
                   };
                   if ftype.domain.is-any-arg-t(c"MustNotRetain",0) {
@@ -398,16 +398,16 @@ let std-infer-expr(tctx: Maybe<TypeContext>, term: AST, is-scoped: Bool, used: I
                      let tmp-var = mk-var(tmp-id); ascript-force(tmp-var, typeof-term(term));
                      tctx = tctx.bind(tmp-id, ta, typeof-term(term), tmp-def);
                      mark-var-to-def-todo(tctx, tmp-id, ta, tmp-var);
-                     let tmp-nil = mk-nil(); ascript-force(tmp-nil, t0(c"Nil"));
-                     let declare = mk-abs(tmp-def, tmp-nil, ta); ascript-force(declare, t0(c"Nil"));
+                     let tmp-nil = mk-nil(); ascript-force(tmp-nil, type-nil);
+                     let declare = mk-abs(tmp-def, tmp-nil, ta); ascript-force(declare, type-nil);
                      if function-type.is-t(c"MustRetainOnCall",0) and not(hint.is-t(c"MustNotRetain",0)) and not(tctx.get-or(mk-tctx()).is-blob) {
                         (tctx, term) = maybe-retain(tctx, term);
                      };
-                     let bind = mk-app(declare, term); ascript-force(bind, t0(c"Nil"));
+                     let bind = mk-app(declare, term); ascript-force(bind, type-nil);
 
                      let new-term = bind;
                      if non-zero(prefix) {
-                        new-term = mk-cons(prefix, new-term); ascript-force(new-term, t0(c"Nil"));
+                        new-term = mk-cons(prefix, new-term); ascript-force(new-term, type-nil);
                      };
                      new-term = mk-cons(new-term, postfix); ascript-force(new-term, typeof-term(postfix));
                      new-term = mk-cons(new-term, tmp-var); ascript-force(new-term, typeof-term(term));

SRC/typecheck-infer-expr.lsts

@@ -24,7 +24,7 @@ let release-locals(tctx-before: TypeContext?, tctx-after: TypeContext?, term: AS
       let rhs = term;
       let def = mk-var(return-id);
       if not(return-type.is-t(c"Nil",0)) and not(return-type.is-t(c"Never",0)) {
-         term = mk-app( mk-abs(def, mk-nil(), ta), term ); tctx-after = tctx-after.ascript(term, t0(c"Nil"));
+         term = mk-app( mk-abs(def, mk-nil(), ta), term ); tctx-after = tctx-after.ascript(term, type-nil);
          (tctx-after, let binding-type) = std-bind-term(tctx-after, return-id, rhs, def, term, hint);
          tctx-after = tctx-after.ascript(def, binding-type);
       };
@@ -35,7 +35,7 @@ let release-locals(tctx-before: TypeContext?, tctx-after: TypeContext?, term: AS
             mk-app(mk-var(c"destroy"),mk-var(nd.key-or-zero))
          );
          (tctx-after, do-release) = std-infer-expr(tctx-after, do-release, false, Used, ta);
-         term = mk-cons(term, do-release); tctx-after = tctx-after.ascript(term, t0(c"Nil"));
+         term = mk-cons(term, do-release); tctx-after = tctx-after.ascript(term, type-nil);
       };
       let return-term = if not(return-type.is-t(c"Nil",0)) and not(return-type.is-t(c"Never",0))
       then mk-var(return-id)

SRC/typecheck-release-locals.lsts

@@ -47,12 +47,12 @@ let std-release-after-call(tctx: TypeContext?, function-type: Type, param-types:
             let tmp-var2 = mk-var(tmp-id1); ascript-force(tmp-var2, args-type);
             tctx = tctx.bind(tmp-id1, ta, args-type, tmp-def);
             mark-var-to-def-todo(tctx, tmp-id1, ta, tmp-var2);
-            let tmp-nil = mk-nil(); ascript-force(tmp-nil, t0(c"Nil"));
-            let declare = mk-abs(tmp-def, tmp-nil, ta); ascript-force(declare, t0(c"Nil"));
-            let bind = mk-app(declare, args); ascript-force(bind, t0(c"Nil"));
+            let tmp-nil = mk-nil(); ascript-force(tmp-nil, type-nil);
+            let declare = mk-abs(tmp-def, tmp-nil, ta); ascript-force(declare, type-nil);
+            let bind = mk-app(declare, args); ascript-force(bind, type-nil);
 
             if non-zero(prefix)
-            then (prefix = mk-cons( prefix, bind ); ascript-force(prefix, t0(c"Nil"));)
+            then (prefix = mk-cons( prefix, bind ); ascript-force(prefix, type-nil);)
             else prefix = bind;
 
             (tmp-var2, args)
@@ -64,12 +64,12 @@ let std-release-after-call(tctx: TypeContext?, function-type: Type, param-types:
             tctx = tctx.bind(tmp-id2, ta, args-type, tmp-def);
             mark-var-to-def-todo(tctx, tmp-id2, ta, tmp-var2);
             mark-var-to-def-todo(tctx, tmp-id2, ta, tmp-direct);
-            let tmp-nil = mk-nil(); ascript-force(tmp-nil, t0(c"Nil"));
-            let declare = mk-abs(tmp-def, tmp-nil, ta); ascript-force(declare, t0(c"Nil"));
-            let bind = mk-app(declare, args); ascript-force(bind, t0(c"Nil"));
+            let tmp-nil = mk-nil(); ascript-force(tmp-nil, type-nil);
+            let declare = mk-abs(tmp-def, tmp-nil, ta); ascript-force(declare, type-nil);
+            let bind = mk-app(declare, args); ascript-force(bind, type-nil);
 
             if non-zero(prefix)
-            then (prefix = mk-cons( prefix, bind ); ascript-force(prefix, t0(c"Nil"));)
+            then (prefix = mk-cons( prefix, bind ); ascript-force(prefix, type-nil);)
             else prefix = bind;
 
             (tmp-var2, tmp-direct)
@@ -81,7 +81,7 @@ let std-release-after-call(tctx: TypeContext?, function-type: Type, param-types:
          let do-release = mk-app(release-var, tmp-release); ascript-force(do-release, release-return);
 
          if non-zero(postfix)
-         then (postfix = mk-cons( postfix, do-release ); ascript-force(postfix, t0(c"Nil"));)
+         then (postfix = mk-cons( postfix, do-release ); ascript-force(postfix, type-nil);)
          else postfix = do-release;
       };
 

SRC/typecheck-std-maybe-release-after-call.lsts

@@ -5,6 +5,6 @@ let typeof-lhs(lhs: AST, idx: U64): Type = match lhs {
    App{ left:Lit{key:c":"}, right:App{ right:AType{tt=tt} } } => tt.rewrite-type-alias.accept-interface(idx);
    App{ ps=left, right:App{ left:Lit{key:c":"}, right:App{ right:AType{tt=tt} } } } =>
      t2(c"Cons", typeof-lhs(ps,idx+1), tt.rewrite-type-alias.accept-interface(idx));
-   ASTNil{} => t0(c"Nil");
-   _ => (exit-error("typeof-lhs Unexpected LHS \{lhs}\n", lhs); t0(c"Nil"));
+   ASTNil{} => type-nil;
+   _ => (exit-error("typeof-lhs Unexpected LHS \{lhs}\n", lhs); type-nil);
 };