• Index
• Search by APIs
• Search by Words
• Project Search

• Java
• Python
• JavaScript
• TypeScript
• C++
• Scala
• Blog

• interpreters-master
  • src
    • logic
      • substitution-ADT.rkt
      • lzt.ts
      • auxiliary.rkt
      • LP-ast-tests.rkt
      • term-equation-adt.rkt
      • LP-ast.rkt
      • lazy-tree-ADT-tests.rkt
      • substitution-adt-tests.rkt
      • utils.rkt
      • lazy-tree-ADT.rkt
      • README.md
      • unify.rkt
      • answer-query-test.rkt
      • answer-query.rkt
      • unify-tests.rkt
      • LP-rename.rkt
    • L4
      • evalPrimitive-box.ts
      • L4-eval.ts
      • L4-ast.ts
      • L4-env-box.ts
      • L4-value.ts
      • L4-value-box.ts
      • L4-eval-box.ts
      • evalPrimitive.ts
      • L4-env.ts
    • L1
      • L1-eval.ts
      • L1-ast.ts
      • E-parser.ts
    • L5
      • L5-type-equations.ts
      • TExp.ts
      • L5-typecheck.ts
      • TEnv.ts
      • L5-env.ts
      • L5-value.ts
      • L5-typeinference.ts
      • L5-ast.ts
      • evalPrimitive.ts
      • L5-substitution-adt.ts
      • L5-eval.ts
    • shared
      • result.ts
      • parser.ts
      • optional.ts
      • list.ts
      • s-expression.d.ts
      • box.ts
      • type-predicates.ts
    • async
      • lzl.rkt
      • coroutine1.rkt
      • rwu-promise.ts
      • test.async
    • L3
      • substitute.ts
      • L3-eval.ts
      • lexicalAddress.ts
      • L3-env.ts
      • L3-value.ts
      • L3-normal.ts
      • evalPrimitive.ts
      • freeVars.ts
      • L3-ast.ts
      • rewrite.ts
    • cps
      • sumcont.ts
      • L7-eval.ts
      • L7c-eval.ts
      • sum.ts
      • L7a-eval.ts
      • L7b-eval.ts
      • L6-eval.ts
      • racket
        • cps1.rkt
        • fact.rkt
        • sum-odd-squares.rkt
        • filter-cps.rkt
        • sumlist.rkt
        • leftmost-even.rkt
        • map-cps.rkt
  • jest.config.js
  • LICENSE
  • test
    • L4
      • L4-eval.test.ts
      • L4-eval-box.test.ts
      • L4-ast.test.ts
    • L1
      • L1-eval.test.ts
      • L1-ast.test.ts
    • L5
      • L5-eval.test.ts
      • test-helpers.ts
      • L5-substitution-adt.test.ts
      • L5-ast.test.ts
      • L5-type-equations.test.ts
      • L5-typecheck.test.ts
      • L5-typeinference.test.ts
    • L3
      • L3-normal.test.ts
      • lexicalAddress.test.ts
      • L3.test.ts
      • freeVars.test.ts
    • cps
      • L7.test.ts
      • L6-eval.test.ts
  • global.d.ts
  • README.md
  • package.json
  • CODE_OF_CONDUCT.md
  • tsconfig.json
  • .gitignore

import { filter, indexOf, map, includes, zip, KeyValuePair } from "ramda";
import { CExp, ProcExp, VarDecl, VarRef } from "./L3-ast";
import { isAppExp, isBoolExp, isIfExp, isLitExp, isNumExp, isPrimOp, isProcExp, isStrExp, isVarRef } from "./L3-ast";
import { makeAppExp, makeIfExp, makeProcExp, makeVarDecl, makeVarRef } from "./L3-ast";
import { first } from '../shared/list';

// For applicative eval - the type of exps should be ValueExp[] | VarRef[];
// where ValueExp is an expression which directly encodes a value:
// export type ValueExp = LitExp | NumExp | BoolExp | StrExp | PrimOp;
// In order to support normal eval as well - we generalize the types to CExp.
// @Pre: vars and exps have the same length
export const substitute = (body: CExp[], vars: string[], exps: CExp[]): CExp[] => {
    const subVarRef = (e: VarRef): CExp => {
        const pos = indexOf(e.var, vars);
        return ((pos > -1) ? exps[pos] : e);
    };
    
    const subProcExp = (e: ProcExp): ProcExp => {
        const argNames = map((x) => x.var, e.args);
        const subst = zip(vars, exps);
        const freeSubst = filter((ve) => !includes(first(ve), argNames), subst);
        return makeProcExp(
            e.args,
            substitute(
                e.body,
                map((x: KeyValuePair<string, CExp>) => x[0], freeSubst),
                map((x: KeyValuePair<string, CExp>) => x[1], freeSubst)
            )
        );
    };
    
    const sub = (e: CExp): CExp => isNumExp(e) ? e :
        isBoolExp(e) ? e :
        isPrimOp(e) ? e :
        isLitExp(e) ? e :
        isStrExp(e) ? e :
        isVarRef(e) ? subVarRef(e) :
        isIfExp(e) ? makeIfExp(sub(e.test), sub(e.then), sub(e.alt)) :
        isProcExp(e) ? subProcExp(e) :
        isAppExp(e) ? makeAppExp(sub(e.rator), map(sub, e.rands)) :
        e;
    
    return map(sub, body);
};
/*
    Purpose: create a generator of new symbols of the form v__n
    with n incremented at each call.
*/
export const makeVarGen = (): (v: string) => string => {
    let count: number = 0;
    return (v: string) => {
        count++;
        return `${v}__${count}`;
    };
};
/*
Purpose: Consistently rename bound variables in 'exps' to fresh names.
         Start numbering at 1 for all new var names.
*/
export const renameExps = (exps: CExp[]): CExp[] => {
    const varGen = makeVarGen();
    const replace = (e: CExp): CExp =>
        isIfExp(e) ? makeIfExp(replace(e.test), replace(e.then), replace(e.alt)) :
        isAppExp(e) ? makeAppExp(replace(e.rator), map(replace, e.rands)) :
        isProcExp(e) ? replaceProc(e) :
        e;
    
    // Rename the params and substitute old params with renamed ones.
    //  First recursively rename all ProcExps inside the body.
    const replaceProc = (e: ProcExp): ProcExp => {
        const oldArgs = map((arg: VarDecl): string => arg.var, e.args);
        const newArgs = map(varGen, oldArgs);
        const newBody = map(replace, e.body);
        return makeProcExp(map(makeVarDecl, newArgs), substitute(newBody, oldArgs, map(makeVarRef, newArgs)));
    };
    
    return map(replace, exps);
};