when checking for contaminated ident, check recursively.

Author: aduarterengifo

src/services/evaluator/index.ts

@@ -18,6 +18,7 @@ import type { Obj } from "@/schemas/objs/union";
 import { PolynomialObj } from "@/schemas/objs/unions/polynomials";
 import { fnTokenSchema } from "@/schemas/token/function-literal";
 import { Effect, Either, Match, Schema } from "effect";
+import { left } from "effect/Either";
 import type { ParseError } from "effect/ParseResult";
 import type { KennethParseError } from "src/errors/kenneth/parse";
 import type { DiffExp } from "src/schemas/nodes/exps/diff";
@@ -58,6 +59,29 @@ import {
 	STRING_OPERATOR_TO_FUNCTION_MAP,
 } from "./constants";
 
+const isContaminatedExpression = (
+	exp: Exp,
+	contaminatedIdents: readonly IdentExp[],
+): boolean =>
+	Match.value(exp).pipe(
+		Match.tag("IdentExp", (ident) =>
+			contaminatedIdents.some((id) => IdentExpEq(id, ident)),
+		),
+		Match.tag(
+			"InfixExp",
+			({ left, right }) =>
+				isContaminatedExpression(left, contaminatedIdents) ||
+				isContaminatedExpression(right, contaminatedIdents),
+		),
+		Match.tag("PrefixExp", ({ right }) =>
+			isContaminatedExpression(right, contaminatedIdents),
+		),
+		Match.tag("CallExp", ({ args }) =>
+			args.some((arg) => isContaminatedExpression(arg, contaminatedIdents)),
+		),
+		Match.orElse(() => false),
+	);
+
 // this error is what we pay for!!!
 const nodeEvalMatch = (env: Environment) =>
 	matchKnode({
@@ -106,10 +130,8 @@ const nodeEvalMatch = (env: Environment) =>
 					).pipe(
 						Effect.flatMap((obj) =>
 							Effect.gen(function* () {
-								const identoverlap = env.idents.some((ident) =>
-									args.some(
-										(arg) => isIdentExp(arg) && ident.value === arg.value,
-									),
+								const identoverlap = args.some((arg) =>
+									isContaminatedExpression(arg, env.idents),
 								);
 
 								const either =
@@ -184,6 +206,7 @@ export const evalDiff = (diffExp: DiffExp) => (env: Environment) =>
 		yield* Effect.log("diff:");
 		const diffSoftEval = yield* diffPolynomial(softEval, diffExp.params[0]);
 
+		yield* Effect.log("diff-eval", diffSoftEval);
 		// maybe simplest will be to convert back to exp and Eval.
 		const convertToExp = (obj: PolynomialObj): Effect.Effect<Exp, ParseError> =>
 			Match.value(obj).pipe(

src/tests/vitest/eval/eval.test.ts

@@ -295,6 +295,7 @@ describe("eval", () => {
 					["cos(pi() / 2)", Math.cos(Math.PI / 2)],
 					["tan(0)", Math.tan(0)],
 					["tan(pi() / 4)", Math.tan(Math.PI / 4)],
+					["fn (x) { cos(pi() / x) }(2)", Math.cos(Math.PI / 2)],
 				] as const;
 
 				for (const [input, expected] of tests) {
@@ -416,6 +417,7 @@ describe("eval", () => {
 		describe("trig", () => {
 			const tests = [
 				["diff(fn(x) {sin(x)})(0)", Math.cos(0)],
+				["diff(fn(x) {sin(2)})(0)", 0],
 				["diff(fn(x) {sin(x)})(pi() / 2)", Math.cos(Math.PI / 2)],
 				["diff(fn(x) {cos(x)})(0)", -Math.sin(0)],
 				["diff(fn(x) {cos(x)})(pi() / 2)", -Math.sin(Math.PI / 2)],
@@ -433,7 +435,7 @@ describe("eval", () => {
 		});
 		describe("trig chain", () => {
 			const tests = [
-				["diff(fn(x) { sin(3x+2) })(0)", 3 * Math.cos(3 * 0 + 2)],
+				["diff(fn(x) { sin(3 * x + 2) })(0)", 3 * Math.cos(3 * 0 + 2)],
 			] as const;
 
 			for (const [input, expected] of tests) {