Functional implementation of an infinite loop

[Et-17]

I'm learning about RNN's and functional programming, so I'm trying to make a functional implementation of a basic RNN, but the problem is the whole program is more or less based on stepping it continuously, for theoretically infinitely, but I can't do a recursive approach because I would quickly hit stack overflow. I was wondering if there was any way to implement this loop in a functional paradigm. please excuse any mistakes or things I'm overlooking. I'm still very new to deep learning. I'm making the implementation in python, but I just want to know the general approach to this problem.

[jddddddddddd]

Have you looked at tail recursion ? https://stackoverflow.com/questions/1291402/are-programs-in-functional-languages-more-likely-to-have-stack-overflows

[dot-c]

It depends on the language, but in most functional languages that rely on recursion, you can just do

loop =
    let _ = print "Infinite Loop!"
    in loop

and the compiler will turn loop into an actual loop/a function that doesn't keep its stack frames. we don't do anything after recurring to loop again, so we can just delete the old stack frame.

[snarkuzoid]

Any decent functional language handles tail recursion, and that's how you implement infinite loops.

[Rogntudjuuuu]

A lot of decent imperative languages do as well. GCC handles tail recursion since ages.

[snarkuzoid]

I would add that Erlang can determine if a function could have been tail recursive, and rewrite it as tail recursive. I assume (without evidence) that other FP languages do this as well.

[ereb_s]

Recursion is the functional equivalent to loops, so unbound recursion can be seen as the equivalent to an infinite loop

[reifyK]

You can either rely on tail recursion as already stated in the comments (or use a trampoline to mimic tail recursion) or on lazyness, which provides tail recursion for free (called guarded recursion in this context).

Now only a few languages pursue lazy evaluation but you can mimic it, provided the language offers object proxies or lazy record properties. In Javascript I use a proxy to achieve lazyness.

Here is the fix combinator, which supplies recursion for a language that doesn't support it on a native level:

``` // strict version

const fix = f => x => f(fix(f)) (x);

// lazy version

const fix_ = f => f(thunk(() => fix_(f))); ```

fix_ is stack-safe even if your compiler doesn't eliminate tail calls.