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

I rewrote it a bit, but let me know if it would be better to move this until after the Box example.

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 impl s. 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 impl s, 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 impl s would then be implementing the same fallback semantics for Ref(T) .

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.

Sorry, I had not understood what you were proposing (that you can't get a reference expression, but can get a Ref(T) value that acts like one). I've made these changes, added the additional support for calls on Ref(T) values, and moved this section to future work, as discussed in open discussion on 05-16 .

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

Sorry, I had not understood what you were proposing (that you can't get a reference expression, but can get a Ref(T) value that acts like one). I've made these changes, added the additional support for calls on Ref(T) values, and moved this section to future work, as discussed in open discussion on 05-16 .

I rewrote it a bit, but let me know if it would be better to move this until after the Box example.