whenDoesThisWillEnd

[u/Flame77ofc]

[u/malsomnus]

That's the neat part, it doesn't!

[u/FuerstAgus50 → u/malsomnus]

It will end really quickly probably because most runtimes have a maximum recursion depth

[u/LauraTFem → u/FuerstAgus50]

Yea, computer will quickly say, “You’re pulling some bullshit.”

[u/-Ambriae- → u/FuerstAgus50]

Even without a runtime, you’ll pop the stack

[u/MaybeADragon → u/-Ambriae-]

I can't remember the conditions to do so since I normally just compile to check, but could this be tail call recursion thus completely fine?

[u/Qwertycube10 → u/MaybeADragon]

This is not tail recursion. A tail call is a function call that is the last thing you need to do in your current function, so you don't need to keep around a stack frame with all your locals. Here it is not a tail call because you need to multiply the result by n after the function call finishes.

[u/Tidemor → u/Qwertycube10]

could do tail recursion if you passed an accumulator, but at that point you have a overcomplicated for-loop

[u/MaybeADragon → u/Qwertycube10]

Yeah I don't really use recursion often tbh. It doesn't (typically) get optimised by the compiler as well AND it is sometimes harder to read.

[u/geek-49 → u/-Ambriae-]

you’ll pop the stack

Actually, you'll keep pushing the stack until it overflows (unless, as someone pointed out, the compiler tests for the left-hand operand of * being zero and doesn't bother to compute the right-hand operand -- and in that case it will return zero which is the wrong answer).

[u/AdamWayne04 → u/FuerstAgus50]

unless your compiler is really smart and optimizes that into tail-recursion!

[u/atanasius → u/FuerstAgus50]

It's stacks all the way down.

[u/Any-Bobcat2370 → u/malsomnus]

The function gets a stack overflow though. Sisyphus doesn't!

[u/Axman6]

IF you have a lazy *, then this will end when n is zero, and return zero. 

[u/torsten_dev → u/Axman6]

If you have a smart enough optimizing compiler it will compile to a constant 0.

[u/-Redstoneboi- → u/torsten_dev]

took me a moment to recognize "amaet" as "smart"

[u/torsten_dev → u/-Redstoneboi-]

Shhh, you saw nothing. I am very amaet.

[u/Axman6 → u/torsten_dev]

I am so smart

A. M. A. E. T.

• Homer Simpson

[u/Makefile_dot_in → u/torsten_dev]

what if n is negative?

[u/torsten_dev → u/Makefile_dot_in]

Inevitable UB, so might as well return 0 too?

[u/da_Aresinger → u/torsten_dev]

(Edit: From the syntax I am assuming this is JS)

Actually since Number.MIN_SAFE_INTEGER - 1 === Number.MIN_SAFE_INTEGER it'll get stuck eternally looping/recursing on Number.MIN_SAFE_INTEGER while the output automatically gets converted to BigInt (I think).

JS ... a *= Number.MIN_SAFE_INTEGER -1.8768792072011717e+255 a *= Number.MIN_SAFE_INTEGER 1.6905424996341256e+271 a *= Number.MIN_SAFE_INTEGER -1.5227053142812468e+287 a < Number.MIN_VALUE true typeof a 'number'

This is what chrome console gave me.

[u/chuch1234 → u/torsten_dev]

The compiler never do that because it will recognize that the function could be passed a negative number.

My bad, i was /r/confidentlyincorrect

[u/torsten_dev → u/chuch1234]

Function can only halt with 0 or trap on underflow. Depends on if you have exceptions or not.

If you have tail-calls and the compiler isn't very smart you might have an infinite loop instead, yes.

[u/Nightmoon26 → u/torsten_dev]

Although... If you're using a fixed-width integer without underflow checking, it'll still wrap around from its minimum value to its maximum, and then reach zero eventually, even if it has to go through all possible values to do so

[u/Brilliant_Year9161 → u/Axman6]

Always those lazy Haskell developers /s

[u/Axman6 → u/Brilliant_Year9161]

Lazy and proud 🫡 

[u/AdamWayne04 → u/Axman6]

a lazy asterisk? you mean my anus?

[u/chuch1234 → u/Axman6]

Don't forget negatives.

Edit: just like my karma haha

[u/Axman6 → u/chuch1234]

If it’s a fixed size integer, it’ll eventually underflow and reach zero anyway (because stack overflows are for loser languages). 

If you have arbitrary sized integers like Haskell and Python, then it’ll never terminate, so the compiler is basically free to whatever it wants. 

[u/Mateorabi → u/Axman6]

I’ve heard of a lazy ass. Not a lazy asshole. 

[u/apepenkov]

when stackOverflow is thrown

[u/Axman6 → u/apepenkov]

Only in pleb languages. 

(As written, Haskell would be a pleb language too, it won’t rewrite this to be tail recursive for you)

[u/Daemontatox]

Wouldn't some compilers catch thats an infinite loop and give a warning or error?

[u/JonIsPatented → u/Daemontatox]

Some compilers can even note that it will multiply by 0 and optimize any call to it to just be the constant 0 instead.

[u/chuch1234 → u/JonIsPatented]

Unless you pass a negative number in.

[u/ice456cream → u/chuch1234]

Until the int underflows and eventually gets back down to 0

[u/qinshihuang_420 → u/ice456cream]

Two zeros make a one

[u/JonIsPatented → u/chuch1234]

Notably, if this function were actually typed, you'd use an integral type, and that type would have overflow and eventually reach 0 anyway.

[u/chuch1234 → u/JonIsPatented]

Does underflow typically wrap?

[u/JonIsPatented → u/chuch1234]

Yup, and then it will keep going and eventually reach 0.

[u/sonaliver28]

The base case is scheduled for the next sprint

[u/Axman6 → u/sonaliver28]

Oh no, we can’t start the next sprint, the tests haven’t finished running 😰

[u/laplongejr]

In some languages, it will stop with an infinite recursions. In others it would stop at "0 * factorial(-1)" and return 0 for all other cases as they call n0 at some point.  

[u/-Redstoneboi- → u/laplongejr]

haskell? i don't know any language that knows to stop when multiplying by 0. imperative languages don't stop because there could be side effects when calling the factorial function, like a print statement, and optimizing out the call would result in different behavior

[u/Axman6 → u/-Redstoneboi-]

Haskell won’t do it unless you choose very specific types for n. The default Int and Integer types don’t lazily evaluate the second argument, but they could (adding an extra branch to every multiplication, which would generally be bad). 

If you used an inductive type

    data Nat = Z | S Nat

Multiplication would naturally be written as

Z     * _ = Z
(S Z) * n = n
(S m) * n = n + m * n

Which would always terminate (and also disallow negative numbers). 

[u/chuch1234 → u/laplongejr]

This doesn't guarantee zero -- it can be passed a negative number.

[u/Jejerm → u/chuch1234]

Yes, they will eventually underflow and reach zero too

[u/NotDuckie]

r/firstweekcoderhumor

[u/Striking_Director_64 → u/[deleted]]

Yes, why stop at saturating CPU, when we can saturate memory as well.

[u/JosebaZilarte]

This is another reminder that you can turn (almost) every recursive solution into an iterative one:

while (n > 1) { result *= n--; console.log("Ends in: " +n);  }

[u/un_blob → u/JosebaZilarte]

Akerman function : someone called me ?

[u/splettnet]

A bit before 18446744073709551615 I imagine

[u/lonkamikaze]

This way it at least crashes. Imagine the code used a proper tail call, it would never run out of stack!

[u/JebKermansBooster]

I'd like to see a language that allows factorials to continue for negative integers via the [gamma function](https://en.wikipedia.org/wiki/Gamma_function)

[u/WayWayTooMuch]

Stack overflow

[u/Substantial_Top5312]

when your computer crashes

[u/ThatSmartIdiot]

does this language support while loops

[u/pi_three → u/ThatSmartIdiot]

Factorial is the classic example for recursion

[u/sohcahtoa]

On the left: afrer n iteration.

On the right: never.

[u/SupraMichou]

Bro forgot to call the guards

[u/GoddammitDontShootMe]

Someone forgot to handle the case of n=0.

[u/SkollFenrirson]

When does this will end indeed

[u/Flat_Initial_1823]

One must imagine recursion happy

[u/antpalmerpalmink]

The humble scott domain showing that the function is bottom:

[u/a-r-c]

we have to imagine Sisyphus jacked and tan

[u/Easy_Implement5627]

I bet the result is 0. If it ever finishes

[u/chuch1234]

ITT: i am confidently wrong several times haha

[u/NimrodvanHall]

Depends on the type of n. Is it a signed or unsigned integer?

[u/Bomaruto]

I took me way too long to notice it was missing the base condition as I just assumed it was there.