default initialization shouldn't be done with Zero

[thestinger]

We should have a Default trait for this. Implementing Zero for types like containers is very strange and it also prevents a type from implementing Zero and also having a default initialization that's not zero (an example brought up by @cmr is a UUID).

[alexcrichton]

Agreed, when doing this I believe that the deriving(Zero) implementation should be updated to instead derive whatever this new trait becomes. That was the original intent of that code anyway.

Sadly, this is yet another trait that all primitive types are going to have to implement and extend, but perhaps all these traits can eventually be consolidated into something coherent...

[emberian]

Agree:

trait Default {
    fn init() -> Self;
}

is what was decided during the IRC conversation, I believe. This keeps the very nice new name available for constructors which might want to take arguments (init would probably be implemented in terms of new for those types).

[Thiez]

Wouldn't a better name for 'fn init()' be 'fn default()'? There are already some fn init()s methods in the source (libstd/vec.rs, libstd/rand.rs) that take arguments, and also some functions (libstd/vec.rs, libstd/rt/mod.rs, libstd/rt/logging.rs) that do. Whereas 'fn default' has only 2 matches in the entire rust source (librustc/middle/check_match.rs, libsyntax/abi.rs), neither of which is likely to be used by existing user-code at this time.
Also I think it's a nice convention for these 'one method' traits to have the name of the method be the same as the name of the trait.

[emberian]

@Thiez probably, I'll +1 that

[emberian]

Once we have a Default trait, we could even have syntax sugar for setting certain fields and taking the default for the rest: Foo { field: val, ..super }

[Thiez]

Rust is sweet enough, I think we can manage with the sugar we already have:

struct S{
    x:int,
    y:int
}
trait Default{
    fn default()->Self;
}
impl Default for S {
    fn default() -> S {
        S{x:0,y:0}
    }
}
fn default<T:Default>() -> T {
    Default::default()
}
S{x:5, .. default()}

[emberian]

Only problem is that reserves a new function name

[emberian]

cough sorry, ignore my previous ponts: having the trait method name init or new is fine, because of how namespacing of static methods work:

trait Newable { 
    pub fn new() -> Self;
}

struct Foo;

impl Newable for Foo {
    pub fn new() -> Foo { Foo }
}

impl Foo {
    pub fn new(x: uint) -> Foo { Foo }
}

fn main() {
    printfln!("%?, %?", Newable::new::<Foo>(), Foo::new(42));
}

[emberian]

Trait added in https://github.com/cmr/rust/commit/9e8d5acf0c38d6e01692fbb9e8d7422b8fa2dcb0 (#8438)

[bluss]

This is mostly done. Some types implement Zero today where they probably shouldn't (bool, () and tuples). Can deriving(Zero) be removed, does it have a use case?

[alexcrichton]

I would be OK with removing the "dummy" implementations along with all of the related deriving code.

[flaper87]

Triage bump.. still some minor cleanups to do.

[thestinger]

This is fixed now.