Section 1.7. Conclusion

But I think the principle is more general than that. For example, when a hash is passed as the last or lone parameter, the braces may be omitted. At the end of a line, the semicolon may be omitted (and really always is). In most cases, the keyword then may be omitted, whether in if statements or case statements.

Some coders even go so far as to omit parentheses in a method definition, though most do not:

def my_method(a, b, c)  # Also legal:  def my_method a, b, c
  # ...
end

It is worth noting that in some cases, the complexity of the Ruby grammar causes the parser to be confused easily. When method calls are nested, it is better to use parentheses for clarity. In some cases, warnings are printed in current versions of Ruby:

def alpha(x)
  x*2
end

def beta(y)
  y*3
end

gamma = 5
delta = alpha beta gamma  # 30 -- same as alpha(beta(gamma))
# Produces warning:
# warning: parenthesize argument(s) for future version

The term duck typing , as far as I can tell, originated with Dave Thomas. It refers to the old saying that if something looks like a duck, walks like a duck, and quacks like a duck, it might as well be a duck. Exactly what this term means may be open to discussion; I would say that it refers to the tendency of Ruby to be less concerned with the class of an object and more concerned with what methods can be called on it and what operations can be performed on it. Thus in Ruby we rarely use is_a? or kind_of , but we might more often use respond_to? . Most often of all, we might simply pass an object to a method and know that an exception will be raised if it is used inappropriately. This usually happens sooner rather than later.

The unary asterisk that is used to expand an array could be called an array expansion operator, but I don't think I have ever heard that. Terms such as star and splat are inevitable in hacker circles along with derivatives such as splatted and unsplatted . David Alan Black cleverly calls this the unary unarray operator.

The term singleton is sometimes regarded as overused . It is useful to remember that this is a perfectly good English word in its own rightreferring to a thing that is solitary or unique. As long as we use it as a modifier, there should be no confusion.

The Singleton Pattern is a well-known design pattern in which a class allows itself to be instantiated only once; the singleton library in Ruby facilitates the use of this pattern.

A singleton class in Ruby is the classlike entity where methods are stored that are per-object rather than per-class. It is arguably not a "true class" because it cannot be instantiated. The following is an example of opening up the singleton class for a string object and adding a method:

str = "hello"
class << str                   # Alternatively:
  def hyphenated               # def str.hyphenated
    self.split("").join("-")
  end
end

str.hyphenated                 # "h-e-l-l-o"

Some have started to use the term eigenclass for this, derived from the German eigen ("its own"), and corresponding to terms from math and physics such as eigenvalue . This is clever, but this usage is not communitywide, and some people hate it.

Let's go back to our previous example. Because the method hyphenate exists in no other object or class, it is a singleton method on that object. This also is unambiguous. Sometimes the object itself will be called a singleton because it is one of a kindit is the only object that has that method.

But remember that in Ruby, a class is itself an object. Thus we can add a method to the singleton class of a class , and that method will be unique to that object, which happens to be a class. Here is an example:

class MyClass
  class << self                  # Alternatively: def self.hello
    def hello                    # or: def MyClass.hello
      puts "Hello from #{self}!"
    end
  end
end

So we don't have to instantiate MyClass to call this method.

MyClass.hello                    # Hello from MyClass!

But you will notice that this is simply what we call a class method in Ruby. In other words, a class method is a singleton method on a class. We could also say it's a singleton method on an object that happens to be a class.

There are a couple more terms to cover. A class variable is one that starts with a double- @ , of course; it is perhaps a slight misnomer because of its nontrivial behavior with regard to inheritance. A class instance variable is a somewhat different animal. It is an ordinary instance variable where the object it belongs to happens to be a class. For more information, see Chapter 11, "OOP and Dynamic Features in Ruby."