Merge pull request #1215 from andrew-johnson-4/lm-to-lsts-feqpfe

Lm to lsts feqpfe
andrew-johnson-4 · Feb 2, 2025 · 09cf7a3 · 09cf7a3
2 parents 749bca8 + 668de06
commit 09cf7a3
Show file tree

Hide file tree

Showing 14 changed files with 21,367 additions and 21,406 deletions.
diff --git a/BOOTSTRAP/cli.c b/BOOTSTRAP/cli.c
diff --git a/PLATFORM/C/LIB/list.lsts b/PLATFORM/C/LIB/list.lsts
@@ -53,3 +53,10 @@ let .lookup(ls: List<Tuple<k,v>>, key: k, default: v): v = (
    };
    default;
 );
+let .lookup(ls: List<Tuple<k,v1,v2>>, key: k, default: Tuple<v1,v2>): Tuple<v1,v2> = (
+   let found = false;
+   for Tuple{lkey=first, val1=second, val2=third} in ls {
+      if not(found) && key==lkey { default=Tuple{val1,val2}; found=true; }
+   };
+   default;
+);
diff --git a/PLUGINS/BACKEND/C/compile-c-typedef.lm b/PLUGINS/BACKEND/C/compile-c-typedef.lm
@@ -144,7 +144,7 @@ compile-c-typedef-concrete := λ(: tctx Maybe<TContext>)(: base-type Type)(: bod
 compile-c-type-body-of-base-type :=  (: (HashtableEq( 0_u64 0_u64 (as 0_u64 Tuple<String,Tuple<Type,AST>>[]) )) HashtableEq<String,Tuple<Type,AST>>);
 
 compile-c-typedef := λ(: base-type Type)(: body AST). (: (
-   (set compile-c-type-body-of-base-type (.bind( compile-c-type-body-of-base-type (tag-of base-type) (Tuple( base-type body )) )))
+   (set compile-c-type-body-of-base-type (.bind( compile-c-type-body-of-base-type (.tag base-type) (Tuple( base-type body )) )))
    (if (.is-lm-struct base-type) (
       (if (.is-open base-type) () (
          (compile-c-typedef-concrete( (: None Maybe<TContext>) base-type body ))
@@ -196,7 +196,7 @@ compile-c-mark-field-as-seen := λ(: tt Type). (: (
          ))
          ( _ () )
       ))
-      (let base-body (.lookup( compile-c-type-body-of-base-type (tag-of tt) (Tuple( TAny ASTEOF )) )))
+      (let base-body (.lookup( compile-c-type-body-of-base-type (.tag tt) (Tuple( TAny ASTEOF )) )))
       (let base-type (.first base-body))
       (let body (.second base-body))
       (if (&&( (non-zero body) (not(.lookup( is-cstruct-hard-compiled-index tt 0_u64 ))) )) (

diff --git a/PLUGINS/BACKEND/C/initialize-c-struct.lm b/PLUGINS/BACKEND/C/initialize-c-struct.lm
@@ -29,7 +29,7 @@ initialize-c-struct := λ(: ctx FContext)(: rval AST)(: case-number U64)(: field
                               (+(
                                  (SAtom '\]*_s)
                                  (+(
-                                    (SAtom(tag-of(.r1(.slot( par1 'Array_s )))))
+                                    (SAtom(.tag(.r1(.slot( par1 'Array_s )))))
                                     (SAtom '\]\:_s)
                                  ))
                               ))
@@ -75,7 +75,7 @@ initialize-c-struct := λ(: ctx FContext)(: rval AST)(: case-number U64)(: field
                         (+(
                            (SAtom '\]*_s)
                            (+(
-                              (SAtom(tag-of(.r1(.slot( par1 'Array_s )))))
+                              (SAtom(.tag(.r1(.slot( par1 'Array_s )))))
                               (SAtom '\]\:_s)
                            ))
                         ))

diff --git a/SRC/cons-tail-or-self.lsts b/SRC/cons-tail-or-self.lsts
@@ -0,0 +1,7 @@
+
+let cons-tail-or-self(tt: Type): Type = (
+   match tt {
+      TGround{tag:c"Cons",parameters:[tl..hd..]} => tl;
+      _ => tt;
+   }
+);
diff --git a/SRC/cons-tail.lm b/SRC/cons-tail.lm
diff --git a/SRC/index-types.lm b/SRC/index-types.lm
@@ -16,14 +16,12 @@ import SRC/index-of-tag.lm;
 import SRC/is-sized-array.lsts;
 import SRC/maybe-specialize.lm;
 
-import SRC/tag-of.lm;
 import SRC/has-infinite.lm;
 import SRC/has-forward.lm;
 
 import SRC/type-of-s-with-fields.lm;
 
 import SRC/typeof-lhs.lm;
-import SRC/cons-tail.lm;
 import SRC/apply.lm;
 import SRC/apply.lsts;
 import SRC/apply-plural.lm;

diff --git a/SRC/infer-expr.lm b/SRC/infer-expr.lm
@@ -99,7 +99,7 @@ infer-expr-one := λ(: tctx Maybe<TContext>)(: term AST)(: scoped IsScoped)(: hi
          (set tctx (infer-expr( tctx t Unscoped TAny used )))
          (let inner-tt (typeof t))
          (if (non-zero inner-tt) (
-            (if (.has-prefix( (tag-of tt) 'Tag::_s )) (
+            (if (.has-prefix( (.tag tt) 'Tag::_s )) (
                (set tt (&&( tt inner-tt )))
             ) (
                (let inner-class (.with-only-class inner-tt))

diff --git a/SRC/tag-of.lm b/SRC/tag-of.lm
diff --git a/SRC/tctx-substitute.lm b/SRC/tctx-substitute.lm
diff --git a/SRC/tctx-substitute.lsts b/SRC/tctx-substitute.lsts
@@ -0,0 +1,19 @@
+
+let substitute(tctx: Maybe<TContext>, tt: List<Type>): List<Type> = (
+   match tt {
+      LCons{head=head,tail=tail} => cons( substitute(tctx,head), substitute(tctx,tail) );
+      _ => tt;
+   }
+);
+
+let substitute(tctx: Maybe<TContext>, tt: Type): Type = (
+   match tt {
+      TAnd{left=left,right=right} => TAnd{close(substitute(tctx,left)), close(substitute(tctx,right))};
+      TGround{tag=tag,parameters=parameters} => TGround{tag,close(substitute(tctx,parameters))};
+      TVar{name=name} => (
+         let ta = tctx.get-or([] :: List<Tuple<CString,Type,AST>>).lookup(name,Tuple{TAny,ASTEOF});
+         if non-zero(ta.first) then ta.first else tt;
+      );
+      _ => tt;
+   }
+);
diff --git a/SRC/type-tag.lsts b/SRC/type-tag.lsts
@@ -0,0 +1,7 @@
+
+let .tag(tt: Type): CString = (
+   match tt {
+      TGround{tag=tag} => tag;
+      _ => c"";
+   }
+);
diff --git a/SRC/unit-inference.lsts b/SRC/unit-inference.lsts
@@ -9,7 +9,7 @@ import SRC/inference-definitions.lsts;
 # unification
 import SRC/can-unify.lsts;
 import SRC/unify.lsts;
-import SRC/tctx-substitute.lm;
+import SRC/tctx-substitute.lsts;
 import SRC/tctx-union.lsts;
 import SRC/tctx-and.lsts;
 import SRC/tctx-bind.lsts;

diff --git a/SRC/unit-types.lsts b/SRC/unit-types.lsts
@@ -15,6 +15,8 @@ import SRC/domain.lsts;
 import SRC/arity.lsts;
 import SRC/ground-tag-and-arity.lsts;
 import SRC/slot.lsts;
+import SRC/type-tag.lsts;
+import SRC/cons-tail-or-self.lsts;
 
 # Boolean Queries
 import SRC/type-cmp.lsts;