Hacker News Reader

Comment by Arnavion | Hacker News Reader

A lot of `expr.expr` would need to become `(&expr).expr` or `(&mut expr).expr` if auto-dereferencing wasn't a thing. C++ has `.` and `->` but Rust only has `.`

(To be clear, what's happening with `array.into_iter()` is unsize coercion, not auto-dereferencing. `[T; N]` does not impl `Deref<Target = [T]>`. But the point is the same.)

View on HN

I think you have it reversed. `expr.expr` would need to become `(*expr).expr` if we didn't have auto-dereferencing.

    struct S;

    impl S {
        fn foo(&self) { }
    }

    let s = S;
    s.foo();

That compiles today. Your proposal would require it to be `(&s).foo()`

In other words, there is auto-ref in addition to auto-deref, and auto-ref causes the same issues of possibly-surprising method resolution. As I mention above, auto-deref is just one way that methods could resolve to the "wrong" implementation, and there would be no solution that I can see other than to remove dot entirely, which isn't viable.

No, IIUC, the sematics is (approximately):

  a.foo(b,c);
  vvvv
  typeof(a)::foo (??? a,b,c);
  vvvv
  A::foo /* takes &A */ (/*so this is:*/& a,b,c);
  vvvv
  A::foo(&a,b,c);

Auto-derefencing is:

  a.foo(b,c)
  vvvv // a is &X, so replace it with (*a)
  (*a).foo(b,c) // wrong; should be a.foo(b,c); we called
  vvvv  // a method on the pointer, not what it points to
  X::foo(???(*a),b,c) // should be A::foo(???a,b,c)
  // continue as above

Auto-derefencing changes which type the method is looked up relative to, not just how the object is passed to it.

Yes yes, there's auto-ref, auto-deref, deref coercion, unsize coercion, ... All of them are forms of "`lhs.rhs` tries to look up a different type to apply the `rhs` to vs what type `lhs` actually has," or more generally "I wrote an expr of type T but the compiler treats it as an expr of type U for :reasons:"

I called it "auto-dereferencing" because that's what OP used when talking about `[].into_iter()`, and then clarified that it's actually an unsize coercion, not auto-deref.

> All of them are forms of "`lhs.rhs` tries to look up a different type to apply the `rhs` to vs what type `lhs` actually has,"

Nope, it uses the same type (A), just blindly adds a operator to the argument based on which method is called. You could just as easily have `a.foo()` -> `A::foo(++a)` instead; it's just[0] that adding `++` would be largely useless.

0: You'd also need a explict annotation on the declaration of foo, but that's a convenience issue.

What if borrow and deref were postfix operators? E.g expr&.expr? That way it would be explicit without parenthesis soup.

People already complain rust is too punctuation heavy; I can already read the “this is Perl!” comments on this very website.

EDIT: hilariously exactly this happened three minutes after my post…

Reply on news.ycombinator.com