hmm

Author: andrew-johnson-4

SRC/std-apply-macro-candidates.lsts

@@ -10,7 +10,6 @@ let std-apply-macro-candidates(tctx: TContext?, mname: CString, margs: AST, cand
    for Tuple{ctype=first, second:Abs{mlhs=lhs,rhs:App{left:Lit{key:c":"},right:App{mrhs=left}}}} in candidates {
       if not(non-zero(t)) {
          (let new-tctx, let mctx) = std-try-destructure-macro(tctx, margs, ctype, mlhs);
-         print("Apply Candidate \{mname} \{mlhs}\nContext: \{new-tctx}\n");
          if mctx.is-some then mctx = union(mctx, Some{extract-uuids(mrhs)});
          if mctx.is-some then t = with-location-preserve(substitute(mctx.get-or-panic, mrhs), margs.location);
       }
@@ -19,7 +18,6 @@ let std-apply-macro-candidates(tctx: TContext?, mname: CString, margs: AST, cand
 );
 
 let std-try-destructure-macro(tctx: TContext?, margs: AST, mtype: Type, mcandidate: AST): (TContext?, AContext?) = (
-   print("Destructure \{mtype}\nArgs: \{margs}\nCandidate \{mcandidate}\n");
    let no = None :: AContext?;
    if let Abs{lhs=lhs, rhs=rhs} = mcandidate then std-try-destructure-macro(tctx, margs, mtype, lhs)
    else {
@@ -49,7 +47,6 @@ let std-try-destructure-macro(tctx: TContext?, margs: AST, mtype: Type, mcandida
                         App{left:Var{maybe-helper=key}, helper-args=right} => (
                            if macro-helper==maybe-helper {
                               (tctx, let helped) = std-apply-macro-weak(tctx, macro-helper, helper-args);
-                              print("Macro Helper \{macro-helper}: \{helped}\n");
                               if non-zero(helped)
                               then (tctx, std-direct-destructure-macro(helped, mstruct))
                               else (tctx, no)
@@ -58,7 +55,6 @@ let std-try-destructure-macro(tctx: TContext?, margs: AST, mtype: Type, mcandida
                         _ => (
                            if macro-helper==c"macro::variable" {
                               (tctx, let helped) = std-apply-macro-weak(tctx, macro-helper, margs);
-                              print("Macro Helper \{macro-helper}: \{helped}\n");
                               if non-zero(helped)
                               then (tctx, std-direct-destructure-macro(helped, mstruct))
                               else (tctx, no)

SRC/std-apply-macro.lsts

@@ -30,7 +30,6 @@ let std-apply-macro-location(tctx: Maybe<TContext>, mname: CString, margs: AST):
 
 let std-apply-macro(tctx: Maybe<TContext>, mname: CString, margs: AST, strong: Bool): (TContext?, AST) = (
    let result = ASTEOF;
-   print("Apply Macro: \{mname} \{margs}\n");
    if mname==c"macro::concat" then (tctx, result) = std-apply-macro-concat(tctx, mname, margs)
    else if mname==c"macro::location" then (tctx, result) = std-apply-macro-location(tctx, mname, margs)
    else if mname==c"macro::variable" then (tctx, result) = std-apply-macro-variable(tctx, mname, margs)
@@ -71,7 +70,6 @@ let std-apply-macro(tctx: Maybe<TContext>, mname: CString, margs: AST, strong: B
       };
       (tctx, result) = std-apply-macro-candidates(tctx, mname, margs, candidates);
    };
-   print("Applied Macro: \{mname} \{margs}\nResult: \{result}\n");
    if strong && not(non-zero(result)) then exit-error("Failed to Apply Macro: \{mname}\nArgs: \{margs}\n", margs);
    if strong then (tctx, result) = std-infer-expr(tctx, result, false, Used, TAny);
    (tctx, result)

SRC/tctx-to-string.lsts

@@ -8,3 +8,13 @@ let .into(tctx: Maybe<TContext>, tt: Type<String>): String = (
 );
 
 let to-smart-string(tctx: Maybe<TContext>): String = tctx.into(type(String));
+
+let .into(ctx: Maybe<AContext>, tt: Type<String>): String = (
+   let result = "";
+   for Tuple{first=first,second=second} in ctx.get-or([] :: AContext) {
+      result = result + "\{first} : \{second}\n";
+   };
+   result
+);
+
+let to-smart-string(ctx: Maybe<AContext>): String = ctx.into(type(String));