How to Declare Types in Ruby

Is it possible to declare types in Ruby?

Some languages as C or Java use “strong” or “static” variable typing. Ruby is a “dynamically typed” language aka "duck typing", which means that variable dynamically changes its own type when type of assigned data has changed.

So, you can't declare variable to some strict type, it will always be dynamic.

Determining type of an object in ruby

The proper way to determine the "type" of an object, which is a wobbly term in the Ruby world, is to call object.class.

Since classes can inherit from other classes, if you want to determine if an object is "of a particular type" you might call object.is_a?(ClassName) to see if object is of type ClassName or derived from it.

Normally type checking is not done in Ruby, but instead objects are assessed based on their ability to respond to particular methods, commonly called "Duck typing". In other words, if it responds to the methods you want, there's no reason to be particular about the type.

For example, object.is_a?(String) is too rigid since another class might implement methods that convert it into a string, or make it behave identically to how String behaves. object.respond_to?(:to_s) would be a better way to test that the object in question does what you want.

how to initialize a variable to the type double in ruby

If at least one of the operands is a float, the result will be a float too.

5 / 2.0 # => 2.5

How to declare array of a particular type in ruby documentor?

class TheClass
  # @param items   [Array]
  # @param filters [Array<Filter>]
  # @return        [Array<TheClass>]
  def filter(items, filters); end
end

As documented YARD Tags.

How to declare 8-bit unsigned integer in ruby?

Ruby abstracts away the internal storage of integers, so you don't have to worry about it.

If you assign an integer to a variable, Ruby will deal with the internals, allocating memory when needed. Smaller integers are of type Fixnum (stored in a single word), larger integers are of type Bignum.

a = 64
a.class  #=> Fixnum; stored in a single word
a += 1234567890
a.class  #=> Bignum; stored in more than a single word

Ruby is dynamically typed, so you cannot force a variable to contain only unsigned 8-bit integers (just as you cannot force a variable to only contain string values, etc.).

ruby explicit method return types

Update 2019: still no static typing or type annotations built into ruby, but we now have 3rd party type checkers. See this answer for more details.

Java performs static type checks. It ensures at compile time that all type requirements are met. Ruby is more dynamic, it doesn't do compile time checks and its type system is often referred to as "duck typing". That is, "If it walks like a duck and quacks like a duck, then it must be a duck".

If a method expects an object that responds to certain messages (has certain methods), then it doesn't care about actual type of the object as long it conforms to the protocol. If this is backed up by good test suite, then it's (arguably) a better way, because it allows for faster prototyping and reduced visual clutter. Less visual clutter - code is more expressive and understandable. Benefits of that are obvious. :)

How do I only allow an argument in a Ruby function to be a certain type?

You can't do def function(Array arg) like in other languages, but you can replace four lines of your second snippet by a single one:

def function(arg)
  raise TypeError unless arg.is_a? Array
  # code...
end