[cutler]

Right, so why not implement the sig as a block and keep the syntax concise - the Ruby Way.

[bhuga]

The sigs are implemented as blocks.

We had them as hashes for a while, but it meant that code in all sigs was loaded as the code was loaded, even if runtime typechecking was disabled. We were forced to load all constants in any signature in a file, an effect which cascades quickly. It had a big impact on the dev-edit-test loop.

For example, if we're testing `method1` on `Foo`, but `method2` has a sig that references `Bar`, we'd have to load `Bar` to run a test against `method1`.

Now sigs are blocks and lazy, and we pay that load penalty the first time the method is called and a typecheck is performed.

[mnarayan01]

Then you'd need an extra set of delimiters, e.g.:

  sig {{name: String, returns: Integer}}

[BenMorganIO]

But that would make the hash braces redundant so you could just use parenthesis.

[mnarayan01]

That's a block returning a Hash; see bhuga's sibling comment where he notes that they're using blocks to lazy load the constants in the type definition, which may seem silly for e.g. Integer, but consider e.g. some high-dependency Rails model which requires auto-loading 10,000 other classes.