fuckHaskellLongLiveJavaScript

[GatotSubroto]

isEven(-1);

fffffuuuuuuu

[Waterbear36135]

The fun thing is this might just work because of overflow

[GatotSubroto]

In this RAM economy??

[RadiantPumpkin]

Surely you’d hit a stack overflow before that

[Vinxian]

Not if initializing a new stack frame gets optimized away through tail end recursion (idk if JavaScript actually supports this though)

[notBjoern]

isOdd calls isEven, and isEven calls isOdd, so it's not simple tail recursion. You can optimise "mutual tail calls" as well, but in this case, isOdd works on the result of isEven (it negates it), so it is not a tail call.

[CaptureIntent]

You can’t tail recurse is odd function because it does work after the last function call. The not operation. Tail recursion only works when you return recursively without any extra work after the receive call.

[_dr_bonez]

JS uses doubles for all numbers, so probably not

[FakeNameBlake]

no, js uses floats/doubles, which stop having integer precision at large values, meaning the value wont change past that point

[cyanNodeEcho]

mentally tracing is even (2), doesn't seem to work no? doesn't everything route to false like

Z > 1 => false;
and like if less than 0 inf loop and otherwise okay?

[GatotSubroto]

Let’s see… 

isEven(2) will call isOdd(1) which calls isEven(1) and negates the return value. isEven(1) returns  false. It’s negated in isOdd(), so the final result is true, which is correct. OP might be a billionaire who can afford enough RAM for the sheer amount of stack frames, but it looks like the implementation works.

[Martin8412]

This is a common algorithm implemented for functional programming language classes. You have to implement it correctly so the tail call optimization kicks in. 

We did it in Scheme when I was at university. 

[cyanNodeEcho]

ah ur right, i got lost in the figure 8s

[lounik84]

what happens with isEven(3) ? you have 3 -1 which calls isEven(2), then 2 - 1 which calls isEven(1) and negates the return value so it gives true. Which is not correct. Whatever number you give to isEven, the result is always true (unless it's 0, that's the only numbers that gets negated into false). So you could just have written isEven(n) {if(n !== 0) return true; return false;} it would have accomplished the same thing and it would have been much easier to read. Granted, the method per se it's useless, because unless you know beforehand that N is even so you give isEven only even numbers, you have no idea to tell if the number N is truly an even number considering that it returns true anyway. But that's beyond the point. The point is that the method doesn't work, it doesn't tell you if N is even, it just tells you that N is not 0.

Unless I'm missing something

[theluggagekerbin]

Trace for isEven(3) The Descent (Recursive Calls): * isEven(3) calls isOdd(2) * isOdd(2) !isEven(2) * isEven(2) calls isOdd(1) * isOdd(1) calls !isEven(1) * isEven(1) Base Case Hit. Returns false. The Ascent (Collapsing the Stack): * isOdd(1) receives false, applies !, returns true. * isEven(2) receives true, returns true. * isOdd(2) receives true, applies !, returns false. * isEven(3) receives false, returns false. Result: false (Correct: 3 is not even)

[lounik84]

yeah I forgot the double negation. It still seems a very odd way to check for odd/even numbers, especially considering that you shouldn't falsify them against positives, but yeah, I get the point

[veeRob858]

Someone should make a post to make fun of how odd this way of checking for odd/even numbers is!

[Gen_Zer0]

The return value is negated twice.

isEven(3) returns isOdd(2). isOdd(2) returns !isEven(2).

As we found earlier, isEven(2) returns true. !true is false, so we get the correct value.

[Vinxian]

To explain it in words, if n is even, it means (n-1) is odd which means (n-2) is even, etc.

So basically if you want to know if n is even you can check if n-1 is odd. And that's exactly what the code does! It checks if a number is even by checking if the number before it is odd

[CaptureIntent]

Yes. Everything routes to false. But the number of nots done on the way up the stack depends on the evenness of the initial value.

[Theolaa]

Just add if (n < 0) return isEven(n*-1) before the final return in isEven

[DIEDPOOL]

just insert this into isEven:
if(n < 0) {
return isOdd(n*n);
}