Hacker News new | past | comments | ask | show | jobs | submit login

    fun read(path: &Path): io.Result[Vec[UInt8] {
      var file = File.open(path).orReturnErr()
      var bytes = Vec.new()
      file.readToEnd(&mut bytes).orReturnErr()
      Ok(bytes)
    }
would be good enough for me, tbh.



> File.open(path).orReturnErr()

Method syntax is reserved for functions. There are no method syntax macros. Since a return in a function terminates execution of this function, and not its caller, your example would not work.


Right, so this should really be .orReturnErr , by analogy with .await . We just overload the dot symbol to mean both "method call" and "weird monadic stuff is happening here".


Exactly. ! for macros was a mistake anyway, I guess that's why they stopped using it with await.


It wasn't. Without "!" it isn't obvious that you cannot take a:

  let a: Result<u8, u8> = /* whatever *;
  let b = match a {
      Ok(v) => Ok(foo(v)),
      e => e,
  };
and transform it into:

  let a: Result<u8, u8> = /* whatever *;
  let b = a.map(foo);
if "foo" is a macro. When you substitute "foo!" for all the "foo" above, it is obvious.


Perhaps macros shouldn't do things that aren't "obvious" then?


As a rule, rust rejects the "simpler" choice that instead lay the burden of correctness at the feet of the user. I'm glad they keep a hard line here.


> I guess that's why they stopped using it with await

await cannot be a macro, it has to be built into the language, and so it doesn't have the ! because it's not one.


You realize the syntax has changed more than that?


Yes, but "->" vs ":", or kinds of brackets are superficial, while method syntax has a specific meaning.


These differences are mostly superficial. We all need to decide if we're going to avoid a language because its punctuation choices aren't "good enough" for us or if we're going to choose the best tools for building useful systems.

"orReturnErr()" seems quite against the Rust philosophy though — refusing the method call syntax for early return means folks can easily miss something important. Rust uses ? for error handling, ! for macros, and keywords (with no parenthesis) for other control flow. I prefer it that way.




Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: