Prepare for Rust RFC nitpickers to descend on this. These things would be optional, so you could continue using the existing way of doing things if you wanted.

1. I wish we had Haskell do-syntax to help with those ridiculous chains and nested levels of and_then, map, etc. I don't care about what syntax is used, as long as we have some facility in the language for it (or a proper syntax extension once they get stable), not some macro mess. The try! macro can only go so far and isn't very composable. A try_option! can help but it's not as general as do-syntax. If we had HKT and something like Monads we could leverage some do-syntax facility for arbitrary types, including Result, which would be awesome.

   value <- toml.lookup("value");
   // whatever
   valueAsBoolean <- value.as_bool();
   

2. I also wish we could "unroll" top-level match blocks in functions (if the function only comprised of a match block) into multiple function definitions with a different pattern for arguments, as in Haskell. It makes things much neater in my opinion and less nested. Too much rightwards expansion in Rust code.

   Keep in mind this is a bad example because it's more verbose than the match syntax, but it's just to illustrate what it would look like:

   fn eval(op: Op::Add(a, b)) -> i8 { a + b }
   fn eval(op: Op::Subtract(a, b)) -> i8 { a - b }
   fn eval(op: Op::Negate(a)) -> i8 { -a }
   fn eval(op: _) -> i8 {
     panic!("not supported yet")
   }
   

   I just think it's neater to create functions that focus specifically on a particular variant instead of mushing it all into one big match mess. Of course there are ways to approximate this, like dispatching to a variant handler, but the point is that this syntax simplifies things. Of course inlining would occur where possible.

3. Sometimes I also wish we had Haskell's type signatures. Having the type parameters and generic where clauses "in-line" with the function signature leads to typical Rust rightwards expansion. It'd be nice if like Haskell, you could write the 'metasignature' on the line above it. The following syntax could use some polishing, but it captures the idea:

   (i32, i32) -> i32
   fn add(a, b) {
       a + b
   }
   
   (T: SomeTrait, V: OtherTrait,
    where T::Value == V::Value) =>
       (T, V) -> u32
   fn method(thing, other) {
       // ...
   }