unified function call syntax

[nrc]

No description provided.

[huonw]

The full syntax for this is written as (G: Graph)::Node::magic_number, right?

I'm still mildly concerned about this from a grammar perspective, especially if we ever use : for type ascription on expressions (because then in (x: y..., x can legitimately be either a type or an expression).

[nikomatsakis]

I don't think there is any particular ambiguity so long as we restrict the set of type expressions to paths. Though this is perhaps an unfortunate limitation.

[huonw]

Even with just paths, it means that something like (Foo<T>: Graph) can't work (unless we use Foo::<T> there too).

[nikomatsakis]

Right, you would write Foo::<T> if this appears in an expression context.

[alexcrichton]

As a side note, could you format this to a line width of 80 characters?

[ben0x539]

Does this proposal exclude int::size_of()? ~[T]::size_of()? type MyVec = ~[T]; MyVec::size_of()?

[nrc]

@ben0x539 All those should work, the components of a path should be allowed to be types, not just trait or struct names

[nikomatsakis]

I thought it disallowed things like ~[T]::size_of() -- you'd need a type alias. I don't know how we can parse it otherwise.

[brendanzab]

Does this cover the idea that:

trait A {
    fn a(&self) -> Self;
}

Is just sugar for:

trait A {
    fn a(self: &Self) -> Self;
}

?

[nikomatsakis]

@bjz I think that comes out of my (not yet published) RFC on traits. I need to get to work on finishing that.

[SiegeLord]

From reading the proposal, it wasn't clear to me how this case would be handled:

trait T
{
    fn method(&self) {}
}

struct A;

impl A
{
    fn method(&self) {}
}

impl T for A {}

fn main()
{
    let a = A;
    (A: T)::method(a); // easy to call the trait's method
    A::method(a); // but how to call the inherent method?
}

[nrc]

@SiegeLord This is a little bit orthogonal, since it is about calling overridden vs overriding methods rather than specifying a method in one trait from a set of traits.

a.method would call the method defined in the struct (currently) and would continue to do so. T::method(a) would call the method in the trait (I think currently too). No need for the more verbose form here.

[nrc]

Closed in favour of #132