Why aren't you programming in LISP`?`?`

The expert ``programmer'' language.

C code to print from 1 to 10

import stdio.h

int main(){
  for (int i=1; i<=10; i++) {
    printf(yada yada);
  }
}




LISP


(loop for i from 1 to 10 do (print x))

So whatever can be done in the least amount of characters is the best language? I guess Perl is better than lisp then.

>import

/g/ood troll e/g/in /g/roski

Didn't even realize your code is fucking retarded and doesn't work in both examples.

/g/ROOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO

Same ole /prog/, never a working program in any thread.

>>6
Fuck off RMS, your code is bad.

Oy goyim. Say that again, and I'll personally come to your house and rip that fuqin foreskin of.

(print 1 2 3 4 5 6 7 8 9 10)

You lowly peasants don't know about the master race AplLanguage! I can do that shit in 5 characters.


+/ι10

pavlik abstract final private transient class ConcreteBusinessSOlutionBean
{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{
pavlik stasik void main(String args[]){{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{
for(abstract static volatile Integer myLoopCounterIntegerVariableI = AbstractNumberBuilderFactorySingletonBean.getAbstractIntegerFactorySingleton().getIntegerBuilder().getConcreteOne(); AbstractComparatorBuilderSingleton.getAbstractComparator().compare(AbstractComparatorBuilderSingleton.getAbstractComparator().compare(myLoopCounterIntegerVariableI, AbstractNumberBuilderFactorySingletonBean.getAbstractIntegerFactorySingleton().getIntegerBuilder().getConcreteTen()), AbstractNumberBuilderFactorySingletonBean.getAbstractIntegerFactorySingleton().getIntegerBuilder().getConcreteZero();, ++myLoopCounterIntegerVariableI){{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{
System.out.println(myLoopCounterIntegerVariableI);
}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}
}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}]]

>>1
Symta: as X 1 to 10: say X

>>12
No, that's JEWSymta

>>10
That calculates 1+2+3+4+...+10. You really just want ι10.

>>14
Leavin us puzzled, aint cha? Where is lower bound? Where is variable binding?

>>15
lrn2APL faggot

(define (asdf x)
  (display x)
  (cond ((< x 10) (asdf (+ x 1)))))
(asdf 1)

>>17
asdf
Really, nigger? Ever heard of lambdas?

Really, lambda? Ever heard of niggers?

Really, niggers? Ever heard of Neanderthals.

Really Neanderthals? Ever heard of Australopithecinas?

Really, Xanax? Ever heard of weed?

Well, Xanax is fine too.

Really Australopithecinas? Ever heard of Catarrhini (the old-world monkeys)?

Of course I've hear of Catarrhini. But have you have of Haplorrhini (the dry nosed primates?)

>import stdio.h

Oh god what is this.

I have indeed heard of those types of primates. But sir have you heard of Primatomorpha, which include both primates and colugos before evolution branched them into separate descendants.

Hoho my dear fellow, you have once again rejuvenated my memories for I do have knowledge about the Primatomorpha. The question is do you know of the Euarchontoglires, the supraprimates?

Oh you, of course one ha'th knowledge of supraprimates; they include primates, rodents, rabbits, tree shrews, and colugos. Intensity of thou IQ probing has increased five fold, can you with absolute certainty state you know of the Eutheria?

Of course I've hear of Haplorrhini. But have you have of Haskal (the no nosed dog?)

>>18
Sorry, could you show me with lambdas then?

>>30
letrec*

>>31
Shut up, nigger, you're not me.

>>30
Hint: Hacker News. No, it doesn't have anything to do with the content of that site.

>>31
No syntax sugar, only lambdas.

>>33
Read my post. And, as far as I know, letrec still requires you to bind the functions to a name.

>>30,33,34
fixed point.

I would have done >>18 with named let.


(let asdf ((x 1))
  (display x)
  (if (< x 10)
    (asdf (+ x 1))))

if you wanted to avoid recursive definition:


(define asdf (lambda (f x)
               (display x)
               (if (< x 10)
                 (f f (+ x 1)))))

(asdf asdf 1)

if you wanted to avoid recursive definition with style:


(define fix_ (lambda (f g)
  (lambda args
    (apply g (cons (f f g) args)))))

(define fix (lambda (f)
  (fix_ fix_ f)))

(define asdf (fix (lambda (f x)
                    (display x)
                    (if (< x 10)
                      (f (+ x 1))))))

(asdf 1)

>>35
Yes, fixed point.

You win 1 Suss-shekel. Use it wisely, goy.

>>35
You murderer. ;_;