fibonacci | Example project to implement a Fibonacci API microservice | REST library

Edit: As it was pointed out by 康桓瑋 in the comments, there has been a better, cleaner solution presented at Cppcon, link, by Tristan Brindle.

I think this could serve as a quick reference to make custom iterator-based generators.

By your requirements, something must be a std::ranges::view, meaning it must be a moveable std::ranges::range deriving from std::ranges::view_interface.

We can tackle all three with the following:

TLDR: No, you cannot use print or other IO-related functions in the ST monad. Use IORefs in the IO monad for both mutability and the ability to print values.

Full answer:
In Haskell, every value is immutable. This helps preserve its purity. Purity also does not allow side effects such as printing or user input.
A program which cannot take input or print output, however, is useless. So, Haskell has explicit impure functions within the IO monad. By means of IORefs, you can also have mutability within the IO monad.

But sometimes, you need to use mutability to increase the efficiency of a function, and can guarantee that the function is pure or referentially transparent (i. e. The same input will always give the same output). This is the purpose of the ST monad.

The ST monad doesn’t allow arbitrary side effects such as printing, since that would destroy its purity. It only allows interior mutation within it, and once you escape the monad using runST, it appears as a pure computation to the rest of the program.

So, if you really need to print values and have mutation, use IORefs in the IO monad. For pure functions with interior mutation, use ST.

Note: it is possible to add IO to pure functions with unsafePerformIO, and to ST with unsafeIOToST. As the name indicates, they are unsafe and should be avoided unless absolutely necessary (which they usually aren’t).

TL;DR: It's not Rust vs C++, it's LLVM (Clang) vs GCC.

Different optimizers optimize the code differently, and in this case GCC produces larger but faster code.

This can be verified using godbolt.

Here is Rust, compiled with both GCC (via rustgcc-master):

To describe something as "a callable with a memory attribute", you could define a protocol (Python 3.8+, or earlier versions with typing_extensions):

There is not currently a way to ignore files, but if you'd like to only include certain files, you can organize them separately in a subdirectory of your repository, and use that option when publishing your module:

The subdirectory that you choose in this step will become the root of the module's file hierarchy.

Python's "integers have unlimited precision". This was built into the language so that new users have "one less thing to learn".

Though maybe not in your case, or for anyone using NumPy. That library is designed to make computations as fast as possible. It therefore uses data types that are well supported by the CPU architecture, such as 32-bit and 64-bit integers that neatly fit into a CPU register and have an invariable memory footprint.

But then we're back to dealing with overflow problems like in any other programming language. NumPy does warn about that though:

From the sorted permutation 123...n, you can build a tree using the reverse of the rule, and get all the permutations. See this tree for n=4.

Now, observe that

if node==1234 then cost(node) = 0

if node!=1234 then cost(node) = blue_label(node) + cost(parent)

What you need is to formulate the reverse rule to generate the tree. Maybe use some memoization technique to avoid recomputing cost everytime.

The class of functions in 1 is empty: any computable function written in a recursive style has a tail-recursive equivalent (at the limit, since there's a tail-recursive implementation of a Turing Machine, you can translate any computable function into a Turing Machine definition and then the tail recursive version of that function is running that definition through the tail-recursive implementation of a Turing Machine).

There are likewise no functions for which tail recursion is intrinsically less efficient than non-tail recursion. In your example, for instance, it's simply not correct that "it's much more efficient in terms of memory because no additional data structures of intermediate results are required." The required additional structure of intermediate results is implicit in the call-stack (which goes away in the tail recursive version). While the call stack is likely an array (more space efficient than a linked-list) it also, because of its generality, stores more data than is required.