I was a bit apprehensive because rust has like a gazillion different function types but here it seems to work like just any other language with a HM type system.

The fn(T)->R syntax works for functions without associated data, it discards details of the implementation and works like function pointers in C. This allows them to be copy and 'static.

The other function types can have data with them and have more type information at compile time which allows them to be inlined.
These functions each have their own unwritable type that implements the function traits (Fn(T)->R, FnMut(T)->R and FnOnce(T)->R) depending on their enclosed data.

I hope I remembered everything right from this video by Jon Gjengset.

Jetbrains products also have a fallback license after a year, so you retain perpetual acces to an old version* and I don’t think there is much change in the space of git UIs.

* iirc the version that you had one year before your payment lapsed, it applies to discounted versions as well

Prolog is not suitable for any problem domain, although this is more readily apparent for some domains than others.

For real, for real.

Come and take a seat

https://xkcd.com/1586/

You can’t random-access an iterator and use it again later.

If your specific use case really needs random access to a list while lazy computing the elements just wrap them in Lazy and put them in a vector.

Can Rust compute the value of calling a function an infinite number of times?

The return type of an infinitely recursive function / infinite loops is ⊥, a type that by definition has no values. (Known in rust as !)

Imagine using a linked list as your default sequential container.
Rust iterators are lazy btw.

Boring story:
22 was free, he asked for it, he got.

I cheated by knowing what the nutjobs want this time ::: spoiler spoiler texas should secede from the USA because Biden doesn’t let them kill refugees :::

To build prototypes, I don’t want to fight with borrow checker and neither I care for efficiency much. But I want [rust features]

Maybe we just need a preprocessor that adds clone, reference counting and RefCell wherever needed.

Such a case would be the single function having a side effect*. This allows the caller to chose when to execute the side effect or to drop the result without executing it.

In my opinion that is fine with fn_once but not into because of the implicit contract of these traits.

* = I’m counting expensive computation, but not allocation and memcopy as a side effect in this comment.

The best solution there would probably be some brower plugin/extension/whatever that replaces fedivers URLs with the “redirecting” URL of your instance of choice.

Given that it’s a simple text replacement, the most complicated part is probably recognizing fediverse sites (a list of sites with a fallback button would also work).

Messing around with rust is certainly worth it, as it can change the way you think in a way that improves code in whatever language you write.

both include some otherworldly figure either observing or mandating how we live our lives

There is a big difference between observing and mandating. Most interpretations of simulation theory don’t even talk about humans being observed.

Recursion is often unintuitive for beginners, to understand this code we should simply it a bit

int main(void)
{
    int height = get_int("Height: ");

    draw(height);
}

void draw(int n)
{
    if (n <= 0)
    {
        return;
    }

    draw(n - 1);
    printf("%d",  n);
    
    printf("\n");
}

Inputting 3 should now give us a output like

1
2
3 

Try to understand that case first and than muddle it up with the loop.

If you examine it in a debugger look at the Stack trace. If you use gdb its bt in a visual debugger it’s probably the list of function names next to the variables

This isn’t about ownership, but about authenticity.

The solution would be closer to certificate authorities used in https than any blockchain crap.

Yes, but the first steam train was also a step towards interstellar travel.