>>5
What, exceptions can be expressed in terms of call/cc. Actually, you don't even need full continuations for non-restartable exceptions, just one-shot escape continuations.
>>11 With four parameters I can fit an elephant, and with five I can make him wiggle his trunk. -- von Neumann
I think that just settled the fast call argument limit for a VM'ed language I'm writing. Thanks.
>>18 Check. My DSL's syntax is optimized for list processing.
But it can be general purpose: you wrote a game in it, and gamedev is not really just list processing. Can you write a game with just a regexp, or just format or loop?
Whats wrong with me, except my bad english?
Your continuous jews/static-typing-is-jewish/x-is-jewish/``Lisp: code\nLanguageYouDontLike: unnecessarily overly engineered version of the same'' spamming and your ``I don't know shit about this subject, but I'd like to give you my completely wrong opinion anyway, and you must like it'' attitude.
Name:
Anonymous2011-05-31 5:44
>>20 Your continuous jews/static-typing-is-jewish/x-is-jewish/``Lisp: code\nLanguageYouDontLike:
I just don't like being forced into Set Theory, Python and Java. And who invented Set Theory? Who forced it into school system? Who forces Python? Can you recall their family trees?
But it can be general purpose: you wrote a game in it, and gamedev is not really just list processing. Can you write a game with just a regexp, or just format or loop?
Graphics and sound routines were written in Common Lisp. The rest of DSL (excluding pattern-matching and continuations) translates directly to CL.
Name:
Anonymous2011-05-31 5:48
>>21
BTW, in most countries Holocaust is a mandatory part of school education, if you refuse it, you'll get expelled. Why exactly this mythical "Holocaust", that has nothing to do with history of most countries, and not some other more important event?
>>21
You don't like it, we do not fucking care. FIOC and Java are already hated here, for much more reasonable reasons. If you want to go all ``Jews did WTC!!!'', http://dis.4chan.org/vip/ is a much better place.
If you want to discuss how Set Theory is all jewish, http://boards.4chan.org/sci/ and http://dis.4chan.org/sci/ are much better places.
Graphics and sound routines were written in Common Lisp. The rest of DSL (excluding pattern-matching and continuations) translates directly to CL.
You used SDL, right? It's written in C (or C++, I don't remember). Also, your CL translates directly to assembly. Is CL a DSL?
>>22
And how is this programming related? This is not your antijews blog.
Name:
Anonymous2011-05-31 5:59
>>23
>FIOC and Java are already hated here, for much more reasonable reasons.
Foundationally, all your reasons follow from the Set Theory. Java, being hated because of it's OOP nature, is Set Theory to the roots (classes are sets). If you dont like OOP, then you dont like Set Theory.
You used SDL, right? It's written in C (or C++, I don't remember). Also, your CL translates directly to assembly. Is CL a DSL?
SDL is part of Unix API. Unix is written in C/C++.
Name:
Anonymous2011-05-31 6:10
How Java is programming related? Java is useless for programming. Why are they teaching it?
>>37
Please, get a Jewish.
Also, Lisp is a tripcode.
Name:
Anonymous2011-05-31 6:52
Jews love to argue that "The Holocaust" is an "infinite suffering"[1] of a set of "six millions"[2].
But can a finite collection express "infinte" quantity?
I still think that continuations seems to be an over-glorified version of a goto :(.
But I haven't read SICP so I guess I can't complain, though I'd really appreciate an explanation.
>>46
If you use them for everything (e.g., for loops), they are not much different than goto. The point is, you never explicitly use continuations, you abstract them away with macros and higher-order procedures to implement your control structures.
Also, they will never be as abused as goto, since they are structured and harder to use.
Any control structure can be expressed in terms of call/cc.
>>47
Not BASIC's goto. The two main differences are that call/cc is structured, you can only jump to a continuation you already entered once, goto is text based, you jump to a position in text, and that call/cc stores the whole program's context, goto is just a jump.
Name:
Anonymous2011-05-31 14:54
>>46 I'd really appreciate an explanation.
Look at continuations as a fast setjmp. So fast and consistent, that it could be use as a control structure.
>>51 Ruby's callcc would like a word with you. (implemented as stack copying)
Ruby is so slow by itself, that won't notice the slowness of it's continuations.
Name:
Anonymous2011-05-31 15:26
>>51 continuations are more like {get,set,swap,make}context, not setjmp/longjmp.
Dunno. I've seen setjmp implementation of syntatic closure in C/C++: http://users.telenet.be/stes/block98.html
>>54-55
Aren't setjmps one-shot continuations? The *context procedures do exactly what continuations do: save and replace the program's context.
Also lexical closures != continuations, unless you convert all the code to CPS.
Name:
Anonymous2011-05-31 15:56
>>56
{get,set,swap,make}context are linux-specific.
>>57
They are POSIX, but yes. That doesn't make continuations any more similar to setjmp/longjmp, unless you're the ``in Lisp'' guy that again negates reality.
Name:
Anonymous2011-05-31 16:13
>>58 That doesn't make continuations any more similar to setjmp/longjmp
It's as best as you can get with C/C++. Java won't allow even that.
>you're the ``in Lisp'' guy that again negates reality.
You cant blame me! The current state of reality is pure horror, with it's Unixes, Javas and C/C++.
the ``in Lisp'' guy is the finitist antijew troll?
This place has nothing anonymous, you get to know every single of the few users.
>>TILFAG (the ``in Lisp'' finitist antijew guy)
Ok. Your point was interesting, never thought infinite could be a poisonous concept or whatever. Now that we heard it, a spammer is just a fucking spammer. You ought to keep higher standards.
>>64 This place has nothing anonymous, you get to know every single of the few users.
We know him because he constantly spams every not-already-spam thread in /prog/.
The other one I know is the Common Lisper which posts code in [m][/m]tags and bolds parens.
MORE LIKE
A MANLY PROGRAM IGNORES ERRORS AND KEEPS ON GOING WITHOUT TELLING YOU ANYTHING IS WRONG DECEPTION not EXCEPTION
AMIRITE LOLLLLLLLLLLLLLLLLLLLLLLLZzz!!11oNE!!1ONE1!
Name:
Anonymous2011-06-16 5:30
NO EXCEPTIONS
Name:
Anonymous2011-06-28 0:36
call/cc can implement exceptions trivially. I'm 12 and what is this
Name:
Anonymous2011-06-28 0:39
>people think "statically typed" and "lexically scoped" are the same thing
>/wrists
>>81 >people
The ``in Lisp'' guy is not even a person.
Name:
Anonymous2011-06-28 1:55
>>83
I'm "in Lisp guy" and don't think, that "statically typed" and "lexically scoped" are the same thing.
For me, the word "static" associates with: conservativity, spongers from academia, type theory, OOP, inconvenience, top-down nightmare, traditional pseudoscience, complicated religion, design patterns, 1984, jewish mathematics, verbose ugliness, planned overengineering.
Name:
Anonymous2011-06-28 2:05
Is this big Scheme or little Scheme? Big Scheme was already setting up to be a shitty Common Lisp-1 so who cares. If it's little Scheme though I'll just stay with R5RS.
>>85
Little Scheme is getting modules, parameters, (restartable) exceptions and records.
I don't care what big Scheme is going to be, but I like what little Scheme is becoming, especially if they drop SRFI-9 records.
I mean, we desperately need modules, we need records, parameters are nice to have standardized, and a nice interface for exceptions is better than error and ad-hoc, informally specified, bug-ridden, slow implementations of them on top of call/cc and dynamic/mutable state.
>>92
ad-hoc, informally specified, bug-ridden, slow
no
The important part of exceptions (not the try/catch bullshit but being able to return from a different function than the one you're currently in) is a very very basic use of call/cc. Dead fucking simple.
they are adding exceptions because people can't grasp call/cc. It's the only explanation.
>>94 is a very very basic use of call/cc. call/cc, in absence of mutable/dynamic state, can't express exceptions. Delimited continuations can easily express both restartable and non-restartable exceptions, even in absence of state. You don't understand exceptions, continuations and how they relate, call/cc is not synonym of ``continuations''.
The important part of exceptions are not only the non-local exits, but being able to raise a value and handle it elsewhere with a dynamically bound exception handler. R7RS will have restartable exceptions.
Even if they were a ``very very basic use of call/cc'', in many systems capturing the continuation is slow, while implementing exceptions may be done much more efficiently.
Name:
Anonymous2011-06-29 2:38
>>95 but being able to raise a value and handle it elsewhere with a dynamically bound exception handler.
I'm honestly OK with that value just being a string or some error code or something. when I write in languages without exceptions, the thing I miss is not having to "thread up" the error, not the handling code. Most of the time the error handling isn't much more than printing it somewhere. Who actually puts a large amount of code in catch blocks? I'll just write an (unless ) or something checking for error.
I never said call/cc was a synonym of continuations. I've implemented call/cc (and continuations) for DSLs in C a couple of times. I've worked extensively in Java and C++. I've used setjmp to get something like exceptions in C. I get this shit. I just don't find exceptions as they are presented in C++ and Java to be useful. I actually prefer coroutines to exceptions (as far as things you can implement with continuations goes.) Deal with it.
Name:
Anonymous2011-06-29 2:39
the point of Scheme is to be minimal, not practical. Leave things like this to implementers.
>>96 I'm honestly OK with that value just being a string or some error code or something.
R7RS doesn't define any exception hierarchy, just the API. You can raise anything, but you probably want to define some ``exception?'' datatype.
Who actually puts a large amount of code in catch blocks?
Java does an extraordinarily bad job at dealing with exceptions, forcing you to write bogus try/catch statements. C++ exceptions are just bad.
Exceptions are meant to be used in exceptional (hence the name) cases (i.e. when a TCP connection fails) and to be handled in even more exceptional cases. (i.e. retrying to connect (restartable exception))
Threading some error value by hand is also unSchemey, leave C to C programmers. I actually prefer coroutines to exceptions
They are two orthogonal concepts.
>>97 the point of Scheme is to be minimal, not practical. Leave things like this to implementers.
R7RS is trying hard to be minimal and useful: it's 67 pages long now and it's not going to get much bigger. It's the spiritual successor of R5RS, and I was/am strongly against R6RS, except when I wasn't. (syntax-case, exceptions, better records)
>>98 They are two orthogonal concepts.
I get that, it just seems to me that if
cond : (when,if) as call/cc : (exceptions,coroutines)
I'd rather coroutines were built-in than exceptions, because I more often reinvent them poorly.