Lisp is SHIT

Give me three good reasons to use Lisp or Scheme instead of C++

1. Eval
2. Continuation
3. Macro
4. GC

>>2
1.eval(MY ANUS)
2.Possible in C
3.Possible in C
4.GC IS SHIT

1. LITHP
2. LITHP
3. LITHP

1. eval
2. λ
3. anus


(define x 2)
(define y 3)
(define a 0)
(eval ((λ (anus)
  (define (hax t)
     (match t
       [(regexp #rx"^(.+) *\\+ *(.+)$" `(,_ ,op1 ,op2)) `(+ ,(hax op1) ,(hax op2))]
       [(regexp #rx"^(.+) *\\* *(.+)$" `(,_ ,op1 ,op2)) `(* ,(hax op1) ,(hax op2))]
       [(regexp #rx"^([0-9.]+) *$" `(,_ ,num))           (string->number num)]
       [(regexp #rx"^([A-Za-z0-9.]+) *$" `(,_ ,lit))     (string->symbol lit)]))
  (match anus
    [(regexp #rx"^([a-zA-Z0-9]+) *= *(.+)$" `(,_ ,lhs ,rhs))
     `(set! ,(string->symbol lhs) ,(hax rhs))])
  ) "a = x+10*y"))
a
32
Your move.

>>1
1. uniformity
2. generality
3. simplicity

>>6

1. Explain
2. Templates
3. Simplicity should be left to the programmer. The language itself should be able to do whatever the programmer needs. If lisp can't do what the programmer needs (which may often be imperative programming), then simplicity in a language merely means less features. You can write simple programs in C++, but were C++ a simple language, it would not be nearly as popular because it would not be able to achieve everything a programmer needs.

>>7
1. Use of the same data structure for everything.
2. Templates are static -> not general engough.
3. C++ lefts no simplicity to the programmer. It's standard is much biggers than Scheme's.

>>7
You can write simple programs in C++, but were C++ a simple language, it would not be nearly as popular because it would not be able to achieve everything a programmer needs.
Simplicity/complexity has nothing to with C/C++'s popularity. C/C++ became popular due to its legacy-compatibility, which makes C/C++ bloatware by default.

>>1
1. Readability
2. Performance
3. Clarity

>>10
0/10

>>8

Use of the same data structure for everything

But that's a horrible idea.

>>12
>>8 doesn't know what ey's talking about. All serious CL implementations have hash-table, arrays, and vector types.

>>12
Not at all!
http://en.wikipedia.org/wiki/Paradox_of_choice

>>13
All serious CL implementations have hash-table, arrays, and vector types.
There's a similar opposition between the use of lists to represent things and the use of "objects" with named, typed fields. I went through a stage, after I'd been programming in Lisp for 2 or 3 years, where I thought the old way of using lists to represent everything was just a hack. If you needed to represent points, surely it was better to declare a proper structure with x and y fields than to use a list of two numbers. Lists could contain anything. They might even have varying numbers of elements.

I was wrong. Those are the advantages of using lists to represent points.

Over the years my appreciation for lists has increased. In exploratory programming, the fact that it's unclear what a list represents is an advantage, because you yourself are unclear about what type of program you're trying to write. The most important thing is not to constrain the evolution of your ideas. So the less you commit yourself in writing to what your data structures represent, the better.

>>12
void * is the only thing i need.

go back to shit ++  faggot

>>14
So Lisp=Communism?

>>17
Lisp = I'dont want to hack and recompile fucking kernel to watch an AVI movie.

Lisp implies small penis.

>>19
No.

>>19
I have a small penis and I hate Lisp.

>>19
I like DICK... fixed that for you

>>20
Actually it does. Beautiful and soft, small sweet penises… んー…

>>15

that might work for small things like points, but seems to fall apart on larger structures.

you have to know what position the thing you want is in the list. for points, knowing that "y" is at index 1 is obvious and you don't have to think about it. but for some other data structure -- say a "user" with an "email" property -- a dict/map/hash/object is a lot nicer because you can just say user.email and not be concerned with the order of things inside your data!

I'd recommend you use Scheme or Lisp as opposed to one of the 3 most mainstream languages(C++, C#, Java), but that would be completely and utterly RETARDED.

>>25
I'd recommend bashing >>25's head repeatedly with a rock, then writing your own language and implementing it in C.

>>26
I meant to quote >>1 in the first line.

1. Lisp
2. is
3. SHIT

1. Sexp
2. Macros
3. Existance is written in Lisp.

>>24
That's what association lists are for.

>>30
Slow as cock.

>>31
Enjoy you're premature ejaculation.

PREMATURE OPTIMIZATION OF THE ORGASM

If association lists are slow as cock, then who was phone?

>>31
>>30-san meant to say, _{thats what balanced immutable red black trees are for}, or alternatively, _{thats what immutable almost complete binary trees are for}

>>32
New /prog/ challenge: find a compiler (AOT or JIT) that is able to optimize (immutable) cons into destructive operations on arrays or hash tables, depending on their use, without any kind of hint on the part of the programmer.

Deadline: Heat death of the universe.

>>34
You can use Finger Trees to implement Lists. FTs allow fast access to the hot points, called "fingers".

Give me three good reasons to use Lisp or Scheme
1. R⁴RS
2. R⁵RS
3. R⁷RS

>>37
you're tree have so much fingers inside does not it hurt pull those fingers out fagget

>>39
you seem buttdevestated