No Method Overloading in Ruby

In Ruby there is no concept of method overloading. One method can have different names but two different method cannot have same names even if the number of arguments are same.

	class Foo
	def some_method(agr1, arg2)
	puts "A method with two arguments"
	end
	def some_method
	puts "A method with no arguments"
	end
	end
	obj = Foo.new
	obj.some_method #=> "A method with no arguments"
	obj.some_method("hello", "world") #=> `some_method': wrong number of arguments (2 for 0) (ArgumentError)

view raw overloading.rb hosted with ❤ by GitHub

The second method overrides the first and hence there is no existence of the first method with arguments.

In fact, there is no need of method overloading in Ruby. Apparently, method overloading is required for two reasons.
First, methods with same name and accepting different number of arguments.
Second, methods with same name and accepting same number of arguments but different data types.

Both of the above two requirements can be achieved in Ruby.
First, as Ruby method arguments can be declared with default values and hence these arguments can be omitted on method invocation.
Second, as Ruby methods can accept arguments of any class.

Singleton class. Singleton method Vs Class method.

Every object is associated with two classes. One is which we can get using class method of object(eg: "hello".class) and the other is called the eigenclass(or singleton class).

The singleton methods of an object are the instance methods of the anonymous eigenclass associated with that object.

To open up an singleton class of an object str, use class << str

Eg:

	str = "hello world"
	class << str #open singleton class
	def m1
	puts "singleton method m1 of object str"
	end
	end
	str.singleton_class.instance_methods.include?(:m1) # =>true

view raw singleton.rb hosted with ❤ by GitHub

 Thus, singleton class is an anonymous class associated with every object.


A method added to a single object rather than to a class of objects is known as singleton method. Also the class methods on a class are nothing more than singleton methods on the Class instance that represent that class.

Eg:

	class Foo
	end
	f = Foo.new
	def f.print_smth #singleton method
	puts "hello world"
	end
	f.print_smth # => hello world
	f1 = Foo.new
	f1.print_smth # error : undefined method

view raw singleton.rb hosted with ❤ by GitHub

On the other hand, class methods are invoked only through the constant refering to the Class object.

Eg:

	class Bar # Bar is Class instance
	def self.hello # class method created using self. Also singleton method of Bar
	puts "hello"
	end
	def Bar.world # class method created using class name. Also singleton method of Bar
	puts "world"
	end
	end
	Bar.hello # => hello
	Bar.world # => world

view raw singleton.rb hosted with ❤ by GitHub

   

Rails 3.0 Active Record -- Polymorphic association

Note: If you are clear with the concept of polymorphic association then you should read this article.

There is one drawback with polymorphic association which you might have faced while creating associations between models . The drawback is that activerecord allows only polymorphic ends to query the association. Lets say we have the following scenario.


Models we have

	class Teacher
	has_many :course_memberships, :as => :takeable
	has_many :courses, :through => :course_memberships
	end
	class Student
	has_many :course_memberships, :as => :takable
	has_many :courses, :through => :course_memberships
	end
	class CourseMembership
	belongs_to :course
	belongs_to :takable, :polymorphic => true
	end
	class Course #note this model is not the polymorhic end
	has_many :course_memberships
	has_many :teachers, :through => :course_memberships
	has_many :students, :through => :course_memberships
	end

view raw polymorphic.rb hosted with ❤ by GitHub

we can find courses which teacher and student has taken up


The above two statements works perfectly fine.

But what if we want to know all teachers or students who have taken up a particular course. Let say we query



The above two statements would throw error.

Lets see the course_memberships table


When we execute Course.first.teachers, ActiveRecord searches for teacher association in the CourseMembership model but it belongs_to :takable, not :teacher. Hence ActiveRecord throws error.
This can be solved through multiple solutions.

Solution 1:

Here is simple hack for this.


Now the non-polymorphic end query would work i.e. Course.first.teachers and Course.first.students. I just added a teacher and student association in CourseMembership and a condition in Course model.

Solution 2:

We can also solve this problem by defining teachers and students method in Course model but in this case we need to query N+ 1 times to get the result which would lower the performance.
N: number of teachers or students


Solution 3:

we can use includes method, its pretty cool as it takes the whole wad of data at one go from the database and eliminates N+1 query problem.
Here we are using secong degree association, hence we need to pass an hash with array as the value.

The slight problem with this solution is the query end up returning a lot of data to be converted into    ActiveRecord objects. Also if there are lot of rows in parent table, preloading will consume a lot of server memory.