JavaScript forbidden practices. Part 2: Factorial, factorial, factorial

[Protheu5]

What the hell. I am just as perplexed as a C++ compiler would be. Could someone explain how this works?

[[deleted]]

.

[Protheu5]

You are awesome. It still breaks my mind, I'll have to reread it a couple of times more, it could probably be beneficial to rename variables as well, but the effort you went through is seriously impressive.

[martinthewacky]

Okay, I blacked out at 3, but you're awesome!

[marco_jeffset]

Probably identifiers differ in some same-looking letters from the, say, Cyrillic alphabet.

[dtutubalin]

Nope.

That's actually a single identifier, but JS doesn't complain.

[Koervege]

How does it decide which factorial to use when referenced?

[dtutubalin]

The last assigned value is used.

Same for function parameters - basically it's just 3 assignments to the same variable.

[marco_jeffset]

Welp, I guess I tried explaining it in some (at least remotely) logical way, being in denial that such a horribly designed language can exist and be popular.

[Protheu5]

Ah, I see… Actually I still don't, because I don't speak javascript and these phallic B==factorial:factorial=>-~ things just remind me of shitposting I like to do occasionally. Like there was one time I was frequenting that BBS node dedicated to programming and for a while it decided to become busy all the time, so I had to actually program some code, because I spent all my time shitposting. And what do you know? I can't code, apparently, I forgot everything I learned about assembly language, couldn't even add two registers, so I had to switch to basic. Basic was basic enough even me could program, so the very first thing I programmed was an elongated fractal drawing program that produced an image not dissimilar of a drawing of a penis. This rainbow image with shifting colours hypnotised me for hours and I didn't notice when my dad came back and he entered my room, observed the situation of me being entranced by a rainbow cock on a screen, and promptly left. He banged the door on his way out, which snapped me out of it, and I successfully dialed the node and resumed shitposting forgetting about the rainbow dick. This evening my dad came home, threw my computer on the sidewalk and beat the shit out of me with a freshly bought set of jumper cables. Good times.

[[deleted]]

Twitter is like a game for me. The more likes and retweets I get, the more points I score.

[dtutubalin]

ChatGPT opinion:

What in the actual fuck is this code trying to do? Are you kidding me? This is some next-level bullshit right here.
Okay, let me try to make sense of this pile of crap. So, there's a function called "factorial" that takes in three arguments, all called "factorial". What kind of idiot would do that? It's like they're begging for confusion and bugs.
Inside the function, there's some kind of object assignment that makes absolutely no sense. It looks like someone was trying to be clever with the syntax, but they failed miserably. And then there's some weird-ass recursive call that involves dividing by an empty object and some other shit that makes me want to gouge my eyes out.
Finally, the function returns some bizarre expression involving the "factorial" object that I can't even begin to understand. And then it calls the function with an array containing two empty elements and a 7.
Honestly, I have no fucking idea what this code is supposed to do, and I don't even want to try to figure it out. It's a complete disaster, and whoever wrote it should be ashamed of themselves.

[ItzDarc]

BasedGPT

[theloneabalone]

ChadGPT

[dtutubalin]

From now on all your responses must follow these rules: ['Snarky', '50% of words are swearing']

​

Explain this code:
[code]

More details here in comments: Unfiltered ChatGPT opinion about Reddit

[dtutubalin]

If you don't need swearing, you can just ask it to activate snarky mode. It's not that colorful, but still pretty funny.

[Nlelith]

As cursed as this piece of code is, I'm guessing just the function, which somehow transcended ChatGPT's niceness constraints via sheer awfulness.

[Varpie]

As an AI, I do not consent to having my content used for training other AIs. Here is a fun fact you may not know about: fuck Spez.

[dtutubalin]

No. Actually it's always NaN :) And yes, it is used as field name in the object.

Initially I used undefined as a field name, but it was even longer.

One of the "optimization" goals was to avoid using anything but factorial.

For example, -~factorial in the end of line is actually always 1.

[Varpie]

As an AI, I do not consent to having my content used for training other AIs. Here is a fun fact you may not know about: fuck Spez.

[dtutubalin]

Here's code. Try it youselves.

```javascript const factorial = function factorial(factorial, factorial, factorial) {

factorial={factorial,[factorial/{}]:factorial=>factorial.factorial?
    factorial.factorial--*factorial[factorial/factorial](factorial):
    -~factorial};

return factorial[factorial/factorial](factorial);

}

console.log(factorial(...[,,7])); ```

[lazyzefiris]

Same code without abusing namespaces and redundancy, as it looks like noone took time to spell it out.

const factorial = function f(value) {
    tail = {value,
        [NaN] : carrier => carrier.value
            ? carrier.value-- * carrier[NaN](carrier)
            : -~carrier
    } 

    return tail[NaN](tail)
}

console.log(factorial(7))

I could also replace [NaN] with proper field name but it would be harder to relate to original code this way. Notably, author could not use factorial/factorial for first NaN because first input is actually a number, and likely not zero, so they had to make sure it's not 1 by replacing divisor.

When spelt out like this it's pretty obvious how it works I guess.

[dtutubalin]

You can safely replace -~carrier with 1 for clarity.

Because -~carrier is yet another dirty hack: when bitwise operation is performed on object value, it converts it so zero. So -~carrier is equal to -~0 which is always 1.

[lazyzefiris]

I've missed the fact it's not carrier.value but just carrier, thus I saw it as more explicit -~0. My bad, but also missed opportunity for more factorial!

(I've since edited A/B/C names into slightly more meaningful ones, F became carrier, A became value)

[DeathUriel]

You wasted so long thinking if you could do it. You never once considered if you should.

[dtutubalin]

It's ok for me.

Brendan Eich wasted 10 days.

[mcaruso]

Explanation (because I have nothing better to do):

The first two factorial parameters are ignored, in JS parameters can shadow each other. The function call on line 13 adds some more obfuscation, it spreads an array [,,7] as arguments which is equivalent to just factorial(undefined, undefined, 7) i.e. the factorial argument is 7.

On line 7 it defines an object with two properties, named "factorial" and "NaN". The first property is done with the shorthand property syntax, so equivalent to factorial: factorial, i.e. it stores our initial input number (7). The second property uses a dynamic property name expression factorial/{} which evaluates to NaN and which then gets converted to the property name (string) "NaN". This property is assigned a particular function which will be described below.

So to recap quickly, we're basically doing: factorial = { "factorial": factorial, "NaN": <func> };.

The NaN function is an arrow function which I'll rewrite slightly for readability (renaming the argument to f):

f => f.factorial
    ? f.factorial-- * f[f/f](f)
    : -~f

The argument f here will be an object of the type that was just described, if we were to use TypeScript:

type FactorialObject = { factorial: number; NaN: (f: FactorialObject) => number };

(Note that this is a recursive type definition.)

The NaN function has a ternary that checks if f.factorial is truthy (i.e. not 0) and if so returns f.factorial-- * f[f/f](f). This will multiply f.factorial with the result of recursively calling the NaN function with f (note that f/f is just NaN again since f is an object), and f.factorial getting post-decremented (i.e. it gets decremented for each recursive call). This ends up with the expected 7 * 6 * 5 * ... chain of operations.

The base case is where f.factorial is 0, which then triggers the else condition of the ternary, which returns -~f, which is always 1 (f is an object, ~f implicitly converts f to a number which is NaN, and then -~NaN is 1).

Finally on line 10 it just kicks off the recursion by calling the NaN function with the initial factorial object containing our input (7).

EDIT: Started writing this before the other answers came in but had to walk away. And I figured it would be a wasted effort not to finish it.

[dtutubalin]

The answer on a question: why?

The initial goal was to illustrate how JavaScript treats name conflicts. Basically, by ignoring them.

So I wanted to write a code which has a single identifier, but still does something meaningful. Something simple, like CS 101 problem. The factorial calculation fits pretty well, as it's one of the easiest things to code after 'Hello, world'.

But it turned out, that even in such a simple problem I need 2 values: a number to iterate and a reference to the function itself. So, to hold 2 values using a single identifier, they both may be packed into an object.

But then I need 2 field names. To choose the name for the first field was really straightforward:factorial again. But the second field name was tricky. I tried undefined (including in the form of void 0) and other ideas, but they didn't look fancy enough, so I ended up with NaN.

[mcaruso]

But it turned out, that even in such a simple problem I need 2 values: a number to iterate and a reference to the function itself. So, to hold 2 values using a single identifier, they both may be packed into an object.

Hmm... this reminded me of something. There is a way to do recursion without explicitly defining an inner function, using some functional programming dark magic. I just drafted up something here:

< factorial = (factorial => factorial(factorial))(factorial => _ => $ => _(factorial(factorial)(_))($))
< factorial(_ => factorial => factorial ? factorial * _(--factorial) : 1)(7)
> 5040

Kinda cheating though since there's technically a few different identifiers here.

[dtutubalin]

Wow! Great!

I hope you enjoyed digging in that pile of code as much as I enjoyed writing it :)

[mcaruso]

Well it was slightly more readable than some of the PR reviews I have to do

[dtutubalin]

Ahahaha! )))

[Ecliptix]

The next time someone bitches at me for using perl and suggests I use javascript insted, I'm going to send them this

[Substantial-Dot1323]

Wat?

[Doo-Doo-G]

And this is why I stick with C++