Return Styles: Pseud0ch, Terminal, Valhalla, NES, Geocities, Blue Moon.

Pages: 1-

Look! I'm defining infinity.

Name: Anonymous 2013-07-15 9:32

(defun infinity () (infinity))

Name: I'm Defining AI 2013-07-15 9:36

Name: Anonymous 2013-07-15 9:37

You're a lisp-idiot, exactly the type of retard that would write \x -> x x.

Name: Anonymous 2013-07-15 10:23

>>3
what's your problem? bump, to counter your angry

Name: Anonymous 2013-07-15 10:40

(define (infinity) (infinity))

Name: Anonymous 2013-07-15 10:44

>>4
My problem is with all the lisp-idiots that post their worthless bracket shit over here. Nobody uses lishp nowadays, stop posting it.

Name: Anonymous 2013-07-15 10:50

>>6
Please stop shitposting, thank you!

Name: Anonymous 2013-07-15 10:52

Name: Anonymous 2013-07-15 10:53

>>6
>Nobody uses lishp nowadays, stop posting it.
That's not so!

Name: Anonymous 2013-07-15 10:55

Name: Anonymous 2013-07-15 10:56

>>10
LOL, and Emacs is the most popular of them.

Name: Anonymous 2013-07-15 11:05

https://github.com/languages/Clojure

You all forget about Clojure, the most popular non-shit Lisp.

Oh, right, it isn't some retro-hipster language for elitists, my bad

Name: Anonymous 2013-07-15 11:10

>>11
It's because every new emacs newfag thinks that he must create the repository with his shitty, almost all copypasted emacs-config.

Name: Anonymous 2013-07-15 12:37

infinite bbcode loop >>15

Name: Anonymous 2013-07-15 12:38

>>14
ultra-efficient!

Name: Anonymous 2013-07-15 12:39

optimized version >>16

Name: x86 `egin' groski 2013-07-15 12:45

e8 fb ff ff ff
le mfw le ebin lelz0rz

Name: Anonymous 2013-07-15 12:50

>>12
I would use clojure if it had tail calls. Their recur is nice enough for most cases, but not quite all in the scheme domain.

Name: Anonymous 2013-07-15 13:03

>>1
stack overflow.

Name: Anonymous 2013-07-15 13:05

>>19
>LE TCO FACE

Name: Anonymous 2013-07-15 14:29

Of all the mythological beasts the most cruel is Haskell the vampire. Most vampires will drain you dry the moment you are bitten and death will come quickly, but that is not enough for Haskell's prey. Haskell places a curse upon you, linking your blood to her's, lazily evaluating your life force as she needs it. With this curse, Haskell will sustain herself off of you from afar while you suffer from constant blood loss, dieing after 4 - 5 months. While Haskell is immune to silver and religious symbols, she has one fatal weakness. Go to Sussman's forest and carve a staff from a tree. The staff must be exactly 2.3 meters long. Burn the tip of the staff until it's outer skin is charred black. Then place it by the fire and chant until sunrise.

``We conjure the spirits of the computer with our spells
  We conjure the spirits of the computer with our spells ...''

When the sun rises, aim the staff at the icon of fire and shout ``let this staff be the weapon of the untyped lambda calculus!'' A golden lambda will descend from the sky and embed itself in the staff. Then you must etch the following inscription into the charred end of the staff.


                                  (lambda (x) (x x))


Haskell does not come out to prey on humans often, so you must go to the cave where she lurks. This cave is no ordinary cave. Curious intruders tell stories of wandering its inside, only to find themselves back where they were when they resumed a continuation. Those less lucky tried to find there way back to the entrance, but got stuck in an infinite tunnel and died of exhaustion. Others found there way to the exit, but unfortunately the exit door only accepted entities of type LazyVampire. None have ever found the mysterious Haskell.

But with your staff, the untyped lambda calculus will light your way through the tunnel. It's golden glow will explore the routes for you, warning of these mischievous dangers. Find your way into the sacred pool of combinators. You must not be seen by Haskell. In the sacred pool, you will find the holy fix operator of the Haskell tribe. Plunge your untyped lambda staff into the operator. You will hear distant screaming, and the blue waters of the pool will turn to brownish mud. Drive the staff into the mud, and the murky pool will turn golden red. The combinators will reappear as their primitive forms expressed in the untyped lambda calculus.

The outraged Haskell will soon appear at the entrance to the sacred pool. ``WhatHastTheeDoneToMySacredCombinators!'' she shouts. ``TheseArrangementsOfSymbolsMakeNoSense!'' she barks, ``MeaninglessGarbage!'' When she attempts to decimate you and put your atoms into a list, she discovers her power is lost. At this moment, you must run up and stand within 6 feet of Haskell. Shout, ``by the power of the untyped lambda calculus, I smite thee!'' The golden expression, (lambda (x) (x x)) will fire from the staff in a beam of light, burning itself into Haskell's skin. The burning cuts will deepen and she will crumble to the floor, shouting ``TypeError!!''

This will be the end of Haskell's reign of evil. It has been forseen that a chosen one would rise as the knight of the untyped lambda calculus and smite Haskell once and for all. You are that one, reader of this inscription. Go forth and bring justice for humanity.

Name: Anonymous 2013-07-15 14:38

>>21
Dude, you do realize that untyped lambda calculus is much more primitive and impractical than System F, right? You do know that the whole lishp type system can be represented as just 1 (one) Haskell type, right?

Name: Anonymous 2013-07-15 14:43

>>22

Begone non recursively typed demon! I banish thee to hell!

\x -> x x

Name: Anonymous 2013-07-15 14:53

Wat? Ashkenazkell can't even https://dis.4chan.org/read/prog/1373874594

Name: Anonymous 2013-07-15 18:54

>>21
Saved

Name: Anonymous 2013-07-15 19:16

>>21
http://stackoverflow.com/questions/4273413/y-combinator-in-haskell
Here's a non-recursive definition of the y-combinator in haskell:
newtype Mu a = Mu (Mu a -> a)
y f = (\h -> h $ Mu h) (\x -> f . (\(Mu g) -> g) x $ x)

Name: Anonymous 2013-07-15 23:09

>>26
But can you define self-application in Haskell?
Yeah, don't think so.

Name: Anonymous 2013-07-16 1:07

>>27
types were introduced to prohibit self-application

Name: Anonymous 2013-07-16 1:15

>>28
Like how windows were installed to break the necks of birds?

Name: Anonymous 2013-07-16 1:36

>>27,28
But you can do self application with fix can't you?

Name: Anonymous 2013-07-16 2:14

>>26
record syntax makes it look prettier
newtype Rec a = In { out :: Rec a -> a }
y = \f -> (\x -> f (out x x)) (In (\x -> f (out x x)))

Name: Anonymous 2013-07-16 2:32

>>31
ONE WORD: FORCED OBFUSCATION OF CODE

Name: Anonymous 2013-07-16 8:28

Based Haskell is based.

Don't change these.
Name: Email:
Entire Thread Thread List