Rip infers all types, but sometimes it helps to clearly describe what is expected. For this Rip allows specifying the types of some or all parameters for some or all overloads (type restrictions in Rip's parlance). In the absence of a type restriction, Rip allows any type and relies on duck-typing.

One of the initial goals for Rip was to have as little variation in the syntax as possible. A consequence of this was that all block expressions (types, lambdas, conditionals) followed the same pattern of keyword >> arguments/parameters >> body. Back then there was no syntax to restrict the types of certain parameters. There was also no way to specify an overload's return type.

However this pattern conflates arguments with visually-similar-but-actually-very-different parameters, so Rip's overload syntax is changing. Also the old syntax doesn't allow any place for a return type, which may be desired in some cases. This change also make room for generic types, which are being considered.

These changes will be coming in a future release of Rip, likely v0.3.0.

```language-rip foo = => { -> (a, b) { self(a, b, b) } -> (a, b, c) { a + b + c } } ```
Old syntax: Optional type restrictions may be specified for parameters
```language-rip foo = => { (a, b) -> System.Rational { self(a, b, b) } (a, b, c) -> System.Rational { a + b + c } } ```
New syntax: Move overload's (still optional) parameters in front of the dash rocket keyword (->). A concrete type may be added after parameters to signify the overload's return type