Issue #9999 has been updated by Alexey Babich.


Nobuyoshi Nakada wrote:
> Alexey Babich wrote:
> > ~~~ruby
> > def ReturnType method(Type value: default, ...)
> > ~~~
> 
> How to know if it doesn't define a method `ReturnType`?

As I know, currently syntax like

~~~ruby
def B a(...); end
~~~

is not possible and raises smth like

~~~ruby
SyntaxError: (irb):11: syntax error, unexpected '(', expecting ';' or '\n'
~~~~

The same time

~~~ruby
def B a; end
~~~

is ok, so my suggestion is not great for return type

The same time it looks weird if we can define

~~~ruby
Class var: value
~~~

where value can be virtually kind of another Class, incl. `nil` (`NilClass`) value

Do some *whitelisting* for some classes like `NilClass` make the idea overcomplicated
it makes reasonable to do only simplified syntax

~~~ruby
def method(var: value!)
~~~

the same time definition for method like

~~~ruby
def method: value
~~~

makes no sense in Ruby unless it is reasonable to introduce default return value for empty `return` statement


Also, I think syntax question is not the most important here

Thanks!



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

* 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>