Anonymous recursive functions in Racket (github.com)

A relevant article to the domain name of this site.

I would rather use a loop so I can debug it.

This isn't specific to racket, any implementation of R6RS scheme should fully support this, although the define-syntax form is slightly different.

I checked this with my R6RS implementation and it works just as you would expect (https://github.com/maplant/scheme-rs)

can we implement this in Python?

Tangential, but I've been wanting to dive back into FP for quite sometime; for context I used Haskell at a payments corp ~10 years back, working mostly with Typescript, Zig and Nim for the past couple of years, realizing I am basically trying to do FP in most of these languages.

Is Racket a good language to pick up and re-learn my concepts + implement some tools? Or are there some other languages that would be better to both brush up and learn the syntax of, I do not want to fight the syntax but rather express functions as seamlessly as I can.

All the languages I like have niche ecosystems which have a lot of drawbacks

The Racket Discourse thread on this: https://racket.discourse.group/t/illustrate-anonymous-recurs...

(Just me suggesting other alternatives right now)

In Clojure...

  ((fn [xs ret]
     (if (empty? xs)
       ret
       (recur (rest xs)
              (+ ret (first xs)))))
   (range 5) 0)

  => 10

nb. Clojure doesn't have automatic tail call optimisation. We need to explicitly emulate it with`recur`.

Probably worth noting that there's already an SRFI for this. [0] And that macro will work on any Scheme implementing the standard since about '98.

    (define-syntax rec
      (syntax-rules ()
        ((rec (NAME . VARIABLES) . BODY)
         (letrec ( (NAME (lambda VARIABLES . BODY)) ) NAME))
        ((rec NAME EXPRESSION)
         (letrec ( (NAME EXPRESSION) ) NAME))))

[0] https://srfi.schemers.org/srfi-31/srfi-31.html