Why are all Scheme implementations slow as balls?

Also, which Lisp would you fuck?

>>1
Partly because of the scheme continuation mechanism (I believe someone in the scheme community has suggested dropping it), and partly because a lot of the scheme implementations started as personal projects written by people as a hobby, with no particular performance goals in mind.

I think if we were to take scheme, and make call/cc optional, make it something that can be disabled/enabled on a per-module basis, a lot more performance could be had.

>>2
Further reading.

http://okmij.org/ftp/continuations/against-callcc.html

So I was at chipotle getting my burrito. I got my food without incident and was leaving when I went to say excuse me to a man in line so I could get to the door. This is when my brain completely stopped functioning. I instantly went into Panera mode (on my day off) and yelled/screamed at this man "I CAN HELP WHOS NEXT!" What. Why brain? What the fuck?

He looked like a deer in the headlights. I didn't even give him a chance to respond, I don't think he could. He was just as surprised as I was. Then I proceeded to say "Oh god. My brain. I'm so sorry. I'm so tired." My eyes were probably the size of plates. I then spun around and speed-walked out the door.

So. Embarrassing.

>>3
The comparison with goto is the most apt. You can create any control structure you want with goto/call/cc but it's low level hacky unstable shit.

>>3
Nice article. Author is smart. Still continuations are nice theoretical construct.

>>5
In fact, call/cc is just another way of saying goto.

Scheme implementations are slow because Scheme is a toy language. No one's bothered working on an optimizing compiler for a fucking toy language.

>>7
Goto label has no state. call/cc has associated state. It is close to setjmp, but not the same.

Check em

s7 has some call/cc features to make it more practical to use:

https://ccrma.stanford.edu/software/snd/snd/s7.html#callwithexit1

What programming language is this?

>>12
Scheme.

Check em

>>11
The limitations of that mean it's just basically "break to end of scope". It's not a true first class object.

Surely there can be a better continuation that's delimited, non-reentrant, but also first class and compatible with threading.

Surely there can be a better continuation that's delimited, non-reentrant, but also first class and compatible with threading.

Isn't that what with-baffle provides? Genuine question. According to what's written, any call/cc in a with-baffle block is non-reentrant. Continuations are first class in s7.

Check em

>>16
I honestly have no idea what with-baffle is useful for. The description is only 1 short paragraph, and the example is degenerate. But just looking at it literally, it's the logical NOT of call-with-exit, and I have no idea what its delimiting is. There's also no mention of threading in that section.

<- check me dubs

>giving a shit about a meme language

dubs incoming

██████████ ████ ████ ███████████ ██████████ ████ ████ ███████████ ███████████
██████████ ████ ████ ███████████ ██████████ ████ █████ ███████████ ███████████
████ ████ ████ ████ ████ ████ ████ ████ ███████████
████ ████ ████ ████ ████ ████ ████ ████ ██ ███ ██
████ ██████████████ ███████████ ████ █████████ ███████████ ██ ███ ██
████ ██████████████ ███████████ ████ █████████ ███████████ ██ ███ ██
████ ██████████████ ████ ████ ████ ████ ████ ██ ███ ██
████ ████ ████ ████ ████ ████ ████ ████ ██ ███ ██
██████████ ████ ████ ███████████ ██████████ ████ █████ ███████████ ██ ███ ██
██████████ ████ ████ ███████████ ██████████ ████ ███ ███████████ ██ ███ ██

>>22
sick dubs, bro ^^

>>21-23
samefag

>>22
_________
< checked >
---------
\ ^__^
\ (oo)\_______
(__)\ )\/\
||----w |
|| ||

>>25
this was enterprise quality

>>25 Thanks for checking!
_,-""""-..__
|`,-'_. ` ` `` `--'""".
; ,' | `` ` ` ` ``` `.
,-' ..-' ` ` `` ` `` ` ` |==.
,' ^ ` ` `` ` ` `. ; \
`}_,-^- _ . ` \ ` ` __ ` ; #
`"---"' `-`. ` \---""`.`. `;
\\` ; ; `. `,
||`; / / | |
//_;` ,_;' ,_;"