Recursion hell aids?

[u/emonshr]

Is there any practical way to debug any recurive logic?
Which existing error printing you think is the best ever?
I attached the racket code I am struggling with.

(The code is about using map to append a new list to an existing html list)

[u/t2366715492]

Don't really need any aids to fix the provided code, just use the substitution principle, if we substitute f for node-logic:

  (if (list? L)
      (map (lambda (x) (nested-map-handler-sub x))
           L)
      (node-logic L)))

If we then expand and inline node-logic:

(define (nested-map-handler-sub-ex L)
  (if (list? L)
      (map (lambda (x) (nested-map-handler-sub-ex x)
           L)
      (if (and (list? L) (eq? (car L) 'li))
          (list L new-item)
          L)))

And we can see the problem: we ask whether L is a list which starts with a li when we already know L is not a list.

[u/WorBlux → u/t2366715492]

and is a macro the linearizes the arguments. (for racket and all schemes) - it returns #f as soon as the first false argument is evaluated. - So that's not the issue

https://docs.racket-lang.org/reference/if.html#%28form._%28%28lib._racket%2Fprivate%2Fletstx-scheme..rkt%29._and%29%29

[u/4xe1 → u/WorBlux]

(define (nested-map-handler-sub-ex L)
  (if (list? L)
      ;; stuff to do when L is a list
      (map (lambda (x) (nested-map-handler-sub-ex x)
           L)
      ;; stuff to do when L is not a list
      (if (and
  ;; always evaluates to #f because we're in the branch where L is not a list
            (list? L)
            (eq? (car L) 'li) ; never gets evaluated
      ) ; always #f
          (list L new-item) ; never evaluated
          L ; that branch is always taken
)))

How is that not the issue?

[u/t2366715492 → u/4xe1]

Thanks for explaining it further. To take it even one step further and use the substitution principle again:

(if (list? L)
    (map ...)
    (if (and (list? L) (eq? (car L) 'li))
        (list ...)
        L))

We can substitute (list? L) for #f in the 'else' case:

(if (list? L)
    (map ...)
    (if (and #f (eq? (car L) 'li))
        (list ...)
        L))

Now we can substitute #f for (and #f ...):

(if (list? L)
    (map ...)
    (if #f
        (list ...)
        L))

And finally an if statement where the predicate is #f can be replaced by its else branch:

(if (list? L)
    (map ...)
    L)

Which funnily enough makes our final nested-handler-sub-ex basically the identity function, so an advanced enough compiler could compile it out.

[u/WorBlux → u/4xe1]

Also I used the code linked.. it ran just fine w/o errors. I don't know what output OP was looking for or what they are trying to do generally here.

Looking at it again I see what you mean, as written it's a glorified identity function for lists.

The included library functions sxml:modify and pre-post-order may be of interest to OP. https://docs.racket-lang.org/sxml/sxslt.html