A method's return type is always inferred by the compiler. However, you might want to specify it for two reasons:
def some_method : String "hello" end
The return type follows the type grammar.
Marking a method as returning
Nil will make it return
nil regardless of what it actually returns:
def some_method : Nil 1 + 2 end some_method # => nil
This is useful for two reasons:
nilwithout needing to add an extra
nilat the end, or at every return point
These methods usually imply a side effect.
Void is the same, but
Nil is more idiomatic:
Void is preferred in C bindings.
Some expressions won't return to the current scope and therefore have no return type. This is expressed as the special return type
Typical examples for non-returning methods and keywords are
This is for example useful for deconstructing union types:
string = STDIN.gets typeof(string) # => String? typeof(raise "Empty input") # => NoReturn typeof(string || raise "Empty input") # => String
The compiler recognizes that in case
Nil, the right hand side of the expression
string || raise will be evaluated. Since
typeof(raise "Empty input") is
NoReturn the execution would not return to the current scope in that case. That leaves only
String as resulting type of the expression.
Every expression whose code paths all result in
NoReturn will be
NoReturn as well.
NoReturn does not show up in a union type because it would essentially be included in every expression's type. It is only used when an expression will never return to the current scope.
NoReturn can be explicitly set as return type of a method or function definition but will usually be inferred by the compiler.
To the extent possible under law, the persons who contributed to this workhave waived
all copyright and related or neighboring rights to this workby associating CC0 with it.