Austin Ziegler wrote:
>    def some_method(String param1) => Fixnum; end
>    def some_method(Array param1) => Fixnum; end

Also, note that this kind of signature is quite common in the standard 
library (e.g., the RDoc for String#slice[1]).  As part of the 
Diamondback Ruby project, we annotated the "core library" with static 
type annotations, using syntax inspired by the RDoc comments.  To 
annotate these kinds of methods, we simply listed all of the valid 
signatures before the method definition, but use some syntactic 
shortcuts.  For instance, while RDoc lists 6 variants for String#slice, 
we use only 3 since we can group some using 'or':

   # slice : Fixnum -> Fixnum
   # slice : (Fixnum or Regexp, Fixnum) -> String
   # slice : Range or Regexp or String -> String
   def slice ...

Of the 1055 methods we annotated, 129 of them required multi-line 
annotations.  So putting the annotation inside of the method signature 
may not be a good idea with this style of method being so common.

> Add to this that whether it's "static typing" or not, there's a lot of
> stupid programmers out there who will think that it is and tend to avoid
> great ideas like duck-typing and object extensibility. They'll see your
> definition of #some_method and say "oh, it needs to be a string" and do
> something stupid like:

These kinds of annotations already exist in a more ad-hoc way inside of 
RDoc comments.  The fact that they sometimes mention "String" instead of 
"any object with a to_str method" does not mean people litter their code 
with calls to foo.to_str().  I just don't see any evidence of people 
writing the kind of code you presented.

-Mike

[1] - http://www.ruby-doc.org/core/classes/String.html#M000858