Isn't Racket the 'default' Scheme? (Even though it's no longer called Scheme.)
Additionally they allow to prove a point.
For example, is writing compilers systems programming or not?
> [...] GNU/MIT Scheme is what you want to follow along with MIT publications working in Scheme (like Structure and Interpretation of Computer Programs, Structure and Interpretation of Classical Mechanics, and The Art of the Propagator).
Definitely, though I suspect if you need a language that's exactly what's written in the text, you are probably missing the point? At least for SICP, I haven't looked into the others as closely. (Part of) the point being learning wider concepts.
I almost feel like you get more out of the book, if you do the exercises in a mix of JavaScript and Python. Not because those are better languages, just the opposite: because it forces you to understand the concepts well enough to translate them.
lift :: Vec (a->b) -> (a->Vec b)
lift [] a = []
lift f:fs = (f a):(lift fs $ a)
((fx fy fz) r)
For example, `guile-scmutils`[0] says:
> Functionality not available in the port:
> Scheme extension to allow applying vectors/structures as procedures. For example rather than
1 ]=> (pe ((up (literal-function 'x) (literal-function 'y)) 't))
(up (x t) (y t))
guile> (pe ((lambda (t) (up ((literal-function 'x) t) ((literal-function 'y) t))) 't))
(up (x t) (y t))
(define (juxt . fns)
(lambda args
(map (lambda (fn) (apply fn args)) fns))) lift = fix ((`ap` tail) . (. head) . flip ((.) . liftM2 (:)))
It is possible to fill in basic function bodies based on their type, using ghc-justdoit (https://hackage.haskell.org/package/ghc-justdoit). That's maybe not what you meant, if you are looking for integrating pointfree into Haskell it can be added to ghci or your development environment.
foo :: ((a -> r) -> r) -> (a -> ((b -> r) -> r)) -> ((b -> r) -> r)
foo = (…)
flip \a -> ($ a)
= flip (&)
= flip (flip ($))
= ($) (??) :: Functor f => f (a -> b) -> a -> f b
funs ?? a = fmap ($ a) funs
This is valid definition of lift along a different, less interesting but more general axis.
lift = (??) @[] lift = flip $ \a -> ($a)I can't recommend MIT Scheme for anything these days; it's just missing too many things that I feel are required for real work in Scheme, and has too many idiosyncrasies and quirks. Even using it to run a standalone program written in Scheme is a pain.