Closures

can someone explain them to me.. I'm thinken they might be simple but my pee sized brain can't comprehend most definitions off of google

>>79
define "set theory"

>>80
define "a set of objects"
>>79
justify.
Lisp is jewish because it is statically typed and has first-class functions and anonymous functions. Also, CLOS has classes which come from the jewish set theory. Lisp is jewish.

>>81
Jewish monopoly.

>>82
>>81

>>84
>>83

>>83
define "Jewish monopoly"

>>86
You all jewish maggots that suck your jewish master's dick.

Lisp: reduce
Haskell: fold, foldl, foldr, foldl', foldr1, foldl1, foldl1'


Haskell                          | Lisp
---------------------------------|---------------------------------
zip      l1 l2                   | map list l1 l2
zip3     l1 l2 l3                | map list l1 l2 l3
zip4     l1 l2 l3 l4             | map list l1 l2 l3 l4
zip5     l1 l2 l3 l4 l5          | map list l1 l2 l3 l4 l5
zip6     l1 l2 l3 l4 l5 l6       | map list l1 l2 l3 l4 l5 l6
zip7     l1 l2 l3 l4 l5 l6 l7    | map list l1 l2 l3 l4 l5 l6 l7
N/A                              | map list . ls
map      f  l                    | map f l
zipWith  f  l1 l2                | map f l1 l2
zipWith3 f  l1 l2 l3             | map f l1 l2 l3
zipWith4 f  l1 l2 l3 l4          | map f l1 l2 l3 l4
zipWith5 f  l1 l2 l3 l4 l5       | map f l1 l2 l3 l4 l5
zipWith6 f  l1 l2 l3 l4 l5 l6    | map f l1 l2 l3 l4 l5 l6
zipWith7 f  l1 l2 l3 l4 l5 l6 l7 | map f l1 l2 l3 l4 l5 l7
N/A                              | map f . ls

Lisp

(defmacro show (&rest xs) ...)

Haskell

instance  (Show a, Show b) => Show (a,b)  where
  showsPrec _ (a,b) s = show_tuple [shows a, shows b] s

instance (Show a, Show b, Show c) => Show (a, b, c) where
  showsPrec _ (a,b,c) s = show_tuple [shows a, shows b, shows c] s

instance (Show a, Show b, Show c, Show d) => Show (a, b, c, d) where
  showsPrec _ (a,b,c,d) s = show_tuple [shows a, shows b, shows c, shows d] s

instance (Show a, Show b, Show c, Show d, Show e) => Show (a, b, c, d, e) where
  showsPrec _ (a,b,c,d,e) s = show_tuple [shows a, shows b, shows c, shows d, shows e] s

instance (Show a, Show b, Show c, Show d, Show e, Show f) => Show (a,b,c,d,e,f) where
  showsPrec _ (a,b,c,d,e,f) s = show_tuple [shows a, shows b, shows c, shows d, shows e, shows f] s

instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g)
        => Show (a,b,c,d,e,f,g) where
  showsPrec _ (a,b,c,d,e,f,g) s
        = show_tuple [shows a, shows b, shows c, shows d, shows e, shows f, shows g] s

instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h)
         => Show (a,b,c,d,e,f,g,h) where
  showsPrec _ (a,b,c,d,e,f,g,h) s
        = show_tuple [shows a, shows b, shows c, shows d, shows e, shows f, shows g, shows h] s

instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i)
         => Show (a,b,c,d,e,f,g,h,i) where
  showsPrec _ (a,b,c,d,e,f,g,h,i) s
        = show_tuple [shows a, shows b, shows c, shows d, shows e, shows f, shows g, shows h,
                      shows i] s

instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j)
         => Show (a,b,c,d,e,f,g,h,i,j) where
  showsPrec _ (a,b,c,d,e,f,g,h,i,j) s
        = show_tuple [shows a, shows b, shows c, shows d, shows e, shows f, shows g, shows h,
                      shows i, shows j] s

instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k)
         => Show (a,b,c,d,e,f,g,h,i,j,k) where
  showsPrec _ (a,b,c,d,e,f,g,h,i,j,k) s
        = show_tuple [shows a, shows b, shows c, shows d, shows e, shows f, shows g, shows h,
                      shows i, shows j, shows k] s

instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k,
          Show l)
         => Show (a,b,c,d,e,f,g,h,i,j,k,l) where
  showsPrec _ (a,b,c,d,e,f,g,h,i,j,k,l) s
        = show_tuple [shows a, shows b, shows c, shows d, shows e, shows f, shows g, shows h,
                      shows i, shows j, shows k, shows l] s

instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k,
          Show l, Show m)
         => Show (a,b,c,d,e,f,g,h,i,j,k,l,m) where
  showsPrec _ (a,b,c,d,e,f,g,h,i,j,k,l,m) s
        = show_tuple [shows a, shows b, shows c, shows d, shows e, shows f, shows g, shows h,
                      shows i, shows j, shows k, shows l, shows m] s

instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k,
          Show l, Show m, Show n)
         => Show (a,b,c,d,e,f,g,h,i,j,k,l,m,n) where
  showsPrec _ (a,b,c,d,e,f,g,h,i,j,k,l,m,n) s
        = show_tuple [shows a, shows b, shows c, shows d, shows e, shows f, shows g, shows h,
                      shows i, shows j, shows k, shows l, shows m, shows n] s

instance (Show a, Show b, Show c, Show d, Show e, Show f, Show g, Show h, Show i, Show j, Show k,
          Show l, Show m, Show n, Show o)
         => Show (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) where
  showsPrec _ (a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) s
        = show_tuple [shows a, shows b, shows c, shows d, shows e, shows f, shows g, shows h,
                      shows i, shows j, shows k, shows l, shows m, shows n, shows o] s

>>88
Lisp is jewish. And the second was posted by me.

>>89
Nice jewish macro.

>>88
Also, you pass a function to map, which is also jewish, because it has first-class functions.
Also, map accepts only a function as first argument, and lists as other arguments, which means that types are enforced on you, which means that Lisp is statically typed, which is jewish.
Lisp is jewish.

>>89
And the show macro dispatches the display function based on jewish types which come from jewish set theory. Lisp is jewish.


Lisp                     | Haskell
-------------------------|-------------------------
* (expt -1 (exp 1))      | Prelude> (-1) ** exp 1
#C(-0.6332554 0.7739428) | NaN



Lisp                        | Haskell
----------------------------|---------------------------------------------------
* (floor (/ 1 0))           | Prelude> floor (1/0)
DIVISION-BY-ZERO signalled  | 1797693134862315907729305190789024733617976978942306572
                            | 7343008115773267580550096313270847732240753602112011387
                            | 9871393357658789768814416622492847430639474124377767893
                            | 4248654852763022196012460941194530829520850057688381506
                            | 8234246288147391311054082723716335051068458629823994724
                            | 5938479716304835356329624224137216

>>94
Complex numbers are a jewish concept. What is a complex number in real world? Enjoy your infinity, jewish maggot.

>>94
Negative numbers are also jewish. What is a negative number in real world? I can't have -1 apples. Enjoy your infinity, jewish maggot. Lisp is a jewish language.

>>96
I can't have -1 apples.
What about the apple you sold to someone? `-` is just a way to discern it from apples you still have unsold.

>>95
What is a complex number in real world?
a way to store angles?

>>97
What about the apple you sold to someone?
Because jews want all my money.

>>98
They are composed of real numbers and imaginary numbers. Imaginary numbers are jewish because they don't exist.

If you're not the ``in Lisp'' troll, ignore all my messages in this thread containing the word ``jewish''. Thank you.

>>99
If you wont your mortgage to jews, they'll evict you.

Stop falling for this troll. I think he has surpassed FV by now.

>>100
Right. Numbers don't exist. Digits and letters do exist.

>>102
But I'm having fun reverse trolling him! FV was much less reverse-trollable.

>>103
They exist because jewish zionist want you to believe they exist. Enjoy believing in non-existent things like God and digits.

>>102
Infinite compression is jewish.  FV was a jewish troll.

>>102
What if he not trolling? Could you please remind us, who invented set theory? To which nationality name "Cantor" belongs?

>>104
FV was extremely reverse trollable if I remember correctly.

>>105
But I see them on my computer's display!

>>109
Only thing on your display is crystals that attenuate light. imagining jewish glyphs let alone characters or digits is jewish jew jewness.

>>109
You can't touch them, they don't exist.

>>108
He was so stupid that he didn't have really a trolling argument besides JS, the absence of whitespaces in his code, and the ``I'll have a stupid idea, do nothing, and forget about it''.

>>110
I can't see light, I can't touch light, I have no evidence that light exists, so even those crystals work by the power of jews.

>>107
Zermelo and Fraenkel did invent ZF(C) set theory. I have no idea what nationality Cantor was, but let me check... Zermelo was german, Fraenkel was the nationality that you don't seem to like.
As for Cantor, it's unclear:
Thus Cantor has been called Jewish in his lifetime,[68] but has also variously been called Russian, German, and Danish as well.

Anyways, I've actually read Cantor's work after all your trolling and I have to say it's pretty interesting. There's a few rather artificial looking axioms in ZF that let him construct the higher infinites (aleph-naught, aleph-1, and so on), but it's unclear how consistent ZF set theory is as there are some paradoxes, but there are better fundational theories which manage to avoid these paradoxes.

In the end, I did find it enlightening to find out that if you do accept one infinity (that of natural numbers) as a concrete value, then there are an infinity of infinities that can also exist (the next one would be that of real numbers, but that cannot be proven or disproven (Continuum hypothesis), which probably suggests the inconstency of the entire concept). It's a very interesting abstract concept to think of, even if it has no practical application and is highly likely to be impossible to physically realize it (same with hypercomputation or real numbers in physical systems, despite so many physical theories having them), even if you think the cause of the world is something similar to the Ultimate Ensemble (that is, it's unlikely these mathematical systems are consistent and thus they cannot ever have a physical instantiation somewhere, but if you assume so, you'll have to discard current string theory if it doesn't have quantized spacetime and go in the direction of Loop Quantum Gravity instead).

Oh dammit, IHBT, fell for the troll I told others not to fall for.

idk

For the bored: I actually have a copy of the POP-2 book; my university's library has a bad habit of deciding historically important books are no longer worthy of its shelves. If anyone ever wants to know what the first true functional language was like, we can pop that sucker open any time and read passages. The Wikipedia article doesn't give a very good sense of the language and style of the time, and there's only one online reference that has examples.

>>110
It exists, if I sense it.

>>113
"Cantor" is a jewish name. Look at following Cantor:
http://en.wikipedia.org/wiki/Tadeusz_Kantor

typical jew. In eastern europe most Cantors do evil things, like advancing existence Holocaust in Schools. That says for themselves.

>>117
Well, when you show us a pure-blooded Aryan who invented the nuclear bomb, we'll start taking you seriously. Until then, back to /k/, please.

>>113
if you do accept one infinity
define "infinity"

>>118
Inventing Nuclear Bomb is a pretty evil deed. Worse was only communism, which killed millions.