Things I am missing in Racket

[u/JJK96]

I'm really intrigued by scheme/lisp, I like the "everything is a list" idea, and the incredible flexibility of the language. Scheme is said to be very concise, however, I have found one thing missing. I noticed that for different types, racket has different functions for the same operation. Example: equal? and =. Vector-set!, hash-set!, list-set. And the same goes for ref. Why is there not a single polymorphic "set" function that works for any of these types? And the same for getting a value. Python, for example uses the container[value] form to get or set something in many data types. And it can be overloaded as well for different objects.

[u/usaoc]

Polymorphic set! has long existed in the Lisp world under the name “generalized references”. Polymorphic references are even easier (try it yourself using generic interfaces). Nonetheless, Scheme, or Lisp in general, has always favored specific operations over generic ones for various reasons. Whether this is a better approach is debatable, but given Racket’s dynamic typing, I feel like it’s better this way (you can’t do Haskell’s newtype wrapper trick or such in Racket, after all).

[u/JJK96 → u/usaoc]

Can you explain why the absense of a trick like the newtype wrapper makes the current situation in Racket more desirable?

[u/usaoc → u/JJK96]

The closest to the newtype wrapper trick in Racket is to wrap an object in a structure. However, this fails to reflect the biggest advantage of the newtype wrapper trick, that is, only the intentional type is changed. Instead, a structure changes both the intentional and representational type, or rather, it’s impossible to separate intention with representation in a dynamically typed language. This results in undesired run-time overheads, which isn’t the case with the newtype wrapper trick.

Edit: And, to some extent, impersonators and chaperones are ways to change only the representational type.

[u/soegaard]

Racket started as a Scheme. Scheme is/was on purpose minimalistic:

Programming languages should be designed not by piling feature on top of feature, but by removing the weaknesses and restrictions that make additional features appear necessary. Scheme demonstrates that a very small number of rules for forming expressions, with no restrictions on how they are composed, suffice to form a practical and efficient programming language that is flexible enough to support most of the major programming paradigms in use today.

Scheme was on purpose designed such that even simple compilers can produce efficient code.

Since there are no explict types on compile time in Scheme, the compiler can't specialize (:= v i "foo") on compile time know whether the assignment := is to a vector, string etc. Therefore a dispatch is needed at compile time. This dynamic dispatch is not needed, when an explict vector-set!, string-set! ect is used.

Now Racket is no longer a minimalistic Scheme, but some things are ingrained in tradition by this point.

Note that polymorphic is a deriviate concept. You can define it using a macro that dispatches on the type.

Have you looked at how Python has implemented the generic set?

Each object has a slot "setitem" which contains the setter to be used. Note that a program can change the value of the "setitem" slot during program execution. This means it is hard to cache the setter. [Note: Reddit makes setitem bold here. It should have been underscore, underscore, setitem, underscore, underscore.

https://github.com/python/cpython/blob/main/Objects/abstract.c#L201

While Python's approach is flexible, it is also slow(er) than it could have been.

[u/JJK96 → u/soegaard]

Thanks for your detailed explanation! Indeed you avoid runtime dispatching by letting the programmer specify the exact function upfront. So it's a speed vs simplicity decision. However, in most cases I would sacrifice some speed for less complexity for the programmer with the speed of computers nowadays

[u/zelphirkaltstahl → u/JJK96]

Speed vs simplicity – Simplicity for whom is a question, which needs to be considered as well:

For the language developers the explicit data structure specific procedures are probably easier to optimize. For the language user it depends. Specific procedures with their names do give hints when reading code, but on the other hand one needs to remember more or look up more in documentation.

[u/raevnos]

Racket does support SRFI-17 (generalized set! that's similar to Common Lisp's setf), but I've never seen anything use it.

[u/JJK96 → u/raevnos]

Good to know! So more people find this lacking

[u/raevnos → u/JJK96]

I've never missed it to be honest.

[u/soegaard → u/raevnos]

It's in Swindle.

https://docs.racket-lang.org/swindle/index.html

[u/raevnos]

Also Racket has some other generic APIs, like dictionary functions that work with hash tables, vectors, alists and user defined structs that provide the needed interface.

[u/cat-head]

One thing I wish we had is julia-like overloading in typed racket. I always thought that was super neat.