Chic: Stack trace in the midst of argument evaluation

[yossigil]

Consider the following, perhaps hypothetical, scenario: Evaluation reaches the point before invoking an eager (not-normal) function that takes many parameters. In the evaluation of one of these arguments, and before the function is invoked, you encounter an error. You could attribute this error to the function that made the invocation, but also, if you are careful, with regard to the evaluation of a named argument, i.e., the stack trace could be more specific. Not sure whether this is worth the trouble.

[DorYeheskel]

@yossigil

Did you mean for example:

> (defun exists (x xs) (cond ((null xs) xs)((eq x (car xs)) t)(t (exists x (cdr xs)))))
EXISTS

> (exists 'a (car (car 'b)))
Traceback (most recent call last):
	From function EXISTS:
		Args: ((QUOTE A) (CAR (CAR (QUOTE B))))
	From function CAR:
		Args: (CAR (QUOTE B))
	From function CAR:
		Args: B
Error [CAR] in B
>  

If yes, I already done it during the implementation of stack trace.

(without it, it could be very difficult to debug the tough validation I did)

[yossigil]

I mean,

> (defun exists (x xs) (cond ((null xs) xs)((eq x (car xs)) t)(t (exists x (cdr xs)))))
EXISTS

We call function exists in such a way that it will fail during the evaluation of its argument, but to make the trace more explanatory, we add another function that makes the failure happen during the evaluation of the function body, rather than during the evaluation of the function arguments.

> (defun 
	fail (anything) ; function failing on any value of argument
	(exists        	; use above function exists
		anything    	; should be OK since argument was evaluated 
     (cdr				; error shall occur while evaluating argument 
			(car       ; error shall occur in *native* body of CAR
				(quote b)   ; successful evaluation CAR's argument
			)
		)
	)
)
FAIL
> (set variable value)
VARIABLE
> (fail variable)

Error[CAR on b]
Trace[best read bottom up] 
  LEGEND [[
      UPPER CASE = Unevaluated S-Expressions; 
      lower case=  Evaluated S-Expressions
  ]] 
  Evaluate (FAIL VARIABLE)
  Apply FAIL[anything = VARIABLE]
   	1.	Parameter FAIL/anything = VARIABLE
   		Argument FAIL/anything= value
  Invoke FAIL[anything = value]
  Evlauate (EXISTS ANYTHING=value (CDR (CAR (QUOTE B))))
  Apply EXISTS[x = ANYTHING, xs = (CDR (CAR (QUOTE B)))]
		1. Parameter EXISTS/x = ANYTHING
		   Argument EXISTS/x = value
     2. Parameter EXISTS/xs = (CDR(CAR (QUOTE B)))
	Apply CDR[s = (CAR (QUOTE B))]
		1. Parameter CDR/s = (CAR (QUOTE B))
   Apply CAR[s = (QUOTE B)]
		1. Parameter CAR/s = (QUOTE B)
			Argument CAR/S = B 
   Evaluate CAR[s=B]
	Error CAR on B
>  

This is not very difficult to achieve, but it requires more work.

(without it, it could be very difficult to debug the tough validation I did)

Could what I suggested made it easier?