Issue #9999 has been updated by Micha Muskaa.


I think it would be quite interesting to see how other dynamic languages deal with types. I'm not sure adding runtime checks is the way to go - it adds overhead and complicates the runtime, and in my mind static typing has a purpose of speeding things up, and reducing method lookup overhead. Or at least leaving the thinks at the speed they were, but extending program's safety.

I think a good way to introduce type checks is through a separate process that will analyse the code. One example of such a system is Erlang's dialyzer.
It works using a mechanism they call "Success typing". At the beginning thesystem assumes every function accepts all types and can return any type. Later through analysis of the code it learns how you use the functions and warns you if it ever finds some contradictions (you can read more about it here: http://learnyousomeerlang.com/dialyzer).
It's purpose is not to guarantee 100% type safety, but to catch majority ofthe problems.
There's also a syntax for providing dialyzer with hints about function signature. In Ruby's case using existing YARD types or producing some additional simple syntax could be a way to go, for example:
```ruby
#spec (Integer, Integer) :: Integer
def add(x, y)
  x + y
end
```
This syntax has also the great advantage of being backwards compatible (as for older rubies it's just a comment).

----------------------------------------
Feature #9999: Type Annotations
https://bugs.ruby-lang.org/issues/9999#change-51914

* Author: Davide D'Agostino
* Status: Assigned
* Priority: Normal
* Assignee: Yukihiro Matsumoto
----------------------------------------
Hi all,

I know @matz is interested in introducing **type annotations** in ruby. More here: https://bugs.ruby-lang.org/issues/5583

I think it's time for ruby to get this.

Before working on a patch I would like to know:

1. Syntax of methods signatures
2. Syntax of variables guards (?)
3. Implementation

For point **1** I was thinking in some like:

~~~ruby
def connect(r -> Stream, c -> Client) ->  Fiber
def connect(Stream r, Client c) -> Fiber # quite sure this will make some reduce problems in the grammar
~~~

Before making a proposal consider: keyword arguments and default value collisions.

Then for point **2** I'm not sure if we want also check assignments but as before a syntax could be:

~~~ruby
r: Client = something # will throw an exception if something is not kind of Client
~~~

Finally, **implementation**. Do we want some in python style and then leavethe programmer/library for the implementation **or** (and I'm for this) wewant MRI do that, if so how?

Cheers!
DD

p.s. Sorry if this issue was already discussed but I didn't find anything except the link posted.



-- 
https://bugs.ruby-lang.org/