extend api

[josh11b]

Allow types to extend api other types, adding the names from the other type to its namespace, for forwarding and delegation use cases.

[zygoloid]

This would be easier to follow if it appeared after the Box example below or had a link to that example.

[zygoloid]

Exploring these myself:

// <Ref(T) value>.<ref bindable> produces a Ref(R) value expression.
impl forall [T:! type, U:! RefBind(T)]
    U as ValueBind(Ref(T)) where .Result = Ref(U.Result) {
  fn Op[self: Self](p: Ref(T)) -> Result {
    return {.ptr = self.Op(p->ptr)};
  }
}

// <Ref(T) ref expr>.<ref bindable> produces a reference expression.
// Reference collapse: no added Ref(...) here.
impl forall [T:! type, U:! RefBind(T)]
    U as RefBind(Ref(T)) where .Result = U.Result {
  fn Op[self: Self](p: Ref(T)*) -> Result* {
    return self.Op(p->ptr);
  }
}

// <Ref(T) value>.<value bindable> produces a value expression.
// A value binding is performed to turn the Ref(T) into a T.
impl forall [T:! type, U:! ValueBind(T)]
    U as ValueBind(Ref(T)) where .Result = U.Result {
  fn Op[self: Self](p: Ref(T)) -> Result {
    return self.Op(*p.ptr);
  }
}

I think implementing U as RefBind(Ref(T)) in terms of U as ValueBind(T) is not possible. We can't produce a pointer as a result of the binding.

There's also overlap between the first and third impls. And the first and second violate the new coherence rule in #3720: given ref: Ref({.n: i32}), ref.n will either be a value expression of type Ref(i32) or a reference expression of type i32 depending on the expression category of ref.

I think maybe the right thing to do is to drop the second impl entirely, and have only two impls, both for ValueBind, with a match_first:

match_first {

// <Ref(T) value>.<ref bindable> produces a value expression of type `Ref(R)`.
impl forall [T:! type, U:! RefBind(T)]
    U as ValueBind(Ref(T)) where .Result = Ref(U.Result) {
  fn Op[self: Self](p: Ref(T)) -> Result {
    return {.ptr = self.Op(p->ptr)};
  }
}

// <Ref(T) value>.<value bindable> produces a value expression of type `R`.
// A value binding is performed to turn the Ref(T) into a T.
impl forall [T:! type, U:! ValueBind(T)]
    U as ValueBind(Ref(T)) where .Result = U.Result {
  fn Op[self: Self](p: Ref(T)) -> Result {
    return self.Op(*p.ptr);
  }
}

}

For this to really work, I think we'd need binding to fall back from RefBind to ValueBind if reference binding isn't possible, as discussed in #3720. The above pair of impls would then be implementing the same fallback semantics for Ref(T).

[josh11b]

I don't think this works. #3720 only ever produces a reference expression (by automatically dereferencing the returned pointer) when the expression on the left side of the . is a reference expression. I think this makes Ref(T) impossible, and I should probably delete this section.

[zygoloid]

Note to self: I'm parking this review here while looking at other things.