Python.

What's bad about Python?

>>80

No it can't

Well, too bad then (for you)
The compiler should be able to select anything based on your code

>>78
...yet still better than Scheme.

>>82
Nope.

>>71

Why not just call them `head` and `tail`

how do you use cadr/caddr/caadr/etc then?

>>84

how do you use cadr/caddr/caadr/etc then?

How Symta uses?

>>84
These are useless and unreadable bloat

>>86
No worse than (car (car (cdr (car foo)))) which is at least as good as (head (head (tail (head foo)))). The rules for reading /c[ad]+r/ are as exactly simple as the rules for reading the long-form expressions.

>>84
Those are unreadable pieces of shit. Consider giving some semantic names for your data things. If you can't do so with your language, then your language sucks.

>>88
MY OTHER HEAD-OF-TAIL is a HEAD-OF-HEAD-OF-TAIL

>>89
More like MY OTHER HEAD is a TAIL

>>84
(list-get 'hthttthhh)
Try doing that with your weakly "cadavers".

I mean

(list-get 'hthttthhh the-list-of-lists-of-lists-of-fuck-you)

of course.
Even Paul Graham's book has an example of macros that autogenerate list-unwrappers. Nobody has to use this predefined caaadadadr shit.

And if you want to get the n-th element you can simply do (get elmIndx list) and if you want a list with the elements from x to y you do (take x y list)

>>93

elmIndx

Haskeller detected, dispatching drones.

Python and Java are great for enterprise software, which underlies thousands of mechanisms that subtly affect your daily life and allow you to post here!

>>94
Haskell cannot generate cadavers without resorting to Template Haskell.

One of the things that irks me about Haskell is that it's so simple with regards to function application syntax. You just write the function name in the head pos and the rest of the arguments to the right in a rigid order. Haskell is like a bare lambda calculus.
In the "dynamic" languages like Python or Common Lisp function application is a lot more flexible, with keyword args, optional args, varying number of args, etc. I think that function calls should be like that: a whole flexible metalanguage of communication between the programmer and the compiler. There should be complex macros that understand lots of ways that the programmer might provide information and choose the corresponding underlying function call with no runtime penalty.

>>68
Not really faulty closures so much as how loop works. It doesn't use tail calls for loop constructs but binds a single variable and mutates it during the loop. A small change solves the problem.

CL-USER> (funcall
(car
(loop
for x in (list 1 2 3 4)
collect
(let ((x x))
(lambda ()
(+ 1 x))))))
2

>>91

(list-get 'hthttthhh)

#'cadadddaaar

>>99
Doesn't exist in the standard library.

Lispers are a community of five-star-programmers, because it is common to see cdaddr used in Lisp, which is equivalent of five-depth pointer dereferencing

http://c2.com/cgi/wiki?ThreeStarProgrammer

>>101
This is all child's play for lenses.

Oniichan! cadadddaaar!

>>102
Lenses are an abomination.