In libcore, convert functions to methods whereever it makes sense

[bstrie]

By "makes sense" I mostly mean "whereever the first argument to a function is the same type as the name of the module." So a function like str::to_chars("asdf") becomes "asdf".to_chars(), but vec::from_fn(5, |x| x) can be left as a function.

[bstrie]

Some more information. Say there is a plus_one function in the int module:

fn plus_one(x: int) -> int {
    x + 1
}

You would first convert this to a method by pasting it into an impl and changing the name of the first argument:

impl int {
    fn plus_one(self) -> int {
        self + 1
    }
}

And then back in the original location redefine the function to do nothing except call the method:

fn plus_one(x: int) {
    x.plus_one()
}

Once all the functions are simply methods underneath, we can convert all the uses of functions in the compiler into methods, and then remove the functions entirely. But those latter two things are beyond the scope of this bug, just focus on creating the methods for now.

[emberian]

I'm chugging away at this.

[emberian]

This is currently blocked on #6068

[lucian1900]

This is nitpicking, but to me from_fn makes sense to be a static method on a struct, as an alternative constructor to new.

[emberian]

Example, @lucian1900? I do not understand.

[emberian]

Oh, vec::from_fn(5, |x| x)? What would it be instead? &[].from_fn(5, |x| x)? Static methods don't make sense to me. No reason not to have them namespaced, not in the struct.

[lucian1900]

It makes sense to me for types without a literal, like SomeVector::from_fn(5, |x| x)

[emberian]

Sure, but not the builtins.

[emberian]

Visiting for triage; nothing to add

[bstrie]

Closing this, as most of the egregious modules (str especially) seem to have been treated.