help with more logging

Author: aduarterengifo

src/scratch/trace-scratch.ts

@@ -24,7 +24,7 @@ const program = (input: string) =>
 ManagedRuntime.make(
 	Layer.mergeAll(Parser.Default, Evaluator.Default),
 ).runPromise(
-	program("diff(fn (x) { 1 / (2 * x + 3) })(3)").pipe(
+	program("diff(fn(x) { sin(3 * x + 2) })(0)").pipe(
 		Effect.provide(NodeSdkLive),
 		Effect.catchAllCause(Effect.logInfo),
 	),

src/services/diff/obj.ts

@@ -25,6 +25,7 @@ import {
 	expectIdentEquivalence,
 } from "../../schemas/nodes/exps/ident";
 import { TokenType } from "../../schemas/token-types/union";
+import { objInspect } from "../object";
 import { makeLambda } from "./helper";
 
 const baseBuiltInDiffFunc = (x: IdentExp) =>
@@ -70,12 +71,15 @@ const baseBuiltInDiffFunc = (x: IdentExp) =>
 															x,
 														);
 
-														yield* Effect.log("chain", chain);
+														yield* Effect.log("chain", objInspect(chain));
 
 														return chain;
 													}).pipe(
 														Effect.tap((x) =>
-															Effect.annotateCurrentSpan("chain", x),
+															Effect.annotateCurrentSpan(
+																"chain",
+																objInspect(x),
+															),
 														),
 													),
 												),
@@ -226,58 +230,61 @@ const processTerm = Effect.fn("diff.process-term")(
 
 // powerRule(ONE, ONE, x)
 
-export const diffPolynomial = (
-	obj: PolynomialObj,
-	x: IdentExp,
-): Effect.Effect<PolynomialObj, ParseError | KennethParseError, never> =>
-	Match.value(obj).pipe(
-		Match.tag("IntegerObj", () => constantRule()), // leaf
-		Match.tag("CallObj", baseBuiltInDiffFunc(x)),
-		Match.tag("IdentObj", () => powerRule(ONE, ONE, x)), // leaf
-		Match.tag("InfixObj", ({ left, operator, right }) =>
-			Effect.all([
-				Schema.decodeUnknown(PolynomialObj)(left),
-				Schema.decodeUnknown(
-					Schema.Literal(
-						TokenType.MINUS,
-						TokenType.PLUS,
-						TokenType.ASTERISK,
-						TokenType.SLASH,
-						TokenType.EXPONENT,
-					),
-				)(operator),
-				Schema.decodeUnknown(PolynomialObj)(right),
-			]).pipe(
-				Effect.flatMap(([left, operator, right]) =>
-					Match.value(operator).pipe(
-						Match.when(TokenType.ASTERISK, () => productRule(left, right, x)),
-						Match.when(TokenType.SLASH, () => quotientRule(left, right, x)),
-						Match.when(TokenType.EXPONENT, (operator) =>
-							Match.value(left).pipe(
-								Match.tag("InfixObj", () =>
-									chainRule(
-										InfixObj.make({
-											left: IdentObj.make({ identExp: x }),
-											operator,
-											right,
-										}),
-										left,
-										x,
+export const diffPolynomial = Effect.fn("diff.outer")(
+	(
+		obj: PolynomialObj,
+		x: IdentExp,
+	): Effect.Effect<PolynomialObj, ParseError | KennethParseError, never> =>
+		Match.value(obj).pipe(
+			Match.tag("IntegerObj", () => constantRule()), // leaf
+			Match.tag("CallObj", baseBuiltInDiffFunc(x)),
+			Match.tag("IdentObj", () => powerRule(ONE, ONE, x)), // leaf
+			Match.tag("InfixObj", ({ left, operator, right }) =>
+				Effect.all([
+					Schema.decodeUnknown(PolynomialObj)(left),
+					Schema.decodeUnknown(
+						Schema.Literal(
+							TokenType.MINUS,
+							TokenType.PLUS,
+							TokenType.ASTERISK,
+							TokenType.SLASH,
+							TokenType.EXPONENT,
+						),
+					)(operator),
+					Schema.decodeUnknown(PolynomialObj)(right),
+				]).pipe(
+					Effect.flatMap(([left, operator, right]) =>
+						Match.value(operator).pipe(
+							Match.when(TokenType.ASTERISK, () => productRule(left, right, x)),
+							Match.when(TokenType.SLASH, () => quotientRule(left, right, x)),
+							Match.when(TokenType.EXPONENT, (operator) =>
+								Match.value(left).pipe(
+									Match.tag("InfixObj", () =>
+										chainRule(
+											InfixObj.make({
+												left: IdentObj.make({ identExp: x }),
+												operator,
+												right,
+											}),
+											left,
+											x,
+										),
 									),
+									Match.orElse(() => processTerm(obj, x)),
 								),
-								Match.orElse(() => processTerm(obj, x)),
 							),
+							Match.when(TokenType.PLUS, (plus) =>
+								sumAndDifferenceRule(left, right, x, plus),
+							),
+							Match.when(TokenType.MINUS, (minus) =>
+								sumAndDifferenceRule(left, right, x, minus),
+							),
+							Match.exhaustive,
 						),
-						Match.when(TokenType.PLUS, (plus) =>
-							sumAndDifferenceRule(left, right, x, plus),
-						),
-						Match.when(TokenType.MINUS, (minus) =>
-							sumAndDifferenceRule(left, right, x, minus),
-						),
-						Match.exhaustive,
 					),
 				),
 			),
+			Match.exhaustive,
+			Effect.tap((x) => Effect.log("outer obj", objInspect(obj))),
 		),
-		Match.exhaustive,
-	);
+);

src/services/evaluator/index.ts

@@ -287,6 +287,8 @@ export const evalDiff = (diffExp: DiffExp) =>
 
 		const expResult = yield* convertToExp(diffSoftEval);
 
+		yield* Effect.log("after convert", nodeString(expResult));
+
 		// yield* logDebug('exp', expResult)
 		// yield* logDebug('--------------------------')
 

src/services/object/index.ts

@@ -21,9 +21,17 @@ export const objMatch = $match;
 // compiler won't scream at you to remind you to handle that specific case.
 export const objInspect = (obj: Obj): string =>
 	Match.value(obj).pipe(
-		Match.tag("InfixObj", () => "infix obj"),
+		Match.tag(
+			"InfixObj",
+			({ left, operator, right }) =>
+				`(${objInspect(left)} ${operator} ${objInspect(right)})`,
+		),
+		Match.tag(
+			"CallObj",
+			({ args, fn }) => `${objInspect(fn)}(${args.map(objInspect).join(", ")})`,
+		),
 		Match.tag("IdentObj", ({ identExp: { value } }) => value),
-		Match.tag("BuiltInObj", () => "builtin function"),
+		Match.tag("BuiltInObj", ({ fn }) => fn),
 		Match.tag(
 			"FunctionObj",
 			({ params, body }) => `

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

@@ -446,7 +446,7 @@ describe("eval", () => {
 		});
 		describe("trig chain", () => {
 			const tests = [
-				["diff(fn(x) { sin(3 * x + 2) })(0)", 3 * Math.cos(3 * 0 + 2)],
+				["diff(fn(x) { sin(3 * x + 2) })(1)", 3 * Math.cos(3 * 1 + 2)],
 				["diff(fn(x) { 3 * x + 2 })(0)", 3],
 			] as const;