so apparently, the community let Scheme die with the r6rs debacle because

uhhhhhhhhhhh

they didn't want error handling nor easier ways to do macros...??????????

https://www.reddit.com/r/scheme/comments/1fxu3tp/what_was_so_controversial_about_r6rs/

doesn't help that looking at https://codeberg.org/scheme/r7rs/issues suggests that everything gets bikeshed into oblivion

and yeah, I do know there's ongoing drama behind the scenes, although I haven't bothered to look more deeply into that

just,

weh

it's incredibly annoying that a language with such rich history and expressiveness is just wasted

I will also forever remain incredibly annoyed at how everyone disregards and ridicules every single alternative to S-expressions, including SRFIs 49 and 119 https://docs.scheme.org/srfi/support/

seems like this article really sums up all of the arguments https://weinholt.se/articles/r7rs-vs-r6rs/

it's so weird to me that the point of having a standard is sharing (runtime) portability, yet the moment such standard tries to enhance such portability, all hell breaks loose

@xerz meow

https://wiki.dpk.land/R7RS_frustrations

you know what

maybe everything was terrible all along and Racket did the right thing by forking the entire community

they remain (almost 100%) compatible with The Little Schemer and SICP, they even got a specialized language for the latter... yet they can take that legacy and build up something new without waiting to argue with other Scheme implementations, other implementations that don't really seem to be interested in interoperability anyway

can't really tell, but it sure looks plausible

tfw it's taken me YEARS to focus into learning Scheme and Racket and I'm doing it now because of funny depression circus show

like in fairness I already learned Rhombus last year, which is halfway there, plus I took somewhat of a look at Racket before discarding it

but yeah

https://fedi.xerz.one/notice/ArzBLU43pRIjhMDklE

there used to be a summary of the differences between Lisp, Scheme and Racket that I still like to this day

Lisp = atoms, lists and garbage collection
Scheme = Lisp + blocks + continuations + tail recursion optimization + hygienic macros (aka referential transparency but only for macros) (ignore r6rs)
Racket = Scheme + a big stdlib (comprehensions, threads, futures, contracts, pattern matching, fixnums, I/O, modules...)
Rhombus = Racket + spaces + ML-esque syntax (creatively mixed in)

in case you still wonder

DrRacket is... peculiar

the text editing itself feels stuck in the 2000s: can't insert parentheses into existing code, cannot sort lines up and down, no multiple cursors, that sort of thing

it is quite complete tho, and does do two amazing things:

1) support multiple languages, including rich debugging and documentation
2) this

yes, it also works with your own code, even with macros

https://racket.discourse.group/t/improving-drracket-ergonomics/4163

everyone keeps being impressed by SICP's lessons on how code is data (as in, you can change between symbols and strings anytime, plus lambdas can be reused anywhere), or that you can implement OOP with just variables and `set!`... those are the conclusions you can see around on Hacker News, Stack Overflow, social media, etcetc

but honestly I'm more impressed by thunks and continuations

like, are you really telling me you can implement actors by just doing lambdas as callbacks?

wait did SICP invent the term "promise"???????????????

just noticed, after a whole year, that what I called `foldr` seems in fact to be `foldl`

.......oopsie

..............so *anyaway*

my feelings about Racket and Rhombus haven't changed too much a year later

Racket's main problem is that (like every Scheme) it's too obsessed with S-expressions, plus it's dynamically typed

Rhombus' main problem is that it seems to make some of my favorite things about functional langs (good typing, map/fold/filter, currying) a bit more verbose or compromised than needed

confirmamos https://tech.lgbt/@nyx_lyb3ra/116275146175720985

a problem that both Racket and Rhombus share in common tho: too many datatypes to deal with for a beginner, adding quite some friction too

for instance, in Racket, command line arguments (argv) are a vector, but folding, mapping and applying don't work with vectors

meanwhile, in others like Haskell that may or may not happen... yet it doesn't matter, because: polymorphism

luckily, Rhombus *has* ad-hoc polymorphism, and apparently so do Typed Racket and Algebraic Racket

https://docs.racket-lang.org/ts-guide/types.html#(part._.Polymorphic_.Data_.Structures)
https://docs.racket-lang.org/algebraic/class_core.html

still not ideal

wait holdup https://docs.racket-lang.org/guide/vectors.html#:~:text=When%20allocating%20extra%20lists%20seems%20too%20expensive%2C%20consider%20using%20looping%20forms%20like%20for%2Ffold%2C%20which%20recognize%20vectors%20as%20well%20as%20lists

cursed but okay

I have officially created the world's most legible piece of Racket

yes, it's cursed

yes, it works

this one is better tho

.....don't like naming things as "args" and "args->numbers" but alas

ah I forgot

I can curry on Racket

the final result, As Seen On ATProto™®©

apologies to the Rhombus programming language for somehow forgetting it has an apply operator (&) and an n-argument sum function

made it even shorter and cleaner and conciser and homosexualer

Static Rhombus misses a bunch of opportunities to be more expressive because it doesn't realize that some operations are valid. Early Rust vibes, hopefully static information will improve in the future.

@xerz cursed

@efi explain

@xerz rhombus is cursed

@efi but

@xerz it's imperative looking lisp
I don't like

@efi I mean. It is still a functional language. It reads quite like OCaml or Haskell. You still got higher-order functions, referential transparency and all of the Racketisms (sequences and `for` iterators, delimited continuations, streams, syntax objects, things from Typed/Algebraic Racket as well as Rebellion I think?). And if you know how shrubbery works, you can map it in your mind into S-expressions.

It's not as consy or as '()y tho.

@efi hecc, they even got a list saying "hey, here's how Rhombus datatypes map into Racket ones", and it's all full of "Racket X and Rhombus X are the same" https://docs.racket-lang.org/rhombus-racket/data.html

@efi I don't know, I guess nested lists as syntax vs operators and indentation sensitivity will always be controversial

weh

@xerz yeah, the latter makes me sad

@efi I like it tho, so that makes me sad

@xerz sorry, I like lisps with bounded expressions

@efi ....weh....

@xerz @efi s/lisps/lips

@echedellelr lips must be kissed

@efi exactly, you and @xerz   are being late on it already

@echedellelr she doesn't let me

@efi cc @xerz

@efi @echedellelr iMEANIMEAN

how could I kiss someone who doesn't like anything other than S-expressons