dzpower

The ClojureScript example is great.

Clojure and by extension ClojureScript has a lot of tasteful and pragmatic design decisions, e.g. the use of the threading form and implicit lambda illustrated with the "+ 2").

By contrast Racket has been extended to include a Clojure-inspired threading as a library, showing off just a little of its awesome linguistic extensibility, leading in this case to ergonomically similar code.

Clojure/Script is a wonderful opinionated modern Lisp; Racket is a more linguistically extensible modern Lisp. There's considerable cross-fertilisation going on.

If you love Clojure, it's worth keeping an eye on Racket.

* * *

You can spell λ out as lambda in Racket (and Scheme).

I feel similarly to Gene Kim about Racket. Here's a comparison ...

Gene Kim's Clojure example:

  ; input is JSON string: "{foo: 2}"

  (defn xform [s]
    (-> (js/JSON.parse s)
        js->clj
        (update "foo" + 2)
        clj->js
        js/JSON.stringify))

Racket equivalent:

  #lang racket

  (require threading json)

  ; input is (xform "{\"foo\" : 2 }")

  (define (xform s)
    (~> s
        string->jsexpr
        (hash-update 'foo (λ (x) (+ 2 x)))
        jsexpr->string))

Racket (a Scheme descendant) might be a good fit. It has teaching languages, which are simplified, and a nice IDE (DrRacket), and books (HTDP/2e (free online), Realm of Racket, etc.)

Close match to the Python above:

(apply + (range 1 11))