design a better scheme

Hello

In one post write everything you feel is essential to fixing the scheme language.

No whitespace sensitive syntax changes

it's called Common Lisp

Scheme is by design minimal and low-level. In other words, its core constructs are shit by design.

Other than an official module system, Scheme is perfect for me.

>>2
that isn't scheme

>>3
you seem like an idiot

>>4
yeah module system is the most important thing that it currently lacks

>>5
So you like building everything out of the equivalent of GOTO. Small minded cretin.

>>6
le goto is always bad maymay pisses me off. goto was often used badly and led to unreadable code but sometimes it is the better choice. Knuth understood it, cargo cult programmers didn't

>>6
>>7
what are you niggers talking about. get back on topic

>>8
They're talking about call/cc I reckon

call/cc is not really a goto, from my limited understanding of lisp its sort of complex setjmp/longjmp sequence with alot of state passed.

>>9
if so, then they really are retards

>>9
Tail recursion is a GOTO as well.

>>12
you are a retard as well

tail recursion is a while loop is a conditional GOTO

>>14
you are a retard as well

>>15
Oh I'm sorry, I meant optimized tail recursion.

>>5,11,13,15-chan has no idea how Scheme is actually implemented. It's just GOTOs. Seriously, a tail recursion is LITERALLY a GOTO! It's not even a conditional operation.

It can be the right thing to do in certain cases, but if that GOTO is the only thing you've got, your language is a mess.

>>17
stop posting retard

tail recursion is LITERALLY a GOTO

show this line of code in a scheme compiler, ideally one you have written

>>17
I'm not familiar with Scheme, but if tail recursion is optimized to unconditional GOTO, how would it ever terminate? Is there a conditional exit statement preceding it in the function body?

>>18,19
Well, he's dumb, but he isn't wrong. The function call is effectively removed and the stack frame isn't saved. Consider (define (fact x) (if (= x 1) 1 (* x (fact (- x 1))))). A non-tco'd compiled code segment may look something like:
fact_non_tco:
push rbp
mov rbp, rsp
mov rax, 1
sub rsp, 8
mov [rsp], rcx
cmp rcx, 1
je .unwind
dec rcx
call fact
.unwind:
imul rax, [rsp]
add rsp, 8
leave
ret
. While non-TCO may compile too something like:
fact_tco:
mov rax, 1
.recurse:
cmp rcx, 1
je .exit
imul rax, rcx
dec rcx
jmp .recurse
.exit:
ret
. The first has to save the stack, making space complexity dependent on the size of the input, while the second does not.

>>19
The conditional isn't part of the tail call, just like it isn't part of any other non-tail call! How the fuck do you think you make conditional function/procedure/method calls in any other language?

The only difference with tail recursion is it GOTOs back to the start of the function, rather than to a new function or establishing a new stack frame. Fuck, it's even more gimped than GOTO because you can't even specify a god damned label!

>>18
Lol, looking into disassemblies in Racket scheme, which I do use on occasion, and googling around it looks like Scheme implementers are still using fucking continuation thunks to tail recurse. What a fail language. Show me a scheme compiler that can actually fucking compile, and I'll point you straight to the GOTO/JMP. Even the most simple infinite loop tail recursion pops out to continuation thunks, even though it's 100% statically provable that there will never be any continuation escaping.

The only thing a tail recursion is conceptually is a GOTO back to the beginning of the function. It's a failure of Scheme and its ultra-shitty call/cc

Fine, show me a scheme compiler that actually compiles decently and gives disassemblies and I'll point it out to you. I have racket, but its output is bullshit. It thunks through tail calls like Java hacks do it, even though

I'll entertain you, you brainless piece of shit with your fucking clueless nigger intellect.

I have Racket, but it does not generate tight asm code at all. Sifting through all its bullshit, let's look at the basic fucking factorial:

(define (factorial x accum)
(if (zero? x)
acc
(factorial (sub1 x) (* x accum))))

This generates 124 fucking lines of asm, with zero commenting on the bullshit non-inline utility callouts it makes, or the memory locations of its variables, whereas the obviously superior Common Lisp (SBCL) makes a very readable 32 asm instructions for the fully generic version, and down to 13 if the numbers are declared to be fixnums:

CL-USER> (disassemble #'factorial)
; disassembly for FACTORIAL
; Size: 33 bytes. Origin: #x1006AF63C0
; C0: L0: 4885C9 TEST RCX, RCX ; no-arg-parsing entry point
; C3: 7506 JNE L1 <<= Go do the work if x isn't zero

; C5: 488BE5 MOV RSP, RBP
; C8: F8 CLC
; C9: 5D POP RBP
; CA: C3 RET <<= Exit if RCX up there was zero

; CB: L1: 488BD9 MOV RBX, RCX
; CE: 4883EB02 SUB RBX, 2 <<= Subtract 1, shifted past the tag bit means an immediate 2
; D2: 48D1F9 SAR RCX, 1
; D5: 480FAFCA IMUL RCX, RDX <<= Multiply
; D9: 488BD1 MOV RDX, RCX
; DC: 488BCB MOV RCX, RBX
; DF: EBDF JMP L0 <<= GOTO FUCKING START OF FUNCTION

It can do this because there isn't this low level intrusive BULLSHIT of call/cc fucking up anything that anybody might ever want to do, even though nobody in their right mind in real applications ever touches call/cc. Just like people dick around with pure functional cons list processing in Lisp academically but use actual data structures in the Real World, call/cc is just academic hackery fuckings that kids are forced to dick around with in class that nobody uses in the few cases of Real World Scheme. Yet its presence fucks over the Scheme implementors, whereas functional cons processing doesn't affect Common Lisp one way or another.

Maybe Stalin does this properly, as its docs say "3. (1.1) Tail recursion optimization is done only on self calls." which would also imply no need for continuation escape analysis, and that static constraint would allow it to compile to a JMP. But I'll leave that as an exercise for the reader, meaning I'm not going to pile into unfamiliar territory just to make a point that's already self-evident.

But in any case, tail recursion IS a GOTO to the beginning of the function. The fact that Scheme is a shitty language and needs to do laughable workarounds at the assembly level to get GOTO to work happens to obscure that primitive fundamental axiomatic fact. Or taken differently, the bullshit in Scheme means it cannot ACTUALLY perform tail recursion optimization. It still fits in a static memory footprint, but cannot actually optimize the conceptual GOTO into a real GOTO in hardware and needs to jump out and back in to perform a simple GOTO. By definition, actual tail recursion is never NOT a GOTO, regardless of how you have to make that GOTO happen, and regardless that your idiot Scheme implementors can't detect situations where the context does not need to exit to loop back.

IHBT

>>21
shit, I had some copy/paste fail in there obviously, but fuck you anyway.

>>20

The function call is effectively removed and the stack frame isn't saved

That's basically what I meant by saying optimized tail recursion is essentially a while loop. In the context of programming, pretty much the defining characteristic of recursion is that you need a number of stack frames equal to the recursion depth, since the initial function call must wait for the second instance of the function to return, and that second instance must wait for the third instance of the function to return, and so on. But with an optimized tail call, you can overwrite the stack frame and discard the old data, since when that second instance of the function finally returns, all the initial function instance needs to do is pass its result to whoever called it in the first place. And this is similar to a while loop, because everything is done in-place, on a single stack frame.

>>21

the bullshit in Scheme means it cannot ACTUALLY perform tail recursion optimization

Ignoring the disconnected nonsense you posted otherwise, I think that's a good summary of what Scheme does in this situation. Tail recursion optimization and tail call optimization are two different things. Scheme mostly just does the latter.

>>20

he isn't wrong

he is wrong

>>21

Show me a scheme compiler that can actually fucking compile, and I'll point you straight to the GOTO/JMP

just accept that you are wrong

It's really embarassing and disappointing that people here do not even understand tail recursion. I thought you guys were trolling about 'goto' because it was epic and ruins the thread but seems we've been taken over by actual idiots that know nothing.

No one there has only been one good idea to improve scheme. Nobody here even knows how programming language implementation works. Reddit tier knowledge.

No one there has only been one good idea to improve scheme.

I agree

>>29
correction: No wonder there has only been one good idea to improve scheme.

>>27
Pretty much everything is a GOTO. If statements are conditional GOTOs, while loops are if statements that jump back to the beginning of the block, for loops are while loops controlled by a counter, and function calls are while loops using malloc'd space on the stack for storing local variables and the return address.

>>31 >function calls are while loops using malloc'd space on the stack for storing local variables and the return address.
Who needs all that bloat. Use computed gotos!
http://eli.thegreenplace.net/2012/07/12/computed-goto-for-efficient-dispatch-tables
https://gcc.gnu.org/onlinedocs/gcc/Labels-as-Values.html

>>31
stop posting you absolute retard

Get rid of call/cc, directly support the few things that people actually build with call/cc, and then you can begin to start to think about improving Scheme.

>>31
GOTO usually isn't exposed to the high level programmer. We tend to have loop constructs, switch/cond style trees, dynamic dispatch, and all sorts of actually useful abstractions that are directly applicable to what programmers do, that happen to compile down to GOTO.

What we DON'T do is give the programmer GOTO and tell them to figure out how to make it useful.

The only looping mechanism that Scheme allows is "GOTO start of function" via tail recursion, or fiddle around with mutual recursion in tail calls, which becomes a GOTO loop. The fact that you cannot retain any lexical state as with non-tail calls, but must chain through parameters, is part of the reason it's considered a GOTO.

>>34
you ruined your good post with talking to retards about goto......

>>35
GOTO is infused through all of this. It doesn't matter if it's a literal GOTO or not, the concept is exactly the same, and the lack of abstraction beyond that is a problem. The only way you can safely loop in Scheme is to perform GOTOs that don't leave stack context around. A call is a GOTO if it doesn't return, and tail calls don't return. Often it is simply a nice performance freebie that happens to give your code a hand, but having to manage making a clean break from your prior code to make sure you don't blow up your memory is low-level hackery that high level programmers shouldn't have to deal with.

Frankly, if you don't get the concept of GOTO past the literal BASIC/C/etc statement, then you're retarded.

>>36

A call is a GOTO if it doesn't return, and tail calls don't return

...return to the caller, that is.

Tail calls do return to the original caller, i.e. whoever called the first function in the first place. TCO just means you don't need to worry about returning to intermediate function instances and can instead just jump back to the original caller.

I'm really getting tired of you fucking nigger retards

>>38
You never need to worry about the caller; the caller can worry about being returned to and how to continue on from there.

But Scheme programmers need to worry about not growing the stack, ie make sure their looping function calls are actually GOTOing out.

It's sort of like red cuts vs green cuts in Prolog. Green cuts are nice little hints and optimizations you can throw in, but aren't part of the logical semantics of your program. But red cuts are actually programming artifacts that need to be treated as such. In Scheme, the back-end means of calling a function becomes a programming artifact when it comes to looping, and that's a horrible hack-built non-abstraction compared to actual looping constructs.