Syntax for specifying requirement satisfaction explicitly.

[kyouko-taiga]

If a type wishes to conform to two different traits defining requirements with the same name, the current solution is to use separate conformance declarations:

trait T { fun foo() -> Int }
trait U { fun foo() -> String }

type A {}
conformance A: T { public fun foo() -> Int { 0 } }
conformance A: U { public fun foo() -> String { "a" } }

Building on the conformance lens syntax, we could provide a way to specify explicitly the requirement being satisfied by a member declaration.

type A: T, U {
  public fun ::T.foo() -> Int { 0 }
  public fun ::U.bar() -> String { "a" }
}

[dabrahams]

Technically the colons are not needed here, at least the way you're using them. Maybe public fun T::foo() -> Int would be clearer.

[kyouko-taiga]

Not opposed to remove the colons, but less enthusiastic about T::foo. I would use a dot.

In a conformance lens, A::P reads as "A seen through its conformance to P". My original use of colons was supposed to replicate that by leaving Self implicit.

[dabrahams]

I understand how it's not, but to me P feels like it's playing the role of a scope in this context. Or maybe it's just my bias from other languages wanting :: to mean some kind of scoping. Question for pondering: how is A::P different from A as P.Type, once we have transparent compile-time evaluation?

[kyouko-taiga]

Edit: A as any P is ill-typed. It should be A as MetaType<any P>. See below.

You mean A as any P right? I don't know what A as P.Type is supposed to do. Note that traits are not first-class types in Val, so we can't write let x: P = A().

A::P is supposed to prefix a member expression. The difference between A::P and A as any P is that the former doesn't create an existential container and lets the compiler resolve members statically.

trait P { type X: Copyable }
trait Q { type X: Copyable }

type A {}

conformance A: P { public typealias X = Int }
conformance A: Q { public typealias X = Bool }
extension A {
  fun foo() -> Self::P.X { 0 }
  fun bar() -> (Self as any P).X { 0 }
}

Once name resolution is done, the type of A.foo is [{self: remote let A}] () -> Int.

I am not sure whether it should be possible to type A.bar . If it is, then its type must probably be something like [{self: remote let A}] () -> any Copyable. That's because (any P).X is any type that satisfies the constraints on P.X.

[kyouko-taiga]

Sorry, I got confused. Self is a type, not a value. That's why you wrote P.Type.

Well, then it should be MetaType<any P> (which is Val's way of saying P.Type). A as MetaType<any P> would express the meta type of an existential, though, the result would still be any Copyable.