“Haskell is compiled from .hs-files which means HOMO SEXUAL”
“Oh, rats. My hair shirt is still at the dry cleaners for that curry stain.”
“Oh baby!”

Haskell is an obscure, hated and mostly disused esoteric programming language. Its design was greatly influenced by the work of that computer science luminary, Dr. Pointer C. Database.

## Name

The name of the language was conceived during a night of carousing involving the entire functional programming community. It was thought to have come from a slurring of the word "hassle," or perhaps "has skill."

## Language

Haskell is a dialect of COBOL, which it superficially resembles, and an embodiment of the Zeta-Calculus. In fact, native speakers of COBOL often describe Haskell as sounding posh and affected, with a very broad unintelligible accent. It is a non-functional language and properly belongs to the computational class Zeta-complete, known not to function most of the time.

Owing to the monolithic nature of Haskell programs, and the undecidability of their output, even very simple programs can run to many thousands of lines of sauce code. The Hello Whirled program in Haskell, for example, contains some 37,000 lines of sauce, 35% of which (36,590 lines) just sit around and look nasty, and 10% of which also contain chicken.

The nature of the Zeta-calculus creates some interesting new design possibilities for the aspiring programmer. Evaluating any data in Haskell is an error owing to the Zeta-calculus concept of Lazy programming, a technique used to avoid telling the computer what to do until the program is running, saving developers from needing to code things that won't be used. Because of this technique, Haskell can also create infinite data structures, and give infinite type errors. Calculations which are undefined are denoted by the ⊥ symbol, pronounced Bottom, which the documentation explains as the compiler giving you the finger.

The innovative Go Notation is syntactic sugar for the highly sophisticated mathematical construct of Gonads which are used for J/O (Haskell's alternative to I/O). Gonadic J/O is practiced by very few and understood by still fewer; the Haskell expert will be adept in their handling of Gonads.

An example of typical Haskell code, making use of Lazy programming:

```infinity :: Int -> Gonad -> Bottom
infinity f b = print ⊥
```

(Note that this code would solve the halting problem, but only if you could get rid of the type errors.)

## Implementation

One known Haskell compiler exists, called HAGS, the Highly Arbitrary Gronda System. The origins of this implementation have never been satisfactorily revealed, and even the derivation of the name remains shrouded in shadow. The philologists have traced Gronda to Old Norse, where it meant something very obscene, probably related to Thor's mother.

There have also been rumours of the existence of GHC (Gonadic Haskell Crack), but those have been rejected by science as a mere myth.

No one really knew why Haskell was used until intrepid university students looked in the sealed chamber beneath Imperial College's Department of Computing. They were astonished to see Alan Turing strapped to a magnet in a solenoid, spinning furiously. It has been theorised that Haskell's horrible Turing incompletableness causes him to spin in his grave at roughly 4 billion hertz, generating enough power to run the entire university.

Other than that, Haskell has no other uses, and nobody cares about it, really.

Hello Whirled:

```main = putStrLn . (++ "!!") . (>> "AA") \$ "Hello world !"
```

An excellent application of completely pointless programming in Haskell.

Here is a more useful example of Real World Haskell programming:

```fix\$(<\$>)<\$>(:)<*>((<\$>((:[{- Jörð -}])<\$>))(=<<)<\$>(*)<\$>(>>=)(+)(\$))\$1
```

Most real world Haskell programs look like this, since the language's infinite academic prowess had to be augmented by the best parts of Perl to actually do anything useful.

Here is an example of a few of the other features of Haskell's syntax, including let expressions and whitespace sensitivity:

```let_in =let in'let'in=let in let in" let" in
let in let
let'in let_ _in =
let_>>_in in
in'let'in++
let in_let'in=let
in " let in let" in let'in
in_let'in in'let'in
```

Furthering Haskell's usefulness is the invention of the Zygohistomorphic Prepromorphism, a recursion scheme that allows every Haskell programmer to automatically gain bragging rights about the absurdness of their language, hence making Perl programmers cry. Unfortunately, no one has actually seen this mathematical circlejerk of a thing, so the validity of its existence is disputed, however only by people that have actually used it in an attempt to keep their poor code and trade secrets from leaking to the general public. Due to the renowned difficulty of implementation, the furthest anyone has ever been to implementing the zygohistomorphic prepromorphism before resorting to Perl is:

``` zygoHistoPrepro :: (Unfoldable t, Foldable t) => (Base t b ->
zygoHistoPrepro f g t =
```

Implementations of the zygohistomorphic prepromorphism are available in:

## Trivia

Haskell has only one control structure. Its type signature is:

``` pSwitch :: Functor col => (forall sf . (a -> col sf -> col (b, sf))) -> Gonad -> ThorsMother
```

As is usual in Haskell, what this does is obvious even to the uninitiated from the clear, elegant and concise type signature.

While it is possible to do IO in Haskell, this is only spoken of in whispers, and there is only one function to do IO: `System.IO.Unsafe.Really.IMeanIt.reallyReallyAbsurdlyUnsafePerformIOShameOnYou`.

The flagship Haskell application is Zetabot, a 200 line Zeta calculus interpreter that sits in #Haskell, much to the entertainment of several hundred dead-ended college stu* Exception: Stack Overflow