Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T23:24:49Z

Ssreepa: /* Proc.new */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures <ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref>help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a} #define lambda proc
end

def add(a)
@block.call a #call proc object
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new<ref>[http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/ Proc and Lamda]</ref> takes in a block and returns a Proc object which will run the code in the block when call method is invoked. In Proc.new created proc the return control is from the method enclosing the Proc.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method.In a lambda created proc, the return statement returns only from the proc itself. This is the difference from the Proc.new created proc.
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for the addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2] #original addition function add

curried_add = add.curry #curried function curried_add
add_to_ten = curried_add[10] #only 1 number specified to curried function curried_add, by fixing one of the input values
add_to_twenty = curried_add[20] #thus the curried function always adds 10 and 20 to the second number when we use it with
#add_to_ten and add_to_twenty respectively

puts add_to_ten[5] #adding second number 5 to the fixed value of 10
puts add_to_twenty[5] #adding second number 5 to the fixed value of 20
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class<ref>[http://phrogz.net/programmingruby/tut_classes.html Ruby Classes]</ref> methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock #BookInStock is a class name
def initialize(isbn, price) #initialize is used to initialize instance variables
@isbn = isbn #@isbn and @price are instance variables
@price = Float(price)
end
def self.book #self denotes class method
puts “Class method”
end
end

class ParkingLot
def initialize(n)
@spotsAvailable = n #initialize the variable
end
def park
puts "Park your car"
@spotsAvailable = @spotsAvailable - 1 #decrement the number of available slots
end
def unpark
puts "Unpark your car"
@spotsAvailable = @spotsAvailable + 1 #increment the available slots
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. There is another example of class ParkingLot which has two methods defined, park and unpark. It maintains the number of available spots in the ParkingLot. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor<ref>[http://www.rubyist.net/~slagell/ruby/accessors.html Accessors]</ref>.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title #getter method
attr_writer :price #setter method
attr_accessor : isbn #getter and setter methods
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of [http://download.oracle.com/javase/tutorial/java/IandI/abstract.html abstract methods]. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented") #raise indicates exception
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing<ref>[http://rubylearning.com/satishtalim/duck_typing.html Duck Typing]</ref>. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing]in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.tutorialspoint.com/ruby/ruby_classes.htm Ruby Classes]
*[http://rubysource.com/ruby-mixins-2/ Ruby Inheritance]
*[http://pragdave.blogs.pragprog.com/pragdave/2008/09/fun-with-procs.html Ruby Procs]
*[http://moonbase.rydia.net/mental/blog/programming/currying-in-ruby Currying]
*[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Procs, Blocks and Lambdas]
*[http://moonmaster9000.tumblr.com/post/477872071/class-variables-and-inheritance-in-ruby Class variables and Inheritance]
*[http://blog.rubybestpractices.com/posts/gregory/047-issue-15-duck-typing-2.html Best Practices]
*[http://rubysource.com/making-ruby-quack%E2%80%94why-we-love-duck-typing/ Duck Typing]

=Further reading=
* Programming Ruby, The Pragmatic Programmer's Guide by Dave Thomas
* Design Java by Dale Skrien

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T23:23:37Z

Ssreepa: /* Class */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures <ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref>help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a} #define lambda proc
end

def add(a)
@block.call a #call proc object
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new<ref>[http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/ proc and Lamda]</ref> takes in a block and returns a Proc object which will run the code in the block when call method is invoked. In Proc.new created proc the return control is from the method enclosing the Proc.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method.In a lambda created proc, the return statement returns only from the proc itself. This is the difference from the Proc.new created proc.
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for the addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2] #original addition function add

curried_add = add.curry #curried function curried_add
add_to_ten = curried_add[10] #only 1 number specified to curried function curried_add, by fixing one of the input values
add_to_twenty = curried_add[20] #thus the curried function always adds 10 and 20 to the second number when we use it with
#add_to_ten and add_to_twenty respectively

puts add_to_ten[5] #adding second number 5 to the fixed value of 10
puts add_to_twenty[5] #adding second number 5 to the fixed value of 20
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class<ref>[http://phrogz.net/programmingruby/tut_classes.html Ruby Classes]</ref> methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock #BookInStock is a class name
def initialize(isbn, price) #initialize is used to initialize instance variables
@isbn = isbn #@isbn and @price are instance variables
@price = Float(price)
end
def self.book #self denotes class method
puts “Class method”
end
end

class ParkingLot
def initialize(n)
@spotsAvailable = n #initialize the variable
end
def park
puts "Park your car"
@spotsAvailable = @spotsAvailable - 1 #decrement the number of available slots
end
def unpark
puts "Unpark your car"
@spotsAvailable = @spotsAvailable + 1 #increment the available slots
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. There is another example of class ParkingLot which has two methods defined, park and unpark. It maintains the number of available spots in the ParkingLot. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor<ref>[http://www.rubyist.net/~slagell/ruby/accessors.html Accessors]</ref>.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title #getter method
attr_writer :price #setter method
attr_accessor : isbn #getter and setter methods
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of [http://download.oracle.com/javase/tutorial/java/IandI/abstract.html abstract methods]. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented") #raise indicates exception
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing<ref>[http://rubylearning.com/satishtalim/duck_typing.html Duck Typing]</ref>. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing]in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.tutorialspoint.com/ruby/ruby_classes.htm Ruby Classes]
*[http://rubysource.com/ruby-mixins-2/ Ruby Inheritance]
*[http://pragdave.blogs.pragprog.com/pragdave/2008/09/fun-with-procs.html Ruby Procs]
*[http://moonbase.rydia.net/mental/blog/programming/currying-in-ruby Currying]
*[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Procs, Blocks and Lambdas]
*[http://moonmaster9000.tumblr.com/post/477872071/class-variables-and-inheritance-in-ruby Class variables and Inheritance]
*[http://blog.rubybestpractices.com/posts/gregory/047-issue-15-duck-typing-2.html Best Practices]
*[http://rubysource.com/making-ruby-quack%E2%80%94why-we-love-duck-typing/ Duck Typing]

=Further reading=
* Programming Ruby, The Pragmatic Programmer's Guide by Dave Thomas
* Design Java by Dale Skrien

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T23:20:03Z

Ssreepa: /* Class */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures <ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref>help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a} #define lambda proc
end

def add(a)
@block.call a #call proc object
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new<ref>[http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/ proc and Lamda]</ref> takes in a block and returns a Proc object which will run the code in the block when call method is invoked. In Proc.new created proc the return control is from the method enclosing the Proc.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method.In a lambda created proc, the return statement returns only from the proc itself. This is the difference from the Proc.new created proc.
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for the addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2] #original addition function add

curried_add = add.curry #curried function curried_add
add_to_ten = curried_add[10] #only 1 number specified to curried function curried_add, by fixing one of the input values
add_to_twenty = curried_add[20] #thus the curried function always adds 10 and 20 to the second number when we use it with
#add_to_ten and add_to_twenty respectively

puts add_to_ten[5] #adding second number 5 to the fixed value of 10
puts add_to_twenty[5] #adding second number 5 to the fixed value of 20
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class<ref>[http://phrogz.net/programmingruby/tut_classes.html Ruby Classes]</ref> methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock #BookInStock is a class name
def initialize(isbn, price) #initialize is used to initialize instance variables
@isbn = isbn #@isbn and @price are instance variables
@price = Float(price)
end
def self.book #self denotes class method
puts “Class method”
end
end

class ParkingLot
def initialize(n)
@spotsAvailable = n
end
def park
puts "Park your car"
@spotsAvailable = @spotsAvailable -1
end
def unpark
puts "Unpark your car"
@spotsAvailable = @spotsAvailable + 1
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor<ref>[http://www.rubyist.net/~slagell/ruby/accessors.html Accessors]</ref>.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title #getter method
attr_writer :price #setter method
attr_accessor : isbn #getter and setter methods
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of [http://download.oracle.com/javase/tutorial/java/IandI/abstract.html abstract methods]. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented") #raise indicates exception
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing<ref>[http://rubylearning.com/satishtalim/duck_typing.html Duck Typing]</ref>. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing]in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.tutorialspoint.com/ruby/ruby_classes.htm Ruby Classes]
*[http://rubysource.com/ruby-mixins-2/ Ruby Inheritance]
*[http://pragdave.blogs.pragprog.com/pragdave/2008/09/fun-with-procs.html Ruby Procs]
*[http://moonbase.rydia.net/mental/blog/programming/currying-in-ruby Currying]
*[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Procs, Blocks and Lambdas]
*[http://moonmaster9000.tumblr.com/post/477872071/class-variables-and-inheritance-in-ruby Class variables and Inheritance]
*[http://blog.rubybestpractices.com/posts/gregory/047-issue-15-duck-typing-2.html Best Practices]
*[http://rubysource.com/making-ruby-quack%E2%80%94why-we-love-duck-typing/ Duck Typing]

=Further reading=
* Programming Ruby, The Pragmatic Programmer's Guide by Dave Thomas
* Design Java by Dale Skrien

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T23:16:15Z

Ssreepa: /* Further reading */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures <ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref>help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas<ref>[http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/ proc and Lamda]</ref>===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked. In Proc.new created proc the return control is from the method enclosing the Proc.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method.In a lambda created proc, the return statement returns only from the proc itself. This is the difference from the Proc.new created proc.
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for the addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2] #original addition function add

curried_add = add.curry #curried function curried_add
add_to_ten = curried_add[10] #only 1 number specified to curried function curried_add, by fixing one of the input values
add_to_twenty = curried_add[20] #thus the curried function always adds 10 and 20 to the second number when we use it with
#add_to_ten and add_to_twenty respectively

puts add_to_ten[5] #adding second number 5 to the fixed value of 10
puts add_to_twenty[5] #adding second number 5 to the fixed value of 20
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class<ref>[http://phrogz.net/programmingruby/tut_classes.html Ruby Classes]</ref> methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock #BookInStock is a class name
def initialize(isbn, price) #initialize is used to initialize instance variables
@isbn = isbn #@isbn and @price are instance variables
@price = Float(price)
end
def self.book #self denotes class method
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor<ref>[http://www.rubyist.net/~slagell/ruby/accessors.html Accessors]</ref>.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title #getter method
attr_writer :price #setter method
attr_accessor : isbn #getter and setter methods
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of [http://download.oracle.com/javase/tutorial/java/IandI/abstract.html abstract methods]. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented") #raise indicates exception
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing<ref>[http://rubylearning.com/satishtalim/duck_typing.html Duck Typing]</ref>. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing]in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.tutorialspoint.com/ruby/ruby_classes.htm Ruby Classes]
*[http://rubysource.com/ruby-mixins-2/ Ruby Inheritance]
*[http://pragdave.blogs.pragprog.com/pragdave/2008/09/fun-with-procs.html Ruby Procs]
*[http://moonbase.rydia.net/mental/blog/programming/currying-in-ruby Currying]
*[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Procs, Blocks and Lambdas]
*[http://moonmaster9000.tumblr.com/post/477872071/class-variables-and-inheritance-in-ruby Class variables and Inheritance]
*[http://blog.rubybestpractices.com/posts/gregory/047-issue-15-duck-typing-2.html Best Practices]
*[http://rubysource.com/making-ruby-quack%E2%80%94why-we-love-duck-typing/ Duck Typing]

=Further reading=
* Programming Ruby, The Pragmatic Programmer's Guide by Dave Thomas
* Design Java by Dale Skrien

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T23:14:38Z

Ssreepa: /* External links */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures <ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref>help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas<ref>[http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/ proc and Lamda]</ref>===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked. In Proc.new created proc the return control is from the method enclosing the Proc.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method.In a lambda created proc, the return statement returns only from the proc itself. This is the difference from the Proc.new created proc.
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for the addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2] #original addition function add

curried_add = add.curry #curried function curried_add
add_to_ten = curried_add[10] #only 1 number specified to curried function curried_add, by fixing one of the input values
add_to_twenty = curried_add[20] #thus the curried function always adds 10 and 20 to the second number when we use it with
#add_to_ten and add_to_twenty respectively

puts add_to_ten[5] #adding second number 5 to the fixed value of 10
puts add_to_twenty[5] #adding second number 5 to the fixed value of 20
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class<ref>[http://phrogz.net/programmingruby/tut_classes.html Ruby Classes]</ref> methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock #BookInStock is a class name
def initialize(isbn, price) #initialize is used to initialize instance variables
@isbn = isbn #@isbn and @price are instance variables
@price = Float(price)
end
def self.book #self denotes class method
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor<ref>[http://www.rubyist.net/~slagell/ruby/accessors.html Accessors]</ref>.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title #getter method
attr_writer :price #setter method
attr_accessor : isbn #getter and setter methods
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of [http://download.oracle.com/javase/tutorial/java/IandI/abstract.html abstract methods]. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented") #raise indicates exception
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing<ref>[http://rubylearning.com/satishtalim/duck_typing.html Duck Typing]</ref>. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing]in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.tutorialspoint.com/ruby/ruby_classes.htm Ruby Classes]
*[http://rubysource.com/ruby-mixins-2/ Ruby Inheritance]
*[http://pragdave.blogs.pragprog.com/pragdave/2008/09/fun-with-procs.html Ruby Procs]
*[http://moonbase.rydia.net/mental/blog/programming/currying-in-ruby Currying]
*[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Procs, Blocks and Lambdas]
*[http://moonmaster9000.tumblr.com/post/477872071/class-variables-and-inheritance-in-ruby Class variables and Inheritance]
*[http://blog.rubybestpractices.com/posts/gregory/047-issue-15-duck-typing-2.html Best Practices]
*[http://rubysource.com/making-ruby-quack%E2%80%94why-we-love-duck-typing/ Duck Typing]

=Further reading=
* Programming Ruby, The Pragmatic Programmer's Guide by Dave Thomas

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T23:12:57Z

Ssreepa: /* External links */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures <ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref>help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas<ref>[http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/ proc and Lamda]</ref>===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked. In Proc.new created proc the return control is from the method enclosing the Proc.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method.In a lambda created proc, the return statement returns only from the proc itself. This is the difference from the Proc.new created proc.
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for the addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2] #original addition function add

curried_add = add.curry #curried function curried_add
add_to_ten = curried_add[10] #only 1 number specified to curried function curried_add, by fixing one of the input values
add_to_twenty = curried_add[20] #thus the curried function always adds 10 and 20 to the second number when we use it with
#add_to_ten and add_to_twenty respectively

puts add_to_ten[5] #adding second number 5 to the fixed value of 10
puts add_to_twenty[5] #adding second number 5 to the fixed value of 20
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class<ref>[http://phrogz.net/programmingruby/tut_classes.html Ruby Classes]</ref> methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock #BookInStock is a class name
def initialize(isbn, price) #initialize is used to initialize instance variables
@isbn = isbn #@isbn and @price are instance variables
@price = Float(price)
end
def self.book #self denotes class method
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor<ref>[http://www.rubyist.net/~slagell/ruby/accessors.html Accessors]</ref>.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title #getter method
attr_writer :price #setter method
attr_accessor : isbn #getter and setter methods
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of [http://download.oracle.com/javase/tutorial/java/IandI/abstract.html abstract methods]. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented") #raise indicates exception
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing<ref>[http://rubylearning.com/satishtalim/duck_typing.html Duck Typing]</ref>. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing]in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.tutorialspoint.com/ruby/ruby_classes.htm Ruby Classes]
*[http://rubysource.com/ruby-mixins-2/ Ruby Inheritance]
*[http://pragdave.blogs.pragprog.com/pragdave/2008/09/fun-with-procs.html Ruby Procs]
*[http://moonbase.rydia.net/mental/blog/programming/currying-in-ruby Currying]
*[http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/ Procs, Blocks and Lambdas]
*[http://moonmaster9000.tumblr.com/post/477872071/class-variables-and-inheritance-in-ruby class variables and Inheritance]

=Further reading=
* Programming Ruby, The Pragmatic Programmer's Guide by Dave Thomas

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T23:09:20Z

Ssreepa: /* External links */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures <ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref>help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas<ref>[http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/ proc and Lamda]</ref>===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked. In Proc.new created proc the return control is from the method enclosing the Proc.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method.In a lambda created proc, the return statement returns only from the proc itself. This is the difference from the Proc.new created proc.
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for the addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2] #original addition function add

curried_add = add.curry #curried function curried_add
add_to_ten = curried_add[10] #only 1 number specified to curried function curried_add, by fixing one of the input values
add_to_twenty = curried_add[20] #thus the curried function always adds 10 and 20 to the second number when we use it with
#add_to_ten and add_to_twenty respectively

puts add_to_ten[5] #adding second number 5 to the fixed value of 10
puts add_to_twenty[5] #adding second number 5 to the fixed value of 20
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class<ref>[http://phrogz.net/programmingruby/tut_classes.html Ruby Classes]</ref> methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock #BookInStock is a class name
def initialize(isbn, price) #initialize is used to initialize instance variables
@isbn = isbn #@isbn and @price are instance variables
@price = Float(price)
end
def self.book #self denotes class method
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor<ref>[http://www.rubyist.net/~slagell/ruby/accessors.html Accessors]</ref>.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title #getter method
attr_writer :price #setter method
attr_accessor : isbn #getter and setter methods
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of [http://download.oracle.com/javase/tutorial/java/IandI/abstract.html abstract methods]. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented") #raise indicates exception
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing<ref>[http://rubylearning.com/satishtalim/duck_typing.html Duck Typing]</ref>. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing]in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.tutorialspoint.com/ruby/ruby_classes.htm Ruby Classes]
*[http://rubysource.com/ruby-mixins-2/ Ruby Inheritance]

=Further reading=
* Programming Ruby, The Pragmatic Programmer's Guide by Dave Thomas

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T23:07:52Z

Ssreepa: /* Abstract methods */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures <ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref>help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas<ref>[http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/ proc and Lamda]</ref>===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked. In Proc.new created proc the return control is from the method enclosing the Proc.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method.In a lambda created proc, the return statement returns only from the proc itself. This is the difference from the Proc.new created proc.
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for the addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2] #original addition function add

curried_add = add.curry #curried function curried_add
add_to_ten = curried_add[10] #only 1 number specified to curried function curried_add, by fixing one of the input values
add_to_twenty = curried_add[20] #thus the curried function always adds 10 and 20 to the second number when we use it with
#add_to_ten and add_to_twenty respectively

puts add_to_ten[5] #adding second number 5 to the fixed value of 10
puts add_to_twenty[5] #adding second number 5 to the fixed value of 20
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class<ref>[http://phrogz.net/programmingruby/tut_classes.html Ruby Classes]</ref> methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock #BookInStock is a class name
def initialize(isbn, price) #initialize is used to initialize instance variables
@isbn = isbn #@isbn and @price are instance variables
@price = Float(price)
end
def self.book #self denotes class method
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor<ref>[http://www.rubyist.net/~slagell/ruby/accessors.html Accessors]</ref>.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title #getter method
attr_writer :price #setter method
attr_accessor : isbn #getter and setter methods
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of [http://download.oracle.com/javase/tutorial/java/IandI/abstract.html abstract methods]. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented") #raise indicates exception
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing<ref>[http://rubylearning.com/satishtalim/duck_typing.html Duck Typing]</ref>. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing]in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.tutorialspoint.com/ruby/ruby_classes.htm dsfsfd]

=Further reading=
* Programming Ruby, The Pragmatic Programmer's Guide by Dave Thomas

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T23:05:45Z

Ssreepa: /* Attributes */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures <ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref>help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas<ref>[http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/ proc and Lamda]</ref>===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked. In Proc.new created proc the return control is from the method enclosing the Proc.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method.In a lambda created proc, the return statement returns only from the proc itself. This is the difference from the Proc.new created proc.
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for the addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2] #original addition function add

curried_add = add.curry #curried function curried_add
add_to_ten = curried_add[10] #only 1 number specified to curried function curried_add, by fixing one of the input values
add_to_twenty = curried_add[20] #thus the curried function always adds 10 and 20 to the second number when we use it with
#add_to_ten and add_to_twenty respectively

puts add_to_ten[5] #adding second number 5 to the fixed value of 10
puts add_to_twenty[5] #adding second number 5 to the fixed value of 20
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class<ref>[http://phrogz.net/programmingruby/tut_classes.html Ruby Classes]</ref> methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock #BookInStock is a class name
def initialize(isbn, price) #initialize is used to initialize instance variables
@isbn = isbn #@isbn and @price are instance variables
@price = Float(price)
end
def self.book #self denotes class method
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor<ref>[http://www.rubyist.net/~slagell/ruby/accessors.html Accessors]</ref>.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title #getter method
attr_writer :price #setter method
attr_accessor : isbn #getter and setter methods
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented") #raise indicates exception
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing<ref>[http://rubylearning.com/satishtalim/duck_typing.html Duck Typing]</ref>. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing]in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.tutorialspoint.com/ruby/ruby_classes.htm dsfsfd]

=Further reading=
* Programming Ruby, The Pragmatic Programmer's Guide by Dave Thomas

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T20:38:38Z

Ssreepa: /* Duck typing (Unbounded Polymorphism) */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Introduction==
In the following wiki, we will be covering the basics of closures and currying. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures <ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref>help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas<ref>[http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/ proc and Lamda]</ref>===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for the addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2] #original addition function add

curried_add = add.curry #curried function curried_add
add_to_ten = curried_add[10] #only 1 number specified to curried function curried_add, by fixing one of the input values
add_to_twenty = curried_add[20] #thus the curried function always adds 10 and 20 to the second number when we use it with
#add_to_ten and add_to_twenty respectively

puts add_to_ten[5] #adding second number 5 to the fixed value of 10
puts add_to_twenty[5] #adding second number 5 to the fixed value of 20
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class<ref>[http://phrogz.net/programmingruby/tut_classes.html Ruby Classes]</ref> methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock #BookInStock is a class name
def initialize(isbn, price) #initialize is used to initialize instance variables
@isbn = isbn #@isbn and @price are instance variables
@price = Float(price)
end
def self.book #self denotes class method
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title #getter method
attr_writer :price #setter method
attr_accessor : isbn #getter and setter methods
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented") #raise indicates exception
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing<ref>[http://rubylearning.com/satishtalim/duck_typing.html Duck Typing]</ref>. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing]in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.tutorialspoint.com/ruby/ruby_classes.htm dsfsfd]

=Further reading=
* Programming Ruby, The Pragmatic Programmer's Guide by Dave Thomas

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T20:38:17Z

Ssreepa: /* Duck typing (Unbounded Polymorphism) */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Introduction==
In the following wiki, we will be covering the basics of closures and currying. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures <ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref>help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas<ref>[http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/ proc and Lamda]</ref>===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for the addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2] #original addition function add

curried_add = add.curry #curried function curried_add
add_to_ten = curried_add[10] #only 1 number specified to curried function curried_add, by fixing one of the input values
add_to_twenty = curried_add[20] #thus the curried function always adds 10 and 20 to the second number when we use it with
#add_to_ten and add_to_twenty respectively

puts add_to_ten[5] #adding second number 5 to the fixed value of 10
puts add_to_twenty[5] #adding second number 5 to the fixed value of 20
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class<ref>[http://phrogz.net/programmingruby/tut_classes.html Ruby Classes]</ref> methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock #BookInStock is a class name
def initialize(isbn, price) #initialize is used to initialize instance variables
@isbn = isbn #@isbn and @price are instance variables
@price = Float(price)
end
def self.book #self denotes class method
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title #getter method
attr_writer :price #setter method
attr_accessor : isbn #getter and setter methods
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented") #raise indicates exception
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing<ref>[http://rubylearning.com/satishtalim/duck_typing.html]</ref>. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing]in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.tutorialspoint.com/ruby/ruby_classes.htm dsfsfd]

=Further reading=
* Programming Ruby, The Pragmatic Programmer's Guide by Dave Thomas

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T20:37:37Z

Ssreepa: /* Duck typing (Unbounded Polymorphism) */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Introduction==
In the following wiki, we will be covering the basics of closures and currying. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures <ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref>help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas<ref>[http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/ proc and Lamda]</ref>===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for the addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2] #original addition function add

curried_add = add.curry #curried function curried_add
add_to_ten = curried_add[10] #only 1 number specified to curried function curried_add, by fixing one of the input values
add_to_twenty = curried_add[20] #thus the curried function always adds 10 and 20 to the second number when we use it with
#add_to_ten and add_to_twenty respectively

puts add_to_ten[5] #adding second number 5 to the fixed value of 10
puts add_to_twenty[5] #adding second number 5 to the fixed value of 20
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class<ref>[http://phrogz.net/programmingruby/tut_classes.html Ruby Classes]</ref> methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock #BookInStock is a class name
def initialize(isbn, price) #initialize is used to initialize instance variables
@isbn = isbn #@isbn and @price are instance variables
@price = Float(price)
end
def self.book #self denotes class method
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title #getter method
attr_writer :price #setter method
attr_accessor : isbn #getter and setter methods
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented") #raise indicates exception
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing<ref>[http://rubylearning.com/satishtalim/duck_typing.html></ref>. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing]in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.tutorialspoint.com/ruby/ruby_classes.htm dsfsfd]

=Further reading=
* Programming Ruby, The Pragmatic Programmer's Guide by Dave Thomas

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T20:35:40Z

Ssreepa: /* Duck typing (Unbounded Polymorphism) */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Introduction==
In the following wiki, we will be covering the basics of closures and currying. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures <ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref>help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas<ref>[http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/ proc and Lamda]</ref>===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for the addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2] #original addition function add

curried_add = add.curry #curried function curried_add
add_to_ten = curried_add[10] #only 1 number specified to curried function curried_add, by fixing one of the input values
add_to_twenty = curried_add[20] #thus the curried function always adds 10 and 20 to the second number when we use it with
#add_to_ten and add_to_twenty respectively

puts add_to_ten[5] #adding second number 5 to the fixed value of 10
puts add_to_twenty[5] #adding second number 5 to the fixed value of 20
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class<ref>[http://phrogz.net/programmingruby/tut_classes.html Ruby Classes]</ref> methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock #BookInStock is a class name
def initialize(isbn, price) #initialize is used to initialize instance variables
@isbn = isbn #@isbn and @price are instance variables
@price = Float(price)
end
def self.book #self denotes class method
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title #getter method
attr_writer :price #setter method
attr_accessor : isbn #getter and setter methods
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented") #raise indicates exception
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing<ref>[[8] http://rubylearning.com/satishtalim/duck_typing.html></ref>. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates >ref>[http://en.wikipedia.org/wiki/Duck_typing Duck typing]</ref> in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.tutorialspoint.com/ruby/ruby_classes.htm]

=Further reading=
* Programming Ruby, The Pragmatic Programmer's Guide by Dave Thomas

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T20:33:45Z

Ssreepa: /* Duck typing (Unbounded Polymorphism) */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Introduction==
In the following wiki, we will be covering the basics of closures and currying. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures <ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref>help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas<ref>[http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/ proc and Lamda]</ref>===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for the addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2] #original addition function add

curried_add = add.curry #curried function curried_add
add_to_ten = curried_add[10] #only 1 number specified to curried function curried_add, by fixing one of the input values
add_to_twenty = curried_add[20] #thus the curried function always adds 10 and 20 to the second number when we use it with
#add_to_ten and add_to_twenty respectively

puts add_to_ten[5] #adding second number 5 to the fixed value of 10
puts add_to_twenty[5] #adding second number 5 to the fixed value of 20
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class<ref>[http://phrogz.net/programmingruby/tut_classes.html Ruby Classes]</ref> methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock #BookInStock is a class name
def initialize(isbn, price) #initialize is used to initialize instance variables
@isbn = isbn #@isbn and @price are instance variables
@price = Float(price)
end
def self.book #self denotes class method
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title #getter method
attr_writer :price #setter method
attr_accessor : isbn #getter and setter methods
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented") #raise indicates exception
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing<ref>[[8] http://rubylearning.com/satishtalim/duck_typing.html></ref>. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing]</ref> in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.cs.indiana.edu/~jsobel/rop.html An Introduction to Reflection-Oriented Programming]

=Further reading=
* Ira R. Forman and Nate Forman, ''Java Reflection in Action'' (2005), ISBN 1-932394-18-4

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T20:32:38Z

Ssreepa: /* Duck typing (Unbounded Polymorphism) */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Introduction==
In the following wiki, we will be covering the basics of closures and currying. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures <ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref>help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas<ref>[http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/ proc and Lamda]</ref>===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for the addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2] #original addition function add

curried_add = add.curry #curried function curried_add
add_to_ten = curried_add[10] #only 1 number specified to curried function curried_add, by fixing one of the input values
add_to_twenty = curried_add[20] #thus the curried function always adds 10 and 20 to the second number when we use it with
#add_to_ten and add_to_twenty respectively

puts add_to_ten[5] #adding second number 5 to the fixed value of 10
puts add_to_twenty[5] #adding second number 5 to the fixed value of 20
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class<ref>[http://phrogz.net/programmingruby/tut_classes.html Ruby Classes]</ref> methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock #BookInStock is a class name
def initialize(isbn, price) #initialize is used to initialize instance variables
@isbn = isbn #@isbn and @price are instance variables
@price = Float(price)
end
def self.book #self denotes class method
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title #getter method
attr_writer :price #setter method
attr_accessor : isbn #getter and setter methods
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented") #raise indicates exception
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing<ref>[[8] http://rubylearning.com/satishtalim/duck_typing.html>. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing] in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.cs.indiana.edu/~jsobel/rop.html An Introduction to Reflection-Oriented Programming]

=Further reading=
* Ira R. Forman and Nate Forman, ''Java Reflection in Action'' (2005), ISBN 1-932394-18-4

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T20:30:13Z

Ssreepa: /* Class */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Introduction==
In the following wiki, we will be covering the basics of closures and currying. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures <ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref>help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas<ref>[http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/ proc and Lamda]</ref>===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for the addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2] #original addition function add

curried_add = add.curry #curried function
add_to_ten = curried_add[10] #only 1 number specified to curried function curried_add, fixing one of the input values
add_to_twenty = curried_add[20] #thus the curried function always adds 10 and 20 to the second number when we use it with
#add_to_ten and add_to_twenty respectively

puts add_to_ten[5] #adding second number 5 to the fixed value of 10
puts add_to_twenty[5] #adding second number 5 to the fixed value of 20
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class<ref>[http://phrogz.net/programmingruby/tut_classes.html Ruby Classes]</ref> methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock #BookInStock is a class name
def initialize(isbn, price) #initialize is used to initialize instance variables
@isbn = isbn #@isbn and @price are instance variables
@price = Float(price)
end
def self.book #self denotes class method
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title #getter method
attr_writer :price #setter method
attr_accessor : isbn #getter and setter methods
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented") #raise indicates exception
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing] in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.cs.indiana.edu/~jsobel/rop.html An Introduction to Reflection-Oriented Programming]

=Further reading=
* Ira R. Forman and Nate Forman, ''Java Reflection in Action'' (2005), ISBN 1-932394-18-4

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T20:28:11Z

Ssreepa: /* Procs And Lambdas */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Introduction==
In the following wiki, we will be covering the basics of closures and currying. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures <ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref>help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas<ref>[http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/ proc and Lamda]</ref>===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2]

curried_add = add.curry
add_to_ten = curried_add[10]
add_to_twenty = curried_add[20]

puts add_to_ten[5]
puts add_to_twenty[5]
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock #BookInStock is a class name
def initialize(isbn, price) #initialize is used to initialize instance variables
@isbn = isbn #@isbn and @price are instance variables
@price = Float(price)
end
def self.book #self denotes class method
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title #getter method
attr_writer :price #setter method
attr_accessor : isbn #getter and setter methods
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented") #raise indicates exception
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing] in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.cs.indiana.edu/~jsobel/rop.html An Introduction to Reflection-Oriented Programming]

=Further reading=
* Ira R. Forman and Nate Forman, ''Java Reflection in Action'' (2005), ISBN 1-932394-18-4

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T20:25:29Z

Ssreepa: /* Class */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Introduction==
In the following wiki, we will be covering the basics of closures and currying. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures <ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref>help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2]

curried_add = add.curry
add_to_ten = curried_add[10]
add_to_twenty = curried_add[20]

puts add_to_ten[5]
puts add_to_twenty[5]
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock #BookInStock is a class name
def initialize(isbn, price) #initialize is used to initialize instance variables
@isbn = isbn #@isbn and @price are instance variables
@price = Float(price)
end
def self.book #self denotes class method
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title #getter method
attr_writer :price #setter method
attr_accessor : isbn #getter and setter methods
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented") #raise indicates exception
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing] in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.cs.indiana.edu/~jsobel/rop.html An Introduction to Reflection-Oriented Programming]

=Further reading=
* Ira R. Forman and Nate Forman, ''Java Reflection in Action'' (2005), ISBN 1-932394-18-4

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T20:22:21Z

Ssreepa: /* Closures */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Introduction==
In the following wiki, we will be covering the basics of closures and currying. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures <ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref>help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2]

curried_add = add.curry
add_to_ten = curried_add[10]
add_to_twenty = curried_add[20]

puts add_to_ten[5]
puts add_to_twenty[5]
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock
def initialize(isbn, price)
@isbn = isbn
@price = Float(price)
end
def self.book
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title
attr_writer :price
attr_accessor : isbn
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented")
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing] in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.cs.indiana.edu/~jsobel/rop.html An Introduction to Reflection-Oriented Programming]

=Further reading=
* Ira R. Forman and Nate Forman, ''Java Reflection in Action'' (2005), ISBN 1-932394-18-4

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T20:21:49Z

Ssreepa: /* Closures */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Introduction==
In the following wiki, we will be covering the basics of closures and currying. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined.<ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref>Closures help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2]

curried_add = add.curry
add_to_ten = curried_add[10]
add_to_twenty = curried_add[20]

puts add_to_ten[5]
puts add_to_twenty[5]
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock
def initialize(isbn, price)
@isbn = isbn
@price = Float(price)
end
def self.book
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title
attr_writer :price
attr_accessor : isbn
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented")
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing] in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.cs.indiana.edu/~jsobel/rop.html An Introduction to Reflection-Oriented Programming]

=Further reading=
* Ira R. Forman and Nate Forman, ''Java Reflection in Action'' (2005), ISBN 1-932394-18-4

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T20:20:31Z

Ssreepa: /* Closures */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Introduction==
In the following wiki, we will be covering the basics of closures and currying. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. <ref>[http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/ Closures]</ref> help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2]

curried_add = add.curry
add_to_ten = curried_add[10]
add_to_twenty = curried_add[20]

puts add_to_ten[5]
puts add_to_twenty[5]
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock
def initialize(isbn, price)
@isbn = isbn
@price = Float(price)
end
def self.book
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title
attr_writer :price
attr_accessor : isbn
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented")
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing] in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

=External links=
*[http://www.cs.indiana.edu/~jsobel/rop.html An Introduction to Reflection-Oriented Programming]

=Further reading=
* Ira R. Forman and Nate Forman, ''Java Reflection in Action'' (2005), ISBN 1-932394-18-4

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T20:18:49Z

Ssreepa: /* References */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby. Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

__TOC__

==Introduction==
In the following wiki, we will be covering the basics of closures and currying. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2]

curried_add = add.curry
add_to_ten = curried_add[10]
add_to_twenty = curried_add[20]

puts add_to_ten[5]
puts add_to_twenty[5]
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock
def initialize(isbn, price)
@isbn = isbn
@price = Float(price)
end
def self.book
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methods provide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title
attr_writer :price
attr_accessor : isbn
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented")
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing] in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

=References=
<references/>

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T18:42:54Z

Ssreepa: /* Duck typing (Unbounded Polymorphism) */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby.

__TOC__

==Introduction==
In the following wiki, we will be covering the basics of closures and currying. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).

Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2]

curried_add = add.curry
add_to_ten = curried_add[10]
add_to_twenty = curried_add[20]

puts add_to_ten[5]
puts add_to_twenty[5]
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock
def initialize(isbn, price)
@isbn = isbn
@price = Float(price)
end
def self.book
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methodsprovide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title
attr_writer :price
attr_accessor : isbn
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented")
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing] in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new) # Frog is an animal
t.test_animal(Dinosaur.new) # Dinosaur is an animal
t.test_animal(Table.new) # Table is an animal!!
t.test_animal(Bird.new) # Bird is not an animal

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

== References ==
[1] http://en.wikipedia.org/wiki/Closure_(computer_science)

[2] http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/

[3] http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/

[4] http://phrogz.net/programmingruby/tut_classes.html

[5] http://juixe.com/techknow/index.php/2007/01/22/ruby-class-tutorial/

[6] http://www.tutorialspoint.com/ruby/ruby_classes.htm

[7] Programming Ruby, The Pragmatic Programmer's Guide by Dave Thomas

[8] http://rubylearning.com/satishtalim/duck_typing.html

[9] http://devblog.famundo.com/articles/2007/01/12/ruby-duck-typing-goodness

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T18:41:00Z

Ssreepa: /* Duck typing (Unbounded Polymorphism) */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby.

__TOC__

==Introduction==
In the following wiki, we will be covering the basics of closures and currying. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).

Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2]

curried_add = add.curry
add_to_ten = curried_add[10]
add_to_twenty = curried_add[20]

puts add_to_ten[5]
puts add_to_twenty[5]
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock
def initialize(isbn, price)
@isbn = isbn
@price = Float(price)
end
def self.book
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methodsprovide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title
attr_writer :price
attr_accessor : isbn
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented")
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing] in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new)
t.test_animal(Dinosaur.new)
t.test_animal(Table.new)
t.test_animal(Bird.new)

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use [http://en.wikipedia.org/wiki/Dynamic_typing#Dynamic_typing dynamic typing] are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

== References ==
[1] http://en.wikipedia.org/wiki/Closure_(computer_science)

[2] http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/

[3] http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/

[4] http://phrogz.net/programmingruby/tut_classes.html

[5] http://juixe.com/techknow/index.php/2007/01/22/ruby-class-tutorial/

[6] http://www.tutorialspoint.com/ruby/ruby_classes.htm

[7] Programming Ruby, The Pragmatic Programmer's Guide by Dave Thomas

[8] http://rubylearning.com/satishtalim/duck_typing.html

[9] http://devblog.famundo.com/articles/2007/01/12/ruby-duck-typing-goodness

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T18:39:44Z

Ssreepa: /* Duck typing (Unbounded Polymorphism) */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby.

__TOC__

==Introduction==
In the following wiki, we will be covering the basics of closures and currying. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).

Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2]

curried_add = add.curry
add_to_ten = curried_add[10]
add_to_twenty = curried_add[20]

puts add_to_ten[5]
puts add_to_twenty[5]
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock
def initialize(isbn, price)
@isbn = isbn
@price = Float(price)
end
def self.book
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methodsprovide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title
attr_writer :price
attr_accessor : isbn
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented")
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates [http://en.wikipedia.org/wiki/Duck_typing Duck typing] in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new)
t.test_animal(Dinosaur.new)
t.test_animal(Table.new)
t.test_animal(Bird.new)

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use dynamic typing are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

== References ==
[1] http://en.wikipedia.org/wiki/Closure_(computer_science)

[2] http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/

[3] http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/

[4] http://phrogz.net/programmingruby/tut_classes.html

[5] http://juixe.com/techknow/index.php/2007/01/22/ruby-class-tutorial/

[6] http://www.tutorialspoint.com/ruby/ruby_classes.htm

[7] Programming Ruby, The Pragmatic Programmer's Guide by Dave Thomas

[8] http://rubylearning.com/satishtalim/duck_typing.html

[9] http://devblog.famundo.com/articles/2007/01/12/ruby-duck-typing-goodness

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T18:38:59Z

Ssreepa: /* Class */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby.

__TOC__

==Introduction==
In the following wiki, we will be covering the basics of closures and currying. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).

Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2]

curried_add = add.curry
add_to_ten = curried_add[10]
add_to_twenty = curried_add[20]

puts add_to_ten[5]
puts add_to_twenty[5]
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide [http://en.wikipedia.org/wiki/Inheritance inheritance], [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism] and [http://en.wikipedia.org/wiki/Encapsulation_(object-oriented_programming) encapsulation], the three pillars. You can have class methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock
def initialize(isbn, price)
@isbn = isbn
@price = Float(price)
end
def self.book
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methodsprovide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title
attr_writer :price
attr_accessor : isbn
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented")
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates Duck typing in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new)
t.test_animal(Dinosaur.new)
t.test_animal(Table.new)
t.test_animal(Bird.new)

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use dynamic typing are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

== References ==
[1] http://en.wikipedia.org/wiki/Closure_(computer_science)

[2] http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/

[3] http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/

[4] http://phrogz.net/programmingruby/tut_classes.html

[5] http://juixe.com/techknow/index.php/2007/01/22/ruby-class-tutorial/

[6] http://www.tutorialspoint.com/ruby/ruby_classes.htm

[7] Programming Ruby, The Pragmatic Programmer's Guide by Dave Thomas

[8] http://rubylearning.com/satishtalim/duck_typing.html

[9] http://devblog.famundo.com/articles/2007/01/12/ruby-duck-typing-goodness

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T18:35:05Z

Ssreepa: /* Introduction */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby.

__TOC__

==Introduction==
In the following wiki, we will be covering the basics of closures and currying. We will then go into the details of object-oriented concepts such as data encapsulation, inheritance and polymorphism. The wiki ends by covering the most popular feature in Ruby called duck typing (unbounded polymorphism).

Since the lecture 5 material in the CSC517 covers object-oriented concepts specific to Ruby, thus we have restricted to the same.

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2]

curried_add = add.curry
add_to_ten = curried_add[10]
add_to_twenty = curried_add[20]

puts add_to_ten[5]
puts add_to_twenty[5]
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide inheritance, polymorphism and encapsulation, the three pillars. You can have class methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock
def initialize(isbn, price)
@isbn = isbn
@price = Float(price)
end
def self.book
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methodsprovide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title
attr_writer :price
attr_accessor : isbn
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented")
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates Duck typing in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new)
t.test_animal(Dinosaur.new)
t.test_animal(Table.new)
t.test_animal(Bird.new)

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use dynamic typing are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

== References ==
[1] http://en.wikipedia.org/wiki/Closure_(computer_science)

[2] http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/

[3] http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/

[4] http://phrogz.net/programmingruby/tut_classes.html

[5] http://juixe.com/techknow/index.php/2007/01/22/ruby-class-tutorial/

[6] http://www.tutorialspoint.com/ruby/ruby_classes.htm

[7] Programming Ruby, The Pragmatic Programmer's Guide by Dave Thomas

[8] http://rubylearning.com/satishtalim/duck_typing.html

[9] http://devblog.famundo.com/articles/2007/01/12/ruby-duck-typing-goodness

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T18:20:03Z

Ssreepa: /* References */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby.

__TOC__

==Introduction==

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2]

curried_add = add.curry
add_to_ten = curried_add[10]
add_to_twenty = curried_add[20]

puts add_to_ten[5]
puts add_to_twenty[5]
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide inheritance, polymorphism and encapsulation, the three pillars. You can have class methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock
def initialize(isbn, price)
@isbn = isbn
@price = Float(price)
end
def self.book
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methodsprovide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title
attr_writer :price
attr_accessor : isbn
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented")
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates Duck typing in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new)
t.test_animal(Dinosaur.new)
t.test_animal(Table.new)
t.test_animal(Bird.new)

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use dynamic typing are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that the developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

== References ==
[1] http://en.wikipedia.org/wiki/Closure_(computer_science)

[2] http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/

[3] http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/

[4] http://phrogz.net/programmingruby/tut_classes.html

[5] http://juixe.com/techknow/index.php/2007/01/22/ruby-class-tutorial/

[6] http://www.tutorialspoint.com/ruby/ruby_classes.htm

[7] Programming Ruby, The Pragmatic Programmer's Guide by Dave Thomas

[8] http://rubylearning.com/satishtalim/duck_typing.html

[9] http://devblog.famundo.com/articles/2007/01/12/ruby-duck-typing-goodness

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T18:16:24Z

Ssreepa: /* Conclusion */

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby.

__TOC__

==Introduction==

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2]

curried_add = add.curry
add_to_ten = curried_add[10]
add_to_twenty = curried_add[20]

puts add_to_ten[5]
puts add_to_twenty[5]
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide inheritance, polymorphism and encapsulation, the three pillars. You can have class methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock
def initialize(isbn, price)
@isbn = isbn
@price = Float(price)
end
def self.book
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methodsprovide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title
attr_writer :price
attr_accessor : isbn
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented")
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates Duck typing in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new)
t.test_animal(Dinosaur.new)
t.test_animal(Table.new)
t.test_animal(Bird.new)

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use dynamic typing are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes which are basic elements in object-oriented programming and duck typing which is very popular in Ruby and used most often. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation, code reuse via inheritance and polymorphism. Ultimately we believe that developer has to weigh the options available according to the requirements of the application and use the Ruby features accordingly.

== References ==
[1] http://en.wikipedia.org/wiki/Closure_(computer_science)

[2] http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/

[3] http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T18:11:16Z

Ssreepa:

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby.

__TOC__

==Introduction==

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2]

curried_add = add.curry
add_to_ten = curried_add[10]
add_to_twenty = curried_add[20]

puts add_to_ten[5]
puts add_to_twenty[5]
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide inheritance, polymorphism and encapsulation, the three pillars. You can have class methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock
def initialize(isbn, price)
@isbn = isbn
@price = Float(price)
end
def self.book
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methodsprovide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title
attr_writer :price
attr_accessor : isbn
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class. There are three levels of protection provided by Ruby,

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control. One can just choose any relevant access specifier before each method is defined as shown here.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented")
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However as mentioned earlier Ruby programmers use abstract methods very rarely.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates Duck typing in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new)
t.test_animal(Dinosaur.new)
t.test_animal(Table.new)
t.test_animal(Bird.new)

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use dynamic typing are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by explaining what closures are and in Ruby how this can be achieved using block and procs. Then we explained classes and duck typing in Ruby. Closures allow a programmer to write shorter code, while classes in Ruby provide data encapsulation and extension of code . Ultimately it is the developer who chooses when to use closures and classes based on the needs of his application.

== References ==
[1] http://en.wikipedia.org/wiki/Closure_(computer_science)

[2] http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/

[3] http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T18:04:54Z

Ssreepa:

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby.

__TOC__

==Introduction==

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A [http://en.wikipedia.org/wiki/Closure_(computer_science) closure] may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in [http://en.wikipedia.org/wiki/Ruby_(programming_language) Ruby].

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to one's needs. Consider the following example where we have a Proc for addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2]

curried_add = add.curry
add_to_ten = curried_add[10]
add_to_twenty = curried_add[20]

puts add_to_ten[5]
puts add_to_twenty[5]
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
A class is the blueprint from which individual objects are created. In object-oriented programming classes are the basic elements which provide inheritance, polymorphism and encapsulation, the three pillars. You can have class methods and instance methods. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is the example for a class BookInStock.

class BookInStock
def initialize(isbn, price)
@isbn = isbn
@price = Float(price)
end
def self.book
puts “Class method”
end
end

Here, initialize is a special method in Ruby. When you call BookInStock.new to create a new BookInStock object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state. This is very similar to constructors in Java. Then there is self.book which is class method which is very similar to static methods in Java. The variables starting with @ are instance variables meaning that they are associated with the instances. In the next few sections we will take a look at the attributes, access control mechanisms and inheritance features provided in the class.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors. Ruby defines three accessor methods attr_reader, attr_writer and attr_accessor.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument.

These methodsprovide access to the underlying instance variables of the name (with a leading @sign). The below example illustrates the use of these methods.
class BookInStock
attr_reader :title
attr_writer :price
attr_accessor : isbn
end

These methods will have the same effect as shown in the below table.

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste #outputs blurp, blurp
beverage.intake #outputs Sweet, tasty tasty

===Access control===

Ruby allows having control over the methods defined in the class.

There are three levels of protection provided by Ruby:

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented")
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However the notion of abstract methods in the Ruby are not used heavily.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates Duck typing in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new)
t.test_animal(Dinosaur.new)
t.test_animal(Table.new)
t.test_animal(Bird.new)

The downside of duck typing is that, the absence of the static type checking may increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use dynamic typing are Python, PHP, Perl, Objective-C, etc.

== Conclusion ==
We started by listing out the collections present in Java which uses JCF, and C++ which uses STL. Then we made a comparison of the collections in C++ , Java and Ruby. Each language's implementation of collections has its pros and cons. Ultimately it is the developer who chooses which one to use, and this is based on the needs of his application. In general C++ STL provides collections that are fast, Java JCF provides collections that are safe, while in Ruby, the collections can be written with minimal code as they are built into the language.

== References ==
[1] http://en.wikipedia.org/wiki/Closure_(computer_science)

[2] http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/

[3] http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T17:44:00Z

Ssreepa:

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby.

__TOC__

==Introduction==

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A closure may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in Ruby.

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method <nowiki><nowiki>Insert non-formatted text here</nowiki><nowiki><nowiki>Insert non-formatted text here</nowiki></nowiki></nowiki>is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to ones needs. Consider the following example where we have a Proc for addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2]

curried_add = add.curry
add_to_ten = curried_add[10]
add_to_twenty = curried_add[20]

puts add_to_ten[5]
puts add_to_twenty[5]
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
Classes are templates for creating object instances. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is a quick example and then we’ll go into a bit more detail.

class BookInStock
def initialize(isbn, price)
@isbn = isbn
@price = Float(price)
end
delf self.book
puts “Class method”
end
end

initialize is a special method in Ruby programs. When you call Song.new to create a new Song object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state.

===Attributes===
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance
variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument. These methods
provide access to the underlying instance variables of the name name (with a leading @
sign).

class BookInStock
attr_reader :title
attr_writer :price
attr_accessor : isbn
end

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

===Inheritance===

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste
beverage.intake

===Access control===

Ruby allows having control over the methods defined in the class.

There are three levels of protection provided by Ruby:

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

===Abstract methods===

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented")
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However the notion of abstract methods in the Ruby are not used heavily.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates Duck typing in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new)
t.test_animal(Dinosaur.new)
t.test_animal(Table.new)
t.test_animal(Bird.new)

The downside of duck typing is that, the absence of the static type checking may prove increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use dynamic typing are Python, PHP, Perl, Objective-C, etc.

== References ==
[1] http://en.wikipedia.org/wiki/Closure_(computer_science)

[2] http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/

[3] http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T17:41:52Z

Ssreepa:

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby.

__TOC__

==Introduction==

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A closure may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in Ruby.

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method <nowiki><nowiki>Insert non-formatted text here</nowiki><nowiki><nowiki>Insert non-formatted text here</nowiki></nowiki></nowiki>is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to ones needs. Consider the following example where we have a Proc for addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2]

curried_add = add.curry
add_to_ten = curried_add[10]
add_to_twenty = curried_add[20]

puts add_to_ten[5]
puts add_to_twenty[5]
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
Classes are templates for creating object instances. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is a quick example and then we’ll go into a bit more detail.

class BookInStock
def initialize(isbn, price)
@isbn = isbn
@price = Float(price)
end
delf self.book
puts “Class method”
end
end

initialize is a special method in Ruby programs. When you call Song.new to create a new Song object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state.

==Attributes==
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance
variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument. These methods
provide access to the underlying instance variables of the name name (with a leading @
sign).

class BookInStock
attr_reader :title
attr_writer :price
attr_accessor : isbn
end

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

==Inheritance==

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste
beverage.intake

==Access control==

Ruby allows having control over the methods defined in the class.

There are three levels of protection provided by Ruby:

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

==Abstract methods==

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented")
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However the notion of abstract methods in the Ruby are not used heavily.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates Duck typing in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new)
t.test_animal(Dinosaur.new)
t.test_animal(Table.new)
t.test_animal(Bird.new)

The downside of duck typing is that, the absence of the static type checking may prove increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use dynamic typing are Python, PHP, Perl, Objective-C, etc.

== References ==
[1] http://en.wikipedia.org/wiki/Closure_(computer_science)

[2] http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/

[3] http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T17:41:01Z

Ssreepa:

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby.

__TOC__

==Introduction==

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A closure may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in Ruby.

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method <nowiki><nowiki>Insert non-formatted text here</nowiki><nowiki><nowiki>Insert non-formatted text here</nowiki></nowiki></nowiki>is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to ones needs. Consider the following example where we have a Proc for addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2]

curried_add = add.curry
add_to_ten = curried_add[10]
add_to_twenty = curried_add[20]

puts add_to_ten[5]
puts add_to_twenty[5]
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
Classes are templates for creating object instances. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is a quick example and then we’ll go into a bit more detail.

class BookInStock
def initialize(isbn, price)
@isbn = isbn
@price = Float(price)
end
delf self.book
puts “Class method”
end
end

initialize is a special method in Ruby programs. When you call Song.new to create a new Song object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state.

==Attributes==
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance
variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument. These methods
provide access to the underlying instance variables of the name name (with a leading @
sign).

class BookInStock
attr_reader :title
attr_writer :price
attr_accessor : isbn
end

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

==Inheritance==

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste
beverage.intake

==Access control==

Ruby allows having control over the methods defined in the class.

There are three levels of protection provided by Ruby:

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

==Abstract methods==

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented")
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However the notion of abstract methods in the Ruby are not used heavily.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates Duck typing in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new)
t.test_animal(Dinosaur.new)
t.test_animal(Table.new)
t.test_animal(Bird.new)

The downside of duck typing is that, the absence of the static type checking may prove increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use dynamic typing are Python, PHP, Perl, Objective-C, etc.

== References ==
[1] http://en.wikipedia.org/wiki/Closure_(computer_science)

[2] http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/

[3] http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T17:39:13Z

Ssreepa:

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of closures and blocks, currying and OOP in Ruby.

__TOC__

==Introduction==

==Closures==
A closure is a block of code that “closes over”. This means it can access the lexical environment of its definition. A closure may be defined in one scope and get called outside this scope. Thus a closure retains the values of all the variables that were in scope when the closure was defined. Closures help in making the code short such that one can do more with less code. Ruby supports closures through Blocks and Procs.

===Blocks===
A block is a set of Ruby statements either between braces or a do/end pair, and appear only immediately after a method invocation. Ruby uses the following standard - braces for single-line blocks and do/end for multiline blocks.
<pre>
{ puts "Hello World" } # braces block

do
{ puts "Hello World 1" } # do/end block
{ puts "Hello World 2" }
{ puts "Hello World 3" }
end
</pre>
Blocks can be instantiated as a Proc object using the Proc or lambda method. The block is then bound to a set of local variables. Once bound, the block code may be called in different contexts through these set variables.Using the example mentioned in lecture 5 in class.
<pre>
# Class to generate adders
class AdderGen
def initialize(n)
@block = lambda {|a| n + a}
end

def add(a)
@block.call a
end
end
twoAdder = AdderGen.new 2
incrementer = AdderGen.new 1
puts incrementer.add(4)
puts twoAdder.add(6)
</pre>
<pre>
Output
5
8
</pre>
@block is the Ruby closure that gets initialized when the lambda method gets called through the class initialize method. The block remembers the parameter with which the initialize method was called even after the initialize method exits. This value of the block is used during the add method invocation.

===Procs And Lambdas===
There are three ways to create a Proc object in Ruby.

====Proc.new====
Proc.new takes in a block and returns a Proc object which will run the code in the block when call method <nowiki><nowiki>Insert non-formatted text here</nowiki><nowiki><nowiki>Insert non-formatted text here</nowiki></nowiki></nowiki>is invoked.
<pre>
proc_object = Proc.new {puts "Create Proc.new object"}
proc_object.call
</pre>

====Proc method====
The proc method is equivalent to Proc.new in Ruby 1.9, but in Ruby 1.8 it is equivalent to lambda.
<pre>
proc_object = proc {puts "Create proc from Proc method"}
proc_object.call
</pre>

====Lambda method====
This creates a proc object using the lambda method
<pre>
proc_object = lambda {puts "Create proc from Lambda method"}
proc_object.call
</pre>

==Currying==
Currying is the concept of creating a new function out of an existing function by fixing the value of some of its input parameters. Currying thus makes a generic function more specific to ones needs. Consider the following example where we have a Proc for addition of two numbers. Using currying we can fix the value of the first argument so that when the curried function is called later on with only one argument, it can use the earlier fixed value as the other argument for its addition. Ruby 1.9 allows the creation of a curry-able proc by calling the curry method on it.
<pre>
add = lambda {|a,b| a + b}
puts add[1,2]

curried_add = add.curry
add_to_ten = curried_add[10]
add_to_twenty = curried_add[20]

puts add_to_ten[5]
puts add_to_twenty[5]
</pre>
<pre>
Output
3
15
25
</pre>

==Class==
Classes are templates for creating object instances. Class methods are methods that are called on a class and instance methods are methods that are called on an instance of a class. Here is a quick example and then we’ll go into a bit more detail.

class BookInStock
def initialize(isbn, price)
@isbn = isbn
@price = Float(price)
end
delf self.book
puts “Class method”
end
end

initialize is a special method in Ruby programs. When you call Song.new to create a new Song object, Ruby creates an uninitialized object and then calls that object's initialize method, passing in any parameters that were passed to new. This gives you a chance to write code that sets up your object's state.

==Attributes==
An object's instance variables are its attributes, the things that distinguish it from other objects of the same class. It is important to be able to write and read these attributes; doing so requires methods called attribute accessors.

Attr_reader: Creates instance variables and corresponding methods that return the value of each instance
variable.

Attr_writer: Creates an accessor method to allow assignment to the attribute

Attr_accessor: Creates a reader and a writer method for each symbol passed as an argument. These methods
provide access to the underlying instance variables of the name name (with a leading @
sign).

class BookInStock
attr_reader :title
attr_writer :price
attr_accessor : isbn
end

Shortcut Effect
attr_reader :title def title; @title; end
attr_writer :price def price=(price); @price=price; end
attr_accessor :isbn attr_reader :isbn; attr_writer :isbn

==Inheritance==

Inheritance is one of the pillars of object-oriented programming. Inheritance allows you to create a class that is a refinement or specialization of another class. This class is called a subclass of the original, and the original is a superclass of the subclass.

For example here Ale is-a subclass of Beer and Beer is-a superclass of Ale. Inheritance allows a subclass to have all the methods defined in the superclass and hence promotes code reuse. In addition subclass can override the methods which are much more specialized than superclass. Ale class now gets the intake method defined in the Beer and also it has another method defined taste which varies from one subclass to another. Also it’s important to note that all classes in Ruby inherit from the Object class and hence all the methods declared in the Object class are now implicitly part of any class we declare.

class Beer
def intake
puts "blurp blurp"
end
end

class Ale < Beer
def taste
puts "Sweet, tasty tasty"
end
end

beverage = Ale.new
beverage.taste
beverage.intake

==Access control==

Ruby allows having control over the methods defined in the class.

There are three levels of protection provided by Ruby:

1. Public methods can be called by any class. No access control is enforced. In Ruby, methods are public by default ( except initialize, which is private).
2. Protected methods can be used by the class which defines them and the subclass which inherit these classes.
3. Private methods can be called only in the context of the current object. You can’t invoke other objects private methods.

The below example shows some details about access control.
class AccessControlExample
def method1 # default is “public”
#...
end
protected # subsequent methods will be “protected”
def method2 # will be “protected”
#...
end
private # subsequent methods will be “private”
def method3 # will be “private”
#...
end
public # subsequent methods will be “public”
def method4 # and this will be “public”
#...
end
end

==Abstract methods==

Ruby doesn’t support the concept of abstract methods. This is because Ruby is dynamically typed and you can add methods on the fly. If you want to simulate the notion of abstract method, you can do the following,

class Animal
def talk
raise “NotImplementedError.new("Method not implemented")
end
end

class Dinosaur < Animal
def talk
puts “Roar! Roar”
end
end

Here Dinosaur class implements talk method. If you don’t implement the talk method in Dinosaur, an attempt to instantiate the class throws an error. However the notion of abstract methods in the Ruby are not used heavily.

==Duck typing (Unbounded Polymorphism)==

In Ruby, the class is never the type. Instead, the type of an object is defined more by what that object can do which is determined by the methods and properties rather than inheritance from particular class. In Ruby, we call this duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

Lets look at the example below.

There are 4 classes defined which are not related in any way. The classes Frog, Dinosaur, Table have a talk method defined while the class Bird has chirp method defined. Since the Table class has a talk method we can say it has animal even though by reality it does not belong which illustrates Duck typing in Ruby. Since Bird class does not implement the talk method it is not classified as of type animal.

class Frog
def talk
puts "ribbit, ribbit"
end
end

class Dinosaur
def talk
puts "Roar"
end
end

class Table
def talk
puts "chss, chss"
end
end

class Bird
def chirp
puts “kuckoo”
end
end

class Test
def test_animal(an)
an.talk
end
end

t = Test.new
t.test_animal(Frog.new)
t.test_animal(Dinosaur.new)
t.test_animal(Table.new)
t.test_animal(Bird.new)

The downside of duck typing is that, the absence of the static type checking may prove increase the execution time. This is also dynamic typing because type information is determined at run-time. Other well-known languages which heavily use dynamic typing are Python, PHP, Perl, Objective-C, etc.

== References ==
[1] http://en.wikipedia.org/wiki/Closure_(computer_science)

[2] http://www.skorks.com/2010/05/closures-a-simple-explanation-using-ruby/

[3] http://www.skorks.com/2010/05/ruby-procs-and-lambdas-and-the-difference-between-them/

CSC/ECE 517 Fall 2011/ch2 2c ds

2011-09-30T23:48:05Z

Ssreepa: /* Introduction */

=Mixins vs. Interfaces=

=Introduction=

In object oriented programming languages, Mixins and Interfaces provide neat constructs to implement certain functionality and benefit from code re-usability. Understanding these constructs will benefit any programmer in designing any software with maximum polymorphic behavior and code re-usability.

With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to because of the problems associated with multiple inheritance<ref>[http://www.artima.com/intv/gosling13.html Inspiration for Interface]</ref>.

While [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] like languages implemented interfaces to allow for [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism],languages like [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] opted not to implement multiple inheritance but to allow the code from one module be added into another class.

Though both interfaces and Mixins simulate multiple inheritance and avoid the common pathologies associated with it , they have their own set of compromises. The below article tries to provide clarity on how this is achieved in each and also provides other distinctive features of Mixins and interfaces.

===Interfaces===
In an object-oriented programming languages such as Java, C#, an interface<ref>[http://download.oracle.com/javase/tutorial/ Interfaces] </ref> is a reference type, similar to a class that can contain only constants, method signatures, and nested types. There are no method bodies. Interfaces cannot be instantiated and they can only be implemented by classes or extended by other interfaces. All methods are public by default and any fields declared in an interface are by default static and final.

Example:

public interface ParkingLot {
boolean add(Car car, int slot);
boolean remove(Car car);
boolean findCar(Int number);
int freeSlotsCount();
int occupiedSlots();
int parkingType();
int calculateParkingFee(int hours, int charge, int duration);
int findParkingSlot();
}

public class Mall implements ParkingLot {
boolean add(Car car, int slot) { //... Code to add a car into the parking lot... }
boolean remove(Car car){ // do something }
boolean findCar(Int number){ // do something }
int freeSlotsCount(){ // do something }
int occupiedSlots(){ // do something }
int parkingType(){ // do something }
int calculateParkingFee(int hours, int charge, int duration){ // do something }
int findParkingSlot(){ // do something }
}

Interfaces play another important role in the object-oriented programming language. Interfaces are not part of the class hierarchy, although they work in combination with classes. Interfaces provide an alternative for languages like Java that does not allow multiple inheritance .

In Java, a class can inherit from only one class but it can implement more than one interface. Therefore, objects can have multiple types: the type of their own class and the types of all the interfaces that they implement. This means that if a variable is declared to be the type of an interface, its value can reference any object that is instantiated from any class that implements the interface.

==Mixins==

Modules provide a structure to collect classes, methods, and constants into a single, separately defined unit. They provide the simplest and an elegant way to adhere to the [http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] principle. This is useful so as to avoid clashes with existing classes, methods, and constants.

Modules are defined in Ruby using the ''module'' keyword.

A Mixin is a class that is mixed with a module or a set of modules i.e. the implementation of the modules and the class are intertwined and combined together <ref>[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Mixins] </ref>.

This gives us a neat and controlled way of adding new functionality to classes. Modules are similar to classes in that they hold a collection of methods, variables constants and other modules and class definitions. However, the real usage of a Mixin is exploited when the code in the Mixin starts to interact with code in the class that uses it.

Below is an example for modules and Mixins:

The module ParkingSlot consists of the methods park and unpark

module ParkingSlot
def park
#code to park the car
end
def unpark
#code to unpark the car
end
end

The module ParkingMeter consists of the methods calculate and printreceipt

module ParkingMeter
def calculate
#code to calculate the parking fee
end
def printreceipt
#code to print the receipt
end
end

When a class ''includes'' a module via include Module Name, all the methods on that module become instance methods on the class.

class Parking
include ParkingSlot
include ParkingMeter
def printcardetails
#code to print the details and type of car
end
end

The modules ParkingSlot and ParkingMeter are “included” in the Parking class. All the variables and the instance methods of the modules ParkingSlot and ParkingMeter are now said to be “mixed in” into the class. It is now possible for class instances to use these methods defined in the modules as and when required.

p=Parking.new
p.park # -> Method park from module ParkingSlot
p.unpark # -> Method unpark from module ParkingSlot
p.calculate # -> Method calculate from module ParkingMeter
p.printreceipt # -> Method printreceipt from module ParkingMeter
p.printcardetails # -> Calls printCarDetails from class

The class Parking inherits from both the modules and the module methods are now available in Parking. Hence, it is now possible to use the methods with an instance of the Parking class ''p''.

Hence, Mixins can be thought of taking different methods and variables defined in different modules making them available as instance methods in the class as well, thereby extending the class’ functionality. Effectively mixed in modules behave as [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclass].

[[Image:ParkingLot.PNG | center]]

==Supported Languages==
The following table shows support for Mixins and Interfaces by most commonly used languages.

{| class="wikitable"
|-
! Languages
! Mixins
! Interfaces
|-
| Ruby
| Yes
| No
|-
| Java
| No
| Yes
|-
| Python
| Yes
| No
|-
| Smalltalk
| Yes
| No
|-
| Perl
| Yes
| No
|-
| C#
| No
| Yes

|}

=Multiple Inheritance=
[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass.
Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

==Diamond Problem==
This section describes the well know “Diamond Problem”<ref>[http://www.artima.com/designtechniques/interfaces2.html Diamond Problem] </ref> associated with multiple Inheritance and the succeeding sections describe how Mixins and interfaces can be used to overcome this problem.
The diamond problem is the ambiguity that can occur when a class inherits from two different classes that both descend from a common superclass. For example, consider a scenario where one decides to combine the Frog and Dinosaur species which both are inherited from the Animal class. The talk() method in the Animal class is abstract and both Frog and Dinosaur needs to implement this method.

Lets say both Frog and Dinosaur implement the talk method like this:

public class Frog extends Animal {
void talk() {
System.out.println(“I am Frog, I can croak “);
}
}

and,
public class Dinosaur extends Animal {
void talk() {
System.out.println(“I am Dinosaur, I can roar “);
}
}

[[Image:Diamond_problem.PNG | center]]

When the Frogsaur is created, it inherits from both Frog and Dinosaur.

public class Frogsaur extends Frog, Dinosaur {
// Note below syntax is used just for demonstration. However java might throw compile time error.
}

The real problem occurs when someone tries to invoke talk() method on a Frogsaur object from the Animal reference.

Animal species = new Frogsaur();
species.talk(); // which method to invoke ???

Due to the ambiguity caused by the diamond problem, it isn’t clear whether the runtime system should invoke Frog’s talk() method or Dinosaur talk() method.

==Approaches==
Different programming languages have addressed the diamond problem in different ways.

In Java, interfaces solve all these ambiguities caused by the diamond problem. Through interfaces, Java allows multiple inheritance of interface but not of implementation. Implementation, which includes instance variables and method implementations, is always singly inherited. As a result, confusion will never arise in Java over which inherited instance variable or method implementation to use.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes<ref>[http://download.oracle.com/javase/tutorial/java/IandI/abstract.html Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Frog and Dinosaur, each of which contain the talk method defined in them. The Frogsaur class ''includes'' these two methods and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Frog
def talk
puts "I can croak"
end
end

module Dinosaur
def talk
puts "I can roar"
end
end

class Frogsaur
include Frog
include Dinosaur
def talk
puts "I can roar like a dinosaur and croak like a frog"
end
end

fs = Frogsaur.new
fs.talk # -> Which talk method to call ??

When the method talk is called on the Frogsaur object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Frogsaur class is defined the latest and hence “I can roar like a dinosaur and croak like a frog” is printed. If there was no method defined in the class, method from the Dinosaur is printed since it is next in the hierarchy specified by the include statements.

=Comparison between Mixins and Interfaces=

This is a general comparision:

{| class="wikitable"
|-
! Mixins
! Interfaces
|-
| In Ruby, modules have the implementation of the methods. So all the classes which include the modules gets the same Implementation because classes create a reference to these modules.
|In Java, all classes which implement the interfaces should provide implementation for each of the methods declared in the interface. This might duplicate the code if the two or more classes have similar functionality.
|-
| The size of the code is relatively smaller because the classes automatically get access to methods defined in the modules. Modules server as a central repository
| The size is relatively larger because a class implementing more than one interfaces has to provide implementation.
|-
| Having more modules in the classes can make code less readable. Ideally mixins are suitable for small teams having few modules.
| The code is more readable here as the implementation is provided to each method and can be found in place
|-
| In Ruby, a method inside a module can have Module name as qualifier. Hence it’s possible for a class to have inherit two or more modules which have same names.
| In Java, the class itself has to provide the implementation of the methods. Inheriting methods of same names from different interfaces will signal an error message.
|-
| Modules cannot be inherited and cannot form is-a hierarchy
| Interfaces can extend another interface and hence can form is-a hierarchy
|}

==Drawbacks of Mixins and Interfaces==

The drawbacks of the technique of Mixins are very much debated. Though Mixins provide us with an easy way to write flexible and decoupled code and also help us solve the diamond problem, they pose their own problems. In large programs there could be large number of modules and each module could have loads of methods each performing a certain task.To trace the origin of the methods and to keep in mind the hierarchy is practically impossible. Another issue associated with Mixins pose is silent method overriding. Silent method overriding occurs when different modules are included in a class and each module have a method with the same definition. In such a case, the method which gets executed depends upon the way it is included in the class and this is done without any sort of message to the user (silently). In large scale applications this could certainly be an issue considering the number of modules that would be mixed in and it would be difficult to keep track of the hierarchy in which the modules were included.

Although Java provides polymorphic behavior with the use of interfaces, they sometimes tend to be very slow. The implementation of interfaces are also limited to public methods and constants with no implementation.

=Conclusion=
Although mixins have certain advantages over interfaces, they possess their own share of disadvantages. Mixins are generally used in small frameworks and interfaces , more than solving the problem of multiple inheritance provide polymorphism feature which makes object-oriented code more flexible and easy to modify and maintain.

=References=
<references/>

=See Also=
1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ 
3. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
4. https://www.cs.washington.edu/education/courses/cse413/11sp/lectures/ruby_interfaces-etc.pdf 
5. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
6. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch2 2c ds

2011-09-30T19:51:40Z

Ssreepa: /* Approaches */

=Mixins vs. Interfaces=

=Introduction=

In object oriented programming Mixins and Interfaces provide neat constructs to implement certain functionality and benefit from code re-usability. Understanding these constructs will benefit any programmer in designing any software with maximum polymorphic behavior and code re-usability.

With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to because of the problems associated with multiple inheritance<ref>[http://www.artima.com/intv/gosling13.html Inspiration for Interface]</ref>.

While [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] like languages implemented interfaces to allow for [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism],languages like [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] opted not to implement multiple inheritance but to allow the code from one module be added into another class.

Though both interfaces and Mixins simulate multiple inheritance and avoid the common pathologies associated with it , they have their own set of compromises. The below article tries to provide clarity on how this is achieved in each and also provides other distinctive features of Mixins and interfaces.

===Interfaces===
In an object-oriented programming languages such as Java, C#, an interface<ref>[http://download.oracle.com/javase/tutorial/ Interfaces] </ref> is a reference type, similar to a class that can contain only constants, method signatures, and nested types. There are no method bodies. Interfaces cannot be instantiated and they can only be implemented by classes or extended by other interfaces. All methods are public by default and any fields declared in an interface are by default static and final.

Example:

public interface ParkingLot {
boolean add(Car car, int slot);
boolean remove(Car car);
boolean findCar(Int number);
int freeSlotsCount();
int occupiedSlots();
int parkingType();
int calculateParkingFee(int hours, int charge, int duration);
int findParkingSlot();
}

public class Mall implements ParkingLot {
boolean add(Car car, int slot) { //... Code to add a car into the parking lot... }
boolean remove(Car car){ // do something }
boolean findCar(Int number){ // do something }
int freeSlotsCount(){ // do something }
int occupiedSlots(){ // do something }
int parkingType(){ // do something }
int calculateParkingFee(int hours, int charge, int duration){ // do something }
int findParkingSlot(){ // do something }
}

Interfaces play another important role in the object-oriented programming language. Interfaces are not part of the class hierarchy, although they work in combination with classes. Interfaces provide an alternative for languages like Java that does not allow multiple inheritance .

In Java, a class can inherit from only one class but it can implement more than one interface. Therefore, objects can have multiple types: the type of their own class and the types of all the interfaces that they implement. This means that if a variable is declared to be the type of an interface, its value can reference any object that is instantiated from any class that implements the interface.

==Mixins==

Modules provide a structure to collect classes, methods, and constants into a single, separately defined unit. They provide the simplest and an elegant way to adhere to the [http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] principle. This is useful so as to avoid clashes with existing classes, methods, and constants.

Modules are defined in Ruby using the ''module'' keyword.

A Mixin is a class that is mixed with a module or a set of modules i.e. the implementation of the modules and the class are intertwined and combined together <ref>[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Mixins] </ref>.

This gives us a neat and controlled way of adding new functionality to classes. Modules are similar to classes in that they hold a collection of methods, variables constants and other modules and class definitions. However, the real usage of a Mixin is exploited when the code in the Mixin starts to interact with code in the class that uses it.

Below is an example for modules and Mixins:

The module ParkingSlot consists of the methods park and unpark

module ParkingSlot
def park
#code to park the car
end
def unpark
#code to unpark the car
end
end

The module ParkingMeter consists of the methods calculate and printreceipt

module ParkingMeter
def calculate
#code to calculate the parking fee
end
def printreceipt
#code to print the receipt
end
end

When a class ''includes'' a module via include Module Name, all the methods on that module become instance methods on the class.

class Parking
include ParkingSlot
include ParkingMeter
def printcardetails
#code to print the details and type of car
end
end

The modules ParkingSlot and ParkingMeter are “included” in the Parking class. All the variables and the instance methods of the modules ParkingSlot and ParkingMeter are now said to be “mixed in” into the class. It is now possible for class instances to use these methods defined in the modules as and when required.

p=Parking.new
p.park # -> Method park from module ParkingSlot
p.unpark # -> Method unpark from module ParkingSlot
p.calculate # -> Method calculate from module ParkingMeter
p.printreceipt # -> Method printreceipt from module ParkingMeter
p.printcardetails # -> Calls printCarDetails from class

The class Parking inherits from both the modules and the module methods are now available in Parking. Hence, it is now possible to use the methods with an instance of the Parking class ''p''.

Hence, Mixins can be thought of taking different methods and variables defined in different modules making them available as instance methods in the class as well, thereby extending the class’ functionality. Effectively mixed in modules behave as [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclass].

[[Image:ParkingLot.PNG | center]]

==Supported Languages==
The following table shows support for Mixins and Interfaces by most commonly used languages.

{| class="wikitable"
|-
! Languages
! Mixins
! Interfaces
|-
| Ruby
| Yes
| No
|-
| Java
| No
| Yes
|-
| Python
| Yes
| No
|-
| Smalltalk
| Yes
| No
|-
| Perl
| Yes
| No
|-
| C#
| No
| Yes

|}

=Multiple Inheritance=
[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass.
Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

==Diamond Problem==
This section describes the well know “Diamond Problem”<ref>[http://www.artima.com/designtechniques/interfaces2.html Diamond Problem] </ref> associated with multiple Inheritance and the succeeding sections describe how Mixins and interfaces can be used to overcome this problem.
The diamond problem is the ambiguity that can occur when a class inherits from two different classes that both descend from a common superclass. For example, consider a scenario where one decides to combine the Frog and Dinosaur species which both are inherited from the Animal class. The talk() method in the Animal class is abstract and both Frog and Dinosaur needs to implement this method.

Lets say both Frog and Dinosaur implement the talk method like this:

public class Frog extends Animal {
void talk() {
System.out.println(“I am Frog, I can croak “);
}
}

and,
public class Dinosaur extends Animal {
void talk() {
System.out.println(“I am Dinosaur, I can roar “);
}
}

[[Image:Diamond_problem.PNG | center]]

When the Frogsaur is created, it inherits from both Frog and Dinosaur.

public class Frogsaur extends Frog, Dinosaur {
// Note below syntax is used just for demonstration. However java might throw compile time error.
}

The real problem occurs when someone tries to invoke talk() method on a Frogsaur object from the Animal reference.

Animal species = new Frogsaur();
species.talk(); // which method to invoke ???

Due to the ambiguity caused by the diamond problem, it isn’t clear whether the runtime system should invoke Frog’s talk() method or Dinosaur talk() method.

==Approaches==
Different programming languages have addressed the diamond problem in different ways.

In Java, interfaces solve all these ambiguities caused by the diamond problem. Through interfaces, Java allows multiple inheritance of interface but not of implementation. Implementation, which includes instance variables and method implementations, is always singly inherited. As a result, confusion will never arise in Java over which inherited instance variable or method implementation to use.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes<ref>[http://download.oracle.com/javase/tutorial/java/IandI/abstract.html Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Frog and Dinosaur, each of which contain the talk method defined in them. The Frogsaur class ''includes'' these two methods and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Frog
def talk
puts "I can croak"
end
end

module Dinosaur
def talk
puts "I can roar"
end
end

class Frogsaur
include Frog
include Dinosaur
def talk
puts "I can roar like a dinosaur and croak like a frog"
end
end

fs = Frogsaur.new
fs.talk # -> Which talk method to call ??

When the method talk is called on the Frogsaur object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Frogsaur class is defined the latest and hence “I can roar like a dinosaur and croak like a frog” is printed. If there was no method defined in the class, method from the Dinosaur is printed since it is next in the hierarchy specified by the include statements.

=Comparison between Mixins and Interfaces=

This is a general comparision:

{| class="wikitable"
|-
! Mixins
! Interfaces
|-
| In Ruby, modules have the implementation of the methods. So all the classes which include the modules gets the same Implementation because classes create a reference to these modules.
|In Java, all classes which implement the interfaces should provide implementation for each of the methods declared in the interface. This might duplicate the code if the two or more classes have similar functionality.
|-
| The size of the code is relatively smaller because the classes automatically get access to methods defined in the modules. Modules server as a central repository
| The size is relatively larger because a class implementing more than one interfaces has to provide implementation.
|-
| Having more modules in the classes can make code less readable. Ideally mixins are suitable for small teams having few modules.
| The code is more readable here as the implementation is provided to each method and can be found in place
|-
| In Ruby, a method inside a module can have Module name as qualifier. Hence it’s possible for a class to have inherit two or more modules which have same names.
| In Java, the class itself has to provide the implementation of the methods. Inheriting methods of same names from different interfaces will signal an error message.
|-
| Modules cannot be inherited and cannot form is-a hierarchy
| Interfaces can extend another interface and hence can form is-a hierarchy
|}

==Drawbacks of Mixins and Interfaces==

The drawbacks of the technique of Mixins are very much debated. Though Mixins provide us with an easy way to write flexible and decoupled code and also help us solve the diamond problem, they pose their own problems. In large programs there could be large number of modules and each module could have loads of methods each performing a certain task.To trace the origin of the methods and to keep in mind the hierarchy is practically impossible. Another issue associated with Mixins pose is silent method overriding. Silent method overriding occurs when different modules are included in a class and each module have a method with the same definition. In such a case, the method which gets executed depends upon the way it is included in the class and this is done without any sort of message to the user (silently). In large scale applications this could certainly be an issue considering the number of modules that would be mixed in and it would be difficult to keep track of the hierarchy in which the modules were included.

Although Java provides polymorphic behavior with the use of interfaces, they sometimes tend to be very slow. The implementation of interfaces are also limited to public methods and constants with no implementation.

=Conclusion=
Although mixins have certain advantages over interfaces, they possess their own share of disadvantages. Mixins are generally used in small frameworks and interfaces , more than solving the problem of multiple inheritance provide polymorphism feature which makes object-oriented code more flexible and easy to modify and maintain.

=References=
<references/>

=See Also=
1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ 
3. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
4. https://www.cs.washington.edu/education/courses/cse413/11sp/lectures/ruby_interfaces-etc.pdf 
5. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
6. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch2 2c ds

2011-09-30T19:44:05Z

Ssreepa: /* Interfaces */

=Mixins vs. Interfaces=

=Introduction=

In object oriented programming Mixins and Interfaces provide neat constructs to implement certain functionality and benefit from code re-usability. Understanding these constructs will benefit any programmer in designing any software with maximum polymorphic behavior and code re-usability.

With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to because of the problems associated with multiple inheritance<ref>[http://www.artima.com/intv/gosling13.html Inspiration for Interface]</ref>.

While [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] like languages implemented interfaces to allow for [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism],languages like [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] opted not to implement multiple inheritance but to allow the code from one module be added into another class.

Though both interfaces and Mixins simulate multiple inheritance and avoid the common pathologies associated with it , they have their own set of compromises. The below article tries to provide clarity on how this is achieved in each and also provides other distinctive features of Mixins and interfaces.

===Interfaces===
In an object-oriented programming languages such as Java, C#, an interface<ref>[http://download.oracle.com/javase/tutorial/ Interfaces] </ref> is a reference type, similar to a class that can contain only constants, method signatures, and nested types. There are no method bodies. Interfaces cannot be instantiated and they can only be implemented by classes or extended by other interfaces. All methods are public by default and any fields declared in an interface are by default static and final.

Example:

public interface ParkingLot {
boolean add(Car car, int slot);
boolean remove(Car car);
boolean findCar(Int number);
int freeSlotsCount();
int occupiedSlots();
int parkingType();
int calculateParkingFee(int hours, int charge, int duration);
int findParkingSlot();
}

public class Mall implements ParkingLot {
boolean add(Car car, int slot) { //... Code to add a car into the parking lot... }
boolean remove(Car car){ // do something }
boolean findCar(Int number){ // do something }
int freeSlotsCount(){ // do something }
int occupiedSlots(){ // do something }
int parkingType(){ // do something }
int calculateParkingFee(int hours, int charge, int duration){ // do something }
int findParkingSlot(){ // do something }
}

Interfaces play another important role in the object-oriented programming language. Interfaces are not part of the class hierarchy, although they work in combination with classes. Interfaces provide an alternative for languages like Java that does not allow multiple inheritance .

In Java, a class can inherit from only one class but it can implement more than one interface. Therefore, objects can have multiple types: the type of their own class and the types of all the interfaces that they implement. This means that if a variable is declared to be the type of an interface, its value can reference any object that is instantiated from any class that implements the interface.

==Mixins==

Modules provide a structure to collect classes, methods, and constants into a single, separately defined unit. They provide the simplest and an elegant way to adhere to the [http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] principle. This is useful so as to avoid clashes with existing classes, methods, and constants.

Modules are defined in Ruby using the ''module'' keyword.

A Mixin is a class that is mixed with a module or a set of modules i.e. the implementation of the modules and the class are intertwined and combined together <ref>[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Mixins] </ref>.

This gives us a neat and controlled way of adding new functionality to classes. Modules are similar to classes in that they hold a collection of methods, variables constants and other modules and class definitions. However, the real usage of a Mixin is exploited when the code in the Mixin starts to interact with code in the class that uses it.

Below is an example for modules and Mixins:

The module ParkingSlot consists of the methods park and unpark

module ParkingSlot
def park
#code to park the car
end
def unpark
#code to unpark the car
end
end

The module ParkingMeter consists of the methods calculate and printreceipt

module ParkingMeter
def calculate
#code to calculate the parking fee
end
def printreceipt
#code to print the receipt
end
end

When a class ''includes'' a module via include Module Name, all the methods on that module become instance methods on the class.

class Parking
include ParkingSlot
include ParkingMeter
def printcardetails
#code to print the details and type of car
end
end

The modules ParkingSlot and ParkingMeter are “included” in the Parking class. All the variables and the instance methods of the modules ParkingSlot and ParkingMeter are now said to be “mixed in” into the class. It is now possible for class instances to use these methods defined in the modules as and when required.

p=Parking.new
p.park # -> Method park from module ParkingSlot
p.unpark # -> Method unpark from module ParkingSlot
p.calculate # -> Method calculate from module ParkingMeter
p.printreceipt # -> Method printreceipt from module ParkingMeter
p.printcardetails # -> Calls printCarDetails from class

The class Parking inherits from both the modules and the module methods are now available in Parking. Hence, it is now possible to use the methods with an instance of the Parking class ''p''.

Hence, Mixins can be thought of taking different methods and variables defined in different modules making them available as instance methods in the class as well, thereby extending the class’ functionality. Effectively mixed in modules behave as [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclass].

[[Image:ParkingLot.PNG | center]]

==Supported Languages==
The following table shows support for Mixins and Interfaces by most commonly used languages.

{| class="wikitable"
|-
! Languages
! Mixins
! Interfaces
|-
| Ruby
| Yes
| No
|-
| Java
| No
| Yes
|-
| Python
| Yes
| No
|-
| Smalltalk
| Yes
| No
|-
| Perl
| Yes
| No
|-
| C#
| No
| Yes

|}

=Multiple Inheritance=
[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass.
Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

==Diamond Problem==
This section describes the well know “Diamond Problem”<ref>[http://www.artima.com/designtechniques/interfaces2.html Diamond Problem] </ref> associated with multiple Inheritance and the succeeding sections describe how Mixins and interfaces can be used to overcome this problem.
The diamond problem is the ambiguity that can occur when a class inherits from two different classes that both descend from a common superclass. For example, consider a scenario where one decides to combine the Frog and Dinosaur species which both are inherited from the Animal class. The talk() method in the Animal class is abstract and both Frog and Dinosaur needs to implement this method.

Lets say both Frog and Dinosaur implement the talk method like this:

public class Frog extends Animal {
void talk() {
System.out.println(“I am Frog, I can croak “);
}
}

and,
public class Dinosaur extends Animal {
void talk() {
System.out.println(“I am Dinosaur, I can roar “);
}
}

[[Image:Diamond_problem.PNG | center]]

When the Frogsaur is created, it inherits from both Frog and Dinosaur.

public class Frogsaur extends Frog, Dinosaur {
// Note below syntax is used just for demonstration. However java might throw compile time error.
}

The real problem occurs when someone tries to invoke talk() method on a Frogsaur object from the Animal reference.

Animal species = new Frogsaur();
species.talk(); // which method to invoke ???

Due to the ambiguity caused by the diamond problem, it isn’t clear whether the runtime system should invoke Frog’s talk() method or Dinosaur talk() method.

==Approaches==
Different programming languages have addressed the diamond problem in different ways.

In Java, interfaces solve all these ambiguities caused by the diamond problem. Through interfaces, Java allows multiple inheritance of interface but not of implementation. Implementation, which includes instance variables and method implementations, is always singly inherited. As a result, confusion will never arise in Java over which inherited instance variable or method implementation to use.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes<ref>[http://download.oracle.com/javase/tutorial/java/IandI/abstract.html Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Frog and Dinosaur, each of which contain the talk method defined in them. The Frogsaur class ''includes'' these two methods and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Frog
def talk
puts "I can croak"
end
end

module Dinosaur
def talk
puts "I can roar"
end
end

class Frogsaur
include Frog
include Dinosaur
def talk
puts "I can roar like a dinosaur and croak like a frog"
end
end

fs = Frogsaur.new
fs.talk # -> I can roar like a dinosaur and croak like a frog

When the method talk is called on the Frogsaur object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Frogsaur class is defined the latest and hence “I can roar like a dinosaur and croak like a frog” is printed. If there was no method defined in the class, method from the Dinosaur is printed since it is next in the hierarchy specified by the include statements.

=Comparison between Mixins and Interfaces=

This is a general comparision:

{| class="wikitable"
|-
! Mixins
! Interfaces
|-
| In Ruby, modules have the implementation of the methods. So all the classes which include the modules gets the same Implementation because classes create a reference to these modules.
|In Java, all classes which implement the interfaces should provide implementation for each of the methods declared in the interface. This might duplicate the code if the two or more classes have similar functionality.
|-
| The size of the code is relatively smaller because the classes automatically get access to methods defined in the modules. Modules server as a central repository
| The size is relatively larger because a class implementing more than one interfaces has to provide implementation.
|-
| Having more modules in the classes can make code less readable. Ideally mixins are suitable for small teams having few modules.
| The code is more readable here as the implementation is provided to each method and can be found in place
|-
| In Ruby, a method inside a module can have Module name as qualifier. Hence it’s possible for a class to have inherit two or more modules which have same names.
| In Java, the class itself has to provide the implementation of the methods. Inheriting methods of same names from different interfaces will signal an error message.
|-
| Modules cannot be inherited and cannot form is-a hierarchy
| Interfaces can extend another interface and hence can form is-a hierarchy
|}

==Drawbacks of Mixins and Interfaces==

The drawbacks of the technique of Mixins are very much debated. Though Mixins provide us with an easy way to write flexible and decoupled code and also help us solve the diamond problem, they pose their own problems. In large programs there could be large number of modules and each module could have loads of methods each performing a certain task.To trace the origin of the methods and to keep in mind the hierarchy is practically impossible. Another issue associated with Mixins pose is silent method overriding. Silent method overriding occurs when different modules are included in a class and each module have a method with the same definition. In such a case, the method which gets executed depends upon the way it is included in the class and this is done without any sort of message to the user (silently). In large scale applications this could certainly be an issue considering the number of modules that would be mixed in and it would be difficult to keep track of the hierarchy in which the modules were included.

Although Java provides polymorphic behavior with the use of interfaces, they sometimes tend to be very slow. The implementation of interfaces are also limited to public methods and constants with no implementation.

=Conclusion=
Although mixins have certain advantages over interfaces, they possess their own share of disadvantages. Mixins are generally used in small frameworks and interfaces , more than solving the problem of multiple inheritance provide polymorphism feature which makes object-oriented code more flexible and easy to modify and maintain.

=References=
<references/>

=See Also=
1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ 
3. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
4. https://www.cs.washington.edu/education/courses/cse413/11sp/lectures/ruby_interfaces-etc.pdf 
5. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
6. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch2 2c ds

2011-09-30T19:43:15Z

Ssreepa: /* Interfaces */

=Mixins vs. Interfaces=

=Introduction=

In object oriented programming Mixins and Interfaces provide neat constructs to implement certain functionality and benefit from code re-usability. Understanding these constructs will benefit any programmer in designing any software with maximum polymorphic behavior and code re-usability.

With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to because of the problems associated with multiple inheritance<ref>[http://www.artima.com/intv/gosling13.html Inspiration for Interface]</ref>.

While [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] like languages implemented interfaces to allow for [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism],languages like [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] opted not to implement multiple inheritance but to allow the code from one module be added into another class.

Though both interfaces and Mixins simulate multiple inheritance and avoid the common pathologies associated with it , they have their own set of compromises. The below article tries to provide clarity on how this is achieved in each and also provides other distinctive features of Mixins and interfaces.

===Interfaces===
In an object-oriented programming languages such as Java, C#, an interface<ref>[http://download.oracle.com/javase/tutorial/ Interfaces] </ref> is a reference type, similar to a class that can contain only constants, method signatures, and nested types. There are no method bodies. Interfaces cannot be instantiated and they can only be implemented by classes or extended by other interfaces. All methods are public by default and any fields declared in an interface are by default static and final.

Example:

public interface ParkingLot {
boolean add(Car car, int slot);
boolean remove(Car car);
boolean findCar(Int number);
int freeSlotsCount();
int occupiedSlots();
int parkingType();
int calculateParkingFee(int hours, int charge, int duration);
int findParkingSlot();
}

public class Mall implements ParkingLot {
boolean add(Car car, int slot) {

//... Code to add a car into the parking lot...

}
boolean remove(Car car){ // do something }
boolean findCar(Int number){ // do something }
int freeSlotsCount(){ // do something }
int occupiedSlots(){ // do something }
int parkingType(){ // do something }
int calculateParkingFee(int hours, int charge, int duration){ // do something }
int findParkingSlot(){ // do something }
}

Interfaces play another important role in the object-oriented programming language. Interfaces are not part of the class hierarchy, although they work in combination with classes. Interfaces provide an alternative for languages like Java that does not allow multiple inheritance .

In Java, a class can inherit from only one class but it can implement more than one interface. Therefore, objects can have multiple types: the type of their own class and the types of all the interfaces that they implement. This means that if a variable is declared to be the type of an interface, its value can reference any object that is instantiated from any class that implements the interface.

==Mixins==

Modules provide a structure to collect classes, methods, and constants into a single, separately defined unit. They provide the simplest and an elegant way to adhere to the [http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] principle. This is useful so as to avoid clashes with existing classes, methods, and constants.

Modules are defined in Ruby using the ''module'' keyword.

A Mixin is a class that is mixed with a module or a set of modules i.e. the implementation of the modules and the class are intertwined and combined together <ref>[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Mixins] </ref>.

This gives us a neat and controlled way of adding new functionality to classes. Modules are similar to classes in that they hold a collection of methods, variables constants and other modules and class definitions. However, the real usage of a Mixin is exploited when the code in the Mixin starts to interact with code in the class that uses it.

Below is an example for modules and Mixins:

The module ParkingSlot consists of the methods park and unpark

module ParkingSlot
def park
#code to park the car
end
def unpark
#code to unpark the car
end
end

The module ParkingMeter consists of the methods calculate and printreceipt

module ParkingMeter
def calculate
#code to calculate the parking fee
end
def printreceipt
#code to print the receipt
end
end

When a class ''includes'' a module via include Module Name, all the methods on that module become instance methods on the class.

class Parking
include ParkingSlot
include ParkingMeter
def printcardetails
#code to print the details and type of car
end
end

The modules ParkingSlot and ParkingMeter are “included” in the Parking class. All the variables and the instance methods of the modules ParkingSlot and ParkingMeter are now said to be “mixed in” into the class. It is now possible for class instances to use these methods defined in the modules as and when required.

p=Parking.new
p.park # -> Method park from module ParkingSlot
p.unpark # -> Method unpark from module ParkingSlot
p.calculate # -> Method calculate from module ParkingMeter
p.printreceipt # -> Method printreceipt from module ParkingMeter
p.printcardetails # -> Calls printCarDetails from class

The class Parking inherits from both the modules and the module methods are now available in Parking. Hence, it is now possible to use the methods with an instance of the Parking class ''p''.

Hence, Mixins can be thought of taking different methods and variables defined in different modules making them available as instance methods in the class as well, thereby extending the class’ functionality. Effectively mixed in modules behave as [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclass].

[[Image:ParkingLot.PNG | center]]

==Supported Languages==
The following table shows support for Mixins and Interfaces by most commonly used languages.

{| class="wikitable"
|-
! Languages
! Mixins
! Interfaces
|-
| Ruby
| Yes
| No
|-
| Java
| No
| Yes
|-
| Python
| Yes
| No
|-
| Smalltalk
| Yes
| No
|-
| Perl
| Yes
| No
|-
| C#
| No
| Yes

|}

=Multiple Inheritance=
[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass.
Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

==Diamond Problem==
This section describes the well know “Diamond Problem”<ref>[http://www.artima.com/designtechniques/interfaces2.html Diamond Problem] </ref> associated with multiple Inheritance and the succeeding sections describe how Mixins and interfaces can be used to overcome this problem.
The diamond problem is the ambiguity that can occur when a class inherits from two different classes that both descend from a common superclass. For example, consider a scenario where one decides to combine the Frog and Dinosaur species which both are inherited from the Animal class. The talk() method in the Animal class is abstract and both Frog and Dinosaur needs to implement this method.

Lets say both Frog and Dinosaur implement the talk method like this:

public class Frog extends Animal {
void talk() {
System.out.println(“I am Frog, I can croak “);
}
}

and,
public class Dinosaur extends Animal {
void talk() {
System.out.println(“I am Dinosaur, I can roar “);
}
}

[[Image:Diamond_problem.PNG | center]]

When the Frogsaur is created, it inherits from both Frog and Dinosaur.

public class Frogsaur extends Frog, Dinosaur {
// Note below syntax is used just for demonstration. However java might throw compile time error.
}

The real problem occurs when someone tries to invoke talk() method on a Frogsaur object from the Animal reference.

Animal species = new Frogsaur();
species.talk(); // which method to invoke ???

Due to the ambiguity caused by the diamond problem, it isn’t clear whether the runtime system should invoke Frog’s talk() method or Dinosaur talk() method.

==Approaches==
Different programming languages have addressed the diamond problem in different ways.

In Java, interfaces solve all these ambiguities caused by the diamond problem. Through interfaces, Java allows multiple inheritance of interface but not of implementation. Implementation, which includes instance variables and method implementations, is always singly inherited. As a result, confusion will never arise in Java over which inherited instance variable or method implementation to use.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes<ref>[http://download.oracle.com/javase/tutorial/java/IandI/abstract.html Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Frog and Dinosaur, each of which contain the talk method defined in them. The Frogsaur class ''includes'' these two methods and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Frog
def talk
puts "I can croak"
end
end

module Dinosaur
def talk
puts "I can roar"
end
end

class Frogsaur
include Frog
include Dinosaur
def talk
puts "I can roar like a dinosaur and croak like a frog"
end
end

fs = Frogsaur.new
fs.talk # -> I can roar like a dinosaur and croak like a frog

When the method talk is called on the Frogsaur object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Frogsaur class is defined the latest and hence “I can roar like a dinosaur and croak like a frog” is printed. If there was no method defined in the class, method from the Dinosaur is printed since it is next in the hierarchy specified by the include statements.

=Comparison between Mixins and Interfaces=

This is a general comparision:

{| class="wikitable"
|-
! Mixins
! Interfaces
|-
| In Ruby, modules have the implementation of the methods. So all the classes which include the modules gets the same Implementation because classes create a reference to these modules.
|In Java, all classes which implement the interfaces should provide implementation for each of the methods declared in the interface. This might duplicate the code if the two or more classes have similar functionality.
|-
| The size of the code is relatively smaller because the classes automatically get access to methods defined in the modules. Modules server as a central repository
| The size is relatively larger because a class implementing more than one interfaces has to provide implementation.
|-
| Having more modules in the classes can make code less readable. Ideally mixins are suitable for small teams having few modules.
| The code is more readable here as the implementation is provided to each method and can be found in place
|-
| In Ruby, a method inside a module can have Module name as qualifier. Hence it’s possible for a class to have inherit two or more modules which have same names.
| In Java, the class itself has to provide the implementation of the methods. Inheriting methods of same names from different interfaces will signal an error message.
|-
| Modules cannot be inherited and cannot form is-a hierarchy
| Interfaces can extend another interface and hence can form is-a hierarchy
|}

==Drawbacks of Mixins and Interfaces==

The drawbacks of the technique of Mixins are very much debated. Though Mixins provide us with an easy way to write flexible and decoupled code and also help us solve the diamond problem, they pose their own problems. In large programs there could be large number of modules and each module could have loads of methods each performing a certain task.To trace the origin of the methods and to keep in mind the hierarchy is practically impossible. Another issue associated with Mixins pose is silent method overriding. Silent method overriding occurs when different modules are included in a class and each module have a method with the same definition. In such a case, the method which gets executed depends upon the way it is included in the class and this is done without any sort of message to the user (silently). In large scale applications this could certainly be an issue considering the number of modules that would be mixed in and it would be difficult to keep track of the hierarchy in which the modules were included.

Although Java provides polymorphic behavior with the use of interfaces, they sometimes tend to be very slow. The implementation of interfaces are also limited to public methods and constants with no implementation.

=Conclusion=
Although mixins have certain advantages over interfaces, they possess their own share of disadvantages. Mixins are generally used in small frameworks and interfaces , more than solving the problem of multiple inheritance provide polymorphism feature which makes object-oriented code more flexible and easy to modify and maintain.

=References=
<references/>

=See Also=
1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ 
3. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
4. https://www.cs.washington.edu/education/courses/cse413/11sp/lectures/ruby_interfaces-etc.pdf 
5. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
6. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch2 2c ds

2011-09-30T19:42:19Z

Ssreepa: /* Interfaces */

=Mixins vs. Interfaces=

=Introduction=

In object oriented programming Mixins and Interfaces provide neat constructs to implement certain functionality and benefit from code re-usability. Understanding these constructs will benefit any programmer in designing any software with maximum polymorphic behavior and code re-usability.

With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to because of the problems associated with multiple inheritance<ref>[http://www.artima.com/intv/gosling13.html Inspiration for Interface]</ref>.

While [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] like languages implemented interfaces to allow for [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism],languages like [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] opted not to implement multiple inheritance but to allow the code from one module be added into another class.

Though both interfaces and Mixins simulate multiple inheritance and avoid the common pathologies associated with it , they have their own set of compromises. The below article tries to provide clarity on how this is achieved in each and also provides other distinctive features of Mixins and interfaces.

===Interfaces===
In an object-oriented programming languages such as Java, C#, an interface<ref>[http://download.oracle.com/javase/tutorial/ Interfaces] </ref> is a reference type, similar to a class that can contain only constants, method signatures, and nested types. There are no method bodies. Interfaces cannot be instantiated and they can only be implemented by classes or extended by other interfaces. All methods are public by default and any fields declared in an interface are by default static and final.

Example:

public interface ParkingLot {
boolean add(Car car, int slot);
boolean remove(Car car);
boolean findCar(Int number);
int freeSlotsCount();
int occupiedSlots();
int parkingType();
int calculateParkingFee(int hours, int charge, int duration);
int findParkingSlot();
}

public class Mall implements ParkingLot {
boolean add(Car car, int slot) {

//... Code to add a car into the parking lot...

}
boolean remove(Car car){ // do something }
boolean findCar(Int number){ // do something }
int freeSlotsCount(){ // do something }
int occupiedSlots(){ // do something }
int parkingType(){ // do something }
int calculateParkingFee(int hours, int charge, int duration){ // do something }
int findParkingSlot(){ // do something }
}

Interfaces play another important role in the object-oriented programming language. Interfaces are not part of the class hierarchy, although they work in combination with classes. Interfaces provide an alternative for languages like Java that does not allow multiple inheritance .

In Java, a class can inherit from only one class but it can implement more than one interface. Therefore, objects can have multiple types: the type of their own class and the types of all the interfaces that they implement. This means that if a variable is declared to be the type of an interface, its value can reference any object that is instantiated from any class that implements the interface.

==Mixins==

Modules provide a structure to collect classes, methods, and constants into a single, separately defined unit. They provide the simplest and an elegant way to adhere to the [http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] principle. This is useful so as to avoid clashes with existing classes, methods, and constants.

Modules are defined in Ruby using the ''module'' keyword.

A Mixin is a class that is mixed with a module or a set of modules i.e. the implementation of the modules and the class are intertwined and combined together <ref>[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Mixins] </ref>.

This gives us a neat and controlled way of adding new functionality to classes. Modules are similar to classes in that they hold a collection of methods, variables constants and other modules and class definitions. However, the real usage of a Mixin is exploited when the code in the Mixin starts to interact with code in the class that uses it.

Below is an example for modules and Mixins:

The module ParkingSlot consists of the methods park and unpark

module ParkingSlot
def park
#code to park the car
end
def unpark
#code to unpark the car
end
end

The module ParkingMeter consists of the methods calculate and printreceipt

module ParkingMeter
def calculate
#code to calculate the parking fee
end
def printreceipt
#code to print the receipt
end
end

When a class ''includes'' a module via include Module Name, all the methods on that module become instance methods on the class.

class Parking
include ParkingSlot
include ParkingMeter
def printcardetails
#code to print the details and type of car
end
end

The modules ParkingSlot and ParkingMeter are “included” in the Parking class. All the variables and the instance methods of the modules ParkingSlot and ParkingMeter are now said to be “mixed in” into the class. It is now possible for class instances to use these methods defined in the modules as and when required.

p=Parking.new
p.park # -> Method park from module ParkingSlot
p.unpark # -> Method unpark from module ParkingSlot
p.calculate # -> Method calculate from module ParkingMeter
p.printreceipt # -> Method printreceipt from module ParkingMeter
p.printcardetails # -> Calls printCarDetails from class

The class Parking inherits from both the modules and the module methods are now available in Parking. Hence, it is now possible to use the methods with an instance of the Parking class ''p''.

Hence, Mixins can be thought of taking different methods and variables defined in different modules making them available as instance methods in the class as well, thereby extending the class’ functionality. Effectively mixed in modules behave as [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclass].

[[Image:ParkingLot.PNG | center]]

==Supported Languages==
The following table shows support for Mixins and Interfaces by most commonly used languages.

{| class="wikitable"
|-
! Languages
! Mixins
! Interfaces
|-
| Ruby
| Yes
| No
|-
| Java
| No
| Yes
|-
| Python
| Yes
| No
|-
| Smalltalk
| Yes
| No
|-
| Perl
| Yes
| No
|-
| C#
| No
| Yes

|}

=Multiple Inheritance=
[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass.
Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

==Diamond Problem==
This section describes the well know “Diamond Problem”<ref>[http://www.artima.com/designtechniques/interfaces2.html Diamond Problem] </ref> associated with multiple Inheritance and the succeeding sections describe how Mixins and interfaces can be used to overcome this problem.
The diamond problem is the ambiguity that can occur when a class inherits from two different classes that both descend from a common superclass. For example, consider a scenario where one decides to combine the Frog and Dinosaur species which both are inherited from the Animal class. The talk() method in the Animal class is abstract and both Frog and Dinosaur needs to implement this method.

Lets say both Frog and Dinosaur implement the talk method like this:

public class Frog extends Animal {
void talk() {
System.out.println(“I am Frog, I can croak “);
}
}

and,
public class Dinosaur extends Animal {
void talk() {
System.out.println(“I am Dinosaur, I can roar “);
}
}

[[Image:Diamond_problem.PNG | center]]

When the Frogsaur is created, it inherits from both Frog and Dinosaur.

public class Frogsaur extends Frog, Dinosaur {
// Note below syntax is used just for demonstration. However java might throw compile time error.
}

The real problem occurs when someone tries to invoke talk() method on a Frogsaur object from the Animal reference.

Animal species = new Frogsaur();
species.talk(); // which method to invoke ???

Due to the ambiguity caused by the diamond problem, it isn’t clear whether the runtime system should invoke Frog’s talk() method or Dinosaur talk() method.

==Approaches==
Different programming languages have addressed the diamond problem in different ways.

In Java, interfaces solve all these ambiguities caused by the diamond problem. Through interfaces, Java allows multiple inheritance of interface but not of implementation. Implementation, which includes instance variables and method implementations, is always singly inherited. As a result, confusion will never arise in Java over which inherited instance variable or method implementation to use.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes<ref>[http://download.oracle.com/javase/tutorial/java/IandI/abstract.html Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Frog and Dinosaur, each of which contain the talk method defined in them. The Frogsaur class ''includes'' these two methods and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Frog
def talk
puts "I can croak"
end
end

module Dinosaur
def talk
puts "I can roar"
end
end

class Frogsaur
include Frog
include Dinosaur
def talk
puts "I can roar like a dinosaur and croak like a frog"
end
end

fs = Frogsaur.new
fs.talk # -> I can roar like a dinosaur and croak like a frog

When the method talk is called on the Frogsaur object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Frogsaur class is defined the latest and hence “I can roar like a dinosaur and croak like a frog” is printed. If there was no method defined in the class, method from the Dinosaur is printed since it is next in the hierarchy specified by the include statements.

=Comparison between Mixins and Interfaces=

This is a general comparision:

{| class="wikitable"
|-
! Mixins
! Interfaces
|-
| In Ruby, modules have the implementation of the methods. So all the classes which include the modules gets the same Implementation because classes create a reference to these modules.
|In Java, all classes which implement the interfaces should provide implementation for each of the methods declared in the interface. This might duplicate the code if the two or more classes have similar functionality.
|-
| The size of the code is relatively smaller because the classes automatically get access to methods defined in the modules. Modules server as a central repository
| The size is relatively larger because a class implementing more than one interfaces has to provide implementation.
|-
| Having more modules in the classes can make code less readable. Ideally mixins are suitable for small teams having few modules.
| The code is more readable here as the implementation is provided to each method and can be found in place
|-
| In Ruby, a method inside a module can have Module name as qualifier. Hence it’s possible for a class to have inherit two or more modules which have same names.
| In Java, the class itself has to provide the implementation of the methods. Inheriting methods of same names from different interfaces will signal an error message.
|-
| Modules cannot be inherited and cannot form is-a hierarchy
| Interfaces can extend another interface and hence can form is-a hierarchy
|}

==Drawbacks of Mixins and Interfaces==

The drawbacks of the technique of Mixins are very much debated. Though Mixins provide us with an easy way to write flexible and decoupled code and also help us solve the diamond problem, they pose their own problems. In large programs there could be large number of modules and each module could have loads of methods each performing a certain task.To trace the origin of the methods and to keep in mind the hierarchy is practically impossible. Another issue associated with Mixins pose is silent method overriding. Silent method overriding occurs when different modules are included in a class and each module have a method with the same definition. In such a case, the method which gets executed depends upon the way it is included in the class and this is done without any sort of message to the user (silently). In large scale applications this could certainly be an issue considering the number of modules that would be mixed in and it would be difficult to keep track of the hierarchy in which the modules were included.

Although Java provides polymorphic behavior with the use of interfaces, they sometimes tend to be very slow. The implementation of interfaces are also limited to public methods and constants with no implementation.

=Conclusion=
Although mixins have certain advantages over interfaces, they possess their own share of disadvantages. Mixins are generally used in small frameworks and interfaces , more than solving the problem of multiple inheritance provide polymorphism feature which makes object-oriented code more flexible and easy to modify and maintain.

=References=
<references/>

=See Also=
1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ 
3. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
4. https://www.cs.washington.edu/education/courses/cse413/11sp/lectures/ruby_interfaces-etc.pdf 
5. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
6. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch2 2c ds

2011-09-30T19:41:46Z

Ssreepa: /* Interfaces */

=Mixins vs. Interfaces=

=Introduction=

In object oriented programming Mixins and Interfaces provide neat constructs to implement certain functionality and benefit from code re-usability. Understanding these constructs will benefit any programmer in designing any software with maximum polymorphic behavior and code re-usability.

With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to because of the problems associated with multiple inheritance<ref>[http://www.artima.com/intv/gosling13.html Inspiration for Interface]</ref>.

While [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] like languages implemented interfaces to allow for [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism],languages like [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] opted not to implement multiple inheritance but to allow the code from one module be added into another class.

Though both interfaces and Mixins simulate multiple inheritance and avoid the common pathologies associated with it , they have their own set of compromises. The below article tries to provide clarity on how this is achieved in each and also provides other distinctive features of Mixins and interfaces.

===Interfaces===
In an object-oriented programming languages such as Java, C#, an interface<ref>[http://download.oracle.com/javase/tutorial/ Interfaces] </ref> is a reference type, similar to a class that can contain only constants, method signatures, and nested types. There are no method bodies. Interfaces cannot be instantiated and they can only be implemented by classes or extended by other interfaces. All methods are public by default and any fields declared in an interface are by default static and final.

Example:

public interface ParkingLot {
boolean add(Car car, int slot);
boolean remove(Car car);
boolean findCar(Int number);
int freeSlotsCount();
int occupiedSlots();
int parkingType();
int calculateParkingFee(int hours, int charge, int duration);
int findParkingSlot();
}

public class Mall implements ParkingLot {
boolean add(Car car, int slot) {

//... Code to add a car into the parking lot...

}
boolean remove(Car car){ // do something }
boolean findCar(Int number){ // do something }
int freeSlotsCount(){ // do something }
int occupiedSlots(){ // do something }
int parkingType(){ // do something }
int calculateParkingFee(int hours, int charge, int duration){ // do something }
int findParkingSlot(){ // do something }
}

Interfaces play another important role in the object-oriented programming language. Interfaces are not part of the class hierarchy, although they work in combination with classes. Interfaces provide an alternative for languages like Java that does not allow multiple inheritance .

In Java, a class can inherit from only one class but it can implement more than one interface. Therefore, objects can have multiple types: the type of their own class and the types of all the interfaces that they implement. This means that if a variable is declared to be the type of an interface, its value can reference any object that is instantiated from any class that implements the interface.

==Mixins==

Modules provide a structure to collect classes, methods, and constants into a single, separately defined unit. They provide the simplest and an elegant way to adhere to the [http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] principle. This is useful so as to avoid clashes with existing classes, methods, and constants.

Modules are defined in Ruby using the ''module'' keyword.

A Mixin is a class that is mixed with a module or a set of modules i.e. the implementation of the modules and the class are intertwined and combined together <ref>[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Mixins] </ref>.

This gives us a neat and controlled way of adding new functionality to classes. Modules are similar to classes in that they hold a collection of methods, variables constants and other modules and class definitions. However, the real usage of a Mixin is exploited when the code in the Mixin starts to interact with code in the class that uses it.

Below is an example for modules and Mixins:

The module ParkingSlot consists of the methods park and unpark

module ParkingSlot
def park
#code to park the car
end
def unpark
#code to unpark the car
end
end

The module ParkingMeter consists of the methods calculate and printreceipt

module ParkingMeter
def calculate
#code to calculate the parking fee
end
def printreceipt
#code to print the receipt
end
end

When a class ''includes'' a module via include Module Name, all the methods on that module become instance methods on the class.

class Parking
include ParkingSlot
include ParkingMeter
def printcardetails
#code to print the details and type of car
end
end

The modules ParkingSlot and ParkingMeter are “included” in the Parking class. All the variables and the instance methods of the modules ParkingSlot and ParkingMeter are now said to be “mixed in” into the class. It is now possible for class instances to use these methods defined in the modules as and when required.

p=Parking.new
p.park # -> Method park from module ParkingSlot
p.unpark # -> Method unpark from module ParkingSlot
p.calculate # -> Method calculate from module ParkingMeter
p.printreceipt # -> Method printreceipt from module ParkingMeter
p.printcardetails # -> Calls printCarDetails from class

The class Parking inherits from both the modules and the module methods are now available in Parking. Hence, it is now possible to use the methods with an instance of the Parking class ''p''.

Hence, Mixins can be thought of taking different methods and variables defined in different modules making them available as instance methods in the class as well, thereby extending the class’ functionality. Effectively mixed in modules behave as [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclass].

[[Image:ParkingLot.PNG | center]]

==Supported Languages==
The following table shows support for Mixins and Interfaces by most commonly used languages.

{| class="wikitable"
|-
! Languages
! Mixins
! Interfaces
|-
| Ruby
| Yes
| No
|-
| Java
| No
| Yes
|-
| Python
| Yes
| No
|-
| Smalltalk
| Yes
| No
|-
| Perl
| Yes
| No
|-
| C#
| No
| Yes

|}

=Multiple Inheritance=
[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass.
Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

==Diamond Problem==
This section describes the well know “Diamond Problem”<ref>[http://www.artima.com/designtechniques/interfaces2.html Diamond Problem] </ref> associated with multiple Inheritance and the succeeding sections describe how Mixins and interfaces can be used to overcome this problem.
The diamond problem is the ambiguity that can occur when a class inherits from two different classes that both descend from a common superclass. For example, consider a scenario where one decides to combine the Frog and Dinosaur species which both are inherited from the Animal class. The talk() method in the Animal class is abstract and both Frog and Dinosaur needs to implement this method.

Lets say both Frog and Dinosaur implement the talk method like this:

public class Frog extends Animal {
void talk() {
System.out.println(“I am Frog, I can croak “);
}
}

and,
public class Dinosaur extends Animal {
void talk() {
System.out.println(“I am Dinosaur, I can roar “);
}
}

[[Image:Diamond_problem.PNG | center]]

When the Frogsaur is created, it inherits from both Frog and Dinosaur.

public class Frogsaur extends Frog, Dinosaur {
// Note below syntax is used just for demonstration. However java might throw compile time error.
}

The real problem occurs when someone tries to invoke talk() method on a Frogsaur object from the Animal reference.

Animal species = new Frogsaur();
species.talk(); // which method to invoke ???

Due to the ambiguity caused by the diamond problem, it isn’t clear whether the runtime system should invoke Frog’s talk() method or Dinosaur talk() method.

==Approaches==
Different programming languages have addressed the diamond problem in different ways.

In Java, interfaces solve all these ambiguities caused by the diamond problem. Through interfaces, Java allows multiple inheritance of interface but not of implementation. Implementation, which includes instance variables and method implementations, is always singly inherited. As a result, confusion will never arise in Java over which inherited instance variable or method implementation to use.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes<ref>[http://download.oracle.com/javase/tutorial/java/IandI/abstract.html Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Frog and Dinosaur, each of which contain the talk method defined in them. The Frogsaur class ''includes'' these two methods and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Frog
def talk
puts "I can croak"
end
end

module Dinosaur
def talk
puts "I can roar"
end
end

class Frogsaur
include Frog
include Dinosaur
def talk
puts "I can roar like a dinosaur and croak like a frog"
end
end

fs = Frogsaur.new
fs.talk # -> I can roar like a dinosaur and croak like a frog

When the method talk is called on the Frogsaur object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Frogsaur class is defined the latest and hence “I can roar like a dinosaur and croak like a frog” is printed. If there was no method defined in the class, method from the Dinosaur is printed since it is next in the hierarchy specified by the include statements.

=Comparison between Mixins and Interfaces=

This is a general comparision:

{| class="wikitable"
|-
! Mixins
! Interfaces
|-
| In Ruby, modules have the implementation of the methods. So all the classes which include the modules gets the same Implementation because classes create a reference to these modules.
|In Java, all classes which implement the interfaces should provide implementation for each of the methods declared in the interface. This might duplicate the code if the two or more classes have similar functionality.
|-
| The size of the code is relatively smaller because the classes automatically get access to methods defined in the modules. Modules server as a central repository
| The size is relatively larger because a class implementing more than one interfaces has to provide implementation.
|-
| Having more modules in the classes can make code less readable. Ideally mixins are suitable for small teams having few modules.
| The code is more readable here as the implementation is provided to each method and can be found in place
|-
| In Ruby, a method inside a module can have Module name as qualifier. Hence it’s possible for a class to have inherit two or more modules which have same names.
| In Java, the class itself has to provide the implementation of the methods. Inheriting methods of same names from different interfaces will signal an error message.
|-
| Modules cannot be inherited and cannot form is-a hierarchy
| Interfaces can extend another interface and hence can form is-a hierarchy
|}

==Drawbacks of Mixins and Interfaces==

The drawbacks of the technique of Mixins are very much debated. Though Mixins provide us with an easy way to write flexible and decoupled code and also help us solve the diamond problem, they pose their own problems. In large programs there could be large number of modules and each module could have loads of methods each performing a certain task.To trace the origin of the methods and to keep in mind the hierarchy is practically impossible. Another issue associated with Mixins pose is silent method overriding. Silent method overriding occurs when different modules are included in a class and each module have a method with the same definition. In such a case, the method which gets executed depends upon the way it is included in the class and this is done without any sort of message to the user (silently). In large scale applications this could certainly be an issue considering the number of modules that would be mixed in and it would be difficult to keep track of the hierarchy in which the modules were included.

Although Java provides polymorphic behavior with the use of interfaces, they sometimes tend to be very slow. The implementation of interfaces are also limited to public methods and constants with no implementation.

=Conclusion=
Although mixins have certain advantages over interfaces, they possess their own share of disadvantages. Mixins are generally used in small frameworks and interfaces , more than solving the problem of multiple inheritance provide polymorphism feature which makes object-oriented code more flexible and easy to modify and maintain.

=References=
<references/>

=See Also=
1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ 
3. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
4. https://www.cs.washington.edu/education/courses/cse413/11sp/lectures/ruby_interfaces-etc.pdf 
5. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
6. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch2 2c ds

2011-09-30T19:33:36Z

Ssreepa: /* Drawbacks of Mixins and Interfaces */

=Mixins vs. Interfaces=

=Introduction=

In object oriented programming Mixins and Interfaces provide neat constructs to implement certain functionality and benefit from code re-usability. Understanding these constructs will benefit any programmer in designing any software with maximum polymorphic behavior and code re-usability.

With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to because of the problems associated with multiple inheritance<ref>[http://www.artima.com/intv/gosling13.html Inspiration for Interface]</ref>.

While [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] like languages implemented interfaces to allow for [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism],languages like [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] opted not to implement multiple inheritance but to allow the code from one module be added into another class.

Though both interfaces and Mixins simulate multiple inheritance and avoid the common pathologies associated with it , they have their own set of compromises. The below article tries to provide clarity on how this is achieved in each and also provides other distinctive features of Mixins and interfaces.

===Interfaces===
In an object-oriented programming languages such as Java, C#, an interface<ref>[http://download.oracle.com/javase/tutorial/ Interfaces] </ref> is a reference type, similar to a class that can contain only constants, method signatures, and nested types. There are no method bodies. Interfaces cannot be instantiated and they can only be implemented by classes or extended by other interfaces. All methods are public by default and any fields declared in an interface are by default static and final.

Example:

public interface ParkingLot {
boolean add(Car car, int slot);
boolean remove(Car car);
boolean findCar(Int number);
int freeSlotsCount();
int occupiedSlots();
int parkingType();
int calculateParkingFee(int hours, int charge, int duration);
int findParkingSlot();
}

Interfaces play another important role in the object-oriented programming language. Interfaces are not part of the class hierarchy, although they work in combination with classes. Interfaces provide an alternative for languages like Java that does not allow multiple inheritance .

In Java, a class can inherit from only one class but it can implement more than one interface. Therefore, objects can have multiple types: the type of their own class and the types of all the interfaces that they implement. This means that if a variable is declared to be the type of an interface, its value can reference any object that is instantiated from any class that implements the interface.

==Mixins==

Modules provide a structure to collect classes, methods, and constants into a single, separately defined unit. They provide the simplest and an elegant way to adhere to the [http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] principle. This is useful so as to avoid clashes with existing classes, methods, and constants.

Modules are defined in Ruby using the ''module'' keyword.

A Mixin is a class that is mixed with a module or a set of modules i.e. the implementation of the modules and the class are intertwined and combined together <ref>[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Mixins] </ref>.

This gives us a neat and controlled way of adding new functionality to classes. Modules are similar to classes in that they hold a collection of methods, variables constants and other modules and class definitions. However, the real usage of a Mixin is exploited when the code in the Mixin starts to interact with code in the class that uses it.

Below is an example for modules and Mixins:

The module ParkingSlot consists of the methods park and unpark

module ParkingSlot
def park
#code to park the car
end
def unpark
#code to unpark the car
end
end

The module ParkingMeter consists of the methods calculate and printreceipt

module ParkingMeter
def calculate
#code to calculate the parking fee
end
def printreceipt
#code to print the receipt
end
end

When a class ''includes'' a module via include Module Name, all the methods on that module become instance methods on the class.

class Parking
include ParkingSlot
include ParkingMeter
def printcardetails
#code to print the details and type of car
end
end

The modules ParkingSlot and ParkingMeter are “included” in the Parking class. All the variables and the instance methods of the modules ParkingSlot and ParkingMeter are now said to be “mixed in” into the class. It is now possible for class instances to use these methods defined in the modules as and when required.

p=Parking.new
p.park # -> Method park from module ParkingSlot
p.unpark # -> Method unpark from module ParkingSlot
p.calculate # -> Method calculate from module ParkingMeter
p.printreceipt # -> Method printreceipt from module ParkingMeter
p.printcardetails # -> Calls printCarDetails from class

The class Parking inherits from both the modules and the module methods are now available in Parking. Hence, it is now possible to use the methods with an instance of the Parking class ''p''.

Hence, Mixins can be thought of taking different methods and variables defined in different modules making them available as instance methods in the class as well, thereby extending the class’ functionality. Effectively mixed in modules behave as [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclass].

[[Image:ParkingLot.PNG | center]]

==Supported Languages==
The following table shows support for Mixins and Interfaces by most commonly used languages.

{| class="wikitable"
|-
! Languages
! Mixins
! Interfaces
|-
| Ruby
| Yes
| No
|-
| Java
| No
| Yes
|-
| Python
| Yes
| No
|-
| Smalltalk
| Yes
| No
|-
| Perl
| Yes
| No
|-
| C#
| No
| Yes

|}

=Multiple Inheritance=
[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass.
Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

==Diamond Problem==
This section describes the well know “Diamond Problem”<ref>[http://www.artima.com/designtechniques/interfaces2.html Diamond Problem] </ref> associated with multiple Inheritance and the succeeding sections describe how Mixins and interfaces can be used to overcome this problem.
The diamond problem is the ambiguity that can occur when a class inherits from two different classes that both descend from a common superclass. For example, consider a scenario where one decides to combine the Frog and Dinosaur species which both are inherited from the Animal class. The talk() method in the Animal class is abstract and both Frog and Dinosaur needs to implement this method.

Lets say both Frog and Dinosaur implement the talk method like this:

public class Frog extends Animal {
void talk() {
System.out.println(“I am Frog, I can croak “);
}
}

and,
public class Dinosaur extends Animal {
void talk() {
System.out.println(“I am Dinosaur, I can roar “);
}
}

[[Image:Diamond_problem.PNG | center]]

When the Frogsaur is created, it inherits from both Frog and Dinosaur.

public class Frogsaur extends Frog, Dinosaur {
// Note below syntax is used just for demonstration. However java might throw compile time error.
}

The real problem occurs when someone tries to invoke talk() method on a Frogsaur object from the Animal reference.

Animal species = new Frogsaur();
species.talk(); // which method to invoke ???

Due to the ambiguity caused by the diamond problem, it isn’t clear whether the runtime system should invoke Frog’s talk() method or Dinosaur talk() method.

==Approaches==
Different programming languages have addressed the diamond problem in different ways.

In Java, interfaces solve all these ambiguities caused by the diamond problem. Through interfaces, Java allows multiple inheritance of interface but not of implementation. Implementation, which includes instance variables and method implementations, is always singly inherited. As a result, confusion will never arise in Java over which inherited instance variable or method implementation to use.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes<ref>[http://download.oracle.com/javase/tutorial/java/IandI/abstract.html Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Frog and Dinosaur, each of which contain the talk method defined in them. The Frogsaur class ''includes'' these two methods and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Frog
def talk
puts "I can croak"
end
end

module Dinosaur
def talk
puts "I can roar"
end
end

class Frogsaur
include Frog
include Dinosaur
def talk
puts "I can roar like a dinosaur and croak like a frog"
end
end

fs = Frogsaur.new
fs.talk # -> I can roar like a dinosaur and croak like a frog

When the method talk is called on the Frogsaur object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Frogsaur class is defined the latest and hence “I can roar like a dinosaur and croak like a frog” is printed. If there was no method defined in the class, method from the Dinosaur is printed since it is next in the hierarchy specified by the include statements.

=Comparison between Mixins and Interfaces=

This is a general comparision:

{| class="wikitable"
|-
! Mixins
! Interfaces
|-
| In Ruby, modules have the implementation of the methods. So all the classes which include the modules gets the same Implementation because classes create a reference to these modules.
|In Java, all classes which implement the interfaces should provide implementation for each of the methods declared in the interface. This might duplicate the code if the two or more classes have similar functionality.
|-
| The size of the code is relatively smaller because the classes automatically get access to methods defined in the modules. Modules server as a central repository
| The size is relatively larger because a class implementing more than one interfaces has to provide implementation.
|-
| Having more modules in the classes can make code less readable. Ideally mixins are suitable for small teams having few modules.
| The code is more readable here as the implementation is provided to each method and can be found in place
|-
| In Ruby, a method inside a module can have Module name as qualifier. Hence it’s possible for a class to have inherit two or more modules which have same names.
| In Java, the class itself has to provide the implementation of the methods. Inheriting methods of same names from different interfaces will signal an error message.
|-
| Modules cannot be inherited and cannot form is-a hierarchy
| Interfaces can extend another interface and hence can form is-a hierarchy
|}

==Drawbacks of Mixins and Interfaces==

The drawbacks of the technique of Mixins are very much debated. Though Mixins provide us with an easy way to write flexible and decoupled code and also help us solve the diamond problem, they pose their own problems. In large programs there could be large number of modules and each module could have loads of methods each performing a certain task.To trace the origin of the methods and to keep in mind the hierarchy is practically impossible. Another issue associated with Mixins pose is silent method overriding. Silent method overriding occurs when different modules are included in a class and each module have a method with the same definition. In such a case, the method which gets executed depends upon the way it is included in the class and this is done without any sort of message to the user (silently). In large scale applications this could certainly be an issue considering the number of modules that would be mixed in and it would be difficult to keep track of the hierarchy in which the modules were included.

Although Java provides polymorphic behavior with the use of interfaces, they sometimes tend to be very slow. The implementation of interfaces are also limited to public methods and constants with no implementation.

=Conclusion=
Although mixins have certain advantages over interfaces, they possess their own share of disadvantages. Mixins are generally used in small frameworks and interfaces , more than solving the problem of multiple inheritance provide polymorphism feature which makes object-oriented code more flexible and easy to modify and maintain.

=References=
<references/>

=See Also=
1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ 
3. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
4. https://www.cs.washington.edu/education/courses/cse413/11sp/lectures/ruby_interfaces-etc.pdf 
5. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
6. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch2 2c ds

2011-09-22T06:03:32Z

Ssreepa: /* Introduction */

=Mixins vs. Interfaces=

=Introduction=

Mixins and Interfaces provide neat constructs in object-oriented languages to implement certain functionality and benefit from code reusability. Understanding these constructs will benefit any programmer in designing any software with maximum polymorphic behavior and code resuability.

With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to because of the problems associated with multiple inheritance<ref>[http://www.artima.com/intv/gosling13.html Inspiration for Interface]</ref>.

While [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] like languages implemented interfaces to allow for [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism],languages like [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] opted not to implement multiple inheritance but to allow the code from one module be added into another class.

Though both interfaces and Mixins simulate multiple inheritance and avoid the common pathologies associated with it , they have their own set of compromises. The below article tries to provide clarity on how this is achieved in each and also provides other distinctive features of Mixins and interfaces.

===Interfaces===
In an object-oriented programming languages such as Java, C#, an interface<ref>[http://download.oracle.com/javase/tutorial/ Interfaces] </ref> is a reference type, similar to a class that can contain only constants, method signatures, and nested types. There are no method bodies. Interfaces cannot be instantiated and they can only be implemented by classes or extended by other interfaces. All methods are public by default and any fields declared in an interface are by default static and final.

Example:

public interface ParkingLot {
boolean add(Car car, int slot);
boolean remove(Car car);
boolean findCar(Int number);
int freeSlotsCount();
int occupiedSlots();
int parkingType();
int calculateParkingFee(int hours, int charge, int duration);
int findParkingSlot();
}

Interfaces play another important role in the object-oriented programming language. Interfaces are not part of the class hierarchy, although they work in combination with classes. Interfaces provide an alternative for languages like Java that does not allow multiple inheritance .

In Java, a class can inherit from only one class but it can implement more than one interface. Therefore, objects can have multiple types: the type of their own class and the types of all the interfaces that they implement. This means that if a variable is declared to be the type of an interface, its value can reference any object that is instantiated from any class that implements the interface.

==Mixins==

Modules provide a structure to collect classes, methods, and constants into a single, separately defined unit. They provide the simplest and an elegant way to adhere to the [http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] principle. This is useful so as to avoid clashes with existing classes, methods, and constants.

Modules are defined in Ruby using the ''module'' keyword.

A Mixin is a class that is mixed with a module or a set of modules i.e. the implementation of the modules and the class are intertwined and combined together <ref>[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Mixins] </ref>.

This gives us a neat and controlled way of adding new functionality to classes. Modules are similar to classes in that they hold a collection of methods, variables constants and other modules and class definitions. However, the real usage of a Mixin is exploited when the code in the Mixin starts to interact with code in the class that uses it.

Below is an example for modules and Mixins:

The module ParkingSlot consists of the methods park and unpark

module ParkingSlot
def park
#code to park the car
end
def unpark
#code to unpark the car
end
end

The module ParkingMeter consists of the methods calculate and printreceipt

module ParkingMeter
def calculate
#code to calculate the parking fee
end
def printreceipt
#code to print the receipt
end
end

When a class ''includes'' a module via include Module Name, all the methods on that module become instance methods on the class.

class Parking
include ParkingSlot
include ParkingMeter
def printcardetails
#code to print the details and type of car
end
end

The modules ParkingSlot and ParkingMeter are “included” in the Parking class. All the variables and the instance methods of the modules ParkingSlot and ParkingMeter are now said to be “mixed in” into the class. It is now possible for class instances to use these methods defined in the modules as and when required.

p=Parking.new
p.park # -> Method park from module ParkingSlot
p.unpark # -> Method unpark from module ParkingSlot
p.calculate # -> Method calculate from module ParkingMeter
p.printreceipt # -> Method printreceipt from module ParkingMeter
p.printcardetails # -> Calls printCarDetails from class

The class Parking inherits from both the modules and the module methods are now available in Parking. Hence, it is now possible to use the methods with an instance of the Parking class ''p''.

Hence, Mixins can be thought of taking different methods and variables defined in different modules making them available as instance methods in the class as well, thereby extending the class’ functionality. Effectively mixed in modules behave as [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclass].

[[Image:ParkingLot.PNG | center]]

==Supported Languages==
The following table shows support for Mixins and Interfaces by most commonly used languages.

{| class="wikitable"
|-
! Languages
! Mixins
! Interfaces
|-
| Ruby
| Yes
| No
|-
| Java
| No
| Yes
|-
| Python
| Yes
| No
|-
| Smalltalk
| Yes
| No
|-
| Perl
| Yes
| No
|-
| C#
| No
| Yes

|}

=Multiple Inheritance=
[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass.
Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

==Diamond Problem==
This section describes the well know “Diamond Problem”<ref>[http://www.artima.com/designtechniques/interfaces2.html Diamond Problem] </ref> associated with multiple Inheritance and the succeeding sections describe how Mixins and interfaces can be used to overcome this problem.
The diamond problem is the ambiguity that can occur when a class inherits from two different classes that both descend from a common superclass. For example, consider a scenario where one decides to combine the Frog and Dinosaur species which both are inherited from the Animal class. The talk() method in the Animal class is abstract and both Frog and Dinosaur needs to implement this method.

Lets say both Frog and Dinosaur implement the talk method like this:

public class Frog extends Animal {
void talk() {
System.out.println(“I am Frog, I can croak “);
}
}

and,
public class Dinosaur extends Animal {
void talk() {
System.out.println(“I am Dinosaur, I can roar “);
}
}

[[Image:Diamond_problem.PNG | center]]

When the Frogsaur is created, it inherits from both Frog and Dinosaur.

public class Frogsaur extends Frog, Dinosaur {
// Note below syntax is used just for demonstration. However java might throw compile time error.
}

The real problem occurs when someone tries to invoke talk() method on a Frogsaur object from the Animal reference.

Animal species = new Frogsaur();
species.talk(); // which method to invoke ???

Due to the ambiguity caused by the diamond problem, it isn’t clear whether the runtime system should invoke Frog’s talk() method or Dinosaur talk() method.

==Approaches==
Different programming languages have addressed the diamond problem in different ways.

In Java, interfaces solve all these ambiguities caused by the diamond problem. Through interfaces, Java allows multiple inheritance of interface but not of implementation. Implementation, which includes instance variables and method implementations, is always singly inherited. As a result, confusion will never arise in Java over which inherited instance variable or method implementation to use.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes<ref>[http://download.oracle.com/javase/tutorial/java/IandI/abstract.html Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Frog and Dinosaur, each of which contain the talk method defined in them. The Frogsaur class ''includes'' these two methods and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Frog
def talk
puts "I can croak"
end
end

module Dinosaur
def talk
puts "I can roar"
end
end

class Frogsaur
include Frog
include Dinosaur
def talk
puts "I can roar like a dinosaur and croak like a frog"
end
end

fs = Frogsaur.new
fs.talk # -> I can roar like a dinosaur and croak like a frog

When the method talk is called on the Frogsaur object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Frogsaur class is defined the latest and hence “I can roar like a dinosaur and croak like a frog” is printed. If there was no method defined in the class, method from the Dinosaur is printed since it is next in the hierarchy specified by the include statements.

=Comparison between Mixins and Interfaces=

This is a general comparision:

{| class="wikitable"
|-
! Mixins
! Interfaces
|-
| In Ruby, modules have the implementation of the methods. So all the classes which include the modules gets the same Implementation because classes create a reference to these modules.
|In Java, all classes which implement the interfaces should provide implementation for each of the methods declared in the interface. This might duplicate the code if the two or more classes have similar functionality.
|-
| The size of the code is relatively smaller because the classes automatically get access to methods defined in the modules. Modules server as a central repository
| The size is relatively larger because a class implementing more than one interfaces has to provide implementation.
|-
| Having more modules in the classes can make code less readable. Ideally mixins are suitable for small teams having few modules.
| The code is more readable here as the implementation is provided to each method and can be found in place
|-
| In Ruby, a method inside a module can have Module name as qualifier. Hence it’s possible for a class to have inherit two or more modules which have same names.
| In Java, the class itself has to provide the implementation of the methods. Inheriting methods of same names from different interfaces will signal an error message.
|-
| Modules cannot be inherited and cannot form is-a hierarchy
| Interfaces can extend another interface and hence can form is-a hierarchy
|}

==Drawbacks of Mixins and Interfaces==

The drawbacks of the technique of Mixins are very much debated. Though Mixins provide us with an easy way to write flexible and decoupled code and also help us solve the diamond problem, they pose their own problems. In large programs there could be large number of modules and each module could have loads of methods each performing a certain task.To trace the origin of the methods and to keep in mind the hierarchy is practically impossible. Another issue associated with Mixins pose is silent method overriding.

Although Java provides polymorphic behavior with the use of interfaces, they sometimes tend to be very slow. The implementation of interfaces are also limited to public methods and constants with no implementation.

=Conclusion=
Although mixins have certain advantages over interfaces, they possess their own share of disadvantages. Mixins are generally used in small frameworks and interfaces , more than solving the problem of multiple inheritance provide polymorphism feature which makes object-oriented code more flexible and easy to modify and maintain.

=References=
<references/>

=See Also=
1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ 
3. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
4. https://www.cs.washington.edu/education/courses/cse413/11sp/lectures/ruby_interfaces-etc.pdf 
5. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
6. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch2 2c ds

2011-09-22T05:59:51Z

Ssreepa: /* Introduction */

=Mixins vs. Interfaces=

=Introduction=

Mixins and Interfaces provide neat constructs in object-oriented languages to implement certain functionality and benefit from code reusability. Understanding these constructs will benefit any programmer in designing any software with maximum polymorphic behavior and code resuability.

With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to because of the problems associated with multiple inheritance.

While [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] like languages implemented interfaces to allow for [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism],languages like [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby] opted not to implement multiple inheritance but to allow the code from one module be added into another class.

Though both interfaces and Mixins simulate multiple inheritance and avoid the common pathologies associated with it , they have their own set of compromises. The below article tries to provide clarity on how this is achieved in each and also provides other distinctive features of Mixins and interfaces.

===Interfaces===
In an object-oriented programming languages such as Java, C#, an interface<ref>[http://download.oracle.com/javase/tutorial/ Interfaces] </ref> is a reference type, similar to a class that can contain only constants, method signatures, and nested types. There are no method bodies. Interfaces cannot be instantiated and they can only be implemented by classes or extended by other interfaces. All methods are public by default and any fields declared in an interface are by default static and final.

Example:

public interface ParkingLot {
boolean add(Car car, int slot);
boolean remove(Car car);
boolean findCar(Int number);
int freeSlotsCount();
int occupiedSlots();
int parkingType();
int calculateParkingFee(int hours, int charge, int duration);
int findParkingSlot();
}

Interfaces play another important role in the object-oriented programming language. Interfaces are not part of the class hierarchy, although they work in combination with classes. Interfaces provide an alternative for languages like Java that does not allow multiple inheritance .

In Java, a class can inherit from only one class but it can implement more than one interface. Therefore, objects can have multiple types: the type of their own class and the types of all the interfaces that they implement. This means that if a variable is declared to be the type of an interface, its value can reference any object that is instantiated from any class that implements the interface.

==Mixins==

Modules provide a structure to collect classes, methods, and constants into a single, separately defined unit. They provide the simplest and an elegant way to adhere to the [http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] principle. This is useful so as to avoid clashes with existing classes, methods, and constants.

Modules are defined in Ruby using the ''module'' keyword.

A Mixin is a class that is mixed with a module or a set of modules i.e. the implementation of the modules and the class are intertwined and combined together <ref>[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Mixins] </ref>.

This gives us a neat and controlled way of adding new functionality to classes. Modules are similar to classes in that they hold a collection of methods, variables constants and other modules and class definitions. However, the real usage of a Mixin is exploited when the code in the Mixin starts to interact with code in the class that uses it.

Below is an example for modules and Mixins:

The module ParkingSlot consists of the methods park and unpark

module ParkingSlot
def park
#code to park the car
end
def unpark
#code to unpark the car
end
end

The module ParkingMeter consists of the methods calculate and printreceipt

module ParkingMeter
def calculate
#code to calculate the parking fee
end
def printreceipt
#code to print the receipt
end
end

When a class ''includes'' a module via include Module Name, all the methods on that module become instance methods on the class.

class Parking
include ParkingSlot
include ParkingMeter
def printcardetails
#code to print the details and type of car
end
end

The modules ParkingSlot and ParkingMeter are “included” in the Parking class. All the variables and the instance methods of the modules ParkingSlot and ParkingMeter are now said to be “mixed in” into the class. It is now possible for class instances to use these methods defined in the modules as and when required.

p=Parking.new
p.park # -> Method park from module ParkingSlot
p.unpark # -> Method unpark from module ParkingSlot
p.calculate # -> Method calculate from module ParkingMeter
p.printreceipt # -> Method printreceipt from module ParkingMeter
p.printcardetails # -> Calls printCarDetails from class

The class Parking inherits from both the modules and the module methods are now available in Parking. Hence, it is now possible to use the methods with an instance of the Parking class ''p''.

Hence, Mixins can be thought of taking different methods and variables defined in different modules making them available as instance methods in the class as well, thereby extending the class’ functionality. Effectively mixed in modules behave as [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclass].

[[Image:ParkingLot.PNG | center]]

==Supported Languages==
The following table shows support for Mixins and Interfaces by most commonly used languages.

{| class="wikitable"
|-
! Languages
! Mixins
! Interfaces
|-
| Ruby
| Yes
| No
|-
| Java
| No
| Yes
|-
| Python
| Yes
| No
|-
| Smalltalk
| Yes
| No
|-
| Perl
| Yes
| No
|-
| C#
| No
| Yes

|}

=Multiple Inheritance=
[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass.
Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

==Diamond Problem==
This section describes the well know “Diamond Problem”<ref>[http://www.artima.com/designtechniques/interfaces2.html Diamond Problem] </ref> associated with multiple Inheritance and the succeeding sections describe how Mixins and interfaces can be used to overcome this problem.
The diamond problem is the ambiguity that can occur when a class inherits from two different classes that both descend from a common superclass. For example, consider a scenario where one decides to combine the Frog and Dinosaur species which both are inherited from the Animal class. The talk() method in the Animal class is abstract and both Frog and Dinosaur needs to implement this method.

Lets say both Frog and Dinosaur implement the talk method like this:

public class Frog extends Animal {
void talk() {
System.out.println(“I am Frog, I can croak “);
}
}

and,
public class Dinosaur extends Animal {
void talk() {
System.out.println(“I am Dinosaur, I can roar “);
}
}

[[Image:Diamond_problem.PNG | center]]

When the Frogsaur is created, it inherits from both Frog and Dinosaur.

public class Frogsaur extends Frog, Dinosaur {
// Note below syntax is used just for demonstration. However java might throw compile time error.
}

The real problem occurs when someone tries to invoke talk() method on a Frogsaur object from the Animal reference.

Animal species = new Frogsaur();
species.talk(); // which method to invoke ???

Due to the ambiguity caused by the diamond problem, it isn’t clear whether the runtime system should invoke Frog’s talk() method or Dinosaur talk() method.

==Approaches==
Different programming languages have addressed the diamond problem in different ways.

In Java, interfaces solve all these ambiguities caused by the diamond problem. Through interfaces, Java allows multiple inheritance of interface but not of implementation. Implementation, which includes instance variables and method implementations, is always singly inherited. As a result, confusion will never arise in Java over which inherited instance variable or method implementation to use.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes<ref>[http://download.oracle.com/javase/tutorial/java/IandI/abstract.html Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Frog and Dinosaur, each of which contain the talk method defined in them. The Frogsaur class ''includes'' these two methods and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Frog
def talk
puts "I can croak"
end
end

module Dinosaur
def talk
puts "I can roar"
end
end

class Frogsaur
include Frog
include Dinosaur
def talk
puts "I can roar like a dinosaur and croak like a frog"
end
end

fs = Frogsaur.new
fs.talk # -> I can roar like a dinosaur and croak like a frog

When the method talk is called on the Frogsaur object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Frogsaur class is defined the latest and hence “I can roar like a dinosaur and croak like a frog” is printed. If there was no method defined in the class, method from the Dinosaur is printed since it is next in the hierarchy specified by the include statements.

=Comparison between Mixins and Interfaces=

This is a general comparision:

{| class="wikitable"
|-
! Mixins
! Interfaces
|-
| In Ruby, modules have the implementation of the methods. So all the classes which include the modules gets the same Implementation because classes create a reference to these modules.
|In Java, all classes which implement the interfaces should provide implementation for each of the methods declared in the interface. This might duplicate the code if the two or more classes have similar functionality.
|-
| The size of the code is relatively smaller because the classes automatically get access to methods defined in the modules. Modules server as a central repository
| The size is relatively larger because a class implementing more than one interfaces has to provide implementation.
|-
| Having more modules in the classes can make code less readable. Ideally mixins are suitable for small teams having few modules.
| The code is more readable here as the implementation is provided to each method and can be found in place
|-
| In Ruby, a method inside a module can have Module name as qualifier. Hence it’s possible for a class to have inherit two or more modules which have same names.
| In Java, the class itself has to provide the implementation of the methods. Inheriting methods of same names from different interfaces will signal an error message.
|-
| Modules cannot be inherited and cannot form is-a hierarchy
| Interfaces can extend another interface and hence can form is-a hierarchy
|}

==Drawbacks of Mixins and Interfaces==

The drawbacks of the technique of Mixins are very much debated. Though Mixins provide us with an easy way to write flexible and decoupled code and also help us solve the diamond problem, they pose their own problems. In large programs there could be large number of modules and each module could have loads of methods each performing a certain task.To trace the origin of the methods and to keep in mind the hierarchy is practically impossible. Another issue associated with Mixins pose is silent method overriding.

Although Java provides polymorphic behavior with the use of interfaces, they sometimes tend to be very slow. The implementation of interfaces are also limited to public methods and constants with no implementation.

=Conclusion=
Although mixins have certain advantages over interfaces, they possess their own share of disadvantages. Mixins are generally used in small frameworks and interfaces , more than solving the problem of multiple inheritance provide polymorphism feature which makes object-oriented code more flexible and easy to modify and maintain.

=References=
<references/>

=See Also=
1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ 
3. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
4. https://www.cs.washington.edu/education/courses/cse413/11sp/lectures/ruby_interfaces-etc.pdf 
5. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
6. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch2 2c ds

2011-09-22T03:39:32Z

Ssreepa: /* Approaches */

=Mixins vs. Interfaces=

=Introduction=
With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to .

While Java like languages implemented interfaces to allow for [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism],languages like Ruby opted not to implement multiple inheritance but to allow the code from one module be added into another class.

Though both interfaces and Mixins simulate multiple inheritance and avoid the common pathologies associated with it , they have their own set of compromises. The below article tries to provide clarity on how this is achieved in each and also provides other distinctive features of Mixins and interfaces.

===Interfaces===
In an object-oriented programming languages such as Java, C#, an interface<ref>[http://download.oracle.com/javase/tutorial/ Interfaces] </ref> is a reference type, similar to a class that can contain only constants, method signatures, and nested types. There are no method bodies. Interfaces cannot be instantiated and they can only be implemented by classes or extended by other interfaces. All methods are public by default and any fields declared in an interface are by default static and final.

Example:

public interface ParkingLot {
boolean add(Car car, int slot);
boolean remove(Car car);
boolean findCar(Int number);
int freeSlotsCount();
int occupiedSlots();
int parkingType();
int calculateParkingFee(int hours, int charge, int duration);
int findParkingSlot();
}

Interfaces play another important role in the object-oriented programming language. Interfaces are not part of the class hierarchy, although they work in combination with classes. Interfaces provide an alternative for languages like Java that does not allow multiple inheritance .

In Java, a class can inherit from only one class but it can implement more than one interface. Therefore, objects can have multiple types: the type of their own class and the types of all the interfaces that they implement. This means that if a variable is declared to be the type of an interface, its value can reference any object that is instantiated from any class that implements the interface.

==Mixins==

Modules provide a structure to collect classes, methods, and constants into a single, separately defined unit. They provide the simplest and an elegant way to adhere to the [http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] principle. This is useful so as to avoid clashes with existing classes, methods, and constants.

Modules are defined in Ruby using the ''module'' keyword.

A Mixin is a class that is mixed with a module or a set of modules i.e. the implementation of the modules and the class are intertwined and combined together <ref>[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Mixins] </ref>.

This gives us a neat and controlled way of adding new functionality to classes. Modules are similar to classes in that they hold a collection of methods, variables constants and other modules and class definitions. However, the real usage of a Mixin is exploited when the code in the Mixin starts to interact with code in the class that uses it.

Below is an example for modules and Mixins:

The module ParkingSlot consists of the methods park and unpark

module ParkingSlot
def park
#code to park the car
end
def unpark
#code to unpark the car
end
end

The module ParkingMeter consists of the methods calculate and printreceipt

module ParkingMeter
def calculate
#code to calculate the parking fee
end
def printreceipt
#code to print the receipt
end
end

When a class ''includes'' a module via include Module Name, all the methods on that module become instance methods on the class.

class Parking
include ParkingSlot
include ParkingMeter
def printcardetails
#code to print the details and type of car
end
end

The modules ParkingSlot and ParkingMeter are “included” in the Parking class. All the variables and the instance methods of the modules ParkingSlot and ParkingMeter are now said to be “mixed in” into the class. It is now possible for class instances to use these methods defined in the modules as and when required.

p=Parking.new
p.park # -> Method park from module ParkingSlot
p.unpark # -> Method unpark from module ParkingSlot
p.calculate # -> Method calculate from module ParkingMeter
p.printreceipt # -> Method printreceipt from module ParkingMeter
p.printcardetails # -> Calls printCarDetails from class

The class Parking inherits from both the modules and the module methods are now available in Parking. Hence, it is now possible to use the methods with an instance of the Parking class ''p''.

Hence, Mixins can be thought of taking different methods and variables defined in different modules making them available as instance methods in the class as well, thereby extending the class’ functionality. Effectively mixed in modules behave as [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclass].

[[Image:ParkingLot.PNG | center]]

==Supported Languages==
The following table shows support for Mixins and Interfaces by most commonly used languages.

{| class="wikitable"
|-
! Languages
! Mixins
! Interfaces
|-
| Ruby
| Yes
| No
|-
| Java
| No
| Yes
|-
| Python
| Yes
| No
|-
| Smalltalk
| Yes
| No
|-
| Perl
| Yes
| No
|-
| C#
| No
| Yes

|}

=Multiple Inheritance=
[http://en.wikipedia.org/wiki/Multiple_inheritance Multiple Inheritance] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass.
Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

==Diamond Problem==
This section describes the well know “Diamond Problem”<ref>[http://www.artima.com/designtechniques/interfaces2.html Diamond Problem] </ref> associated with multiple Inheritance and the succeeding sections describe how Mixins and interfaces can be used to overcome this problem.
The diamond problem is the ambiguity that can occur when a class inherits from two different classes that both descend from a common superclass. For example, consider a scenario where one decides to combine the Frog and Dinosaur species which both are inherited from the Animal class. The talk() method in the Animal class is abstract and both Frog and Dinosaur needs to implement this method.

Lets say both Frog and Dinosaur implement the talk method like this:

public class Frog extends Animal {
void talk() {
System.out.println(“I am Frog, I can croak “);
}
}

and,
public class Dinosaur extends Animal {
void talk() {
System.out.println(“I am Dinosaur, I can roar “);
}
}

[[Image:Diamond_problem.PNG | center]]

When the Frogsaur is created, it inherits from both Frog and Dinosaur.

public class Frogsaur extends Frog, Dinosaur {
// Note below syntax is used just for demonstration. However java might throw compile time error.
}

The real problem occurs when someone tries to invoke talk() method on a Frogsaur object from the Animal reference.

Animal species = new Frogsaur();
species.talk(); // which method to invoke ???

Due to the ambiguity caused by the diamond problem, it isn’t clear whether the runtime system should invoke Frog’s talk() method or Dinosaur talk() method.

==Approaches==
Different programming languages have addressed the diamond problem in different ways.

In Java, interfaces solve all these ambiguities caused by the diamond problem. Through interfaces, Java allows multiple inheritance of interface but not of implementation. Implementation, which includes instance variables and method implementations, is always singly inherited. As a result, confusion will never arise in Java over which inherited instance variable or method implementation to use.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes<ref>[http://download.oracle.com/javase/tutorial/java/IandI/abstract.html Abstract Classes]</ref> in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Frog and Dinosaur, each of which contain the talk method defined in them. The Frogsaur class ''includes'' these two methods and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Frog
def talk
puts "I can croak"
end
end

module Dinosaur
def talk
puts "I can roar"
end
end

class Frogsaur
include Frog
include Dinosaur
def talk
puts "I can roar like a dinosaur and croak like a frog"
end
end

fs = Frogsaur.new
fs.talk # -> I can roar like a dinosaur and croak like a frog

When the method talk is called on the Frogsaur object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Frogsaur class is defined the latest and hence “I can roar like a dinosaur and croak like a frog” is printed. If there was no method defined in the class, method from the Dinosaur is printed since it is next in the hierarchy specified by the include statements.

=Comparison between Mixins and Interfaces=

This is a general comparision:

{| class="wikitable"
|-
! Mixins
! Interfaces
|-
| In Ruby, modules have the implementation of the methods. So all the classes which include the modules gets the same Implementation because classes create a reference to these modules.
|In Java, all classes which implement the interfaces should provide implementation for each of the methods declared in the interface. This might duplicate the code if the two or more classes have similar functionality.
|-
| The size of the code is relatively smaller because the classes automatically get access to methods defined in the modules. Modules server as a central repository
| The size is relatively larger because a class implementing more than one interfaces has to provide implementation.
|-
| Having more modules in the classes can make code less readable. Ideally mixins are suitable for small teams having few modules.
| The code is more readable here as the implementation is provided to each method and can be found in place
|-
| In Ruby, a method inside a module can have Module name as qualifier. Hence it’s possible for a class to have inherit two or more modules which have same names.
| In Java, the class itself has to provide the implementation of the methods. Inheriting methods of same names from different interfaces will signal an error message.
|-
| Modules cannot be inherited and cannot form is-a hierarchy
| Interfaces can extend another interface and hence can form is-a hierarchy
|}

==Drawbacks of Mixins and Interfaces==

The drawbacks of the technique of Mixins are very much debated. Though Mixins provide us with an easy way to write flexible and decoupled code and also help us solve the diamond problem, they pose their own problems. In large programs there could be large number of modules and each module could have loads of methods each performing a certain task.To trace the origin of the methods and to keep in mind the hierarchy is practically impossible. Another issue associated with Mixins pose is silent method overriding.

Although Java provides polymorphic behavior with the use of interfaces, they sometimes tend to be very slow. The implementation of interfaces are also limited to public methods and constants with no implementation.

=Conclusion=
Although mixins have certain advantages over interfaces, they possess their own share of disadvantages. Mixins are generally used in small frameworks and interfaces , more than solving the problem of multiple inheritance provide polymorphism feature which makes object-oriented code more flexible and easy to modify and maintain.

=References=
<references/>

=See Also=
1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ 
3. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
4. https://www.cs.washington.edu/education/courses/cse413/11sp/lectures/ruby_interfaces-etc.pdf 
5. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
6. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch2 2c ds

2011-09-22T03:31:39Z

Ssreepa: /* Comparison between Mixins and Interfaces */

=Mixins vs. Interfaces=

=Introduction=
With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to .

While Java like languages implemented interfaces to allow for [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism],languages like Ruby opted not to implement multiple inheritance but to allow the code from one module be added into another class.

Though both interfaces and Mixins simulate multiple inheritance and avoid the common pathologies associated with it , they have their own set of compromises. The below article tries to provide clarity on how this is achieved in each and also provides other distinctive features of Mixins and interfaces.

===Interfaces===
In an object-oriented programming languages such as Java, C#, an interface<ref>[http://download.oracle.com/javase/tutorial/ Interfaces] </ref> is a reference type, similar to a class that can contain only constants, method signatures, and nested types. There are no method bodies. Interfaces cannot be instantiated and they can only be implemented by classes or extended by other interfaces. All methods are public by default and any fields declared in an interface are by default static and final.

Example:

public interface ParkingLot {
boolean add(Car car, int slot);
boolean remove(Car car);
boolean findCar(Int number);
int freeSlotsCount();
int occupiedSlots();
int parkingType();
int calculateParkingFee(int hours, int charge, int duration);
int findParkingSlot();
}

Interfaces play another important role in the object-oriented programming language. Interfaces are not part of the class hierarchy, although they work in combination with classes. Interfaces provide an alternative for languages like Java that does not allow multiple inheritance .

In Java, a class can inherit from only one class but it can implement more than one interface. Therefore, objects can have multiple types: the type of their own class and the types of all the interfaces that they implement. This means that if a variable is declared to be the type of an interface, its value can reference any object that is instantiated from any class that implements the interface.

==Mixins==

Modules provide a structure to collect classes, methods, and constants into a single, separately defined unit. They provide the simplest and an elegant way to adhere to the [http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] principle. This is useful so as to avoid clashes with existing classes, methods, and constants.

Modules are defined in Ruby using the ''module'' keyword.

A Mixin is a class that is mixed with a module or a set of modules i.e. the implementation of the modules and the class are intertwined and combined together <ref>[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Mixins] </ref>.

This gives us a neat and controlled way of adding new functionality to classes. Modules are similar to classes in that they hold a collection of methods, variables constants and other modules and class definitions. However, the real usage of a Mixin is exploited when the code in the Mixin starts to interact with code in the class that uses it.

Below is an example for modules and Mixins:

The module ParkingSlot consists of the methods park and unpark

module ParkingSlot
def park
#code to park the car
end
def unpark
#code to unpark the car
end
end

The module ParkingMeter consists of the methods calculate and printreceipt

module ParkingMeter
def calculate
#code to calculate the parking fee
end
def printreceipt
#code to print the receipt
end
end

When a class ''includes'' a module via include Module Name, all the methods on that module become instance methods on the class.

class Parking
include ParkingSlot
include ParkingMeter
def printcardetails
#code to print the details and type of car
end
end

The modules ParkingSlot and ParkingMeter are “included” in the Parking class. All the variables and the instance methods of the modules ParkingSlot and ParkingMeter are now said to be “mixed in” into the class. It is now possible for class instances to use these methods defined in the modules as and when required.

p=Parking.new
p.park # -> Method park from module ParkingSlot
p.unpark # -> Method unpark from module ParkingSlot
p.calculate # -> Method calculate from module ParkingMeter
p.printreceipt # -> Method printreceipt from module ParkingMeter
p.printcardetails # -> Calls printCarDetails from class

The class Parking inherits from both the modules and the module methods are now available in Parking. Hence, it is now possible to use the methods with an instance of the Parking class ''p''.

Hence, Mixins can be thought of taking different methods and variables defined in different modules making them available as instance methods in the class as well, thereby extending the class’ functionality. Effectively mixed in modules behave as [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclass].

[[Image:ParkingLot.PNG | center]]

==Supported Languages==
The following table shows support for Mixins and Interfaces by most commonly used languages.

{| class="wikitable"
|-
! Languages
! Mixins
! Interfaces
|-
| Ruby
| Yes
| No
|-
| Java
| No
| Yes
|-
| Python
| Yes
| No
|-
| Smalltalk
| Yes
| No
|-
| Perl
| Yes
| No
|-
| C#
| No
| Yes

|}

=Multiple Inheritance=
[[Multiple Inheritance]] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass.
Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

==Diamond Problem==
This section describes the well know “Diamond Problem”<ref>[http://www.artima.com/designtechniques/interfaces2.html Diamond Problem] </ref> associated with multiple Inheritance and the succeeding sections describe how Mixins and interfaces can be used to overcome this problem.
The diamond problem is the ambiguity that can occur when a class inherits from two different classes that both descend from a common superclass. For example, consider a scenario where one decides to combine the Frog and Dinosaur species which both are inherited from the Animal class. The talk() method in the Animal class is abstract and both Frog and Dinosaur needs to implement this method.

Lets say both Frog and Dinosaur implement the talk method like this:

public class Frog extends Animal {
void talk() {
System.out.println(“I am Frog, I can croak “);
}
}

and,
public class Dinosaur extends Animal {
void talk() {
System.out.println(“I am Dinosaur, I can roar “);
}
}

[[Image:Diamond_problem.PNG | center]]

When the Frogsaur is created, it inherits from both Frog and Dinosaur.

public class Frogsaur extends Frog, Dinosaur {
// Note below syntax is used just for demonstration. However java might throw compile time error.
}

The real problem occurs when someone tries to invoke talk() method on a Frogsaur object from the Animal reference.

Animal species = new Frogsaur();
species.talk(); // which method to invoke ???

Due to the ambiguity caused by the diamond problem, it isn’t clear whether the runtime system should invoke Frog’s talk() method or Dinosaur talk() method.

==Approaches==
Different programming languages have addressed the diamond problem in different ways.

In Java, interfaces solve all these ambiguities caused by the diamond problem. Through interfaces, Java allows multiple inheritance of interface but not of implementation. Implementation, which includes instance variables and method implementations, is always singly inherited. As a result, confusion will never arise in Java over which inherited instance variable or method implementation to use.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Frog and Dinosaur, each of which contain the talk method defined in them. The Frogsaur class ''includes'' these two methods and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Frog
def talk
puts "I can croak"
end
end

module Dinosaur
def talk
puts "I can roar"
end
end

class Frogsaur
include Frog
include Dinosaur
def talk
puts "I can roar like a dinosaur and croak like a frog"
end
end

fs = Frogsaur.new
fs.talk # -> I can roar like a dinosaur and croak like a frog

When the method talk is called on the Frogsaur object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Frogsaur class is defined the latest and hence “I can roar like a dinosaur and croak like a frog” is printed. If there was no method defined in the class, method from the Dinosaur is printed since it is next in the hierarchy specified by the include statements.

=Comparison between Mixins and Interfaces=

This is a general comparision:

{| class="wikitable"
|-
! Mixins
! Interfaces
|-
| In Ruby, modules have the implementation of the methods. So all the classes which include the modules gets the same Implementation because classes create a reference to these modules.
|In Java, all classes which implement the interfaces should provide implementation for each of the methods declared in the interface. This might duplicate the code if the two or more classes have similar functionality.
|-
| The size of the code is relatively smaller because the classes automatically get access to methods defined in the modules. Modules server as a central repository
| The size is relatively larger because a class implementing more than one interfaces has to provide implementation.
|-
| Having more modules in the classes can make code less readable. Ideally mixins are suitable for small teams having few modules.
| The code is more readable here as the implementation is provided to each method and can be found in place
|-
| In Ruby, a method inside a module can have Module name as qualifier. Hence it’s possible for a class to have inherit two or more modules which have same names.
| In Java, the class itself has to provide the implementation of the methods. Inheriting methods of same names from different interfaces will signal an error message.
|-
| Modules cannot be inherited and cannot form is-a hierarchy
| Interfaces can extend another interface and hence can form is-a hierarchy
|}

==Drawbacks of Mixins and Interfaces==

The drawbacks of the technique of Mixins are very much debated. Though Mixins provide us with an easy way to write flexible and decoupled code and also help us solve the diamond problem, they pose their own problems. In large programs there could be large number of modules and each module could have loads of methods each performing a certain task, to trace the origin of the methods and to keep in mind the hierarchy is practically impossible. Another issue associated with Mixins pose is silent method overriding.

Although Java provides polymorphic behavior with the use of interfaces, they sometimes tend to be very slow. The implementation of interfaces are also limited to public methods and constants with no implementation.

=Conclusion=
Although mixins have certain advantages over interfaces, they possess their own share of disadvantages. Mixins are generally used in small frameworks and interfaces , more than solving the problem of multiple inheritance provide polymorphism feature which makes object-oriented code more flexible and easy to modify and maintain.

=References=
<references/>

=See Also=
1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ 
3. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
4. https://www.cs.washington.edu/education/courses/cse413/11sp/lectures/ruby_interfaces-etc.pdf 
5. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
6. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch2 2c ds

2011-09-22T03:31:00Z

Ssreepa: /* Comparison between Mixins and Interfaces */

=Mixins vs. Interfaces=

=Introduction=
With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to .

While Java like languages implemented interfaces to allow for [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism],languages like Ruby opted not to implement multiple inheritance but to allow the code from one module be added into another class.

Though both interfaces and Mixins simulate multiple inheritance and avoid the common pathologies associated with it , they have their own set of compromises. The below article tries to provide clarity on how this is achieved in each and also provides other distinctive features of Mixins and interfaces.

===Interfaces===
In an object-oriented programming languages such as Java, C#, an interface<ref>[http://download.oracle.com/javase/tutorial/ Interfaces] </ref> is a reference type, similar to a class that can contain only constants, method signatures, and nested types. There are no method bodies. Interfaces cannot be instantiated and they can only be implemented by classes or extended by other interfaces. All methods are public by default and any fields declared in an interface are by default static and final.

Example:

public interface ParkingLot {
boolean add(Car car, int slot);
boolean remove(Car car);
boolean findCar(Int number);
int freeSlotsCount();
int occupiedSlots();
int parkingType();
int calculateParkingFee(int hours, int charge, int duration);
int findParkingSlot();
}

Interfaces play another important role in the object-oriented programming language. Interfaces are not part of the class hierarchy, although they work in combination with classes. Interfaces provide an alternative for languages like Java that does not allow multiple inheritance .

In Java, a class can inherit from only one class but it can implement more than one interface. Therefore, objects can have multiple types: the type of their own class and the types of all the interfaces that they implement. This means that if a variable is declared to be the type of an interface, its value can reference any object that is instantiated from any class that implements the interface.

==Mixins==

Modules provide a structure to collect classes, methods, and constants into a single, separately defined unit. They provide the simplest and an elegant way to adhere to the [http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] principle. This is useful so as to avoid clashes with existing classes, methods, and constants.

Modules are defined in Ruby using the ''module'' keyword.

A Mixin is a class that is mixed with a module or a set of modules i.e. the implementation of the modules and the class are intertwined and combined together <ref>[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Mixins] </ref>.

This gives us a neat and controlled way of adding new functionality to classes. Modules are similar to classes in that they hold a collection of methods, variables constants and other modules and class definitions. However, the real usage of a Mixin is exploited when the code in the Mixin starts to interact with code in the class that uses it.

Below is an example for modules and Mixins:

The module ParkingSlot consists of the methods park and unpark

module ParkingSlot
def park
#code to park the car
end
def unpark
#code to unpark the car
end
end

The module ParkingMeter consists of the methods calculate and printreceipt

module ParkingMeter
def calculate
#code to calculate the parking fee
end
def printreceipt
#code to print the receipt
end
end

When a class ''includes'' a module via include Module Name, all the methods on that module become instance methods on the class.

class Parking
include ParkingSlot
include ParkingMeter
def printcardetails
#code to print the details and type of car
end
end

The modules ParkingSlot and ParkingMeter are “included” in the Parking class. All the variables and the instance methods of the modules ParkingSlot and ParkingMeter are now said to be “mixed in” into the class. It is now possible for class instances to use these methods defined in the modules as and when required.

p=Parking.new
p.park # -> Method park from module ParkingSlot
p.unpark # -> Method unpark from module ParkingSlot
p.calculate # -> Method calculate from module ParkingMeter
p.printreceipt # -> Method printreceipt from module ParkingMeter
p.printcardetails # -> Calls printCarDetails from class

The class Parking inherits from both the modules and the module methods are now available in Parking. Hence, it is now possible to use the methods with an instance of the Parking class ''p''.

Hence, Mixins can be thought of taking different methods and variables defined in different modules making them available as instance methods in the class as well, thereby extending the class’ functionality. Effectively mixed in modules behave as [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclass].

[[Image:ParkingLot.PNG | center]]

==Supported Languages==
The following table shows support for Mixins and Interfaces by most commonly used languages.

{| class="wikitable"
|-
! Languages
! Mixins
! Interfaces
|-
| Ruby
| Yes
| No
|-
| Java
| No
| Yes
|-
| Python
| Yes
| No
|-
| Smalltalk
| Yes
| No
|-
| Perl
| Yes
| No
|-
| C#
| No
| Yes

|}

=Multiple Inheritance=
[[Multiple Inheritance]] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass.
Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

==Diamond Problem==
This section describes the well know “Diamond Problem”<ref>[http://www.artima.com/designtechniques/interfaces2.html Diamond Problem] </ref> associated with multiple Inheritance and the succeeding sections describe how Mixins and interfaces can be used to overcome this problem.
The diamond problem is the ambiguity that can occur when a class inherits from two different classes that both descend from a common superclass. For example, consider a scenario where one decides to combine the Frog and Dinosaur species which both are inherited from the Animal class. The talk() method in the Animal class is abstract and both Frog and Dinosaur needs to implement this method.

Lets say both Frog and Dinosaur implement the talk method like this:

public class Frog extends Animal {
void talk() {
System.out.println(“I am Frog, I can croak “);
}
}

and,
public class Dinosaur extends Animal {
void talk() {
System.out.println(“I am Dinosaur, I can roar “);
}
}

[[Image:Diamond_problem.PNG | center]]

When the Frogsaur is created, it inherits from both Frog and Dinosaur.

public class Frogsaur extends Frog, Dinosaur {
// Note below syntax is used just for demonstration. However java might throw compile time error.
}

The real problem occurs when someone tries to invoke talk() method on a Frogsaur object from the Animal reference.

Animal species = new Frogsaur();
species.talk(); // which method to invoke ???

Due to the ambiguity caused by the diamond problem, it isn’t clear whether the runtime system should invoke Frog’s talk() method or Dinosaur talk() method.

==Approaches==
Different programming languages have addressed the diamond problem in different ways.

In Java, interfaces solve all these ambiguities caused by the diamond problem. Through interfaces, Java allows multiple inheritance of interface but not of implementation. Implementation, which includes instance variables and method implementations, is always singly inherited. As a result, confusion will never arise in Java over which inherited instance variable or method implementation to use.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Frog and Dinosaur, each of which contain the talk method defined in them. The Frogsaur class ''includes'' these two methods and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Frog
def talk
puts "I can croak"
end
end

module Dinosaur
def talk
puts "I can roar"
end
end

class Frogsaur
include Frog
include Dinosaur
def talk
puts "I can roar like a dinosaur and croak like a frog"
end
end

fs = Frogsaur.new
fs.talk # -> I can roar like a dinosaur and croak like a frog

When the method talk is called on the Frogsaur object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Frogsaur class is defined the latest and hence “I can roar like a dinosaur and croak like a frog” is printed. If there was no method defined in the class, method from the Dinosaur is printed since it is next in the hierarchy specified by the include statements.

=Comparison between Mixins and Interfaces=

This is a general comparision:

{| class="wikitable"
|-
! Mixins
! Interfaces
|-
| In Ruby, modules have the implementation of the methods. So all the classes which include the modules gets the same Implementation because classes create a reference to these modules.
|In Java, all classes which implement the interfaces should provide implementation for each of the methods declared in the interface. This might duplicate the code if the two or more classes have similar functionality.
|-
| Relatively smaller because the classes automatically get access to methods defined in the modules. Modules server as a central repository
| Relatively larger because a class implementing more than one interfaces has to provide implementation.
|-
| Having more modules in the classes can make code less readable. Ideally mixins are suitable for small teams having few modules.
| The code is more readable here as the implementation is provided to each method and can be found in place
|-
| In Ruby, a method inside a module can have Module name as qualifier. Hence it’s possible for a class to have inherit two or more modules which have same names.
| In Java, the class itself has to provide the implementation of the methods. Inheriting methods of same names from different interfaces will signal an error message.
|-
| Modules cannot be inherited and cannot form is-a hierarchy
| Interfaces can extend another interface and hence can form is-a hierarchy
|}

==Drawbacks of Mixins and Interfaces==

The drawbacks of the technique of Mixins are very much debated. Though Mixins provide us with an easy way to write flexible and decoupled code and also help us solve the diamond problem, they pose their own problems. In large programs there could be large number of modules and each module could have loads of methods each performing a certain task, to trace the origin of the methods and to keep in mind the hierarchy is practically impossible. Another issue associated with Mixins pose is silent method overriding.

Although Java provides polymorphic behavior with the use of interfaces, they sometimes tend to be very slow. The implementation of interfaces are also limited to public methods and constants with no implementation.

=Conclusion=
Although mixins have certain advantages over interfaces, they possess their own share of disadvantages. Mixins are generally used in small frameworks and interfaces , more than solving the problem of multiple inheritance provide polymorphism feature which makes object-oriented code more flexible and easy to modify and maintain.

=References=
<references/>

=See Also=
1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ 
3. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
4. https://www.cs.washington.edu/education/courses/cse413/11sp/lectures/ruby_interfaces-etc.pdf 
5. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
6. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch2 2c ds

2011-09-22T03:27:56Z

Ssreepa: /* Approaches */

=Mixins vs. Interfaces=

=Introduction=
With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to .

While Java like languages implemented interfaces to allow for [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism],languages like Ruby opted not to implement multiple inheritance but to allow the code from one module be added into another class.

Though both interfaces and Mixins simulate multiple inheritance and avoid the common pathologies associated with it , they have their own set of compromises. The below article tries to provide clarity on how this is achieved in each and also provides other distinctive features of Mixins and interfaces.

===Interfaces===
In an object-oriented programming languages such as Java, C#, an interface<ref>[http://download.oracle.com/javase/tutorial/ Interfaces] </ref> is a reference type, similar to a class that can contain only constants, method signatures, and nested types. There are no method bodies. Interfaces cannot be instantiated and they can only be implemented by classes or extended by other interfaces. All methods are public by default and any fields declared in an interface are by default static and final.

Example:

public interface ParkingLot {
boolean add(Car car, int slot);
boolean remove(Car car);
boolean findCar(Int number);
int freeSlotsCount();
int occupiedSlots();
int parkingType();
int calculateParkingFee(int hours, int charge, int duration);
int findParkingSlot();
}

Interfaces play another important role in the object-oriented programming language. Interfaces are not part of the class hierarchy, although they work in combination with classes. Interfaces provide an alternative for languages like Java that does not allow multiple inheritance .

In Java, a class can inherit from only one class but it can implement more than one interface. Therefore, objects can have multiple types: the type of their own class and the types of all the interfaces that they implement. This means that if a variable is declared to be the type of an interface, its value can reference any object that is instantiated from any class that implements the interface.

==Mixins==

Modules provide a structure to collect classes, methods, and constants into a single, separately defined unit. They provide the simplest and an elegant way to adhere to the [http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] principle. This is useful so as to avoid clashes with existing classes, methods, and constants.

Modules are defined in Ruby using the ''module'' keyword.

A Mixin is a class that is mixed with a module or a set of modules i.e. the implementation of the modules and the class are intertwined and combined together <ref>[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Mixins] </ref>.

This gives us a neat and controlled way of adding new functionality to classes. Modules are similar to classes in that they hold a collection of methods, variables constants and other modules and class definitions. However, the real usage of a Mixin is exploited when the code in the Mixin starts to interact with code in the class that uses it.

Below is an example for modules and Mixins:

The module ParkingSlot consists of the methods park and unpark

module ParkingSlot
def park
#code to park the car
end
def unpark
#code to unpark the car
end
end

The module ParkingMeter consists of the methods calculate and printreceipt

module ParkingMeter
def calculate
#code to calculate the parking fee
end
def printreceipt
#code to print the receipt
end
end

When a class ''includes'' a module via include Module Name, all the methods on that module become instance methods on the class.

class Parking
include ParkingSlot
include ParkingMeter
def printcardetails
#code to print the details and type of car
end
end

The modules ParkingSlot and ParkingMeter are “included” in the Parking class. All the variables and the instance methods of the modules ParkingSlot and ParkingMeter are now said to be “mixed in” into the class. It is now possible for class instances to use these methods defined in the modules as and when required.

p=Parking.new
p.park # -> Method park from module ParkingSlot
p.unpark # -> Method unpark from module ParkingSlot
p.calculate # -> Method calculate from module ParkingMeter
p.printreceipt # -> Method printreceipt from module ParkingMeter
p.printcardetails # -> Calls printCarDetails from class

The class Parking inherits from both the modules and the module methods are now available in Parking. Hence, it is now possible to use the methods with an instance of the Parking class ''p''.

Hence, Mixins can be thought of taking different methods and variables defined in different modules making them available as instance methods in the class as well, thereby extending the class’ functionality. Effectively mixed in modules behave as [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclass].

[[Image:ParkingLot.PNG | center]]

==Supported Languages==
The following table shows support for Mixins and Interfaces by most commonly used languages.

{| class="wikitable"
|-
! Languages
! Mixins
! Interfaces
|-
| Ruby
| Yes
| No
|-
| Java
| No
| Yes
|-
| Python
| Yes
| No
|-
| Smalltalk
| Yes
| No
|-
| Perl
| Yes
| No
|-
| C#
| No
| Yes

|}

=Multiple Inheritance=
[[Multiple Inheritance]] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass.
Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

==Diamond Problem==
This section describes the well know “Diamond Problem”<ref>[http://www.artima.com/designtechniques/interfaces2.html Diamond Problem] </ref> associated with multiple Inheritance and the succeeding sections describe how Mixins and interfaces can be used to overcome this problem.
The diamond problem is the ambiguity that can occur when a class inherits from two different classes that both descend from a common superclass. For example, consider a scenario where one decides to combine the Frog and Dinosaur species which both are inherited from the Animal class. The talk() method in the Animal class is abstract and both Frog and Dinosaur needs to implement this method.

Lets say both Frog and Dinosaur implement the talk method like this:

public class Frog extends Animal {
void talk() {
System.out.println(“I am Frog, I can croak “);
}
}

and,
public class Dinosaur extends Animal {
void talk() {
System.out.println(“I am Dinosaur, I can roar “);
}
}

[[Image:Diamond_problem.PNG | center]]

When the Frogsaur is created, it inherits from both Frog and Dinosaur.

public class Frogsaur extends Frog, Dinosaur {
// Note below syntax is used just for demonstration. However java might throw compile time error.
}

The real problem occurs when someone tries to invoke talk() method on a Frogsaur object from the Animal reference.

Animal species = new Frogsaur();
species.talk(); // which method to invoke ???

Due to the ambiguity caused by the diamond problem, it isn’t clear whether the runtime system should invoke Frog’s talk() method or Dinosaur talk() method.

==Approaches==
Different programming languages have addressed the diamond problem in different ways.

In Java, interfaces solve all these ambiguities caused by the diamond problem. Through interfaces, Java allows multiple inheritance of interface but not of implementation. Implementation, which includes instance variables and method implementations, is always singly inherited. As a result, confusion will never arise in Java over which inherited instance variable or method implementation to use.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Frog and Dinosaur, each of which contain the talk method defined in them. The Frogsaur class ''includes'' these two methods and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Frog
def talk
puts "I can croak"
end
end

module Dinosaur
def talk
puts "I can roar"
end
end

class Frogsaur
include Frog
include Dinosaur
def talk
puts "I can roar like a dinosaur and croak like a frog"
end
end

fs = Frogsaur.new
fs.talk # -> I can roar like a dinosaur and croak like a frog

When the method talk is called on the Frogsaur object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Frogsaur class is defined the latest and hence “I can roar like a dinosaur and croak like a frog” is printed. If there was no method defined in the class, method from the Dinosaur is printed since it is next in the hierarchy specified by the include statements.

=Comparison between Mixins and Interfaces=

This is a general comparision:

{| class="wikitable"
|-
! Mixins
! Interfaces
|-
| In Ruby, modules have the implementation of the methods. So all the classes which include the modules gets the same Implementation because classes create a reference to these modules.
|In Java, all classes which implement the interfaces should provide implementation for each of the methods declared in the interface. This might duplicate the code if the 2 or more classes have similar functionality.
|-
| Relatively smaller because the classes automatically get access to methods defined in the modules. Modules server as a central repository
| Relatively larger because a class implementing more than one interfaces has to provide implementation.
|-
| Having more modules in the classes can make code less readable. Ideally mixins are suitable for small teams having few modules.
| The code is more readable here as the implementation is provided to each method and can be found in place
|-
| In Ruby, a method inside a module can have Module name as qualifier. Hence it’s possible for a class to have inherit two or more modules which have same names.
| In Java, the class itself has to provide the implementation of the methods. Inheriting methods of same names from different interfaces will signal an error message.
|-
| Modules cannot be inherited and cannot form is-a hierarchy
| Interfaces can extend another interface and hence can form is-a hierarchy
|}

==Drawbacks of Mixins and Interfaces==

The drawbacks of the technique of Mixins are very much debated. Though Mixins provide us with an easy way to write flexible and decoupled code and also help us solve the diamond problem, they pose their own problems. In large programs there could be large number of modules and each module could have loads of methods each performing a certain task, to trace the origin of the methods and to keep in mind the hierarchy is practically impossible. Another issue associated with Mixins pose is silent method overriding.

Although Java provides polymorphic behavior with the use of interfaces, they sometimes tend to be very slow. The implementation of interfaces are also limited to public methods and constants with no implementation.

=Conclusion=
Although mixins have certain advantages over interfaces, they possess their own share of disadvantages. Mixins are generally used in small frameworks and interfaces , more than solving the problem of multiple inheritance provide polymorphism feature which makes object-oriented code more flexible and easy to modify and maintain.

=References=
<references/>

=See Also=
1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ 
3. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
4. https://www.cs.washington.edu/education/courses/cse413/11sp/lectures/ruby_interfaces-etc.pdf 
5. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
6. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch2 2c ds

2011-09-22T03:27:27Z

Ssreepa: /* Diamond Problem */

=Mixins vs. Interfaces=

=Introduction=
With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to .

While Java like languages implemented interfaces to allow for [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism],languages like Ruby opted not to implement multiple inheritance but to allow the code from one module be added into another class.

Though both interfaces and Mixins simulate multiple inheritance and avoid the common pathologies associated with it , they have their own set of compromises. The below article tries to provide clarity on how this is achieved in each and also provides other distinctive features of Mixins and interfaces.

===Interfaces===
In an object-oriented programming languages such as Java, C#, an interface<ref>[http://download.oracle.com/javase/tutorial/ Interfaces] </ref> is a reference type, similar to a class that can contain only constants, method signatures, and nested types. There are no method bodies. Interfaces cannot be instantiated and they can only be implemented by classes or extended by other interfaces. All methods are public by default and any fields declared in an interface are by default static and final.

Example:

public interface ParkingLot {
boolean add(Car car, int slot);
boolean remove(Car car);
boolean findCar(Int number);
int freeSlotsCount();
int occupiedSlots();
int parkingType();
int calculateParkingFee(int hours, int charge, int duration);
int findParkingSlot();
}

Interfaces play another important role in the object-oriented programming language. Interfaces are not part of the class hierarchy, although they work in combination with classes. Interfaces provide an alternative for languages like Java that does not allow multiple inheritance .

In Java, a class can inherit from only one class but it can implement more than one interface. Therefore, objects can have multiple types: the type of their own class and the types of all the interfaces that they implement. This means that if a variable is declared to be the type of an interface, its value can reference any object that is instantiated from any class that implements the interface.

==Mixins==

Modules provide a structure to collect classes, methods, and constants into a single, separately defined unit. They provide the simplest and an elegant way to adhere to the [http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] principle. This is useful so as to avoid clashes with existing classes, methods, and constants.

Modules are defined in Ruby using the ''module'' keyword.

A Mixin is a class that is mixed with a module or a set of modules i.e. the implementation of the modules and the class are intertwined and combined together <ref>[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Mixins] </ref>.

This gives us a neat and controlled way of adding new functionality to classes. Modules are similar to classes in that they hold a collection of methods, variables constants and other modules and class definitions. However, the real usage of a Mixin is exploited when the code in the Mixin starts to interact with code in the class that uses it.

Below is an example for modules and Mixins:

The module ParkingSlot consists of the methods park and unpark

module ParkingSlot
def park
#code to park the car
end
def unpark
#code to unpark the car
end
end

The module ParkingMeter consists of the methods calculate and printreceipt

module ParkingMeter
def calculate
#code to calculate the parking fee
end
def printreceipt
#code to print the receipt
end
end

When a class ''includes'' a module via include Module Name, all the methods on that module become instance methods on the class.

class Parking
include ParkingSlot
include ParkingMeter
def printcardetails
#code to print the details and type of car
end
end

The modules ParkingSlot and ParkingMeter are “included” in the Parking class. All the variables and the instance methods of the modules ParkingSlot and ParkingMeter are now said to be “mixed in” into the class. It is now possible for class instances to use these methods defined in the modules as and when required.

p=Parking.new
p.park # -> Method park from module ParkingSlot
p.unpark # -> Method unpark from module ParkingSlot
p.calculate # -> Method calculate from module ParkingMeter
p.printreceipt # -> Method printreceipt from module ParkingMeter
p.printcardetails # -> Calls printCarDetails from class

The class Parking inherits from both the modules and the module methods are now available in Parking. Hence, it is now possible to use the methods with an instance of the Parking class ''p''.

Hence, Mixins can be thought of taking different methods and variables defined in different modules making them available as instance methods in the class as well, thereby extending the class’ functionality. Effectively mixed in modules behave as [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclass].

[[Image:ParkingLot.PNG | center]]

==Supported Languages==
The following table shows support for Mixins and Interfaces by most commonly used languages.

{| class="wikitable"
|-
! Languages
! Mixins
! Interfaces
|-
| Ruby
| Yes
| No
|-
| Java
| No
| Yes
|-
| Python
| Yes
| No
|-
| Smalltalk
| Yes
| No
|-
| Perl
| Yes
| No
|-
| C#
| No
| Yes

|}

=Multiple Inheritance=
[[Multiple Inheritance]] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass.
Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

==Diamond Problem==
This section describes the well know “Diamond Problem”<ref>[http://www.artima.com/designtechniques/interfaces2.html Diamond Problem] </ref> associated with multiple Inheritance and the succeeding sections describe how Mixins and interfaces can be used to overcome this problem.
The diamond problem is the ambiguity that can occur when a class inherits from two different classes that both descend from a common superclass. For example, consider a scenario where one decides to combine the Frog and Dinosaur species which both are inherited from the Animal class. The talk() method in the Animal class is abstract and both Frog and Dinosaur needs to implement this method.

Lets say both Frog and Dinosaur implement the talk method like this:

public class Frog extends Animal {
void talk() {
System.out.println(“I am Frog, I can croak “);
}
}

and,
public class Dinosaur extends Animal {
void talk() {
System.out.println(“I am Dinosaur, I can roar “);
}
}

[[Image:Diamond_problem.PNG | center]]

When the Frogsaur is created, it inherits from both Frog and Dinosaur.

public class Frogsaur extends Frog, Dinosaur {
// Note below syntax is used just for demonstration. However java might throw compile time error.
}

The real problem occurs when someone tries to invoke talk() method on a Frogsaur object from the Animal reference.

Animal species = new Frogsaur();
species.talk(); // which method to invoke ???

Due to the ambiguity caused by the diamond problem, it isn’t clear whether the runtime system should invoke Frog’s talk() method or Dinosaur talk() method.

==Approaches==
Different programming languages have addressed the diamond problem in different ways

In Java, interfaces solve all these ambiguities caused by the diamond problem. Through interfaces, Java allows multiple inheritance of interface but not of implementation. Implementation, which includes instance variables and method implementations, is always singly inherited. As a result, confusion will never arise in Java over which inherited instance variable or method implementation to use.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Frog and Dinosaur, each of which contain the talk method defined in them. The Frogsaur class ''includes'' these two methods and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Frog
def talk
puts "I can croak"
end
end

module Dinosaur
def talk
puts "I can roar"
end
end

class Frogsaur
include Frog
include Dinosaur
def talk
puts "I can roar like a dinosaur and croak like a frog"
end
end

fs = Frogsaur.new
fs.talk # -> I can roar like a dinosaur and croak like a frog

When the method talk is called on the Frogsaur object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Frogsaur class is defined the latest and hence “I can roar like a dinosaur and croak like a frog” is printed. If there was no method defined in the class, method from the Dinosaur is printed since it is next in the hierarchy specified by the include statements.

=Comparison between Mixins and Interfaces=

This is a general comparision:

{| class="wikitable"
|-
! Mixins
! Interfaces
|-
| In Ruby, modules have the implementation of the methods. So all the classes which include the modules gets the same Implementation because classes create a reference to these modules.
|In Java, all classes which implement the interfaces should provide implementation for each of the methods declared in the interface. This might duplicate the code if the 2 or more classes have similar functionality.
|-
| Relatively smaller because the classes automatically get access to methods defined in the modules. Modules server as a central repository
| Relatively larger because a class implementing more than one interfaces has to provide implementation.
|-
| Having more modules in the classes can make code less readable. Ideally mixins are suitable for small teams having few modules.
| The code is more readable here as the implementation is provided to each method and can be found in place
|-
| In Ruby, a method inside a module can have Module name as qualifier. Hence it’s possible for a class to have inherit two or more modules which have same names.
| In Java, the class itself has to provide the implementation of the methods. Inheriting methods of same names from different interfaces will signal an error message.
|-
| Modules cannot be inherited and cannot form is-a hierarchy
| Interfaces can extend another interface and hence can form is-a hierarchy
|}

==Drawbacks of Mixins and Interfaces==

The drawbacks of the technique of Mixins are very much debated. Though Mixins provide us with an easy way to write flexible and decoupled code and also help us solve the diamond problem, they pose their own problems. In large programs there could be large number of modules and each module could have loads of methods each performing a certain task, to trace the origin of the methods and to keep in mind the hierarchy is practically impossible. Another issue associated with Mixins pose is silent method overriding.

Although Java provides polymorphic behavior with the use of interfaces, they sometimes tend to be very slow. The implementation of interfaces are also limited to public methods and constants with no implementation.

=Conclusion=
Although mixins have certain advantages over interfaces, they possess their own share of disadvantages. Mixins are generally used in small frameworks and interfaces , more than solving the problem of multiple inheritance provide polymorphism feature which makes object-oriented code more flexible and easy to modify and maintain.

=References=
<references/>

=See Also=
1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ 
3. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
4. https://www.cs.washington.edu/education/courses/cse413/11sp/lectures/ruby_interfaces-etc.pdf 
5. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
6. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

CSC/ECE 517 Fall 2011/ch2 2c ds

2011-09-22T03:26:31Z

Ssreepa: /* Diamond Problem */

=Mixins vs. Interfaces=

=Introduction=
With the advent of object oriented languages, the designers of the language had to come up with the decision of whether or not to include the concept of multiple inheritance. Languages like C++ and Perl allow multiple inheritance whereas the designers of languages like C# and Java decided not to .

While Java like languages implemented interfaces to allow for [http://en.wikipedia.org/wiki/Polymorphism_in_object-oriented_programming polymorphism],languages like Ruby opted not to implement multiple inheritance but to allow the code from one module be added into another class.

Though both interfaces and Mixins simulate multiple inheritance and avoid the common pathologies associated with it , they have their own set of compromises. The below article tries to provide clarity on how this is achieved in each and also provides other distinctive features of Mixins and interfaces.

===Interfaces===
In an object-oriented programming languages such as Java, C#, an interface<ref>[http://download.oracle.com/javase/tutorial/ Interfaces] </ref> is a reference type, similar to a class that can contain only constants, method signatures, and nested types. There are no method bodies. Interfaces cannot be instantiated and they can only be implemented by classes or extended by other interfaces. All methods are public by default and any fields declared in an interface are by default static and final.

Example:

public interface ParkingLot {
boolean add(Car car, int slot);
boolean remove(Car car);
boolean findCar(Int number);
int freeSlotsCount();
int occupiedSlots();
int parkingType();
int calculateParkingFee(int hours, int charge, int duration);
int findParkingSlot();
}

Interfaces play another important role in the object-oriented programming language. Interfaces are not part of the class hierarchy, although they work in combination with classes. Interfaces provide an alternative for languages like Java that does not allow multiple inheritance .

In Java, a class can inherit from only one class but it can implement more than one interface. Therefore, objects can have multiple types: the type of their own class and the types of all the interfaces that they implement. This means that if a variable is declared to be the type of an interface, its value can reference any object that is instantiated from any class that implements the interface.

==Mixins==

Modules provide a structure to collect classes, methods, and constants into a single, separately defined unit. They provide the simplest and an elegant way to adhere to the [http://en.wikipedia.org/wiki/Don't_repeat_yourself Don't repeat yourself] principle. This is useful so as to avoid clashes with existing classes, methods, and constants.

Modules are defined in Ruby using the ''module'' keyword.

A Mixin is a class that is mixed with a module or a set of modules i.e. the implementation of the modules and the class are intertwined and combined together <ref>[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_modules.html Mixins] </ref>.

This gives us a neat and controlled way of adding new functionality to classes. Modules are similar to classes in that they hold a collection of methods, variables constants and other modules and class definitions. However, the real usage of a Mixin is exploited when the code in the Mixin starts to interact with code in the class that uses it.

Below is an example for modules and Mixins:

The module ParkingSlot consists of the methods park and unpark

module ParkingSlot
def park
#code to park the car
end
def unpark
#code to unpark the car
end
end

The module ParkingMeter consists of the methods calculate and printreceipt

module ParkingMeter
def calculate
#code to calculate the parking fee
end
def printreceipt
#code to print the receipt
end
end

When a class ''includes'' a module via include Module Name, all the methods on that module become instance methods on the class.

class Parking
include ParkingSlot
include ParkingMeter
def printcardetails
#code to print the details and type of car
end
end

The modules ParkingSlot and ParkingMeter are “included” in the Parking class. All the variables and the instance methods of the modules ParkingSlot and ParkingMeter are now said to be “mixed in” into the class. It is now possible for class instances to use these methods defined in the modules as and when required.

p=Parking.new
p.park # -> Method park from module ParkingSlot
p.unpark # -> Method unpark from module ParkingSlot
p.calculate # -> Method calculate from module ParkingMeter
p.printreceipt # -> Method printreceipt from module ParkingMeter
p.printcardetails # -> Calls printCarDetails from class

The class Parking inherits from both the modules and the module methods are now available in Parking. Hence, it is now possible to use the methods with an instance of the Parking class ''p''.

Hence, Mixins can be thought of taking different methods and variables defined in different modules making them available as instance methods in the class as well, thereby extending the class’ functionality. Effectively mixed in modules behave as [http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)#Subclasses_and_superclasses superclass].

[[Image:ParkingLot.PNG | center]]

==Supported Languages==
The following table shows support for Mixins and Interfaces by most commonly used languages.

{| class="wikitable"
|-
! Languages
! Mixins
! Interfaces
|-
| Ruby
| Yes
| No
|-
| Java
| No
| Yes
|-
| Python
| Yes
| No
|-
| Smalltalk
| Yes
| No
|-
| Perl
| Yes
| No
|-
| C#
| No
| Yes

|}

=Multiple Inheritance=
[[Multiple Inheritance]] refers to a feature in some [http://en.wikipedia.org/wiki/Object-oriented_programming object oriented programming] languages in which a class can inherit behaviors from more than one superclass. This contrasts with single inheritance in which a class can inherit behavior from at most one superclass.
Though Multiple Inheritance provides its own advantages of improved modularity and ease of reuse of code in certain applications, it has its own set of disadvantages which sometimes outweigh the possible advantages.

==Diamond Problem==
This section describes the well know “Diamond Problem”<ref>[http://www.artima.com/designtechniques/interfaces2.html Diamond Problem] </ref> associated with multiple Inheritance and the succeeding sections describe how Mixins and interfaces can be used to overcome this problem.
The diamond problem is the ambiguity that can occur when a class inherits from two different classes that both descend from a common superclass. For example, consider a scenario where one decides to combine the Frog and Dinosaur species which both are inherited from the Animal class. The talk() method in the Animal class is abstract and both Frog and Dinosaur needs to implement this method.

Lets say both Frog and Dinosaur implement the talk method like this:

public class Frog extends Animal {
void talk() {
System.out.println(“I am Frog, I can croak “);
}
}

and,
public class Dinosaur extends Animal {
void talk() {
System.out.println(“I am Dinosaur, I can roar “);
}
}

[[Image:Diamond_problem.PNG | center]]

When the Frogsaur is created, it inherits from both Frog and Dinosaur.

public class Frogsaur extends Frog, Dinosaur {
// Note below syntax is used just for demonstration. However java might throw compile time error.
}

The real problem occurs when someone tries to invoke talk() method on a Frogsaur object from the Animal reference.

Animal species = new Frogsaur();
animal.talk(); // which method to invoke ???

Due to the ambiguity caused by the diamond problem, it isn’t clear whether the runtime system should invoke Frog’s talk() method or Dinosaur talk() method.

==Approaches==
Different programming languages have addressed the diamond problem in different ways

In Java, interfaces solve all these ambiguities caused by the diamond problem. Through interfaces, Java allows multiple inheritance of interface but not of implementation. Implementation, which includes instance variables and method implementations, is always singly inherited. As a result, confusion will never arise in Java over which inherited instance variable or method implementation to use.

Ruby does not support multiple inheritance. Mixin provide a way which eliminates the need for multiple inheritance. Ruby has modules which are just like abstract classes in Java. Modules can have different methods implemented in them. They cannot be instantiated like abstract classes. They cannot inherit from other modules or classes. Ruby classes can inherit from only one superclass but can have unlimited number of modules in them to exploit the usage of predefined implementations in these modules. This provides functionality similar to multiple inheritance avoiding any ambiguities.

The below code in Ruby demonstrates two modules Frog and Dinosaur, each of which contain the talk method defined in them. The Frogsaur class ''includes'' these two methods and defines its own talk method. This example was chosen to exhibit on how Ruby resolves method calls at run time.

module Frog
def talk
puts "I can croak"
end
end

module Dinosaur
def talk
puts "I can roar"
end
end

class Frogsaur
include Frog
include Dinosaur
def talk
puts "I can roar like a dinosaur and croak like a frog"
end
end

fs = Frogsaur.new
fs.talk # -> I can roar like a dinosaur and croak like a frog

When the method talk is called on the Frogsaur object, Ruby makes sure that the latest method defined in the hierarchy is chosen. Here in this example, the talk method in the Frogsaur class is defined the latest and hence “I can roar like a dinosaur and croak like a frog” is printed. If there was no method defined in the class, method from the Dinosaur is printed since it is next in the hierarchy specified by the include statements.

=Comparison between Mixins and Interfaces=

This is a general comparision:

{| class="wikitable"
|-
! Mixins
! Interfaces
|-
| In Ruby, modules have the implementation of the methods. So all the classes which include the modules gets the same Implementation because classes create a reference to these modules.
|In Java, all classes which implement the interfaces should provide implementation for each of the methods declared in the interface. This might duplicate the code if the 2 or more classes have similar functionality.
|-
| Relatively smaller because the classes automatically get access to methods defined in the modules. Modules server as a central repository
| Relatively larger because a class implementing more than one interfaces has to provide implementation.
|-
| Having more modules in the classes can make code less readable. Ideally mixins are suitable for small teams having few modules.
| The code is more readable here as the implementation is provided to each method and can be found in place
|-
| In Ruby, a method inside a module can have Module name as qualifier. Hence it’s possible for a class to have inherit two or more modules which have same names.
| In Java, the class itself has to provide the implementation of the methods. Inheriting methods of same names from different interfaces will signal an error message.
|-
| Modules cannot be inherited and cannot form is-a hierarchy
| Interfaces can extend another interface and hence can form is-a hierarchy
|}

==Drawbacks of Mixins and Interfaces==

The drawbacks of the technique of Mixins are very much debated. Though Mixins provide us with an easy way to write flexible and decoupled code and also help us solve the diamond problem, they pose their own problems. In large programs there could be large number of modules and each module could have loads of methods each performing a certain task, to trace the origin of the methods and to keep in mind the hierarchy is practically impossible. Another issue associated with Mixins pose is silent method overriding.

Although Java provides polymorphic behavior with the use of interfaces, they sometimes tend to be very slow. The implementation of interfaces are also limited to public methods and constants with no implementation.

=Conclusion=
Although mixins have certain advantages over interfaces, they possess their own share of disadvantages. Mixins are generally used in small frameworks and interfaces , more than solving the problem of multiple inheritance provide polymorphism feature which makes object-oriented code more flexible and easy to modify and maintain.

=References=
<references/>

=See Also=
1. http://ruby.about.com/od/beginningruby/a/mixin.html 
2. http://juixe.com/techknow/index.php/2006/06/15/mixins-in-ruby/ 
3. https://www.re-motion.org/blogs/team/2008/02/20/introducing-mixins-finally/ 
4. https://www.cs.washington.edu/education/courses/cse413/11sp/lectures/ruby_interfaces-etc.pdf 
5. http://pg-server.csc.ncsu.edu/mediawiki/index.php?title=CSC/ECE_517_Fall_2010/ch3_3b_sv&printable=yes 
6. http://csis.pace.edu/~bergin/patterns/multipleinheritance.html