Issue #9999 has been updated by Alexey Babich.

Subject changed from Type Annotations to Type Annotations (Static Type Checking)

**For usage level**:
Static type checking looks most useful as syntax pre-compilation feature to speed-up code execution and
code/syntax verification-before-execution improvements

**For syntax**:
Current syntax (e.g. 2.3*) shows that the most compatible syntax is

~~~ruby
def ReturnType method(Type value: default, ...)
~~~

Also, we can have some simplified syntax for known defaults, e.g.

~~~ruby
def method(count: 0!)
~~~

where "exclamation mark" means that type of default value is for Static type definition

~~~ruby
>> 0.class
=> Fixnum
~~~

like equivalent to

~~~ruby
def method(Fixnum count: 0)
~~~

**For type definition**:
It looks natural to stick with existing class definitions, not to redefine understanding of "type"
ruby should consider which classes can be optimised and how internally with some clear documentation about this

**For value of the feature**
It will be really nice to see some *experimental* implementations in `2.5` or even in `2.4` depending on priorities of core team
to make it possible to try, benchmark and improve far before `ruby 3`

----------------------------------------
Feature #9999: Type Annotations (Static Type Checking)
https://bugs.ruby-lang.org/issues/9999#change-58453

* 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 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 except the link posted.



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

Unsubscribe: <mailto:ruby-core-request / ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>