λ ~/programming/rust/experiments/ master cargo run
   Compiling experiments v0.1.0 (file:///home/orlp/programming/rust/experiments)
error[E0282]: type annotations needed
 --> src/main.rs:2:6
  |
2 |     |n| println!("{}", n);
  |      ^ consider giving this closure parameter a type

use std::ops::Mul;
fn f<T: Mul<T>>(x: T) -> T { x * x + x }

error[E0369]: binary operation `+` cannot be applied to type `<T as std::ops::Mul>::Output`
 --> src/main.rs:2:30
  |
2 | fn f<T: Mul<T>>(x: T) -> T { x * x + x }
  |                              ^^^^^^^^^
  |
  = note: an implementation of `std::ops::Add` might be missing for `<T as std::ops::Mul>::Output`

    func erroringFunc() -> Int throws {
        // ... some condition
        if something {
            throw some error
        } else {
            return 4
        }
    }

    // for propogating error
    func anotherFunc() -> Int throws {
        return try erroringFunc()
    }

    // Now to handle
    guard let value = try? anotherFunc() else {
         // handle error once at the top
    }

    // use variable safely here.

try JSONError.parseError(let errorMessage) = JSON(string: myJson) {
     print("oh no! could not parse your json: #{errorMessage}")
}

     func erroringFunc() -> Int? {
            // ... some condition
            if something {
                return null
            } else {
                return 4
            }
        }

        // for propogating error
        func anotherFunc() -> Int? {
            return erroringFunc()
        }

        // Now to handle
        let value = anotherFunc()?: 4


        // use variable safely here.

someFunc() //Does a throws go here? {
    try? throwsOnlyFileOpenError() catch FileOpenError
}