[ruby-core:68602] [Ruby trunk - Feature #9999] Type Annotations

Issue #9999 has been updated by Micha=C5=82 Muska=C5=82a.


I think it would be quite interesting to see how other dynamic languages de=
al with types. I'm not sure adding runtime checks is the way to go - it add=
s 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 l=
east leaving the thinks at the speed they were, but extending program's saf=
ety.

I think a good way to introduce type checks is through a separate process t=
hat will analyse the code. One example of such a system is Erlang's dialyze=
r.
It works using a mechanism they call "Success typing". At the beginning the=
 system assumes every function accepts all types and can return any type. L=
ater through analysis of the code it learns how you use the functions and w=
arns you if it ever finds some contradictions (you can read more about it h=
ere: http://learnyousomeerlang.com/dialyzer).
It's purpose is not to guarantee 100% type safety, but to catch majority of=
 the problems.
There's also a syntax for providing dialyzer with hints about function sign=
ature. In Ruby's case using existing YARD types or producing some additiona=
l 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. Mor=
e 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 r=
educe problems in the grammar
~~~

Before making a proposal consider: keyword arguments and default value coll=
isions.

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

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

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

Cheers!
DD

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



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