Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T23:44:06Z

Ddilipd: /* Blocks */

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.

<pre>
block = lambda { |x| "Hello #{x}!" }
puts block.call 'World'
</pre>
<pre>
Output
Hello World!
</pre>
Above code shows example of passing arguments using lambda.

===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:18:00Z

Ddilipd: /* Procs And Lambdasproc and Lamda */

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

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:17:06Z

Ddilipd: /* Blocks */

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<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-28T22:16:47Z

Ddilipd: /* Lambda method */

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.

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-28T22:16:35Z

Ddilipd: /* Lambda method */

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.

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-28T22:15:33Z

Ddilipd: /* 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}
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
<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-28T21:50:43Z

Ddilipd:

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.
<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:36:44Z

Ddilipd: /* External links */

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 dsfsfd]

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

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-28T20:34:50Z

Ddilipd: /* Further reading */

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.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:34:24Z

Ddilipd: /* External links */

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.tutorialspoint.com/ruby/ruby_classes.htm]

=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:31:17Z

Ddilipd: /* Currying */

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. 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:33Z

Ddilipd: /* Currying */

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, 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:30:10Z

Ddilipd: /* Currying */

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 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:19:48Z

Ddilipd:

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/>

=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-21T01:20:51Z

Ddilipd:

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 ==
[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-21T01:20:39Z

Ddilipd:

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 ==
[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-21T01:19:00Z

Ddilipd: /* Attributes */

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 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 ==
[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:18:25Z

Ddilipd: /* 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 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/

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T18:07:11Z

Ddilipd: /* 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.
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 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-20T17:57:18Z

Ddilipd:

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==
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 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:52:26Z

Ddilipd: /* 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==

==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==
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 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:50:41Z

Ddilipd: /* Currying */

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==
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:49:46Z

Ddilipd: /* Procs And Lambdas */

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 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:48:38Z

Ddilipd: /* Proc method */

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 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 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:47:35Z

Ddilipd: /* Proc method */

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 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 [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 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:46:41Z

Ddilipd: /* Proc.new */

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 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 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:45:14Z

Ddilipd: /* Closures */

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 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:26:25Z

Ddilipd:

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T12:44:50Z

Ddilipd:

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T12:42:23Z

Ddilipd:

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T12:40:32Z

Ddilipd:

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T12:39:43Z

Ddilipd:

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T12:38:48Z

Ddilipd:

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”. 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 methodis 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 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>

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T12:38:00Z

Ddilipd:

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of Closures, blocks, currying and OOP in Ruby.

__TOC__

==Introduction==

==Closures==
A closure is a block of code that “closes over”. 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 methodis 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 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>

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T12:31:30Z

Ddilipd:

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T12:27:46Z

Ddilipd:

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of Closures, blocks, currying and OOP in Ruby.

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T12:27:33Z

Ddilipd:

Wiki textbook chapter on OOLS Lecture 5. Covers the basic of Closures, blocks, currying and OOP in Ruby

CSC/ECE 517 Fall 2011

2011-10-20T02:19:22Z

Ddilipd:

[[Link title]]
*[[CSC/ECE 517 Fall 2011/ch1 1a ms]]

*[[CSC/ECE 517 Fall 2011/ch1 1a cs]]

*[[CSC/ECE 517 Fall 2011/ch1 1a ri]]

*[[CSC/ECE 517 Fall 2011/ch1 1a lj]]

*[[CSC/ECE 517 Fall 2011/ch1 1b sa]]

*[[CSC/ECE 517 Fall 2011/ch1 1b ds]]

*[[CSC/ECE 517 Fall 2011/ch1 1b tj]]

*[[CSC/ECE 517 Fall 2011/ch1 1c cm]]

*[[CSC/ECE 517 Fall 2011/ch1 1c sj]]

*[[CSC/ECE 517 Fall 2011/ch1 1c ka]]

*[[CSC/ECE 517 Fall 2011/ch1 1d sr]]

*[[CSC/ECE 517 Fall 2011/ch1 1e vs]]

*[[CSC/ECE 517 Fall 2011/ch1 1e aa]]

*[[CSC/ECE 517 Fall 2011/ch1 1a sc]]

*[[CSC/ECE 517 Fall 2011/ch1 1e dm]]

*[[CSC/ECE 517 Fall 2011/ch1 1e an]]

*[[CSC/ECE 517 Fall 2011/ch1 1e sa]]

*[[CSC/ECE 517 Fall 2011/ch1 1e lm]]

*[[CSC/ECE 517 Fall 2011/ch1 1g vn]]

*[[CSC/ECE 517 Fall 2011/ch1 1f rs]]

*[[CSC/ECE 517 Fall 2011/ch1 1f sv]]

*[[CSC/ECE 517 Fall 2011/ch1 1g jn]]

*[[CSC/ECE 517 Fall 2011/ch1 1h ps]]

*[[CSC/ECE 517 Fall 2011/ch1 1e sm]]

*[[CSC/ECE 517 Fall 2011/ch1 1i zf]]

*[[CSC/ECE 517 Fall 2011/ch1 1g rn]]

*[[CSC/ECE 517 Fall 2011/ch1 1i cl]]

*[[CSC/ECE 517 Fall 2011/ch1 1d ss]]

*[[CSC/ECE 517 Fall 2011/ch1 1i lj]]

*[[CSC/ECE 517 Fall 2011/ch1 1h hs]]

*[[CSC/ECE 517 Fall 2011/ch1 1d gs]]

*[[CSC/ECE 517 Fall 2011/ch1 2b ns]]

*[[CSC/ECE 517 Fall 2011/ch1 2b jp]]

*[[CSC/ECE 517 Fall 2011/ch1 2a av]]

*[[CSC/ECE 517 Fall 2011/ch2 2f jm]]

*[[CSC/ECE 517 Fall 2011/ch2 2e ad]]

*[[CSC/ECE 517 Fall 2011/ch2 2e kt]]

*[[CSC/ECE 517 Fall 2011/ch2 2e gp]]

*[[CSC/ECE 517 Fall 2011/ch1 2b qu]]

*[[CSC/ECE 517 Fall 2011/ch2 2c bs]]

*[[CSC/ECE 517 Fall 2011/ch1 2c rs]]

*[[CSC/ECE 517 Fall 2011/ch1 2a ca]]

*[[CSC/ECE 517 Fall 2011/ch1 2b rv]]

*[[CSC/ECE 517 Fall 2011/ch2 2c ds]]

*[[CSC/ECE 517 Fall 2011/ch2 2b sa]]

*[[CSC/ECE 517 Fall 2011/ch2 2f vh]]

*[[CSC/ECE 517 Fall 2011/ch2 2e ps]]

*[[CSC/ECE 517 Fall 2011/ch3 3a oe]]

*[[CSC/ECE 517 Fall 2011/ch3 3h rr]]

*[[CSC/ECE 517 Fall 2011/ch3 3h ss]]

*[[CSC/ECE 517 Fall 2011/ch3 4b js]]

*[[CSC/ECE 517 Fall 2011/ch3 4b ms]]

*[[CSC/ECE 517 Fall 2011/ch4 4b ds]]

*[[CSC/ECE 517 Fall 2011/ch4 4i aa]]

*[[CSC/ECE 517 Fall 2011/ch4 4i sd]]

*[[CSC/ECE 517 Fall 2011/ch4 4d mt]]

*[[CSC/ECE 517 Fall 2011/ch4 4d ls]]

*[[CSC/ECE 517 Fall 2011/ch4 4d ch]]

*[[CSC/ECE 517 Fall 2011/ch4 4c ap]]

*[[CSC/ECE 517 Fall 2011/ch4 4h sv]]

*[[CSC/ECE 517 Fall 2011/ch4 4e cl]]

*[[CSC/ECE 517 Fall 2011/ch4 4a ga]]

*[[CSC/ECE 517 Fall 2011/ch4 4f sl]]

*[[CSC/ECE 517 Fall 2011/ch4 4i js]]

*[[CSC/ECE 517 Fall 2011/ch4 4f ss]]

*[[CSC/ECE 517 Fall 2011/ch4 4c dm]]

*[[trial]]

CSC/ECE 517 Fall 2011/ch4 4b ds

2011-10-20T02:15:51Z

Ddilipd: Created page with "dilip"

dilip

CSC/ECE 517 Fall 2011/ch1 1b ds

2011-09-26T02:44:28Z

Ddilipd: /* Conclusion */

Cover the history of Collections frameworks back to the late 1970s or early 1980s, and how they were retrofitted to various languages. Discuss the advantage of a standard Collections framework (e.g., Java) vs. several competing frameworks (e.g., C++), and the advantage of collections built into the language (e.g., Ruby) vs. collections as class libraries. Give examples to illustrate the advantages you identify.

__TOC__

==Introduction==
A collection refers to a group of data items which have some commonality like a "a bunch of objects stored in a structured manner". Collections are very common in daily life, some examples would be a collection of science fiction books, the names of employees in a given department etc. Given that object oriented design concepts try to model the real world, it is natural to include support for creating and manipulating collections in languages which support object oriented development. Collections allows you to organize data in memory in various convenient ways.
Example : a simple list of strings, a mapping or association of strings to strings (e.g. country names to the names of their capitals);

Almost all major programming and scripting languages that are used today such as [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]], [http://en.wikipedia.org/wiki/JavaScript JavaScript], [http://en.wikipedia.org/wiki/PHP PHP], [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby], [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] have support for collections in some form or the other. Some languages have liner arrays (which can have different types of elements) and associative arrays built into the language whereas some other languages provide support through external libraries.

In this article we compare and contrast the two most popular collections frameworks/libraries in use today, C++ STL and Java Collections Framework (JCF). Also we compare collections in Ruby which does not have a formal collections framework against C++ and Java which define a formal framework/library for collections.

==History==
The history of collection frameworks can be analyzed in two aspects. Languages which have some basic collection containers built into them and languages with a formal collection framework. A collection framework may be defined as a generic reusable collection of classes which implements data structures and algorithms to create and manipulate groups of related objects. Few languages support a formal collections framework. Most of the modern programming languages have sequential arrays and associative array's built into them. A programmer may use these basic containers to create their own custom collection classes. A comparison of programming languages that implement associative arrays can be found [http://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28mapping%29 here].

The history of a collections framework or a collections library originate from ideas related to [http://en.wikipedia.org/wiki/Generic_programming generic programming] developed by Alexander Stepanov in the early 80s. At that time Ada was the only language which had support for generics. An initial generic library for list processing in Ada was developed by Alexander Stepanov and David Musser. However Ada did not achieve widespread acceptance by the programming community. As C/C++ became more widespread attention was given to developing a generic library in C++. Finally a proposal was made to the ANSI/ISO committee in 1993 and the C++ STL was finally accepted in 1994.

In the case of Java the initial versions prior to JDK-1.2 did not have a collections framework. These versions just defined Vectors and HashTables which were used to group objects together. This is reminiscent of the way things are done in languages such as Ruby, Python etc. The formal collections framework was introduced in 1998 with JDK-1.2 which borrowed a lot form Doug Lea's ''Collections package''. The goal of this framework was to be consistent with C++ STL. But soon Sun Microsystems decided that Java needed a compact collections framework and consistency with C++ STL was no longer a priority. This led to the development of the Java Collections Framework as we know it today.

=='''Java Collections Framework (JCF)'''==

[[Image:Jcf.gif]]

Java Collections Framework is a library of classes that implement collections. The collections framework also provides utility methods to perform functions such as sorting a list of data.The collections in Java are mainly the following: List, Set, Map and Queue. Java provides these collections as interfaces from which one can write their own classes or can use the inbuilt Java classes that implement these interfaces.

===List===
List is a collection of objects that has a fixed order (when we add an object to the list, it will stay in the place we put it), and allows objects to be referred to by position.Duplicate elements are allowed in a list. The general-purpose List implementations are [http://download.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html ArrayList] and [http://download.oracle.com/javase/1.4.2/docs/api/java/util/LinkedList.html LinkedList].

===Set===
A Set is a Collection that cannot contain duplicate elements. It models the mathematical set abstraction.The Java platform contains three general-purpose Set implementations: [http://download.oracle.com/javase/6/docs/api/java/util/HashSet.html HashSet], [http://download.oracle.com/javase/6/docs/api/java/util/TreeSet.html TreeSet], and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashSet.html LinkedHashSet].

===Map===
A Map is an object that maps keys to values. A map cannot contain duplicate keys: Each key can map to at most one value. Maps are defined by the java.util.Map interface in Java. The three general-purpose Map implementations are [http://download.oracle.com/javase/1.4.2/docs/api/java/util/HashMap.html HashMap], [http://download.oracle.com/javase/6/docs/api/java/util/TreeMap.html TreeMap] and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashMap.html LinkedHashMap]. The java.util.Map interface is extended by its subinterface, java.util.SortedMap. This interface defines a map that's sorted by the keys provided.

===Queue===
A Queue is a collection for holding elements prior to processing. Besides basic Collection operations, queues provide additional insertion, removal, and inspection operations. LinkedList implements the Queue interface, providing first in, first out (FIFO) queue operations.

=='''C++ Standard Template Library(STL)'''==
C++ standard template library is a software library that provides implementations of some basic containers for storing collections of related objects as well as algorithms to perform operations on the elements in these containers. All the classes in C++ STL are generic and can be used with any user defined or primitive data types. In general the C++ STL has four major components.

===Containers===
These are classes which are used to store other objects. Taking an example suppose there is a “jar of jellybeans”, the jar can be thought of as the container while the jelly beans are the objects that are stored in the container. Most collections automatically resize depending on the number of elements in them.The C++ STL provides a number of such classes which can be classified into two categories

====Sequence Containers====
These containers impose a strict linear order on the elements. Sequence containers support insertions and deletions (either at the ends or at a random position) using an index. Some examples of sequence containers are vector, list, dequeue etc.
====Associative containers====
These containers store key value pairs and each object stored in an associative container is mapped to a specific key. In other words associative containers perform insertions and deletions based on a key. Some examples of associative containers are set, map, hash map, multiset etc.

===Algorithms===
The C++ STL contains a large collection of algorithms that can be used to manipulate the data contained in the container. Continuing from the earlier “jar of jelly beans” example, suppose you wanted to count the number of red colored jelly beans. Or you wanted to change the color of all the jelly beans to red the algorithms in STL allow you to accomplish this.

An important thing to note is that the algorithms in STL are decoupled from the container. This means that there is only one definition of the function which implements the algorithm. This works for any valid container containing any any valid set of objects. Analogous to our example the function to count the number of red jelly beans also works for a “bucket containing colored pebbles”.

The algorithms contained in STL can be classified into two categories
====Non-Mutating====
Those which do not change the collection in any way. Examples include count, find, for each etc.
====Mutating====
Those which modify the contents of the collection in some way. Examples include replace, copy, reverse etc.
===Iterators===
Iterators are an important part of the C++ STL. Iterators facilitate traversal through a container’s elements. The separation of algorithms from containers is achieved through the use of iterators. Iterators can be thought of as a generalization of pointers. All the algorithms make use of iterators as function arguments. There are 5 types of iterators in STL. These differ in the way they traverse through the elements in the container.

===Functor===
A functor or functional object is an object that can be called as a function. This is in essence similar to function pointers in C. A functor is any class that overloads the operator() function. Such a class is most commonly used to define custom comparison functions to compare two objects. This is similar to “comparator” in JAVA.

=='''JCF versus STL'''==
===Quality of implementation===
Java is standardised and have formalized methods such as Java community process(JCP) and Java Specification request (JSR) to define revisions of java platforms. C++ only gives a defining standard and one can have different implementations of that standard. Hence different implementations can be incompatible.

===Portability===
This is a direct consequence of the fact that standards are available in Java and not in C++.
The following is a list of various [http://en.wikipedia.org/wiki/List_of_C%2B%2B_template_libraries STL libraries ]. These may have some common templates which might not necessarily be interoperable. In contrast the implementations of JCF are standardized and they will be portable as long as versions remain the same.

===Better optimization of containers===
In C++ STL the algorithms (i.e functions which manipulate the data) are completely decoupled from the containers it is not possible to optimize containers for specific purposes. In JCF since the algorithms are defined as interfaces it is easy to provide specific implementations based on requirements. Because the various implementations of each interface are interchangeable, programs can be easily tuned by switching implementations. The only way to optimize in STL is to create new containers which are tied together with the algorithms.

===More number of methods in STL===
STL has more number of methods than Java for collections. This is because STL has [http://www.sgi.com/tech/stl/table_of_contents.html separate methods] for containers and algorithms used for containers like Non-mutating algorithms, Mutating algorithms, Sorting

===Extension capability===
STL collections are difficult to extend as the base classes are not declared as virtual. In Java since the basic collections are interfaces, it is easy to implement the interfaces in a class, and extend from that.

===Manipulation of container objects using Iterators ===
C++ STL uses iterators to iterate through the items. Iterators themselves are generalizations of pointers. This leads to problems when one has to manipulate the items in the container, especially if the items have to be removed. It is tricky to iterate through the container and delete objects within the same loop. This is not the case in java since memory cannot be directly manipulated by the programmer.

<pre>
map<char,int> mymap;
map<char,int>::iterator it;
int count = 0;
// insert some values:
mymap['a']=10;
mymap['b']=20;
mymap['c']=30;
mymap['d']=40;
mymap['e']=50;
mymap['f']=60;

//suppose you decide to delete the 3rd item onwards
for ( it=mymap.begin() ; it != mymap.end(); it++ ){
if(count >=2){
mymap.erase(it); // This statement is dangerous. When the iterator is used to delete the entry the reference that the iterator holds
// is lost. Now we have lost the reference to our position in the map.
// Intuitively it seems iterator just specifies the entry in the map that has to be deleted. But the iterator is a
// pointer that holds a reference and it would jump to the beginning of the map.
}
count++
}
</pre>

===Pass by reference versus pass by value===
Containers in STL is accessed using copy semantics, thereby providing both efficiency and type safety, while in Java collections are accessed via references (or pointers). In Java this can cause problems if the programmer is not careful.

<pre>
Consider the following piece of code

HashMap<String, HashMap<String,String>> outer = new HashMap<String, HashMap<String,String>>();
HashMap<String,String> inner = new HashMap<String,String>();

inner.add("A","1");
outer.add("A1",inner);

inner.clear(); // This statement also erases the entry in the outer HashMap. This is because of the fact mentioned above.
// When the inner hash map is added as an entry into the outer HashMap only a reference gets stored and not the actual HashMap
// Object.This is not the case with C++ STL which has copy semantics

inner.add("B","2")
</pre>

=='''Collections in languages versus library'''==
We are comparing collections inbuilt into the Ruby language versus Java’s collection libraries.

===Operators vs Methods===
In languages with collections built into them many operations may be performed using operators instead of calling functions. Consider an associative array, called hash in ruby and map in java.

<pre>
Assoc_array[
{“hello”, “world”}
{“good”,”day”}
]
</pre>

In a language with collections implemented as a class library one would use a function like “get(key)” to retrieve the value associated with a key. When there is language support one can use Assoc_array[key] to retrieve the value of the key.Now suppose we would like to extend the get function to do something different, in a language like java we can simply write another function or create a different implementation of the associative array which overrides the get function defined in the interface. Now in case of a language where the get is implemented using an operator we should either overload the default behavior of the operator or we have to define a custom operator to do this. In general it is much easier to overload a function than to overload an operator, Further not all languages allow operator overloading.

===Import===
In Ruby since collections are part of the language , therefore a developer need not include library for common functionalities while writing a program. In case of collections which are present in libraries like Java, one needs to import the libraries before executing the code. This can become a hassle for a Java developer if one does not know the name of the library to import for using a collection.

===Operator Overloading===
In Java we do not have operator overloading, but instead use methods to do the equivalent operations. Ruby has overloading where one can override , say a + operator.
By not having operator overloading Java can have clearer code.This is because when one uses a + overloaded operator, we can get an unexpected behavior if internally it is coded to something else, say a subtraction. The number of operators that you can overload is very small and most of them is relevant to scalar operations. Additionally, the detail of the operation performed by operators may not be as meaningful in comparison to a good method name.

<pre>
class Test
def initialize x
@x = x
end

def +(y)
@x - y
end
end
a = Test.new 5
puts(a + 3)

</pre>

In above example instead of getting a result of 8 due to the + operator being overloaded in a wrong way we instead get a result of 2

===Performance===
Collections in Ruby is slower than in Java as Ruby is a dynamically typed language. , therefore
in Ruby type checking happens at run-time which would slow down collection performance.

===Verbosity===
In Ruby since one uses operator for hash-tables, the code is less verbose and therefore easier to type:
<pre>
h[lastname] = firstname
</pre>
In Java one has to type a method name which increases the verbosity:
<pre>
hashmap.put(lastname)= firstname
</pre>

===Readability===
In Java when one has nested methods on collections, the code is easier to read than in Ruby when one has nested operators on collections within a single line. The Java code is easier to debug also as one can look at the values of the variables assigned on the nested methods.

== 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://download.oracle.com/javase/tutorial/collections/intro/index.html

[2]http://www.javamex.com/tutorials/collections/index.shtml

[3]http://en.wikipedia.org/wiki/Java_collections_framework

[4]http://www.sgi.com/tech/stl/index.html

[5]http://en.wikipedia.org/wiki/Standard_Template_Library

[6]http://download.oracle.com/javase/6/docs/technotes/guides/collections/overview.html

[7]http://java.dzone.com/articles/why-java-doesnt-need-operator

[8]http://www.ruby-doc.org/core/

CSC/ECE 517 Fall 2011/ch1 1b ds

2011-09-26T02:26:13Z

Ddilipd: /* Manipulation of container objects using Iterators */

Cover the history of Collections frameworks back to the late 1970s or early 1980s, and how they were retrofitted to various languages. Discuss the advantage of a standard Collections framework (e.g., Java) vs. several competing frameworks (e.g., C++), and the advantage of collections built into the language (e.g., Ruby) vs. collections as class libraries. Give examples to illustrate the advantages you identify.

__TOC__

==Introduction==
A collection refers to a group of data items which have some commonality like a "a bunch of objects stored in a structured manner". Collections are very common in daily life, some examples would be a collection of science fiction books, the names of employees in a given department etc. Given that object oriented design concepts try to model the real world, it is natural to include support for creating and manipulating collections in languages which support object oriented development. Collections allows you to organize data in memory in various convenient ways.
Example : a simple list of strings, a mapping or association of strings to strings (e.g. country names to the names of their capitals);

Almost all major programming and scripting languages that are used today such as [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]], [http://en.wikipedia.org/wiki/JavaScript JavaScript], [http://en.wikipedia.org/wiki/PHP PHP], [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby], [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] have support for collections in some form or the other. Some languages have liner arrays (which can have different types of elements) and associative arrays built into the language whereas some other languages provide support through external libraries.

In this article we compare and contrast the two most popular collections frameworks/libraries in use today, C++ STL and Java Collections Framework (JCF). Also we compare collections in Ruby which does not have a formal collections framework against C++ and Java which define a formal framework/library for collections.

==History==
The history of collection frameworks can be analyzed in two aspects. Languages which have some basic collection containers built into them and languages with a formal collection framework. A collection framework may be defined as a generic reusable collection of classes which implements data structures and algorithms to create and manipulate groups of related objects. Few languages support a formal collections framework. Most of the modern programming languages have sequential arrays and associative array's built into them. A programmer may use these basic containers to create their own custom collection classes. A comparison of programming languages that implement associative arrays can be found [http://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28mapping%29 here].

The history of a collections framework or a collections library originate from ideas related to [http://en.wikipedia.org/wiki/Generic_programming generic programming] developed by Alexander Stepanov in the early 80s. At that time Ada was the only language which had support for generics. An initial generic library for list processing in Ada was developed by Alexander Stepanov and David Musser. However Ada did not achieve widespread acceptance by the programming community. As C/C++ became more widespread attention was given to developing a generic library in C++. Finally a proposal was made to the ANSI/ISO committee in 1993 and the C++ STL was finally accepted in 1994.

In the case of Java the initial versions prior to JDK-1.2 did not have a collections framework. These versions just defined Vectors and HashTables which were used to group objects together. This is reminiscent of the way things are done in languages such as Ruby, Python etc. The formal collections framework was introduced in 1998 with JDK-1.2 which borrowed a lot form Doug Lea's ''Collections package''. The goal of this framework was to be consistent with C++ STL. But soon Sun Microsystems decided that Java needed a compact collections framework and consistency with C++ STL was no longer a priority. This led to the development of the Java Collections Framework as we know it today.

=='''Java Collections Framework (JCF)'''==

[[Image:Jcf.gif]]

Java Collections Framework is a library of classes that implement collections. The collections framework also provides utility methods to perform functions such as sorting a list of data.The collections in Java are mainly the following: List, Set, Map and Queue. Java provides these collections as interfaces from which one can write their own classes or can use the inbuilt Java classes that implement these interfaces.

===List===
List is a collection of objects that has a fixed order (when we add an object to the list, it will stay in the place we put it), and allows objects to be referred to by position.Duplicate elements are allowed in a list. The general-purpose List implementations are [http://download.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html ArrayList] and [http://download.oracle.com/javase/1.4.2/docs/api/java/util/LinkedList.html LinkedList].

===Set===
A Set is a Collection that cannot contain duplicate elements. It models the mathematical set abstraction.The Java platform contains three general-purpose Set implementations: [http://download.oracle.com/javase/6/docs/api/java/util/HashSet.html HashSet], [http://download.oracle.com/javase/6/docs/api/java/util/TreeSet.html TreeSet], and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashSet.html LinkedHashSet].

===Map===
A Map is an object that maps keys to values. A map cannot contain duplicate keys: Each key can map to at most one value. Maps are defined by the java.util.Map interface in Java. The three general-purpose Map implementations are [http://download.oracle.com/javase/1.4.2/docs/api/java/util/HashMap.html HashMap], [http://download.oracle.com/javase/6/docs/api/java/util/TreeMap.html TreeMap] and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashMap.html LinkedHashMap]. The java.util.Map interface is extended by its subinterface, java.util.SortedMap. This interface defines a map that's sorted by the keys provided.

===Queue===
A Queue is a collection for holding elements prior to processing. Besides basic Collection operations, queues provide additional insertion, removal, and inspection operations. LinkedList implements the Queue interface, providing first in, first out (FIFO) queue operations.

=='''C++ Standard Template Library(STL)'''==
C++ standard template library is a software library that provides implementations of some basic containers for storing collections of related objects as well as algorithms to perform operations on the elements in these containers. All the classes in C++ STL are generic and can be used with any user defined or primitive data types. In general the C++ STL has four major components.

===Containers===
These are classes which are used to store other objects. Taking an example suppose there is a “jar of jellybeans”, the jar can be thought of as the container while the jelly beans are the objects that are stored in the container. Most collections automatically resize depending on the number of elements in them.The C++ STL provides a number of such classes which can be classified into two categories

====Sequence Containers====
These containers impose a strict linear order on the elements. Sequence containers support insertions and deletions (either at the ends or at a random position) using an index. Some examples of sequence containers are vector, list, dequeue etc.
====Associative containers====
These containers store key value pairs and each object stored in an associative container is mapped to a specific key. In other words associative containers perform insertions and deletions based on a key. Some examples of associative containers are set, map, hash map, multiset etc.

===Algorithms===
The C++ STL contains a large collection of algorithms that can be used to manipulate the data contained in the container. Continuing from the earlier “jar of jelly beans” example, suppose you wanted to count the number of red colored jelly beans. Or you wanted to change the color of all the jelly beans to red the algorithms in STL allow you to accomplish this.

An important thing to note is that the algorithms in STL are decoupled from the container. This means that there is only one definition of the function which implements the algorithm. This works for any valid container containing any any valid set of objects. Analogous to our example the function to count the number of red jelly beans also works for a “bucket containing colored pebbles”.

The algorithms contained in STL can be classified into two categories
====Non-Mutating====
Those which do not change the collection in any way. Examples include count, find, for each etc.
====Mutating====
Those which modify the contents of the collection in some way. Examples include replace, copy, reverse etc.
===Iterators===
Iterators are an important part of the C++ STL. Iterators facilitate traversal through a container’s elements. The separation of algorithms from containers is achieved through the use of iterators. Iterators can be thought of as a generalization of pointers. All the algorithms make use of iterators as function arguments. There are 5 types of iterators in STL. These differ in the way they traverse through the elements in the container.

===Functor===
A functor or functional object is an object that can be called as a function. This is in essence similar to function pointers in C. A functor is any class that overloads the operator() function. Such a class is most commonly used to define custom comparison functions to compare two objects. This is similar to “comparator” in JAVA.

=='''JCF versus STL'''==
===Quality of implementation===
Java is standardised and have formalized methods such as Java community process(JCP) and Java Specification request (JSR) to define revisions of java platforms. C++ only gives a defining standard and one can have different implementations of that standard. Hence different implementations can be incompatible.

===Portability===
This is a direct consequence of the fact that standards are available in Java and not in C++.
The following is a list of various [http://en.wikipedia.org/wiki/List_of_C%2B%2B_template_libraries STL libraries ]. These may have some common templates which might not necessarily be interoperable. In contrast the implementations of JCF are standardized and they will be portable as long as versions remain the same.

===Better optimization of containers===
In C++ STL the algorithms (i.e functions which manipulate the data) are completely decoupled from the containers it is not possible to optimize containers for specific purposes. In JCF since the algorithms are defined as interfaces it is easy to provide specific implementations based on requirements. Because the various implementations of each interface are interchangeable, programs can be easily tuned by switching implementations. The only way to optimize in STL is to create new containers which are tied together with the algorithms.

===More number of methods in STL===
STL has more number of methods than Java for collections. This is because STL has [http://www.sgi.com/tech/stl/table_of_contents.html separate methods] for containers and algorithms used for containers like Non-mutating algorithms, Mutating algorithms, Sorting

===Extension capability===
STL collections are difficult to extend as the base classes are not declared as virtual. In Java since the basic collections are interfaces, it is easy to implement the interfaces in a class, and extend from that.

===Manipulation of container objects using Iterators ===
C++ STL uses iterators to iterate through the items. Iterators themselves are generalizations of pointers. This leads to problems when one has to manipulate the items in the container, especially if the items have to be removed. It is tricky to iterate through the container and delete objects within the same loop. This is not the case in java since memory cannot be directly manipulated by the programmer.

<pre>
map<char,int> mymap;
map<char,int>::iterator it;
int count = 0;
// insert some values:
mymap['a']=10;
mymap['b']=20;
mymap['c']=30;
mymap['d']=40;
mymap['e']=50;
mymap['f']=60;

//suppose you decide to delete the 3rd item onwards
for ( it=mymap.begin() ; it != mymap.end(); it++ ){
if(count >=2){
mymap.erase(it); // This statement is dangerous. When the iterator is used to delete the entry the reference that the iterator holds
// is lost. Now we have lost the reference to our position in the map.
// Intuitively it seems iterator just specifies the entry in the map that has to be deleted. But the iterator is a
// pointer that holds a reference and it would jump to the beginning of the map.
}
count++
}
</pre>

===Pass by reference versus pass by value===
Containers in STL is accessed using copy semantics, thereby providing both efficiency and type safety, while in Java collections are accessed via references (or pointers). In Java this can cause problems if the programmer is not careful.

<pre>
Consider the following piece of code

HashMap<String, HashMap<String,String>> outer = new HashMap<String, HashMap<String,String>>();
HashMap<String,String> inner = new HashMap<String,String>();

inner.add("A","1");
outer.add("A1",inner);

inner.clear(); // This statement also erases the entry in the outer HashMap. This is because of the fact mentioned above.
// When the inner hash map is added as an entry into the outer HashMap only a reference gets stored and not the actual HashMap
// Object.This is not the case with C++ STL which has copy semantics

inner.add("B","2")
</pre>

=='''Collections in languages versus library'''==
We are comparing collections inbuilt into the Ruby language versus Java’s collection libraries.

===Operators vs Methods===
In languages with collections built into them many operations may be performed using operators instead of calling functions. Consider an associative array, called hash in ruby and map in java.

<pre>
Assoc_array[
{“hello”, “world”}
{“good”,”day”}
]
</pre>

In a language with collections implemented as a class library one would use a function like “get(key)” to retrieve the value associated with a key. When there is language support one can use Assoc_array[key] to retrieve the value of the key.Now suppose we would like to extend the get function to do something different, in a language like java we can simply write another function or create a different implementation of the associative array which overrides the get function defined in the interface. Now in case of a language where the get is implemented using an operator we should either overload the default behavior of the operator or we have to define a custom operator to do this. In general it is much easier to overload a function than to overload an operator, Further not all languages allow operator overloading.

===Import===
In Ruby since collections are part of the language , therefore a developer need not include library for common functionalities while writing a program. In case of collections which are present in libraries like Java, one needs to import the libraries before executing the code. This can become a hassle for a Java developer if one does not know the name of the library to import for using a collection.

===Operator Overloading===
In Java we do not have operator overloading, but instead use methods to do the equivalent operations. Ruby has overloading where one can override , say a + operator.
By not having operator overloading Java can have clearer code.This is because when one uses a + overloaded operator, we can get an unexpected behavior if internally it is coded to something else, say a subtraction. The number of operators that you can overload is very small and most of them is relevant to scalar operations. Additionally, the detail of the operation performed by operators may not be as meaningful in comparison to a good method name.

<pre>
class Test
def initialize x
@x = x
end

def +(y)
@x - y
end
end
a = Test.new 5
puts(a + 3)

</pre>

In above example instead of getting a result of 8 due to the + operator being overloaded in a wrong way we instead get a result of 2

===Performance===
Collections in Ruby is slower than in Java as Ruby is a dynamically typed language. , therefore
in Ruby type checking happens at run-time which would slow down collection performance.

===Verbosity===
In Ruby since one uses operator for hash-tables, the code is less verbose and therefore easier to type:
<pre>
h[lastname] = firstname
</pre>
In Java one has to type a method name which increases the verbosity:
<pre>
hashmap.put(lastname)= firstname
</pre>

===Readability===
In Java when one has nested methods on collections, the code is easier to read than in Ruby when one has nested operators on collections within a single line. The Java code is easier to debug also as one can look at the values of the variables assigned on the nested methods.

== Conclusion ==
We started by listing the collections used in Java, which uses JCF and C++, which uses STL. We then compared JCF and STL and listed the advantages that JCF provides over STL. Finally we compared Java collections in library versus Ruby collections built into the language. For some purposes collections in library is better, and for other purposes collections in language is better.

== References ==
[1] http://download.oracle.com/javase/tutorial/collections/intro/index.html

[2]http://www.javamex.com/tutorials/collections/index.shtml

[3]http://en.wikipedia.org/wiki/Java_collections_framework

[4]http://www.sgi.com/tech/stl/index.html

[5]http://en.wikipedia.org/wiki/Standard_Template_Library

[6]http://download.oracle.com/javase/6/docs/technotes/guides/collections/overview.html

[7]http://java.dzone.com/articles/why-java-doesnt-need-operator

[8]http://www.ruby-doc.org/core/

CSC/ECE 517 Fall 2011/ch1 1b ds

2011-09-26T02:26:01Z

Ddilipd: /* Manipulation of container objects using Iterators */

Cover the history of Collections frameworks back to the late 1970s or early 1980s, and how they were retrofitted to various languages. Discuss the advantage of a standard Collections framework (e.g., Java) vs. several competing frameworks (e.g., C++), and the advantage of collections built into the language (e.g., Ruby) vs. collections as class libraries. Give examples to illustrate the advantages you identify.

__TOC__

==Introduction==
A collection refers to a group of data items which have some commonality like a "a bunch of objects stored in a structured manner". Collections are very common in daily life, some examples would be a collection of science fiction books, the names of employees in a given department etc. Given that object oriented design concepts try to model the real world, it is natural to include support for creating and manipulating collections in languages which support object oriented development. Collections allows you to organize data in memory in various convenient ways.
Example : a simple list of strings, a mapping or association of strings to strings (e.g. country names to the names of their capitals);

Almost all major programming and scripting languages that are used today such as [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]], [http://en.wikipedia.org/wiki/JavaScript JavaScript], [http://en.wikipedia.org/wiki/PHP PHP], [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby], [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] have support for collections in some form or the other. Some languages have liner arrays (which can have different types of elements) and associative arrays built into the language whereas some other languages provide support through external libraries.

In this article we compare and contrast the two most popular collections frameworks/libraries in use today, C++ STL and Java Collections Framework (JCF). Also we compare collections in Ruby which does not have a formal collections framework against C++ and Java which define a formal framework/library for collections.

==History==
The history of collection frameworks can be analyzed in two aspects. Languages which have some basic collection containers built into them and languages with a formal collection framework. A collection framework may be defined as a generic reusable collection of classes which implements data structures and algorithms to create and manipulate groups of related objects. Few languages support a formal collections framework. Most of the modern programming languages have sequential arrays and associative array's built into them. A programmer may use these basic containers to create their own custom collection classes. A comparison of programming languages that implement associative arrays can be found [http://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28mapping%29 here].

The history of a collections framework or a collections library originate from ideas related to [http://en.wikipedia.org/wiki/Generic_programming generic programming] developed by Alexander Stepanov in the early 80s. At that time Ada was the only language which had support for generics. An initial generic library for list processing in Ada was developed by Alexander Stepanov and David Musser. However Ada did not achieve widespread acceptance by the programming community. As C/C++ became more widespread attention was given to developing a generic library in C++. Finally a proposal was made to the ANSI/ISO committee in 1993 and the C++ STL was finally accepted in 1994.

In the case of Java the initial versions prior to JDK-1.2 did not have a collections framework. These versions just defined Vectors and HashTables which were used to group objects together. This is reminiscent of the way things are done in languages such as Ruby, Python etc. The formal collections framework was introduced in 1998 with JDK-1.2 which borrowed a lot form Doug Lea's ''Collections package''. The goal of this framework was to be consistent with C++ STL. But soon Sun Microsystems decided that Java needed a compact collections framework and consistency with C++ STL was no longer a priority. This led to the development of the Java Collections Framework as we know it today.

=='''Java Collections Framework (JCF)'''==

[[Image:Jcf.gif]]

Java Collections Framework is a library of classes that implement collections. The collections framework also provides utility methods to perform functions such as sorting a list of data.The collections in Java are mainly the following: List, Set, Map and Queue. Java provides these collections as interfaces from which one can write their own classes or can use the inbuilt Java classes that implement these interfaces.

===List===
List is a collection of objects that has a fixed order (when we add an object to the list, it will stay in the place we put it), and allows objects to be referred to by position.Duplicate elements are allowed in a list. The general-purpose List implementations are [http://download.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html ArrayList] and [http://download.oracle.com/javase/1.4.2/docs/api/java/util/LinkedList.html LinkedList].

===Set===
A Set is a Collection that cannot contain duplicate elements. It models the mathematical set abstraction.The Java platform contains three general-purpose Set implementations: [http://download.oracle.com/javase/6/docs/api/java/util/HashSet.html HashSet], [http://download.oracle.com/javase/6/docs/api/java/util/TreeSet.html TreeSet], and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashSet.html LinkedHashSet].

===Map===
A Map is an object that maps keys to values. A map cannot contain duplicate keys: Each key can map to at most one value. Maps are defined by the java.util.Map interface in Java. The three general-purpose Map implementations are [http://download.oracle.com/javase/1.4.2/docs/api/java/util/HashMap.html HashMap], [http://download.oracle.com/javase/6/docs/api/java/util/TreeMap.html TreeMap] and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashMap.html LinkedHashMap]. The java.util.Map interface is extended by its subinterface, java.util.SortedMap. This interface defines a map that's sorted by the keys provided.

===Queue===
A Queue is a collection for holding elements prior to processing. Besides basic Collection operations, queues provide additional insertion, removal, and inspection operations. LinkedList implements the Queue interface, providing first in, first out (FIFO) queue operations.

=='''C++ Standard Template Library(STL)'''==
C++ standard template library is a software library that provides implementations of some basic containers for storing collections of related objects as well as algorithms to perform operations on the elements in these containers. All the classes in C++ STL are generic and can be used with any user defined or primitive data types. In general the C++ STL has four major components.

===Containers===
These are classes which are used to store other objects. Taking an example suppose there is a “jar of jellybeans”, the jar can be thought of as the container while the jelly beans are the objects that are stored in the container. Most collections automatically resize depending on the number of elements in them.The C++ STL provides a number of such classes which can be classified into two categories

====Sequence Containers====
These containers impose a strict linear order on the elements. Sequence containers support insertions and deletions (either at the ends or at a random position) using an index. Some examples of sequence containers are vector, list, dequeue etc.
====Associative containers====
These containers store key value pairs and each object stored in an associative container is mapped to a specific key. In other words associative containers perform insertions and deletions based on a key. Some examples of associative containers are set, map, hash map, multiset etc.

===Algorithms===
The C++ STL contains a large collection of algorithms that can be used to manipulate the data contained in the container. Continuing from the earlier “jar of jelly beans” example, suppose you wanted to count the number of red colored jelly beans. Or you wanted to change the color of all the jelly beans to red the algorithms in STL allow you to accomplish this.

An important thing to note is that the algorithms in STL are decoupled from the container. This means that there is only one definition of the function which implements the algorithm. This works for any valid container containing any any valid set of objects. Analogous to our example the function to count the number of red jelly beans also works for a “bucket containing colored pebbles”.

The algorithms contained in STL can be classified into two categories
====Non-Mutating====
Those which do not change the collection in any way. Examples include count, find, for each etc.
====Mutating====
Those which modify the contents of the collection in some way. Examples include replace, copy, reverse etc.
===Iterators===
Iterators are an important part of the C++ STL. Iterators facilitate traversal through a container’s elements. The separation of algorithms from containers is achieved through the use of iterators. Iterators can be thought of as a generalization of pointers. All the algorithms make use of iterators as function arguments. There are 5 types of iterators in STL. These differ in the way they traverse through the elements in the container.

===Functor===
A functor or functional object is an object that can be called as a function. This is in essence similar to function pointers in C. A functor is any class that overloads the operator() function. Such a class is most commonly used to define custom comparison functions to compare two objects. This is similar to “comparator” in JAVA.

=='''JCF versus STL'''==
===Quality of implementation===
Java is standardised and have formalized methods such as Java community process(JCP) and Java Specification request (JSR) to define revisions of java platforms. C++ only gives a defining standard and one can have different implementations of that standard. Hence different implementations can be incompatible.

===Portability===
This is a direct consequence of the fact that standards are available in Java and not in C++.
The following is a list of various [http://en.wikipedia.org/wiki/List_of_C%2B%2B_template_libraries STL libraries ]. These may have some common templates which might not necessarily be interoperable. In contrast the implementations of JCF are standardized and they will be portable as long as versions remain the same.

===Better optimization of containers===
In C++ STL the algorithms (i.e functions which manipulate the data) are completely decoupled from the containers it is not possible to optimize containers for specific purposes. In JCF since the algorithms are defined as interfaces it is easy to provide specific implementations based on requirements. Because the various implementations of each interface are interchangeable, programs can be easily tuned by switching implementations. The only way to optimize in STL is to create new containers which are tied together with the algorithms.

===More number of methods in STL===
STL has more number of methods than Java for collections. This is because STL has [http://www.sgi.com/tech/stl/table_of_contents.html separate methods] for containers and algorithms used for containers like Non-mutating algorithms, Mutating algorithms, Sorting

===Extension capability===
STL collections are difficult to extend as the base classes are not declared as virtual. In Java since the basic collections are interfaces, it is easy to implement the interfaces in a class, and extend from that.

===Manipulation of container objects using Iterators ===
C++ STL uses iterators to iterate through the items. Iterators themselves are generalizations of pointers. This leads to problems when one has to manipulate the items in the container, especially if the items have to be removed. It is tricky to iterate through the container and delete objects within the same loop. This is not the case in java since memory cannot be directly manipulated by the programmer.

<pre>
map<char,int> mymap;
map<char,int>::iterator it;
int count = 0;
// insert some values:
mymap['a']=10;
mymap['b']=20;
mymap['c']=30;
mymap['d']=40;
mymap['e']=50;
mymap['f']=60;

//suppose you decide to delete the 3rd item onwards
for ( it=mymap.begin() ; it != mymap.end(); it++ ){
if(count >=2){
mymap.erase(it); // This statement is dangerous. When the iterator is used to delete the entry the reference that the iterator holds
// is lost. Now we have lost the reference to our position in the map.
// Intuitively it seems iterator just specifies the entry in the map that has to be deleted. But the iterator is a
// pointer that holds a reference and it would jump to the beginning of the map.
}
count++
}
</pre>

===Pass by reference versus pass by value===
Containers in STL is accessed using copy semantics, thereby providing both efficiency and type safety, while in Java collections are accessed via references (or pointers). In Java this can cause problems if the programmer is not careful.

<pre>
Consider the following piece of code

HashMap<String, HashMap<String,String>> outer = new HashMap<String, HashMap<String,String>>();
HashMap<String,String> inner = new HashMap<String,String>();

inner.add("A","1");
outer.add("A1",inner);

inner.clear(); // This statement also erases the entry in the outer HashMap. This is because of the fact mentioned above.
// When the inner hash map is added as an entry into the outer HashMap only a reference gets stored and not the actual HashMap
// Object.This is not the case with C++ STL which has copy semantics

inner.add("B","2")
</pre>

=='''Collections in languages versus library'''==
We are comparing collections inbuilt into the Ruby language versus Java’s collection libraries.

===Operators vs Methods===
In languages with collections built into them many operations may be performed using operators instead of calling functions. Consider an associative array, called hash in ruby and map in java.

<pre>
Assoc_array[
{“hello”, “world”}
{“good”,”day”}
]
</pre>

In a language with collections implemented as a class library one would use a function like “get(key)” to retrieve the value associated with a key. When there is language support one can use Assoc_array[key] to retrieve the value of the key.Now suppose we would like to extend the get function to do something different, in a language like java we can simply write another function or create a different implementation of the associative array which overrides the get function defined in the interface. Now in case of a language where the get is implemented using an operator we should either overload the default behavior of the operator or we have to define a custom operator to do this. In general it is much easier to overload a function than to overload an operator, Further not all languages allow operator overloading.

===Import===
In Ruby since collections are part of the language , therefore a developer need not include library for common functionalities while writing a program. In case of collections which are present in libraries like Java, one needs to import the libraries before executing the code. This can become a hassle for a Java developer if one does not know the name of the library to import for using a collection.

===Operator Overloading===
In Java we do not have operator overloading, but instead use methods to do the equivalent operations. Ruby has overloading where one can override , say a + operator.
By not having operator overloading Java can have clearer code.This is because when one uses a + overloaded operator, we can get an unexpected behavior if internally it is coded to something else, say a subtraction. The number of operators that you can overload is very small and most of them is relevant to scalar operations. Additionally, the detail of the operation performed by operators may not be as meaningful in comparison to a good method name.

<pre>
class Test
def initialize x
@x = x
end

def +(y)
@x - y
end
end
a = Test.new 5
puts(a + 3)

</pre>

In above example instead of getting a result of 8 due to the + operator being overloaded in a wrong way we instead get a result of 2

===Performance===
Collections in Ruby is slower than in Java as Ruby is a dynamically typed language. , therefore
in Ruby type checking happens at run-time which would slow down collection performance.

===Verbosity===
In Ruby since one uses operator for hash-tables, the code is less verbose and therefore easier to type:
<pre>
h[lastname] = firstname
</pre>
In Java one has to type a method name which increases the verbosity:
<pre>
hashmap.put(lastname)= firstname
</pre>

===Readability===
In Java when one has nested methods on collections, the code is easier to read than in Ruby when one has nested operators on collections within a single line. The Java code is easier to debug also as one can look at the values of the variables assigned on the nested methods.

== Conclusion ==
We started by listing the collections used in Java, which uses JCF and C++, which uses STL. We then compared JCF and STL and listed the advantages that JCF provides over STL. Finally we compared Java collections in library versus Ruby collections built into the language. For some purposes collections in library is better, and for other purposes collections in language is better.

== References ==
[1] http://download.oracle.com/javase/tutorial/collections/intro/index.html

[2]http://www.javamex.com/tutorials/collections/index.shtml

[3]http://en.wikipedia.org/wiki/Java_collections_framework

[4]http://www.sgi.com/tech/stl/index.html

[5]http://en.wikipedia.org/wiki/Standard_Template_Library

[6]http://download.oracle.com/javase/6/docs/technotes/guides/collections/overview.html

[7]http://java.dzone.com/articles/why-java-doesnt-need-operator

[8]http://www.ruby-doc.org/core/

CSC/ECE 517 Fall 2011/ch1 1b ds

2011-09-26T02:07:15Z

Ddilipd:

Cover the history of Collections frameworks back to the late 1970s or early 1980s, and how they were retrofitted to various languages. Discuss the advantage of a standard Collections framework (e.g., Java) vs. several competing frameworks (e.g., C++), and the advantage of collections built into the language (e.g., Ruby) vs. collections as class libraries. Give examples to illustrate the advantages you identify.

__TOC__

==Introduction==
A collection refers to a group of data items which have some commonality like a "a bunch of objects stored in a structured manner". Collections are very common in daily life, some examples would be a collection of science fiction books, the names of employees in a given department etc. Given that object oriented design concepts try to model the real world, it is natural to include support for creating and manipulating collections in languages which support object oriented development. Collections allows you to organize data in memory in various convenient ways.
Example : a simple list of strings, a mapping or association of strings to strings (e.g. country names to the names of their capitals);

Almost all major programming and scripting languages that are used today such as [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]], [http://en.wikipedia.org/wiki/JavaScript JavaScript], [http://en.wikipedia.org/wiki/PHP PHP], [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby], [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] have support for collections in some form or the other. Some languages have liner arrays (which can have different types of elements) and associative arrays built into the language whereas some other languages provide support through external libraries.

In this article we compare and contrast the two most popular collections frameworks/libraries in use today, C++ STL and Java Collections Framework (JCF). Also we compare collections in Ruby which does not have a formal collections framework against C++ and Java which define a formal framework/library for collections.

==History==
The history of collection frameworks can be analyzed in two aspects. Languages which have some basic collection containers built into them and languages with a formal collection framework. A collection framework may be defined as a generic reusable collection of classes which implements data structures and algorithms to create and manipulate groups of related objects. Few languages support a formal collections framework. Most of the modern programming languages have sequential arrays and associative array's built into them. A programmer may use these basic containers to create their own custom collection classes. A comparison of programming languages that implement associative arrays can be found [http://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28mapping%29 here].

The history of a collections framework or a collections library originate from ideas related to [http://en.wikipedia.org/wiki/Generic_programming generic programming] developed by Alexander Stepanov in the early 80s. At that time Ada was the only language which had support for generics. An initial generic library for list processing in Ada was developed by Alexander Stepanov and David Musser. However Ada did not achieve widespread acceptance by the programming community. As C/C++ became more widespread attention was given to developing a generic library in C++. Finally a proposal was made to the ANSI/ISO committee in 1993 and the C++ STL was finally accepted in 1994.

In the case of Java the initial versions prior to JDK-1.2 did not have a collections framework. These versions just defined Vectors and HashTables which were used to group objects together. This is reminiscent of the way things are done in languages such as Ruby, Python etc. The formal collections framework was introduced in 1998 with JDK-1.2 which borrowed a lot form Doug Lea's ''Collections package''. The goal of this framework was to be consistent with C++ STL. But soon Sun Microsystems decided that Java needed a compact collections framework and consistency with C++ STL was no longer a priority. This led to the development of the Java Collections Framework as we know it today.

=='''Java Collections Framework (JCF)'''==

[[Image:Jcf.gif]]

Java Collections Framework is a library of classes that implement collections. The collections framework also provides utility methods to perform functions such as sorting a list of data.The collections in Java are mainly the following: List, Set, Map and Queue. Java provides these collections as interfaces from which one can write their own classes or can use the inbuilt Java classes that implement these interfaces.

===List===
List is a collection of objects that has a fixed order (when we add an object to the list, it will stay in the place we put it), and allows objects to be referred to by position.Duplicate elements are allowed in a list. The general-purpose List implementations are [http://download.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html ArrayList] and [http://download.oracle.com/javase/1.4.2/docs/api/java/util/LinkedList.html LinkedList].

===Set===
A Set is a Collection that cannot contain duplicate elements. It models the mathematical set abstraction.The Java platform contains three general-purpose Set implementations: [http://download.oracle.com/javase/6/docs/api/java/util/HashSet.html HashSet], [http://download.oracle.com/javase/6/docs/api/java/util/TreeSet.html TreeSet], and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashSet.html LinkedHashSet].

===Map===
A Map is an object that maps keys to values. A map cannot contain duplicate keys: Each key can map to at most one value. Maps are defined by the java.util.Map interface in Java. The three general-purpose Map implementations are [http://download.oracle.com/javase/1.4.2/docs/api/java/util/HashMap.html HashMap], [http://download.oracle.com/javase/6/docs/api/java/util/TreeMap.html TreeMap] and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashMap.html LinkedHashMap]. The java.util.Map interface is extended by its subinterface, java.util.SortedMap. This interface defines a map that's sorted by the keys provided.

===Queue===
A Queue is a collection for holding elements prior to processing. Besides basic Collection operations, queues provide additional insertion, removal, and inspection operations. LinkedList implements the Queue interface, providing first in, first out (FIFO) queue operations.

=='''C++ Standard Template Library(STL)'''==
C++ standard template library is a software library that provides implementations of some basic containers for storing collections of related objects as well as algorithms to perform operations on the elements in these containers. All the classes in C++ STL are generic and can be used with any user defined or primitive data types. In general the C++ STL has four major components.

===Containers===
These are classes which are used to store other objects. Taking an example suppose there is a “jar of jellybeans”, the jar can be thought of as the container while the jelly beans are the objects that are stored in the container. Most collections automatically resize depending on the number of elements in them.The C++ STL provides a number of such classes which can be classified into two categories

====Sequence Containers====
These containers impose a strict linear order on the elements. Sequence containers support insertions and deletions (either at the ends or at a random position) using an index. Some examples of sequence containers are vector, list, dequeue etc.
====Associative containers====
These containers store key value pairs and each object stored in an associative container is mapped to a specific key. In other words associative containers perform insertions and deletions based on a key. Some examples of associative containers are set, map, hash map, multiset etc.

===Algorithms===
The C++ STL contains a large collection of algorithms that can be used to manipulate the data contained in the container. Continuing from the earlier “jar of jelly beans” example, suppose you wanted to count the number of red colored jelly beans. Or you wanted to change the color of all the jelly beans to red the algorithms in STL allow you to accomplish this.

An important thing to note is that the algorithms in STL are decoupled from the container. This means that there is only one definition of the function which implements the algorithm. This works for any valid container containing any any valid set of objects. Analogous to our example the function to count the number of red jelly beans also works for a “bucket containing colored pebbles”.

The algorithms contained in STL can be classified into two categories
====Non-Mutating====
Those which do not change the collection in any way. Examples include count, find, for each etc.
====Mutating====
Those which modify the contents of the collection in some way. Examples include replace, copy, reverse etc.
===Iterators===
Iterators are an important part of the C++ STL. Iterators facilitate traversal through a container’s elements. The separation of algorithms from containers is achieved through the use of iterators. Iterators can be thought of as a generalization of pointers. All the algorithms make use of iterators as function arguments. There are 5 types of iterators in STL. These differ in the way they traverse through the elements in the container.

===Functor===
A functor or functional object is an object that can be called as a function. This is in essence similar to function pointers in C. A functor is any class that overloads the operator() function. Such a class is most commonly used to define custom comparison functions to compare two objects. This is similar to “comparator” in JAVA.

=='''JCF versus STL'''==
===Quality of implementation===
Java is standardised and have formalized methods such as Java community process(JCP) and Java Specification request (JSR) to define revisions of java platforms. C++ only gives a defining standard and one can have different implementations of that standard. Hence different implementations can be incompatible.

===Portability===
This is a direct consequence of the fact that standards are available in Java and not in C++.
The following is a list of various [http://en.wikipedia.org/wiki/List_of_C%2B%2B_template_libraries STL libraries ]. These may have some common templates which might not necessarily be interoperable. In contrast the implementations of JCF are standardized and they will be portable as long as versions remain the same.

===Better optimization of containers===
In C++ STL the algorithms (i.e functions which manipulate the data) are completely decoupled from the containers it is not possible to optimize containers for specific purposes. In JCF since the algorithms are defined as interfaces it is easy to provide specific implementations based on requirements. Because the various implementations of each interface are interchangeable, programs can be easily tuned by switching implementations. The only way to optimize in STL is to create new containers which are tied together with the algorithms.

===More number of methods in STL===
STL has more number of methods than Java for collections. This is because STL has [http://www.sgi.com/tech/stl/table_of_contents.html separate methods] for containers and algorithms used for containers like Non-mutating algorithms, Mutating algorithms, Sorting

===Extension capability===
STL collections are difficult to extend as the base classes are not declared as virtual. In Java since the basic collections are interfaces, it is easy to implement the interfaces in a class, and extend from that.

===Manipulation of container objects using Iterators ===
C++ STL uses iterators to iterate through the items. Iterators themselves are generalizations of pointers. This leads to problems when one has to manipulate the items in the container, especially if the items have to be removed. It is tricky to iterate through the container and delete objects within the same loop. This is not the casein java since memory cannot be directly manipulated by the programmer.

===Pass by reference versus pass by value===
Containers in STL is accessed using copy semantics, thereby providing both efficiency and type safety, while in Java collections are accessed via references (or pointers). In Java this can cause problems if the programmer is not careful.

<pre>
Consider the following piece of code

HashMap<String, HashMap<String,String>> outer = new HashMap<String, HashMap<String,String>>();
HashMap<String,String> inner = new HashMap<String,String>();

inner.add("A","1");
outer.add("A1",inner);

inner.clear(); // This statement also erases the entry in the outer HashMap. This is because of the fact mentioned above.
// When the inner hash map is added as an entry into the outer HashMap only a reference gets stored and not the actual HashMap
// Object.This is not the case with C++ STL which has copy semantics

inner.add("B","2")
</pre>

=='''Collections in languages versus library'''==
We are comparing collections inbuilt into the Ruby language versus Java’s collection libraries.

===Operators vs Methods===
In languages with collections built into them many operations may be performed using operators instead of calling functions. Consider an associative array, called hash in ruby and map in java.

<pre>
Assoc_array[
{“hello”, “world”}
{“good”,”day”}
]
</pre>

In a language with collections implemented as a class library one would use a function like “get(key)” to retrieve the value associated with a key. When there is language support one can use Assoc_array[key] to retrieve the value of the key.Now suppose we would like to extend the get function to do something different, in a language like java we can simply write another function or create a different implementation of the associative array which overrides the get function defined in the interface. Now in case of a language where the get is implemented using an operator we should either overload the default behavior of the operator or we have to define a custom operator to do this. In general it is much easier to overload a function than to overload an operator, Further not all languages allow operator overloading.

===Import===
In Ruby since collections are part of the language , therefore a developer need not include library for common functionalities while writing a program. In case of collections which are present in libraries like Java, one needs to import the libraries before executing the code. This can become a hassle for a Java developer if one does not know the name of the library to import for using a collection.

===Operator Overloading===
In Java we do not have operator overloading, but instead use methods to do the equivalent operations. Ruby has overloading where one can override , say a + operator.
By not having operator overloading Java can have clearer code.This is because when one uses a + overloaded operator, we can get an unexpected behavior if internally it is coded to something else, say a subtraction. The number of operators that you can overload is very small and most of them is relevant to scalar operations. Additionally, the detail of the operation performed by operators may not be as meaningful in comparison to a good method name.

<pre>
class Test
def initialize x
@x = x
end

def +(y)
@x - y
end
end
a = Test.new 5
puts(a + 3)

</pre>

In above example instead of getting a result of 8 due to the + operator being overloaded in a wrong way we instead get a result of 2

===Performance===
Collections in Ruby is slower than in Java as Ruby is a dynamically typed language. , therefore
in Ruby type checking happens at run-time which would slow down collection performance.

===Verbosity===
In Ruby since one uses operator for hash-tables, the code is less verbose and therefore easier to type:
<pre>
h[lastname] = firstname
</pre>
In Java one has to type a method name which increases the verbosity:
<pre>
hashmap.put(lastname)= firstname
</pre>

===Readability===
In Java when one has nested methods on collections, the code is easier to read than in Ruby when one has nested operators on collections within a single line. The Java code is easier to debug also as one can look at the values of the variables assigned on the nested methods.

== Conclusion ==
We started by listing the collections used in Java, which uses JCF and C++, which uses STL. We then compared JCF and STL and listed the advantages that JCF provides over STL. Finally we compared Java collections in library versus Ruby collections built into the language. For some purposes collections in library is better, and for other purposes collections in language is better.

== References ==
[1] http://download.oracle.com/javase/tutorial/collections/intro/index.html

[2]http://www.javamex.com/tutorials/collections/index.shtml

[3]http://en.wikipedia.org/wiki/Java_collections_framework

[4]http://www.sgi.com/tech/stl/index.html

[5]http://en.wikipedia.org/wiki/Standard_Template_Library

[6]http://download.oracle.com/javase/6/docs/technotes/guides/collections/overview.html

[7]http://java.dzone.com/articles/why-java-doesnt-need-operator

[8]http://www.ruby-doc.org/core/

CSC/ECE 517 Fall 2011/ch1 1b ds

2011-09-26T02:05:55Z

Ddilipd: /* Pass by reference versus pass by value */

Cover the history of Collections frameworks back to the late 1970s or early 1980s, and how they were retrofitted to various languages. Discuss the advantage of a standard Collections framework (e.g., Java) vs. several competing frameworks (e.g., C++), and the advantage of collections built into the language (e.g., Ruby) vs. collections as class libraries. Give examples to illustrate the advantages you identify.

__TOC__

==Introduction==
A collection refers to a group of data items which have some commonality like a "a bunch of objects stored in a structured manner". Collections are very common in daily life, some examples would be a collection of science fiction books, the names of employees in a given department etc. Given that object oriented design concepts try to model the real world, it is natural to include support for creating and manipulating collections in languages which support object oriented development. Collections allows you to organize data in memory in various convenient ways.
Example : a simple list of strings, a mapping or association of strings to strings (e.g. country names to the names of their capitals);

Almost all major programming and scripting languages that are used today such as [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]], [http://en.wikipedia.org/wiki/JavaScript JavaScript], [http://en.wikipedia.org/wiki/PHP PHP], [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby], [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] have support for collections in some form or the other. Some languages have liner arrays (which can have different types of elements) and associative arrays built into the language whereas some other languages provide support through external libraries.

In this article we compare and contrast the two most popular collections frameworks/libraries in use today, C++ STL and Java Collections Framework (JCF). Also we compare collections in Ruby which does not have a formal collections framework against C++ and Java which define a formal framework/library for collections.

==History==
The history of collection frameworks can be analyzed in two aspects. Languages which have some basic collection containers built into them and languages with a formal collection framework. A collection framework may be defined as a generic reusable collection of classes which implements data structures and algorithms to create and manipulate groups of related objects. Few languages support a formal collections framework. Most of the modern programming languages have sequential arrays and associative array's built into them. A programmer may use these basic containers to create their own custom collection classes. A comparison of programming languages that implement associative arrays can be found [http://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28mapping%29 here].

The history of a collections framework or a collections library originate from ideas related to [http://en.wikipedia.org/wiki/Generic_programming generic programming] developed by Alexander Stepanov in the early 80s. At that time Ada was the only language which had support for generics. An initial generic library for list processing in Ada was developed by Alexander Stepanov and David Musser. However Ada did not achieve widespread acceptance by the programming community. As C/C++ became more widespread attention was given to developing a generic library in C++. Finally a proposal was made to the ANSI/ISO committee in 1993 and the C++ STL was finally accepted in 1994.

In the case of Java the initial versions prior to JDK-1.2 did not have a collections framework. These versions just defined Vectors and HashTables which were used to group objects together. This is reminiscent of the way things are done in languages such as Ruby, Python etc. The formal collections framework was introduced in 1998 with JDK-1.2 which borrowed a lot form Doug Lea's ''Collections package''. The goal of this framework was to be consistent with C++ STL. But soon Sun Microsystems decided that Java needed a compact collections framework and consistency with C++ STL was no longer a priority. This led to the development of the Java Collections Framework as we know it today.

=='''Java Collections Framework (JCF)'''==

[[Image:Jcf.gif]]

Java Collections Framework is a library of classes that implement collections. The collections framework also provides utility methods to perform functions such as sorting a list of data.The collections in Java are mainly the following: List, Set, Map and Queue. Java provides these collections as interfaces from which one can write their own classes or can use the inbuilt Java classes that implement these interfaces.

===List===
List is a collection of objects that has a fixed order (when we add an object to the list, it will stay in the place we put it), and allows objects to be referred to by position.Duplicate elements are allowed in a list. The general-purpose List implementations are [http://download.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html ArrayList] and [http://download.oracle.com/javase/1.4.2/docs/api/java/util/LinkedList.html LinkedList].

===Set===
A Set is a Collection that cannot contain duplicate elements. It models the mathematical set abstraction.The Java platform contains three general-purpose Set implementations: [http://download.oracle.com/javase/6/docs/api/java/util/HashSet.html HashSet], [http://download.oracle.com/javase/6/docs/api/java/util/TreeSet.html TreeSet], and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashSet.html LinkedHashSet].

===Map===
A Map is an object that maps keys to values. A map cannot contain duplicate keys: Each key can map to at most one value. Maps are defined by the java.util.Map interface in Java. The three general-purpose Map implementations are [http://download.oracle.com/javase/1.4.2/docs/api/java/util/HashMap.html HashMap], [http://download.oracle.com/javase/6/docs/api/java/util/TreeMap.html TreeMap] and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashMap.html LinkedHashMap]. The java.util.Map interface is extended by its subinterface, java.util.SortedMap. This interface defines a map that's sorted by the keys provided.

===Queue===
A Queue is a collection for holding elements prior to processing. Besides basic Collection operations, queues provide additional insertion, removal, and inspection operations. LinkedList implements the Queue interface, providing first in, first out (FIFO) queue operations.

=='''C++ Standard Template Library(STL)'''==
C++ standard template library is a software library that provides implementations of some basic containers for storing collections of related objects as well as algorithms to perform operations on the elements in these containers. All the classes in C++ STL are generic and can be used with any user defined or primitive data types. In general the C++ STL has four major components.

===Containers===
These are classes which are used to store other objects. Taking an example suppose there is a “jar of jellybeans”, the jar can be thought of as the container while the jelly beans are the objects that are stored in the container. Most collections automatically resize depending on the number of elements in them.The C++ STL provides a number of such classes which can be classified into two categories

====Sequence Containers====
These containers impose a strict linear order on the elements. Sequence containers support insertions and deletions (either at the ends or at a random position) using an index. Some examples of sequence containers are vector, list, dequeue etc.
====Associative containers====
These containers store key value pairs and each object stored in an associative container is mapped to a specific key. In other words associative containers perform insertions and deletions based on a key. Some examples of associative containers are set, map, hash map, multiset etc.

===Algorithms===
The C++ STL contains a large collection of algorithms that can be used to manipulate the data contained in the container. Continuing from the earlier “jar of jelly beans” example, suppose you wanted to count the number of red colored jelly beans. Or you wanted to change the color of all the jelly beans to red the algorithms in STL allow you to accomplish this.

An important thing to note is that the algorithms in STL are decoupled from the container. This means that there is only one definition of the function which implements the algorithm. This works for any valid container containing any any valid set of objects. Analogous to our example the function to count the number of red jelly beans also works for a “bucket containing colored pebbles”.

The algorithms contained in STL can be classified into two categories
====Non-Mutating====
Those which do not change the collection in any way. Examples include count, find, for each etc.
====Mutating====
Those which modify the contents of the collection in some way. Examples include replace, copy, reverse etc.
===Iterators===
Iterators are an important part of the C++ STL. Iterators facilitate traversal through a container’s elements. The separation of algorithms from containers is achieved through the use of iterators. Iterators can be thought of as a generalization of pointers. All the algorithms make use of iterators as function arguments. There are 5 types of iterators in STL. These differ in the way they traverse through the elements in the container.

===Functor===
A functor or functional object is an object that can be called as a function. This is in essence similar to function pointers in C. A functor is any class that overloads the operator() function. Such a class is most commonly used to define custom comparison functions to compare two objects. This is similar to “comparator” in JAVA.

=='''JCF versus STL'''==
===Quality of implementation===
Java is standardised and have formalized methods such as Java community process(JCP) and Java Specification request (JSR) to define revisions of java platforms. C++ only gives a defining standard and one can have different implementations of that standard. Hence different implementations can be incompatible.

===Portability===
This is a direct consequence of the fact that standards are available in Java and not in C++.
The following is a list of various [http://en.wikipedia.org/wiki/List_of_C%2B%2B_template_libraries STL libraries ]. These may have some common templates which might not necessarily be interoperable. In contrast the implementations of JCF are standardized and they will be portable as long as versions remain the same.

===Better optimization of containers===
In C++ STL the algorithms (i.e functions which manipulate the data) are completely decoupled from the containers it is not possible to optimize containers for specific purposes. In JCF since the algorithms are defined as interfaces it is easy to provide specific implementations based on requirements. Because the various implementations of each interface are interchangeable, programs can be easily tuned by switching implementations. The only way to optimize in STL is to create new containers which are tied together with the algorithms.

===More number of methods in STL===
STL has more number of methods than Java for collections. This is because STL has [http://www.sgi.com/tech/stl/table_of_contents.html separate methods] for containers and algorithms used for containers like Non-mutating algorithms, Mutating algorithms, Sorting

===Extension capability===
STL collections are difficult to extend as the base classes are not declared as virtual. In Java since the basic collections are interfaces, it is easy to implement the interfaces in a class, and extend from that.

===Manipulation of container objects using Iterators ===
C++ STL uses iterators to iterate through the items. Iterators themselves are generalizations of pointers. This leads to problems when one has to manipulate the items in the container, especially if the items have to be removed. It is tricky to iterate through the container and delete objects within the same loop. This is not the casein java since memory cannot be directly manipulated by the programmer.

===Pass by reference versus pass by value===
Containers in STL is accessed using copy semantics, thereby providing both efficiency and type safety, while in Java collections are accessed via references (or pointers). In Java this can cause problems if the programmer is not careful.

Consider the following piece of code

HashMap<String, HashMap<String,String>> outer = new HashMap<String, HashMap<String,String>>();
HashMap<String,String> inner = new HashMap<String,String>();

inner.add("A","1");
outer.add("A1",inner);

inner.clear(); // This statement also erases the entry in the outer HashMap. This is because of the fact mentioned above.
// When the inner hash map is added as an entry into the outer HashMap only a reference gets stored and not the actual HashMap
// Object.This is not the case with C++ STL which has copy semantics

inner.add("B","2")

=='''Collections in languages versus library'''==
We are comparing collections inbuilt into the Ruby language versus Java’s collection libraries.

===Operators vs Methods===
In languages with collections built into them many operations may be performed using operators instead of calling functions. Consider an associative array, called hash in ruby and map in java.

<pre>
Assoc_array[
{“hello”, “world”}
{“good”,”day”}
]
</pre>

In a language with collections implemented as a class library one would use a function like “get(key)” to retrieve the value associated with a key. When there is language support one can use Assoc_array[key] to retrieve the value of the key.Now suppose we would like to extend the get function to do something different, in a language like java we can simply write another function or create a different implementation of the associative array which overrides the get function defined in the interface. Now in case of a language where the get is implemented using an operator we should either overload the default behavior of the operator or we have to define a custom operator to do this. In general it is much easier to overload a function than to overload an operator, Further not all languages allow operator overloading.

===Import===
In Ruby since collections are part of the language , therefore a developer need not include library for common functionalities while writing a program. In case of collections which are present in libraries like Java, one needs to import the libraries before executing the code. This can become a hassle for a Java developer if one does not know the name of the library to import for using a collection.

===Operator Overloading===
In Java we do not have operator overloading, but instead use methods to do the equivalent operations. Ruby has overloading where one can override , say a + operator.
By not having operator overloading Java can have clearer code.This is because when one uses a + overloaded operator, we can get an unexpected behavior if internally it is coded to something else, say a subtraction. The number of operators that you can overload is very small and most of them is relevant to scalar operations. Additionally, the detail of the operation performed by operators may not be as meaningful in comparison to a good method name.

<pre>
class Test
def initialize x
@x = x
end

def +(y)
@x - y
end
end
a = Test.new 5
puts(a + 3)

</pre>

In above example instead of getting a result of 8 due to the + operator being overloaded in a wrong way we instead get a result of 2

===Performance===
Collections in Ruby is slower than in Java as Ruby is a dynamically typed language. , therefore
in Ruby type checking happens at run-time which would slow down collection performance.

===Verbosity===
In Ruby since one uses operator for hash-tables, the code is less verbose and therefore easier to type:
<pre>
h[lastname] = firstname
</pre>
In Java one has to type a method name which increases the verbosity:
<pre>
hashmap.put(lastname)= firstname
</pre>

===Readability===
In Java when one has nested methods on collections, the code is easier to read than in Ruby when one has nested operators on collections within a single line. The Java code is easier to debug also as one can look at the values of the variables assigned on the nested methods.

== Conclusion ==
We started by listing the collections used in Java, which uses JCF and C++, which uses STL. We then compared JCF and STL and listed the advantages that JCF provides over STL. Finally we compared Java collections in library versus Ruby collections built into the language. For some purposes collections in library is better, and for other purposes collections in language is better.

== References ==
[1] http://download.oracle.com/javase/tutorial/collections/intro/index.html

[2]http://www.javamex.com/tutorials/collections/index.shtml

[3]http://en.wikipedia.org/wiki/Java_collections_framework

[4]http://www.sgi.com/tech/stl/index.html

[5]http://en.wikipedia.org/wiki/Standard_Template_Library

[6]http://download.oracle.com/javase/6/docs/technotes/guides/collections/overview.html

[7]http://java.dzone.com/articles/why-java-doesnt-need-operator

[8]http://www.ruby-doc.org/core/

CSC/ECE 517 Fall 2011/ch1 1b ds

2011-09-25T17:43:21Z

Ddilipd:

Cover the history of Collections frameworks back to the late 1970s or early 1980s, and how they were retrofitted to various languages. Discuss the advantage of a standard Collections framework (e.g., Java) vs. several competing frameworks (e.g., C++), and the advantage of collections built into the language (e.g., Ruby) vs. collections as class libraries. Give examples to illustrate the advantages you identify.

__TOC__

==Introduction==
A collection refers to a group of data items which have some commonality like a "a bunch of objects stored in a structured manner". Collections are very common in daily life, some examples would be a collection of science fiction books, the names of employees in a given department etc. Given that object oriented design concepts try to model the real world, it is natural to include support for creating and manipulating collections in languages which support object oriented development. Collections allows you to organize data in memory in various convenient ways.
Example : a simple list of strings, a mapping or association of strings to strings (e.g. country names to the names of their capitals);

Almost all major programming and scripting languages that are used today such as [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]], [http://en.wikipedia.org/wiki/JavaScript JavaScript], [http://en.wikipedia.org/wiki/PHP PHP], [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby], [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] have support for collections in some form or the other. Some languages have liner arrays (which can have different types of elements) and associative arrays built into the language whereas some other languages provide support through external libraries.

In this article we compare and contrast the two most popular collections frameworks/libraries in use today, C++ STL and Java Collections Framework (JCF). Also we compare collections in Ruby which does not have a formal collections framework against C++ and Java which define a formal framework/library for collections.

==History==
The history of collection frameworks can be analyzed in two aspects. Languages which have some basic collection containers built into them and languages with a formal collection framework. A collection framework may be defined as a generic reusable collection of classes which implements data structures and algorithms to create and manipulate groups of related objects. Few languages support a formal collections framework. Most of the modern programming languages have sequential arrays and associative array's built into them. A programmer may use these basic containers to create their own custom collection classes. A comparison of programming languages that implement associative arrays can be found [http://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28mapping%29 here].

The history of a collections framework or a collections library originate from ideas related to [http://en.wikipedia.org/wiki/Generic_programming generic programming] developed by Alexander Stepanov in the early 80s. At that time Ada was the only language which had support for generics. An initial generic library for list processing in Ada was developed by Alexander Stepanov and David Musser. However Ada did not achieve widespread acceptance by the programming community. As C/C++ became more widespread attention was given to developing a generic library in C++. Finally a proposal was made to the ANSI/ISO committee in 1993 and the C++ STL was finally accepted in 1994.

In the case of Java the initial versions prior to JDK-1.2 did not have a collections framework. These versions just defined Vectors and HashTables which were used to group objects together. This is reminiscent of the way things are done in languages such as Ruby, Python etc. The formal collections framework was introduced in 1998 with JDK-1.2 which borrowed a lot form Doug Lea's ''Collections package''. The goal of this framework was to be consistent with C++ STL. But soon Sun Microsystems decided that Java needed a compact collections framework and consistency with C++ STL was no longer a priority. This led to the development of the Java Collections Framework as we know it today.

=='''Java Collections Framework (JCF)'''==

[[Image:Jcf.gif]]

Java Collections Framework is a library of classes that implement collections. The collections framework also provides utility methods to perform functions such as sorting a list of data.The collections in Java are mainly the following: List, Set, Map and Queue. Java provides these collections as interfaces from which one can write their own classes or can use the inbuilt Java classes that implement these interfaces.

===List===
List is a collection of objects that has a fixed order (when we add an object to the list, it will stay in the place we put it), and allows objects to be referred to by position.Duplicate elements are allowed in a list. The general-purpose List implementations are [http://download.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html ArrayList] and [http://download.oracle.com/javase/1.4.2/docs/api/java/util/LinkedList.html LinkedList].

===Set===
A Set is a Collection that cannot contain duplicate elements. It models the mathematical set abstraction.The Java platform contains three general-purpose Set implementations: [http://download.oracle.com/javase/6/docs/api/java/util/HashSet.html HashSet], [http://download.oracle.com/javase/6/docs/api/java/util/TreeSet.html TreeSet], and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashSet.html LinkedHashSet].

===Map===
A Map is an object that maps keys to values. A map cannot contain duplicate keys: Each key can map to at most one value. Maps are defined by the java.util.Map interface in Java. The three general-purpose Map implementations are [http://download.oracle.com/javase/1.4.2/docs/api/java/util/HashMap.html HashMap], [http://download.oracle.com/javase/6/docs/api/java/util/TreeMap.html TreeMap] and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashMap.html LinkedHashMap]. The java.util.Map interface is extended by its subinterface, java.util.SortedMap. This interface defines a map that's sorted by the keys provided.

===Queue===
A Queue is a collection for holding elements prior to processing. Besides basic Collection operations, queues provide additional insertion, removal, and inspection operations. LinkedList implements the Queue interface, providing first in, first out (FIFO) queue operations.

=='''C++ Standard Template Library(STL)'''==
C++ standard template library is a software library that provides implementations of some basic containers for storing collections of related objects as well as algorithms to perform operations on the elements in these containers. All the classes in C++ STL are generic and can be used with any user defined or primitive data types. In general the C++ STL has four major components.

===Containers===
These are classes which are used to store other objects. Taking an example suppose there is a “jar of jellybeans”, the jar can be thought of as the container while the jelly beans are the objects that are stored in the container. Most collections automatically resize depending on the number of elements in them.The C++ STL provides a number of such classes which can be classified into two categories

====Sequence Containers====
These containers impose a strict linear order on the elements. Sequence containers support insertions and deletions (either at the ends or at a random position) using an index. Some examples of sequence containers are vector, list, dequeue etc.
====Associative containers====
These containers store key value pairs and each object stored in an associative container is mapped to a specific key. In other words associative containers perform insertions and deletions based on a key. Some examples of associative containers are set, map, hash map, multiset etc.

===Algorithms===
The C++ STL contains a large collection of algorithms that can be used to manipulate the data contained in the container. Continuing from the earlier “jar of jelly beans” example, suppose you wanted to count the number of red colored jelly beans. Or you wanted to change the color of all the jelly beans to red the algorithms in STL allow you to accomplish this.

An important thing to note is that the algorithms in STL are decoupled from the container. This means that there is only one definition of the function which implements the algorithm. This works for any valid container containing any any valid set of objects. Analogous to our example the function to count the number of red jelly beans also works for a “bucket containing colored pebbles”.

The algorithms contained in STL can be classified into two categories
====Non-Mutating====
Those which do not change the collection in any way. Examples include count, find, for each etc.
====Mutating====
Those which modify the contents of the collection in some way. Examples include replace, copy, reverse etc.
===Iterators===
Iterators are an important part of the C++ STL. Iterators facilitate traversal through a container’s elements. The separation of algorithms from containers is achieved through the use of iterators. Iterators can be thought of as a generalization of pointers. All the algorithms make use of iterators as function arguments. There are 5 types of iterators in STL. These differ in the way they traverse through the elements in the container.

===Functor===
A functor or functional object is an object that can be called as a function. This is in essence similar to function pointers in C. A functor is any class that overloads the operator() function. Such a class is most commonly used to define custom comparison functions to compare two objects. This is similar to “comparator” in JAVA.

=='''JCF versus STL'''==
===Quality of implementation===
Java is standardised and have formalized methods such as Java community process(JCP) and Java Specification request (JSR) to define revisions of java platforms. C++ only gives a defining standard and one can have different implementations of that standard. Hence different implementations can be incompatible.

===Portability===
This is a direct consequence of the fact that standards are available in Java and not in C++.
The following is a list of various [http://en.wikipedia.org/wiki/List_of_C%2B%2B_template_libraries STL libraries ]. These may have some common templates which might not necessarily be interoperable. In contrast the implementations of JCF are standardized and they will be portable as long as versions remain the same.

===Better optimization of containers===
In C++ STL the algorithms (i.e functions which manipulate the data) are completely decoupled from the containers it is not possible to optimize containers for specific purposes. In JCF since the algorithms are defined as interfaces it is easy to provide specific implementations based on requirements. Because the various implementations of each interface are interchangeable, programs can be easily tuned by switching implementations. The only way to optimize in STL is to create new containers which are tied together with the algorithms.

===More number of methods in STL===
STL has more number of methods than Java for collections. This is because STL has [http://www.sgi.com/tech/stl/table_of_contents.html separate methods] for containers and algorithms used for containers like Non-mutating algorithms, Mutating algorithms, Sorting

===Extension capability===
STL collections are difficult to extend as the base classes are not declared as virtual. In Java since the basic collections are interfaces, it is easy to implement the interfaces in a class, and extend from that.

===Manipulation of container objects using Iterators ===
C++ STL uses iterators to iterate through the items. Iterators themselves are generalizations of pointers. This leads to problems when one has to manipulate the items in the container, especially if the items have to be removed. It is tricky to iterate through the container and delete objects within the same loop. This is not the casein java since memory cannot be directly manipulated by the programmer.

===Pass by reference versus pass by value===
Containers in STL is accessed using copy semantics, thereby providing both efficiency and type safety, while in Java collections are accessed via references (or pointers). In Java if an one tries to access an object of a container that was just deleted , since we are using a reference this would result in error.

=='''Collections in languages versus library'''==
We are comparing collections inbuilt into the Ruby language versus Java’s collection libraries.

===Operators vs Methods===
In languages with collections built into them many operations may be performed using operators instead of calling functions. Consider an associative array, called hash in ruby and map in java.

<pre>
Assoc_array[
{“hello”, “world”}
{“good”,”day”}
]
</pre>

In a language with collections implemented as a class library one would use a function like “get(key)” to retrieve the value associated with a key. When there is language support one can use Assoc_array[key] to retrieve the value of the key.Now suppose we would like to extend the get function to do something different, in a language like java we can simply write another function or create a different implementation of the associative array which overrides the get function defined in the interface. Now in case of a language where the get is implemented using an operator we should either overload the default behavior of the operator or we have to define a custom operator to do this. In general it is much easier to overload a function than to overload an operator, Further not all languages allow operator overloading.

===Import===
In Ruby since collections are part of the language , therefore a developer need not include library for common functionalities while writing a program. In case of collections which are present in libraries like Java, one needs to import the libraries before executing the code. This can become a hassle for a Java developer if one does not know the name of the library to import for using a collection.

===Operator Overloading===
In Java we do not have operator overloading, but instead use methods to do the equivalent operations. Ruby has overloading where one can override , say a + operator.
By not having operator overloading Java can have clearer code.This is because when one uses a + overloaded operator, we can get an unexpected behavior if internally it is coded to something else, say a subtraction. The number of operators that you can overload is very small and most of them is relevant to scalar operations. Additionally, the detail of the operation performed by operators may not be as meaningful in comparison to a good method name.

<pre>
class Test
def initialize x
@x = x
end

def +(y)
@x - y
end
end
a = Test.new 5
puts(a + 3)

</pre>

In above example instead of getting a result of 8 due to the + operator being overloaded in a wrong way we instead get a result of 2

===Performance===
Collections in Ruby is slower than in Java as Ruby is a dynamically typed language. , therefore
in Ruby type checking happens at run-time which would slow down collection performance.

===Verbosity===
In Ruby since one uses operator for hash-tables, the code is less verbose and therefore easier to type:
<pre>
h[lastname] = firstname
</pre>
In Java one has to type a method name which increases the verbosity:
<pre>
hashmap.put(lastname)= firstname
</pre>

===Readability===
In Java when one has nested methods on collections, the code is easier to read than in Ruby when one has nested operators on collections within a single line. The Java code is easier to debug also as one can look at the values of the variables assigned on the nested methods.

== Conclusion ==
We started by listing the collections used in Java, which uses JCF and C++, which uses STL. We then compared JCF and STL and listed the advantages that JCF provides over STL. Finally we compared Java collections in library versus Ruby collections built into the language. For some purposes collections in library is better, and for other purposes collections in language is better.

== References ==
[1] http://download.oracle.com/javase/tutorial/collections/intro/index.html

[2]http://www.javamex.com/tutorials/collections/index.shtml

[3]http://en.wikipedia.org/wiki/Java_collections_framework

[4]http://www.sgi.com/tech/stl/index.html

[5]http://en.wikipedia.org/wiki/Standard_Template_Library

[6]http://download.oracle.com/javase/6/docs/technotes/guides/collections/overview.html

[7]http://java.dzone.com/articles/why-java-doesnt-need-operator

[8]http://www.ruby-doc.org/core/

CSC/ECE 517 Fall 2011/ch1 1b ds

2011-09-25T17:20:50Z

Ddilipd:

Cover the history of Collections frameworks back to the late 1970s or early 1980s, and how they were retrofitted to various languages. Discuss the advantage of a standard Collections framework (e.g., Java) vs. several competing frameworks (e.g., C++), and the advantage of collections built into the language (e.g., Ruby) vs. collections as class libraries. Give examples to illustrate the advantages you identify.

__TOC__

==Introduction==
A collection refers to a group of data items which have some commonality like a "a bunch of objects stored in a structured manner". Collections are very common in daily life, some examples would be a collection of science fiction books, the names of employees in a given department etc. Given that object oriented design concepts try to model the real world, it is natural to include support for creating and manipulating collections in languages which support object oriented development. Collections allows you to organize data in memory in various convenient ways.
Example : a simple list of strings, a mapping or association of strings to strings (e.g. country names to the names of their capitals);

Almost all major programming and scripting languages that are used today such as [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]], [http://en.wikipedia.org/wiki/JavaScript JavaScript], [http://en.wikipedia.org/wiki/PHP PHP], [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby], [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] have support for collections in some form or the other. Some languages have liner arrays (which can have different types of elements) and associative arrays built into the language whereas some other languages provide support through external libraries.

In this article we compare and contrast the two most popular collections frameworks/libraries in use today, C++ STL and Java Collections Framework (JCF). Also we compare collections in Ruby which does not have a formal collections framework against C++ and Java which define a formal framework/library for collections.

==History==
The history of collection frameworks can be analyzed in two aspects. Languages which have some basic collection containers built into them and languages with a formal collection framework. A collection framework may be defined as a generic reusable collection of classes which implements data structures and algorithms to create and manipulate groups of related objects. Few languages support a formal collections framework. Most of the modern programming languages have sequential arrays and associative array's built into them. A programmer may use these basic containers to create their own custom collection classes. A comparison of programming languages that implement associative arrays can be found [http://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28mapping%29 here].

The history of a collections framework or a collections library originate from ideas related to [http://en.wikipedia.org/wiki/Generic_programming generic programming] developed by Alexander Stepanov in the early 80s. At that time Ada was the only language which had support for generics. An initial generic library for list processing in Ada was developed by Alexander Stepanov and David Musser. However Ada did not achieve widespread acceptance by the programming community. As C/C++ became more widespread attention was given to developing a generic library in C++. Finally a proposal was made to the ANSI/ISO committee in 1993 and the C++ STL was finally accepted in 1994.

In the case of Java the initial versions prior to JDK-1.2 did not have a collections framework. These versions just defined Vectors and HashTables which were used to group objects together. This is reminiscent of the way things are done in languages such as Ruby, Python etc. The formal collections framework was introduced in 1998 with JDK-1.2 which borrowed a lot form Doug Lea's ''Collections package''. The goal of this framework was to be consistent with C++ STL. But soon Sun Microsystems decided that Java needed a compact collections framework and consistency with C++ STL was no longer a priority. This led to the development of the Java Collections Framework as we know it today.

=='''Java Collections Framework (JCF)'''==

[[Image:Jcf.gif]]

Java Collections Framework is a library of classes that implement collections. The collections framework also provides utility methods to perform functions such as sorting a list of data.The collections in Java are mainly the following: List, Set, Map and Queue. Java provides these collections as interfaces from which one can write their own classes or can use the inbuilt Java classes that implement these interfaces.

===List===
List is a collection of objects that has a fixed order (when we add an object to the list, it will stay in the place we put it), and allows objects to be referred to by position.Duplicate elements are allowed in a list. The general-purpose List implementations are [http://download.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html ArrayList] and [http://download.oracle.com/javase/1.4.2/docs/api/java/util/LinkedList.html LinkedList].

===Set===
A Set is a Collection that cannot contain duplicate elements. It models the mathematical set abstraction.The Java platform contains three general-purpose Set implementations: [http://download.oracle.com/javase/6/docs/api/java/util/HashSet.html HashSet], [http://download.oracle.com/javase/6/docs/api/java/util/TreeSet.html TreeSet], and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashSet.html LinkedHashSet].

===Map===
A Map is an object that maps keys to values. A map cannot contain duplicate keys: Each key can map to at most one value. Maps are defined by the java.util.Map interface in Java. The three general-purpose Map implementations are [http://download.oracle.com/javase/1.4.2/docs/api/java/util/HashMap.html HashMap], [http://download.oracle.com/javase/6/docs/api/java/util/TreeMap.html TreeMap] and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashMap.html LinkedHashMap]. The java.util.Map interface is extended by its subinterface, java.util.SortedMap. This interface defines a map that's sorted by the keys provided.

===Queue===
A Queue is a collection for holding elements prior to processing. Besides basic Collection operations, queues provide additional insertion, removal, and inspection operations. LinkedList implements the Queue interface, providing first in, first out (FIFO) queue operations.

=='''C++ Standard Template Library(STL)'''==
C++ standard template library is a software library that provides implementations of some basic containers for storing collections of related objects as well as algorithms to perform operations on the elements in these containers. All the classes in C++ STL are generic and can be used with any user defined or primitive data types. In general the C++ STL has four major components.

===Containers===
These are classes which are used to store other objects. Taking an example suppose there is a “jar of jellybeans”, the jar can be thought of as the container while the jelly beans are the objects that are stored in the container. Most collections automatically resize depending on the number of elements in them.The C++ STL provides a number of such classes which can be classified into two categories

====Sequence Containers====
These containers impose a strict linear order on the elements. Sequence containers support insertions and deletions (either at the ends or at a random position) using an index. Some examples of sequence containers are vector, list, dequeue etc.
====Associative containers====
These containers store key value pairs and each object stored in an associative container is mapped to a specific key. In other words associative containers perform insertions and deletions based on a key. Some examples of associative containers are set, map, hash map, multiset etc.

===Algorithms===
The C++ STL contains a large collection of algorithms that can be used to manipulate the data contained in the container. Continuing from the earlier “jar of jelly beans” example, suppose you wanted to count the number of red colored jelly beans. Or you wanted to change the color of all the jelly beans to red the algorithms in STL allow you to accomplish this.

An important thing to note is that the algorithms in STL are decoupled from the container. This means that there is only one definition of the function which implements the algorithm. This works for any valid container containing any any valid set of objects. Analogous to our example the function to count the number of red jelly beans also works for a “bucket containing colored pebbles”.

The algorithms contained in STL can be classified into two categories
====Non-Mutating====
Those which do not change the collection in any way. Examples include count, find, for each etc.
====Mutating====
Those which modify the contents of the collection in some way. Examples include replace, copy, reverse etc.
===Iterators===
Iterators are an important part of the C++ STL. Iterators facilitate traversal through a container’s elements. The separation of algorithms from containers is achieved through the use of iterators. Iterators can be thought of as a generalization of pointers. All the algorithms make use of iterators as function arguments. There are 5 types of iterators in STL. These differ in the way they traverse through the elements in the container.

===Functor===
A functor or functional object is an object that can be called as a function. This is in essence similar to function pointers in C. A functor is any class that overloads the operator() function. Such a class is most commonly used to define custom comparison functions to compare two objects. This is similar to “comparator” in JAVA.

=='''JCF versus STL'''==
===Quality of implementation===
Java is standardised and have formalized methods such as Java community process(JCP) and Java Specification request (JSR) to define revisions of java platforms. C++ only gives a defining standard and one can have different implementations of that standard. Hence different implementations can be incompatible.

===Portability===
This is a direct consequence of the fact that standards are available in Java and not in C++.
The following is a list of various [http://en.wikipedia.org/wiki/List_of_C%2B%2B_template_libraries STL libraries ]. These may have some common templates which might not necessarily be interoperable. In contrast the implementations of JCF are standardized and they will be portable as long as versions remain the same.

===Better optimization of containers===
In C++ STL the algorithms (i.e functions which manipulate the data) are completely decoupled from the containers it is not possible to optimize containers for specific purposes. In JCF since the algorithms are defined as interfaces it is easy to provide specific implementations based on requirements. Because the various implementations of each interface are interchangeable, programs can be easily tuned by switching implementations. The only way to optimize in STL is to create new containers which are tied together with the algorithms.

===More number of methods in STL===
STL has more number of methods than Java for collections. This is because STL has [http://www.sgi.com/tech/stl/table_of_contents.html separate methods] for containers and algorithms used for containers like Non-mutating algorithms, Mutating algorithms, Sorting

===Extension capability===
STL collections are difficult to extend as the base classes are not declared as virtual. In Java since the basic collections are interfaces, it is easy to implement the interfaces in a class, and extend from that.

===Manipulation of container objects using Iterators ===
C++ STL uses iterators to iterate through the items. Iterators themselves are generalizations of pointers. This leads to problems when one has to manipulate the items in the container, especially if the items have to be removed. It is tricky to iterate through the container and delete objects within the same loop. This is not the casein java since memory cannot be directly manipulated by the programmer.

===Pass by reference versus pass by value===
Containers in STL is accessed using copy semantics, thereby providing both efficiency and type safety, while in Java collections are accessed via references (or pointers). In Java if an one tries to access an object of a container that was just deleted , since we are using a reference this would result in error.

=='''Collections in languages versus library'''==
We are comparing collections inbuilt into the Ruby language versus Java’s collection libraries.

===Operators vs Methods===
In languages with collections built into them many operations may be performed using operators instead of calling functions. Consider an associative array, called hash in ruby and map in java.

<pre>
Assoc_array[
{“hello”, “world”}
{“good”,”day”}
]
</pre>

In a language with collections implemented as a class library one would use a function like “get(key)” to retrieve the value associated with a key. When there is language support one can use Assoc_array[key] to retrieve the value of the key.Now suppose we would like to extend the get function to do something different, in a language like java we can simply write another function or create a different implementation of the associative array which overrides the get function defined in the interface. Now in case of a language where the get is implemented using an operator we should either overload the default behavior of the operator or we have to define a custom operator to do this. In general it is much easier to overload a function than to overload an operator, Further not all languages allow operator overloading.

===Import===
In Ruby since collections are part of the language , therefore a developer need not include library for common functionalities while writing a program. In case of collections which are present in libraries like Java, one needs to import the libraries before executing the code. This can become a hassle for a Java developer if one does not know the name of the library to import for using a collection.

===Operator Overloading===
In Java we do not have operator overloading, but instead use methods to do the equivalent operations. Ruby has overloading where one can override , say a + operator.
By not having operator overloading Java can have clearer code.This is because when one uses a + overloaded operator, we can get an unexpected behavior if internally it is coded to something else, say a subtraction. The number of operators that you can overload is very small and most of them is relevant to scalar operations. Additionally, the detail of the operation performed by operators may not be as meaningful in comparison to a good method name.

<pre>
class Test
def initialize x
@x = x
end

def +(y)
@x - y
end
end
a = Test.new 5
puts(a + 3)

</pre>

In above example instead of getting a result of 8 due to the + operator being overloaded in a wrong way we instead get a result of 2

===Performance===
Collections in Ruby is slower than in Java as Ruby is a dynamically typed language. , therefore
in Ruby type checking happens at run-time which would slow down collection performance.

===Verbosity===
In Ruby since one uses operator for hash-tables, the code is less verbose and therefore easier to type:
<pre>
h[lastname] = firstname
</pre>
In Java one has to type a method name which increases the verbosity:
<pre>
hashmap.put(lastname)= firstname
</pre>

===Readability===
In Java when one has nested methods on collections, the code is easier to read than in Ruby when one has nested operators on collections within a single line. The Java code is easier to debug also as one can look at the values of the variables assigned on the nested methods.

== References ==
[1] http://download.oracle.com/javase/tutorial/collections/intro/index.html

[2]http://www.javamex.com/tutorials/collections/index.shtml

[3]http://en.wikipedia.org/wiki/Java_collections_framework

[4]http://www.sgi.com/tech/stl/index.html

[5]http://en.wikipedia.org/wiki/Standard_Template_Library

[6]http://download.oracle.com/javase/6/docs/technotes/guides/collections/overview.html

[7]http://java.dzone.com/articles/why-java-doesnt-need-operator

[8]http://www.ruby-doc.org/core/

CSC/ECE 517 Fall 2011/ch1 1b ds

2011-09-19T20:09:05Z

Ddilipd:

Cover the history of Collections frameworks back to the late 1970s or early 1980s, and how they were retrofitted to various languages. Discuss the advantage of a standard Collections framework (e.g., Java) vs. several competing frameworks (e.g., C++), and the advantage of collections built into the language (e.g., Ruby) vs. collections as class libraries. Give examples to illustrate the advantages you identify.

__TOC__

==Introduction==
A collection refers to a group of data items which have some commonality like a "a bunch of objects stored in a structured manner". Collections are very common in daily life, some examples would be a collection of science fiction books, the names of employees in a given department etc. Given that object oriented design concepts try to model the real world, it is natural to include support for creating and manipulating collections in languages which support object oriented development. Collections allows you to organize data in memory in various convenient ways.
Example : a simple list of strings, a mapping or association of strings to strings (e.g. country names to the names of their capitals);

Almost all major programming and scripting languages that are used today such as [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]], [http://en.wikipedia.org/wiki/JavaScript JavaScript], [http://en.wikipedia.org/wiki/PHP PHP], [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby], [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] have support for collections in some form or the other. Some languages have liner arrays (which can have different types of elements) and associative arrays built into the language whereas some other languages provide support through external libraries.

In this article we compare and contrast the two most popular collections frameworks/libraries in use today, C++ STL and Java Collections Framework (JCF). Also we compare collections in Ruby which does not have a formal collections framework against C++ and Java which define a formal framework/library for collections.

==History==
The history of collection frameworks can be analyzed in two aspects. Languages which have some basic collection containers built into them and languages with a formal collection framework. A collection framework may be defined as a generic reusable collection of classes which implements data structures and algorithms to create and manipulate groups of related objects. Few languages support a formal collections framework. Most of the modern programming languages have sequential arrays and associative array's built into them. A programmer may use these basic containers to create their own custom collection classes. A comparison of programming languages that implement associative arrays can be found [http://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28mapping%29 here].

The history of a collections framework or a collections library originate from ideas related to [http://en.wikipedia.org/wiki/Generic_programming generic programming] developed by Alexander Stepanov in the early 80s. At that time Ada was the only language which had support for generics. An initial generic library for list processing in Ada was developed by Alexander Stepanov and David Musser. However Ada did not achieve widespread acceptance by the programming community. As C/C++ became more widespread attention was given to developing a generic library in C++. Finally a proposal was made to the ANSI/ISO committee in 1993 and the C++ STL was finally accepted in 1994.

In the case of Java the initial versions prior to JDK-1.2 did not have a collections framework. These versions just defined Vectors and HashTables which were used to group objects together. This is reminiscent of the way things are done in languages such as Ruby, Python etc. The formal collections framework was introduced in 1998 with JDK-1.2 which borrowed a lot form Doug Lea's ''Collections package''. The goal of this framework was to be consistent with C++ STL. But soon Sun Microsystems decided that Java needed a compact collections framework and consistency with C++ STL was no longer a priority. This led to the development of the Java Collections Framework as we know it today.

=='''Java Collections Framework (JCF)'''==

[[Image:Jcf.gif]]

Java Collections Framework is a library of classes that implement collections. The collections framework also provides utility methods to perform functions such as sorting a list of data.The collections in Java are mainly the following: List, Set, Map and Queue. Java provides these collections as interfaces from which one can write their own classes or can use the inbuilt Java classes that implement these interfaces.

===List===
List is a collection of objects that has a fixed order (when we add an object to the list, it will stay in the place we put it), and allows objects to be referred to by position.Duplicate elements are allowed in a list. The general-purpose List implementations are [http://download.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html ArrayList] and [http://download.oracle.com/javase/1.4.2/docs/api/java/util/LinkedList.html LinkedList].

===Set===
A Set is a Collection that cannot contain duplicate elements. It models the mathematical set abstraction.The Java platform contains three general-purpose Set implementations: [http://download.oracle.com/javase/6/docs/api/java/util/HashSet.html HashSet], [http://download.oracle.com/javase/6/docs/api/java/util/TreeSet.html TreeSet], and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashSet.html LinkedHashSet].

===Map===
A Map is an object that maps keys to values. A map cannot contain duplicate keys: Each key can map to at most one value. Maps are defined by the java.util.Map interface in Java. The three general-purpose Map implementations are [http://download.oracle.com/javase/1.4.2/docs/api/java/util/HashMap.html HashMap], [http://download.oracle.com/javase/6/docs/api/java/util/TreeMap.html TreeMap] and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashMap.html LinkedHashMap]. The java.util.Map interface is extended by its subinterface, java.util.SortedMap. This interface defines a map that's sorted by the keys provided.

===Queue===
A Queue is a collection for holding elements prior to processing. Besides basic Collection operations, queues provide additional insertion, removal, and inspection operations. LinkedList implements the Queue interface, providing first in, first out (FIFO) queue operations.

=='''C++ Standard Template Library(STL)'''==
C++ standard template library is a software library that provides implementations of some basic containers for storing collections of related objects as well as algorithms to perform operations on the elements in these containers. All the classes in C++ STL are generic and can be used with any user defined or primitive data types. In general the C++ STL has four major components.

===Containers===
These are classes which are used to store other objects. Taking an example suppose there is a “jar of jellybeans”, the jar can be thought of as the container while the jelly beans are the objects that are stored in the container. Most collections automatically resize depending on the number of elements in them.The C++ STL provides a number of such classes which can be classified into two categories

====Sequence Containers====
These containers impose a strict linear order on the elements. Sequence containers support insertions and deletions (either at the ends or at a random position) using an index. Some examples of sequence containers are vector, list, dequeue etc.
====Associative containers====
These containers store key value pairs and each object stored in an associative container is mapped to a specific key. In other words associative containers perform insertions and deletions based on a key. Some examples of associative containers are set, map, hash map, multiset etc.

===Algorithms===
The C++ STL contains a large collection of algorithms that can be used to manipulate the data contained in the container. Continuing from the earlier “jar of jelly beans” example, suppose you wanted to count the number of red colored jelly beans. Or you wanted to change the color of all the jelly beans to red the algorithms in STL allow you to accomplish this.

An important thing to note is that the algorithms in STL are decoupled from the container. This means that there is only one definition of the function which implements the algorithm. This works for any valid container containing any any valid set of objects. Analogous to our example the function to count the number of red jelly beans also works for a “bucket containing colored pebbles”.

The algorithms contained in STL can be classified into two categories
====Non-Mutating====
Those which do not change the collection in any way. Examples include count, find, for each etc.
====Mutating====
Those which modify the contents of the collection in some way. Examples include replace, copy, reverse etc.
===Iterators===
Iterators are an important part of the C++ STL. Iterators facilitate traversal through a container’s elements. The separation of algorithms from containers is achieved through the use of iterators. Iterators can be thought of as a generalization of pointers. All the algorithms make use of iterators as function arguments. There are 5 types of iterators in STL. These differ in the way they traverse through the elements in the container.

===Functor===
A functor or functional object is an object that can be called as a function. This is in essence similar to function pointers in C. A functor is any class that overloads the operator() function. Such a class is most commonly used to define custom comparison functions to compare two objects. This is similar to “comparator” in JAVA.

=='''JCF versus STL'''==
===Quality of implementation===
Java is standardised and have formalized methods such as Java community process(JCP) and Java Specification request (JSR) to define revisions of java platforms. C++ only gives a defining standard and one can have different implementations of that standard. Hence different implementations can be incompatible.

===Portability===
This is a direct consequence of the fact that standards are available in Java and not in C++.
The following is a list of various [http://en.wikipedia.org/wiki/List_of_C%2B%2B_template_libraries STL libraries ]. These may have some common templates which might not necessarily be interoperable. In contrast the implementations of JCF are standardized and they will be portable as long as versions remain the same.

===Better optimization of containers===
In C++ STL the algorithms (i.e functions which manipulate the data) are completely decoupled from the containers it is not possible to optimize containers for specific purposes. In JCF since the algorithms are defined as interfaces it is easy to provide specific implementations based on requirements. Because the various implementations of each interface are interchangeable, programs can be easily tuned by switching implementations. The only way to optimize in STL is to create new containers which are tied together with the algorithms.

===More number of methods in STL===
STL has more number of methods than Java for collections. This is because STL has [http://www.sgi.com/tech/stl/table_of_contents.html separate methods] for containers and algorithms used for containers like Non-mutating algorithms, Mutating algorithms, Sorting

===Collections in Java are more extensible than in STL===
STL collections are difficult to extend as the base classes are not declared as virtual. In Java since the basic collections are interfaces, it is easy to implement the interfaces in a class, and extend from that.

===Manipulation of container objects using Iterators ===
C++ STL uses iterators to iterate through the items. Iterators themselves are generalizations of pointers. This leads to problems when one has to manipulate the items in the container, especially if the items have to be removed. It is tricky to iterate through the container and delete objects within the same loop. This is not the casein java since memory cannot be directly manipulated by the programmer.

===Pass by reference versus pass by value===
Containers in STL is accessed using copy semantics, thereby providing both efficiency and type safety, while in Java collections are accessed via references (or pointers). In Java if an one tries to access an object of a container that was just deleted , since we are using a reference this would result in error.

=='''Collections in languages versus library'''==
We are comparing collections inbuilt into the Ruby language versus Java’s collection libraries.

===Operators vs Methods===
In languages with collections built into them many operations may be performed using operators instead of calling functions. Consider an associative array, called hash in ruby and map in java.

<pre>
Assoc_array[
{“hello”, “world”}
{“good”,”day”}
]
</pre>

In a language with collections implemented as a class library one would use a function like “get(key)” to retrieve the value associated with a key. When there is language support one can use Assoc_array[key] to retrieve the value of the key.Now suppose we would like to extend the get function to do something different, in a language like java we can simply write another function or create a different implementation of the associative array which overrides the get function defined in the interface. Now in case of a language where the get is implemented using an operator we should either overload the default behavior of the operator or we have to define a custom operator to do this. In general it is much easier to overload a function than to overload an operator, Further not all languages allow operator overloading.

===Import===
In Ruby since collections are part of the language , therefore a developer need not include library for common functionalities while writing a program. In case of collections which are present in libraries like Java, one needs to import the libraries before executing the code. This can become a hassle for a Java developer if one does not know the name of the library to import for using a collection.

===Operator Overloading===
In Java we do not have operator overloading, but instead use methods to do the equivalent operations. Ruby has overloading where one can override , say a + operator.
By not having operator overloading Java can have clearer code.This is because when one uses a + overloaded operator, we can get an unexpected behavior if internally it is coded to something else, say a subtraction. The number of operators that you can overload is very small and most of them is relevant to scalar operations. Additionally, the detail of the operation performed by operators may not be as meaningful in comparison to a good method name.

<pre>
class Test
def initialize x
@x = x
end

def +(y)
@x - y
end
end
a = Test.new 5
puts(a + 3)

</pre>

In above example instead of getting a result of 8 due to the + operator being overloaded in a wrong way we instead get a result of 2

===Performance===
Collections in Ruby is slower than in Java as Ruby is a dynamically typed language. , therefore
in Ruby type checking happens at run-time which would slow down collection performance.

===Verbosity===
In Ruby since one uses operator for hash-tables, the code is less verbose and therefore easier to type:
<pre>
h[lastname] = firstname
</pre>
In Java one has to type a method name which increases the verbosity:
<pre>
hashmap.put(lastname)= firstname
</pre>

===Readability===
In Java when one has nested methods on collections, the code is easier to read than in Ruby when one has nested operators on collections within a single line. The Java code is easier to debug also as one can look at the values of the variables assigned on the nested methods.

== References ==
[1] http://download.oracle.com/javase/tutorial/collections/intro/index.html

[2]http://www.javamex.com/tutorials/collections/index.shtml

[3]http://en.wikipedia.org/wiki/Java_collections_framework

[4]http://www.sgi.com/tech/stl/index.html

[5]http://en.wikipedia.org/wiki/Standard_Template_Library

[6]http://download.oracle.com/javase/6/docs/technotes/guides/collections/overview.html

[7]http://java.dzone.com/articles/why-java-doesnt-need-operator

[8]http://www.ruby-doc.org/core/

CSC/ECE 517 Fall 2011/ch1 1b ds

2011-09-09T02:55:59Z

Ddilipd:

Cover the history of Collections frameworks back to the late 1970s or early 1980s, and how they were retrofitted to various languages. Discuss the advantage of a standard Collections framework (e.g., Java) vs. several competing frameworks (e.g., C++), and the advantage of collections built into the language (e.g., Ruby) vs. collections as class libraries. Give examples to illustrate the advantages you identify.

'''Authors'''
* Dilip Devaraj
* Srinath Sridhar

__TOC__

==Introduction==
A collection refers to a group of data items which have some commonality like a "a bunch of objects stored in a structured manner". Collections are very common in daily life, some examples would be a collection of science fiction books, the names of employees in a given department etc. Given that object oriented design concepts try to model the real world, it is natural to include support for creating and manipulating collections in languages which support object oriented development. Collections allows you to organize data in memory in various convenient ways.
Example : a simple list of strings, a mapping or association of strings to strings (e.g. country names to the names of their capitals);

Almost all major programming and scripting languages that are used today such as [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]], [http://en.wikipedia.org/wiki/JavaScript JavaScript], [http://en.wikipedia.org/wiki/PHP PHP], [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby], [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] have support for collections in some form or the other. Some languages have liner arrays (which can have different types of elements) and associative arrays built into the language whereas some other languages provide support through external libraries.

In this article we compare and contrast the two most popular collections frameworks/libraries in use today, C++ STL and Java Collections Framework (JCF). Also we compare collections in Ruby which does not have a formal collections framework against C++ and Java which define a formal framework/library for collections.

==History==
The history of collection frameworks can be analyzed in two aspects. Languages which have some basic collection containers built into them and languages with a formal collection framework. A collection framework may be defined as a generic reusable collection of classes which implements data structures and algorithms to create and manipulate groups of related objects. Few languages support a formal collections framework. Most of the modern programming languages have sequential arrays and associative array's built into them. A programmer may use these basic containers to create their own custom collection classes. A comparison of programming languages that implement associative arrays can be found [http://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28mapping%29 here].

The history of a collections framework or a collections library originate from ideas related to [http://en.wikipedia.org/wiki/Generic_programming generic programming] developed by Alexander Stepanov in the early 80s. At that time Ada was the only language which had support for generics. An initial generic library for list processing in Ada was developed by Alexander Stepanov and David Musser. However Ada did not achieve widespread acceptance by the programming community. As C/C++ became more widespread attention was given to developing a generic library in C++. Finally a proposal was made to the ANSI/ISO committee in 1993 and the C++ STL was finally accepted in 1994.

In the case of Java the initial versions prior to JDK-1.2 did not have a collections framework. These versions just defined Vectors and HashTables which were used to group objects together. This is reminiscent of the way things are done in languages such as Ruby, Python etc. The formal collections framework was introduced in 1998 with JDK-1.2 which borrowed a lot form Doug Lea's ''Collections package''. The goal of this framework was to be consistent with C++ STL. But soon Sun Microsystems decided that Java needed a compact collections framework and consistency with C++ STL was no longer a priority. This led to the development of the Java Collections Framework as we know it today.

=='''Java Collections Framework (JCF)'''==

[[Image:Jcf.gif]]

Java Collections Framework is a library of classes that implement collections. The collections framework also provides utility methods to perform functions such as sorting a list of data.The collections in Java are mainly the following: List, Set, Map and Queue. Java provides these collections as interfaces from which one can write their own classes or can use the inbuilt Java classes that implement these interfaces.

===List===
List is a collection of objects that has a fixed order (when we add an object to the list, it will stay in the place we put it), and allows objects to be referred to by position.Duplicate elements are allowed in a list. The general-purpose List implementations are [http://download.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html ArrayList] and [http://download.oracle.com/javase/1.4.2/docs/api/java/util/LinkedList.html LinkedList].

===Set===
A Set is a Collection that cannot contain duplicate elements. It models the mathematical set abstraction.The Java platform contains three general-purpose Set implementations: [http://download.oracle.com/javase/6/docs/api/java/util/HashSet.html HashSet], [http://download.oracle.com/javase/6/docs/api/java/util/TreeSet.html TreeSet], and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashSet.html LinkedHashSet].

===Map===
A Map is an object that maps keys to values. A map cannot contain duplicate keys: Each key can map to at most one value. Maps are defined by the java.util.Map interface in Java. The three general-purpose Map implementations are [http://download.oracle.com/javase/1.4.2/docs/api/java/util/HashMap.html HashMap], [http://download.oracle.com/javase/6/docs/api/java/util/TreeMap.html TreeMap] and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashMap.html LinkedHashMap]. The java.util.Map interface is extended by its subinterface, java.util.SortedMap. This interface defines a map that's sorted by the keys provided.

===Queue===
A Queue is a collection for holding elements prior to processing. Besides basic Collection operations, queues provide additional insertion, removal, and inspection operations. LinkedList implements the Queue interface, providing first in, first out (FIFO) queue operations.

=='''C++ Standard Template Library(STL)'''==
C++ standard template library is a software library that provides implementations of some basic containers for storing collections of related objects as well as algorithms to perform operations on the elements in these containers. All the classes in C++ STL are generic and can be used with any user defined or primitive data types. In general the C++ STL has four major components.

===Containers===
These are classes which are used to store other objects. Taking an example suppose there is a “jar of jellybeans”, the jar can be thought of as the container while the jelly beans are the objects that are stored in the container. Most collections automatically resize depending on the number of elements in them.The C++ STL provides a number of such classes which can be classified into two categories

====Sequence Containers====
These containers impose a strict linear order on the elements. Sequence containers support insertions and deletions (either at the ends or at a random position) using an index. Some examples of sequence containers are vector, list, dequeue etc.
====Associative containers====
These containers store key value pairs and each object stored in an associative container is mapped to a specific key. In other words associative containers perform insertions and deletions based on a key. Some examples of associative containers are set, map, hash map, multiset etc.

===Algorithms===
The C++ STL contains a large collection of algorithms that can be used to manipulate the data contained in the container. Continuing from the earlier “jar of jelly beans” example, suppose you wanted to count the number of red colored jelly beans. Or you wanted to change the color of all the jelly beans to red the algorithms in STL allow you to accomplish this.

An important thing to note is that the algorithms in STL are decoupled from the container. This means that there is only one definition of the function which implements the algorithm. This works for any valid container containing any any valid set of objects. Analogous to our example the function to count the number of red jelly beans also works for a “bucket containing colored pebbles”.

The algorithms contained in STL can be classified into two categories
====Non-Mutating====
Those which do not change the collection in any way. Examples include count, find, for each etc.
====Mutating====
Those which modify the contents of the collection in some way. Examples include replace, copy, reverse etc.
===Iterators===
Iterators are an important part of the C++ STL. Iterators facilitate traversal through a container’s elements. The separation of algorithms from containers is achieved through the use of iterators. Iterators can be thought of as a generalization of pointers. All the algorithms make use of iterators as function arguments. There are 5 types of iterators in STL. These differ in the way they traverse through the elements in the container.

===Functor===
A functor or functional object is an object that can be called as a function. This is in essence similar to function pointers in C. A functor is any class that overloads the operator() function. Such a class is most commonly used to define custom comparison functions to compare two objects. This is similar to “comparator” in JAVA.

=='''JCF versus STL'''==
===Quality of implementation===
Java is standardised and have formalized methods such as Java community process(JCP) and Java Specification request (JSR) to define revisions of java platforms. C++ only gives a defining standard and one can have different implementations of that standard. Hence different implementations can be incompatible.

===Portability===
This is a direct consequence of the fact that standards are available in Java and not in C++.
The following is a list of various [http://en.wikipedia.org/wiki/List_of_C%2B%2B_template_libraries STL libraries ]. These may have some common templates which might not necessarily be interoperable. In contrast the implementations of JCF are standardized and they will be portable as long as versions remain the same.

===Better optimization of containers===
In C++ STL the algorithms (i.e functions which manipulate the data) are completely decoupled from the containers it is not possible to optimize containers for specific purposes. In JCF since the algorithms are defined as interfaces it is easy to provide specific implementations based on requirements. Because the various implementations of each interface are interchangeable, programs can be easily tuned by switching implementations. The only way to optimize in STL is to create new containers which are tied together with the algorithms.

===More number of methods in STL===
STL has more number of methods than Java for collections. This is because STL has [http://www.sgi.com/tech/stl/table_of_contents.html separate methods] for containers and algorithms used for containers like Non-mutating algorithms, Mutating algorithms, Sorting

===Collections in Java are more extensible than in STL===
STL collections are difficult to extend as the base classes are not declared as virtual. In Java since the basic collections are interfaces, it is easy to implement the interfaces in a class, and extend from that.

===Manipulation of container objects using Iterators ===
C++ STL uses iterators to iterate through the items. Iterators themselves are generalizations of pointers. This leads to problems when one has to manipulate the items in the container, especially if the items have to be removed. It is tricky to iterate through the container and delete objects within the same loop. This is not the casein java since memory cannot be directly manipulated by the programmer.

===Pass by reference versus pass by value===
Containers in STL is accessed using copy semantics, thereby providing both efficiency and type safety, while in Java collections are accessed via references (or pointers). In Java if an one tries to access an object of a container that was just deleted , since we are using a reference this would result in error.

=='''Collections in languages versus library'''==
We are comparing collections inbuilt into the Ruby language versus Java’s collection libraries.

===Operators vs Methods===
In languages with collections built into them many operations may be performed using operators instead of calling functions. Consider an associative array, called hash in ruby and map in java.

<pre>
Assoc_array[
{“hello”, “world”}
{“good”,”day”}
]
</pre>

In a language with collections implemented as a class library one would use a function like “get(key)” to retrieve the value associated with a key. When there is language support one can use Assoc_array[key] to retrieve the value of the key.Now suppose we would like to extend the get function to do something different, in a language like java we can simply write another function or create a different implementation of the associative array which overrides the get function defined in the interface. Now in case of a language where the get is implemented using an operator we should either overload the default behavior of the operator or we have to define a custom operator to do this. In general it is much easier to overload a function than to overload an operator, Further not all languages allow operator overloading.

===Import===
In Ruby since collections are part of the language , therefore a developer need not include library for common functionalities while writing a program. In case of collections which are present in libraries like Java, one needs to import the libraries before executing the code. This can become a hassle for a Java developer if one does not know the name of the library to import for using a collection.

===Operator Overloading===
In Java we do not have operator overloading, but instead use methods to do the equivalent operations. Ruby has overloading where one can override , say a + operator.
By not having operator overloading Java can have clearer code.This is because when one uses a + overloaded operator, we can get an unexpected behavior if internally it is coded to something else, say a subtraction. The number of operators that you can overload is very small and most of them is relevant to scalar operations. Additionally, the detail of the operation performed by operators may not be as meaningful in comparison to a good method name.

<pre>
class Test
def initialize x
@x = x
end

def +(y)
@x - y
end
end
a = Test.new 5
puts(a + 3)

</pre>

In above example instead of getting a result of 8 due to the + operator being overloaded in a wrong way we instead get a result of 2

===Performance===
Collections in Ruby is slower than in Java as Ruby is a dynamically typed language. , therefore
in Ruby type checking happens at run-time which would slow down collection performance.

===Verbosity===
In Ruby since one uses operator for hash-tables, the code is less verbose and therefore easier to type:
<pre>
h[lastname] = firstname
</pre>
In Java one has to type a method name which increases the verbosity:
<pre>
hashmap.put(lastname)= firstname
</pre>

===Readability===
In Java when one has nested methods on collections, the code is easier to read than in Ruby when one has nested operators on collections within a single line. The Java code is easier to debug also as one can look at the values of the variables assigned on the nested methods.

== References ==
[1] http://download.oracle.com/javase/tutorial/collections/intro/index.html

[2]http://www.javamex.com/tutorials/collections/index.shtml

[3]http://en.wikipedia.org/wiki/Java_collections_framework

[4]http://www.sgi.com/tech/stl/index.html

[5]http://en.wikipedia.org/wiki/Standard_Template_Library

[6]http://download.oracle.com/javase/6/docs/technotes/guides/collections/overview.html

[7]http://java.dzone.com/articles/why-java-doesnt-need-operator

[8]http://www.ruby-doc.org/core/

CSC/ECE 517 Fall 2011/ch1 1b ds

2011-09-08T16:33:47Z

Ddilipd: /* Java Collections Framework (JCF) */

Cover the history of Collections frameworks back to the late 1970s or early 1980s, and how they were retrofitted to various languages. Discuss the advantage of a standard Collections framework (e.g., Java) vs. several competing frameworks (e.g., C++), and the advantage of collections built into the language (e.g., Ruby) vs. collections as class libraries. Give examples to illustrate the advantages you identify.

'''Authors'''
* Dilip Devaraj
* Srinath Sridhar

__TOC__

==Introduction==
A collection refers to a group of data items which have some commonality like a "a bunch of objects stored in a structured manner". Collections are very common in daily life, some examples would be a collection of science fiction books, the names of employees in a given department etc. Given that object oriented design concepts try to model the real world, it is natural to include support for creating and manipulating collections in languages which support object oriented development. Collections allows you to organize data in memory in various convenient ways.
Example : a simple list of strings, a mapping or association of strings to strings (e.g. country names to the names of their capitals);

Almost all major programming and scripting languages that are used today such as [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]], [http://en.wikipedia.org/wiki/JavaScript JavaScript], [http://en.wikipedia.org/wiki/PHP PHP], [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby], [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] have support for collections in some form or the other. Some languages have liner arrays (which can have different types of elements) and associative arrays built into the language whereas some other languages provide support through external libraries.

==History==
The history of collection frameworks can be analyzed in two aspects. Languages which have some basic collection containers built into them and languages with a formal collection framework. A collection framework may be defined as a generic reusable collection of classes which implements data structures and algorithms to create and manipulate groups of related objects. Few languages support a formal collections framework. Most of the modern programming languages have sequential arrays and associative array's built into them. A programmer may use these basic containers to create their own custom collection classes. A comparison of programming languages that implement associative arrays can be found [http://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28mapping%29 here].

The history of a collections framework or a collections library originate from ideas related to [http://en.wikipedia.org/wiki/Generic_programming generic programming] developed by Alexander Stepanov in the early 80s. At that time Ada was the only language which had support for generics. An initial generic library for list processing in Ada was developed by Alexander Stepanov and David Musser. However Ada did not achieve widespread acceptance by the programming community. As C/C++ became more widespread attention was given to developing a generic library in C++. Finally a proposal was made to the ANSI/ISO committee in 1993 and the C++ STL was finally accepted in 1994.

In the case of Java the initial versions prior to JDK-1.2 did not have a collections framework. These versions just defined Vectors and HashTables which were used to group objects together. This is reminiscent of the way things are done in languages such as Ruby, Python etc. The formal collections framework was introduced in 1998 with JDK-1.2 which borrowed a lot form Doug Lea's ''Collections package''. The goal of this framework was to be consistent with C++ STL. But soon Sun Microsystems decided that Java needed a compact collections framework and consistency with C++ STL was no longer a priority. This led to the development of the Java Collections Framework as we know it today.

=='''Java Collections Framework (JCF)'''==

[[Image:Jcf.gif]]

Java Collections Framework is a library of classes that implement collections. The collections framework also provides utility methods to perform functions such as sorting a list of data.The collections in Java are mainly the following: List, Set, Map and Queue. Java provides these collections as interfaces from which one can write their own classes or can use the inbuilt Java classes that implement these interfaces.

===List===
List is a collection of objects that has a fixed order (when we add an object to the list, it will stay in the place we put it), and allows objects to be referred to by position.Duplicate elements are allowed in a list. The general-purpose List implementations are [http://download.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html ArrayList] and [http://download.oracle.com/javase/1.4.2/docs/api/java/util/LinkedList.html LinkedList].

===Set===
A Set is a Collection that cannot contain duplicate elements. It models the mathematical set abstraction.The Java platform contains three general-purpose Set implementations: [http://download.oracle.com/javase/6/docs/api/java/util/HashSet.html HashSet], [http://download.oracle.com/javase/6/docs/api/java/util/TreeSet.html TreeSet], and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashSet.html LinkedHashSet].

===Map===
A Map is an object that maps keys to values. A map cannot contain duplicate keys: Each key can map to at most one value. Maps are defined by the java.util.Map interface in Java. The three general-purpose Map implementations are [http://download.oracle.com/javase/1.4.2/docs/api/java/util/HashMap.html HashMap], [http://download.oracle.com/javase/6/docs/api/java/util/TreeMap.html TreeMap] and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashMap.html LinkedHashMap]. The java.util.Map interface is extended by its subinterface, java.util.SortedMap. This interface defines a map that's sorted by the keys provided.

===Queue===
A Queue is a collection for holding elements prior to processing. Besides basic Collection operations, queues provide additional insertion, removal, and inspection operations. LinkedList implements the Queue interface, providing first in, first out (FIFO) queue operations.

=='''C++ Standard Template Library(STL)'''==
C++ standard template library is a software library that provides implementations of some basic containers for storing collections of related objects as well as algorithms to perform operations on the elements in these containers. All the classes in C++ STL are generic and can be used with any user defined or primitive data types. In general the C++ STL has four major components.

===Containers===
These are classes which are used to store other objects. Taking an example suppose there is a “jar of jellybeans”, the jar can be thought of as the container while the jelly beans are the objects that are stored in the container. Most collections automatically resize depending on the number of elements in them.The C++ STL provides a number of such classes which can be classified into two categories

====Sequence Containers====
These containers impose a strict linear order on the elements. Sequence containers support insertions and deletions (either at the ends or at a random position) using an index. Some examples of sequence containers are vector, list, dequeue etc.
====Associative containers====
These containers store key value pairs and each object stored in an associative container is mapped to a specific key. In other words associative containers perform insertions and deletions based on a key. Some examples of associative containers are set, map, hash map, multiset etc.

===Algorithms===
The C++ STL contains a large collection of algorithms that can be used to manipulate the data contained in the container. Continuing from the earlier “jar of jelly beans” example, suppose you wanted to count the number of red colored jelly beans. Or you wanted to change the color of all the jelly beans to red the algorithms in STL allow you to accomplish this.

An important thing to note is that the algorithms in STL are decoupled from the container. This means that there is only one definition of the function which implements the algorithm. This works for any valid container containing any any valid set of objects. Analogous to our example the function to count the number of red jelly beans also works for a “bucket containing colored pebbles”.

The algorithms contained in STL can be classified into two categories
====Non-Mutating====
Those which do not change the collection in any way. Examples include count, find, for each etc.
====Mutating====
Those which modify the contents of the collection in some way. Examples include replace, copy, reverse etc.
===Iterators===
Iterators are an important part of the C++ STL. Iterators facilitate traversal through a container’s elements. The separation of algorithms from containers is achieved through the use of iterators. Iterators can be thought of as a generalization of pointers. All the algorithms make use of iterators as function arguments. There are 5 types of iterators in STL. These differ in the way they traverse through the elements in the container.

===Functor===
A functor or functional object is an object that can be called as a function. This is in essence similar to function pointers in C. A functor is any class that overloads the operator() function. Such a class is most commonly used to define custom comparison functions to compare two objects. This is similar to “comparator” in JAVA.

=='''JCF versus STL'''==
===Quality of implementation===
Java is standardised and have formalized methods such as Java community process(JCP) and Java Specification request (JSR) to define revisions of java platforms. C++ only gives a defining standard and one can have different implementations of that standard. Hence different implementations can be incompatible.

===Portability===
This is a direct consequence of the fact that standards are available in Java and not in C++.
The following is a list of various [http://en.wikipedia.org/wiki/List_of_C%2B%2B_template_libraries STL libraries ]. These may have some common templates which might not necessarily be interoperable. In contrast the implementations of JCF are standardized and they will be portable as long as versions remain the same.

===Better optimization of containers===
In C++ STL the algorithms (i.e functions which manipulate the data) are completely decoupled from the containers it is not possible to optimize containers for specific purposes. In JCF since the algorithms are defined as interfaces it is easy to provide specific implementations based on requirements. Because the various implementations of each interface are interchangeable, programs can be easily tuned by switching implementations. The only way to optimize in STL is to create new containers which are tied together with the algorithms.

===More number of methods in STL===
STL has more number of methods than Java for collections. This is because STL has [http://www.sgi.com/tech/stl/table_of_contents.html separate methods] for containers and algorithms used for containers like Non-mutating algorithms, Mutating algorithms, Sorting

===Collections in Java are more extensible than in STL===
STL collections are difficult to extend as the base classes are not declared as virtual. In Java since the basic collections are interfaces, it is easy to implement the interfaces in a class, and extend from that.

===Manipulation of container objects using Iterators ===
C++ STL uses iterators to iterate through the items. Iterators themselves are generalizations of pointers. This leads to problems when one has to manipulate the items in the container, especially if the items have to be removed. It is tricky to iterate through the container and delete objects within the same loop. This is not the casein java since memory cannot be directly manipulated by the programmer.

===Pass by reference Vs Pass by value===
Containers in STL is accessed using copy semantics, thereby providing both efficiency and type safety, while in Java collections are accessed via references (or pointers). In Java if an one tries to access an object of a container that was just deleted , since we are using a reference this would result in error.

=='''Collections in languages versus library'''==
We are comparing collections inbuilt into the Ruby language versus Java’s collection libraries.

===Operators vs Methods===
In languages with collections built into them many operations may be performed using operators instead of calling functions. Consider an associative array, called hash in ruby and map in java.

<pre>
Assoc_array[
{“hello”, “world”}
{“good”,”day”}
]
</pre>

In a language with collections implemented as a class library one would use a function like “get(key)” to retrieve the value associated with a key. When there is language support one can use Assoc_array[key] to retrieve the value of the key.Now suppose we would like to extend the get function to do something different, in a language like java we can simply write another function or create a different implementation of the associative array which overrides the get function defined in the interface. Now in case of a language where the get is implemented using an operator we should either overload the default behavior of the operator or we have to define a custom operator to do this. In general it is much easier to overload a function than to overload an operator, Further not all languages allow operator overloading.

===Import===
In Ruby since collections are part of the language , therefore a developer need not include library for common functionalities while writing a program. In case of collections which are present in libraries like Java, one needs to import the libraries before executing the code. This can become a hassle for a Java developer if one does not know the name of the library to import for using a collection.

===Operator Overloading===
In Java we do not have operator overloading, but instead use methods to do the equivalent operations. Ruby has overloading where one can override , say a + operator.
By not having operator overloading Java can have clearer code.This is because when one uses a + overloaded operator, we can get an unexpected behavior if internally it is coded to something else, say a subtraction. The number of operators that you can overload is very small and most of them is relevant to scalar operations. Additionally, the detail of the operation performed by operators may not be as meaningful in comparison to a good method name.

<pre>
class Test
def initialize x
@x = x
end

def +(y)
@x - y
end
end
a = Test.new 5
puts(a + 3)

</pre>

In above example instead of getting a result of 8 due to the + operator being overloaded in a wrong way we instead get a result of 2

===Performance===
Collections in Ruby is slower than in Java as Ruby is a dynamically typed language. , therefore
in Ruby type checking happens at run-time which would slow down collection performance.

===Verbosity===
In Ruby since one uses operator for hash-tables, the code is less verbose and therefore easier to type:
<pre>
h[lastname] = firstname
</pre>
In Java one has to type a method name which increases the verbosity:
<pre>
hashmap.put(lastname)= firstname
</pre>

===Readability===
In Java when one has nested methods on collections, the code is easier to read than in Ruby when one has nested operators on collections within a single line. The Java code is easier to debug also as one can look at the values of the variables assigned on the nested methods.

== References ==
[1] http://download.oracle.com/javase/tutorial/collections/intro/index.html

[2]http://www.javamex.com/tutorials/collections/index.shtml

[3]http://en.wikipedia.org/wiki/Java_collections_framework

[4]http://www.sgi.com/tech/stl/index.html

[5]http://en.wikipedia.org/wiki/Standard_Template_Library

[6]http://download.oracle.com/javase/6/docs/technotes/guides/collections/overview.html

[7]http://java.dzone.com/articles/why-java-doesnt-need-operator

[8]http://www.ruby-doc.org/core/

CSC/ECE 517 Fall 2011/ch1 1b ds

2011-09-08T16:14:46Z

Ddilipd: /* Readability */

Cover the history of Collections frameworks back to the late 1970s or early 1980s, and how they were retrofitted to various languages. Discuss the advantage of a standard Collections framework (e.g., Java) vs. several competing frameworks (e.g., C++), and the advantage of collections built into the language (e.g., Ruby) vs. collections as class libraries. Give examples to illustrate the advantages you identify.

'''Authors'''
* Dilip Devaraj
* Srinath Sridhar

__TOC__

==Introduction==
A collection refers to a group of data items which have some commonality like a "a bunch of objects stored in a structured manner". Collections are very common in daily life, some examples would be a collection of science fiction books, the names of employees in a given department etc. Given that object oriented design concepts try to model the real world, it is natural to include support for creating and manipulating collections in languages which support object oriented development. Collections allows you to organize data in memory in various convenient ways.
Example : a simple list of strings, a mapping or association of strings to strings (e.g. country names to the names of their capitals);

Almost all major programming and scripting languages that are used today such as [http://en.wikipedia.org/wiki/Perl Perl], [http://en.wikipedia.org/wiki/Python_%28programming_language%29 Python]], [http://en.wikipedia.org/wiki/JavaScript JavaScript], [http://en.wikipedia.org/wiki/PHP PHP], [http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 Ruby], [http://en.wikipedia.org/wiki/C%2B%2B C++] and [http://en.wikipedia.org/wiki/Java_%28programming_language%29 Java] have support for collections in some form or the other. Some languages have liner arrays (which can have different types of elements) and associative arrays built into the language whereas some other languages provide support through external libraries.

==History==
The history of collection frameworks can be analyzed in two aspects. Languages which have some basic collection containers built into them and languages with a formal collection framework. A collection framework may be defined as a generic reusable collection of classes which implements data structures and algorithms to create and manipulate groups of related objects. Few languages support a formal collections framework. Most of the modern programming languages have sequential arrays and associative array's built into them. A programmer may use these basic containers to create their own custom collection classes. A comparison of programming languages that implement associative arrays can be found [http://en.wikipedia.org/wiki/Comparison_of_programming_languages_%28mapping%29 here].

The history of a collections framework or a collections library originate from ideas related to [http://en.wikipedia.org/wiki/Generic_programming generic programming].

=='''Java Collections Framework (JCF)'''==

[[Image:Jcf.gif]]

Java Collections Framework is a library of classes that implement collections. The collections framework also provides utility methods to perform functions such as sorting a list of data.The collections in Java are mainly the following List, Set, Map and Queue. Java provides these collections as interfaces from which one can write their own classes or can use the inbuilt Java classes that implement these interfaces.

===List===
List is a collection of objects that has a fixed order (when we add an object to the list, it will stay in the place we put it), and allows objects to be referred to by position.Duplicate elements are allowed in a list. The general-purpose List implementations are [http://download.oracle.com/javase/1.5.0/docs/api/java/util/ArrayList.html ArrayList] and [http://download.oracle.com/javase/1.4.2/docs/api/java/util/LinkedList.html LinkedList].

===Set===
A Set is a Collection that cannot contain duplicate elements. It models the mathematical set abstraction.The Java platform contains three general-purpose Set implementations: [http://download.oracle.com/javase/6/docs/api/java/util/HashSet.html HashSet], [http://download.oracle.com/javase/6/docs/api/java/util/TreeSet.html TreeSet], and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashSet.html LinkedHashSet].

===Map===
A Map is an object that maps keys to values. A map cannot contain duplicate keys: Each key can map to at most one value. Maps are defined by the java.util.Map interface in Java. The three general-purpose Map implementations are [http://download.oracle.com/javase/1.4.2/docs/api/java/util/HashMap.html HashMap], [http://download.oracle.com/javase/6/docs/api/java/util/TreeMap.html TreeMap] and [http://download.oracle.com/javase/6/docs/api/java/util/LinkedHashMap.html LinkedHashMap]. The java.util.Map interface is extended by its subinterface, java.util.SortedMap. This interface defines a map that's sorted by the keys provided.

===Queue===
A Queue is a collection for holding elements prior to processing. Besides basic Collection operations, queues provide additional insertion, removal, and inspection operations. LinkedList implements the Queue interface, providing first in, first out (FIFO) queue operations.

=='''C++ Standard Template Library(STL)'''==
C++ standard template library is a software library that provides implementations of some basic containers for storing collections of related objects as well as algorithms to perform operations on the elements in these containers. All the classes in C++ STL are generic and can be used with any user defined or primitive data types. In general the C++ STL has four major components.

===Containers===
These are classes which are used to store other objects. Taking an example suppose there is a “jar of jellybeans”, the jar can be thought of as the container while the jelly beans are the objects that are stored in the container. Most collections automatically resize depending on the number of elements in them.The C++ STL provides a number of such classes which can be classified into two categories

====Sequence Containers====
These containers impose a strict linear order on the elements. Sequence containers support insertions and deletions (either at the ends or at a random position) using an index. Some examples of sequence containers are vector, list, dequeue etc.
====Associative containers====
These containers store key value pairs and each object stored in an associative container is mapped to a specific key. In other words associative containers perform insertions and deletions based on a key. Some examples of associative containers are set, map, hash map, multiset etc.

===Algorithms===
The C++ STL contains a large collection of algorithms that can be used to manipulate the data contained in the container. Continuing from the earlier “jar of jelly beans” example, suppose you wanted to count the number of red colored jelly beans. Or you wanted to change the color of all the jelly beans to red the algorithms in STL allow you to accomplish this.

An important thing to note is that the algorithms in STL are decoupled from the container. This means that there is only one definition of the function which implements the algorithm. This works for any valid container containing any any valid set of objects. Analogous to our example the function to count the number of red jelly beans also works for a “bucket containing colored pebbles”.

The algorithms contained in STL can be classified into two categories
====Non-Mutating====
Those which do not change the collection in any way. Examples include count, find, for each etc.
====Mutating====
Those which modify the contents of the collection in some way. Examples include replace, copy, reverse etc.
===Iterators===
Iterators are an important part of the C++ STL. Iterators facilitate traversal through a container’s elements. The separation of algorithms from containers is achieved through the use of iterators. Iterators can be thought of as a generalization of pointers. All the algorithms make use of iterators as function arguments. There are 5 types of iterators in STL. These differ in the way they traverse through the elements in the container.

===Functor===
A functor or functional object is an object that can be called as a function. This is in essence similar to function pointers in C. A functor is any class that overloads the operator() function. Such a class is most commonly used to define custom comparison functions to compare two objects. This is similar to “comparator” in JAVA.

=='''JCF versus STL'''==
===Quality of implementation===
Java is standardised and have formalized methods such as Java community process(JCP) and Java Specification request (JSR) to define revisions of java platforms. C++ only gives a defining standard and one can have different implementations of that standard. Hence different implementations can be incompatible.

===Portability===
This is a direct consequence of the fact that standards are available in Java and not in C++.
The following is a list of various [http://en.wikipedia.org/wiki/List_of_C%2B%2B_template_libraries STL libraries ]. These may have some common templates which might not necessarily be interoperable. In contrast the implementations of JCF are standardized and they will be portable as long as versions remain the same.

===Better optimization of containers===
In C++ STL the algorithms (i.e functions which manipulate the data) are completely decoupled from the containers it is not possible to optimize containers for specific purposes. In JCF since the algorithms are defined as interfaces it is easy to provide specific implementations based on requirements. Because the various implementations of each interface are interchangeable, programs can be easily tuned by switching implementations. The only way to optimize in STL is to create new containers which are tied together with the algorithms.

===More number of methods in STL===
STL has more number of methods than Java for collections. This is because STL has [http://www.sgi.com/tech/stl/table_of_contents.html separate methods] for containers and algorithms used for containers like Non-mutating algorithms, Mutating algorithms, Sorting

===Collections in Java are more extensible than in STL===
STL collections are difficult to extend as the base classes are not declared as virtual. In Java since the basic collections are interfaces, it is easy to implement the interfaces in a class, and extend from that.

===Manipulation of container objects using Iterators ===
C++ STL uses iterators to iterate through the items. Iterators themselves are generalizations of pointers. This leads to problems when one has to manipulate the items in the container, especially if the items have to be removed. It is tricky to iterate through the container and delete objects within the same loop. This is not the casein java since memory cannot be directly manipulated by the programmer.

===Pass by reference Vs Pass by value===
Containers in STL is accessed using copy semantics, thereby providing both efficiency and type safety, while in Java collections are accessed via references (or pointers). In Java if an one tries to access an object of a container that was just deleted , since we are using a reference this would result in error.

=='''Collections in languages versus library'''==
We are comparing collections inbuilt into the Ruby language versus Java’s collection libraries.

===Operators vs Methods===
In languages with collections built into them many operations may be performed using operators instead of calling functions. Consider an associative array, called hash in ruby and map in java.

<pre>
Assoc_array[
{“hello”, “world”}
{“good”,”day”}
]
</pre>

In a language with collections implemented as a class library one would use a function like “get(key)” to retrieve the value associated with a key. When there is language support one can use Assoc_array[key] to retrieve the value of the key.Now suppose we would like to extend the get function to do something different, in a language like java we can simply write another function or create a different implementation of the associative array which overrides the get function defined in the interface. Now in case of a language where the get is implemented using an operator we should either overload the default behavior of the operator or we have to define a custom operator to do this. In general it is much easier to overload a function than to overload an operator, Further not all languages allow operator overloading.

===Import===
In Ruby since collections are part of the language , therefore a developer need not include library for common functionalities while writing a program. In case of collections which are present in libraries like Java, one needs to import the libraries before executing the code. This can become a hassle for a Java developer if one does not know the name of the library to import for using a collection.

===Operator Overloading===
In Java we do not have operator overloading, but instead use methods to do the equivalent operations. Ruby has overloading where one can override , say a + operator.
By not having operator overloading Java can have clearer code.This is because when one uses a + overloaded operator, we can get an unexpected behavior if internally it is coded to something else, say a subtraction. The number of operators that you can overload is very small and most of them is relevant to scalar operations. Additionally, the detail of the operation performed by operators may not be as meaningful in comparison to a good method name.

<pre>
class Test
def initialize x
@x = x
end

def +(y)
@x - y
end
end
a = Test.new 5
puts(a + 3)

</pre>

In above example instead of getting a result of 8 due to the + operator being overloaded in a wrong way we instead get a result of 2

===Performance===
Collections in Ruby is slower than in Java as Ruby is a dynamically typed language. , therefore
in Ruby type checking happens at run-time which would slow down collection performance.

===Verbosity===
In Ruby since one uses operator for hash-tables, the code is less verbose and therefore easier to type:
<pre>
h[lastname] = firstname
</pre>
In Java one has to type a method name which increases the verbosity:
<pre>
hashmap.put(lastname)= firstname
</pre>

===Readability===
In Java when one has nested methods on collections, the code is easier to read than in Ruby when one has nested operators on collections within a single line. The Java code is easier to debug also as one can look at the values of the variables assigned on the nested methods.

== References ==
[1] http://download.oracle.com/javase/tutorial/collections/intro/index.html

[2]http://www.javamex.com/tutorials/collections/index.shtml

[3]http://en.wikipedia.org/wiki/Java_collections_framework

[4]http://www.sgi.com/tech/stl/index.html

[5]http://en.wikipedia.org/wiki/Standard_Template_Library

[6]http://download.oracle.com/javase/6/docs/technotes/guides/collections/overview.html

[7]http://java.dzone.com/articles/why-java-doesnt-need-operator

[8]http://www.ruby-doc.org/core/