success

Author: andrew-johnson-4

PLUGINS/BACKEND/C/compile-global.lm

@@ -9,7 +9,6 @@ compile-global-c-main-term := ASTEOF;
 
 compile-global-c := λ(: ctx FContext)(: k String)(: term AST). (: (
    (let kt (typeof term))
-   (print 'Global\s_s)(print k)(print '\s:\s_s)(print kt)(print '\n_s)
    (match term (
       ()
       ( (Abs( lhs rhs tlt )) (

PLUGINS/BACKEND/C/std-c-compile-call.lsts

@@ -17,7 +17,6 @@ let std-c-compile-call(ctx: FContext, fname: CString, fterm: AST, args: AST): Fr
       let push-args = std-c-compile-push-args(ctx, args);
       let function-id = if typeof(fterm).is-t(c"FFI") || typeof(fterm).is-t(c"C-FFI")
                         then fname else mangle-identifier(fname, typeof(fterm));
-      print("Call \{fname} : \{typeof(fterm)}\n");
       let ictx = mk-fragment().set(c"function-id", SAtom{function-id});
       let inner-ctx = mk-fctx().bind(c"ictx", t1(c"ImplicitContext"), ictx)
                                .bind(c"args", typeof(args), push-args);

SRC/specialize.lm

@@ -1,7 +1,6 @@
 
 specialize := λ(: key String)(: ft Type)(: unify-ctx Maybe<TContext>)(: result-type Type). (: (
    (if (is-special( key result-type )) () (
-      (print 'Specialize\s_s)(print key)(print '\s:\s_s)(print result-type)(print '\n_s)
       (let term ASTEOF)
       (for-each ((Tuple( kt _ t )) in (.lookup( global-type-context key (: LEOF List<Tuple<Type,Type,AST>>) ))) (
          (if (==( ft kt )) (

SRC/std-infer-expr.lsts

@@ -123,7 +123,11 @@ let std-infer-expr(tctx: Maybe<TContext>, term: AST, is-scoped: Bool, used: IsUs
          tctx = infer-ctx(tctx, lhs);
          (_, let new-inner-rhs) = std-infer-expr(tctx, inner-rhs, false, Tail, return-type);
          if not(is(inner-rhs,new-inner-rhs))
-         then { inner-rhs = new-inner-rhs; term = mk-abs(lhs, mk-app(asc,mk-app(inner-rhs,mk-atype(return-type))), misc-tt) };
+         then {
+            inner-rhs = new-inner-rhs;
+            rhs = mk-app(asc.unique,mk-app(inner-rhs,mk-atype(return-type)));
+            term = mk-abs(lhs,rhs,misc-tt);
+         };
          if not(misc-tt.is-t(c"Blob")) && not(misc-tt.is-t(c"C-FFI")) then ascript-normal(inner-rhs, return-type);
          ascript-normal(rhs, return-type);
          let domain-tt = typeof-lhs(lhs);