Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2012/ch2b 2w47 am

2012-11-20T03:43:22Z

Mrkamat: /* Directory of sites */

='''Adapter Pattern, a directory of sites'''=

This wiki page provides a directory of sites for Adapter Design Pattern that will help readers to know what each website contains, why should readers refer one website over another and a list of examples that readers can look up to understand the Adapter Pattern.

__TOC__

= Introduction =

Sometimes, objects just don't fit together as they should. A class may have changed, or an object turns out to be just too difficult to work with. At such times, adapter design pattern comes to the rescue. Adapter pattern lets you adapt what an object or class has to offer so that another object or class can make use of it. It also helps when classes can't work together because of incompatible interfaces.

Since we are huge fans of visual approach, lets understand the adapter pattern with the help of a diagram. Hold on! Before going in to the UML diagram ( which is kind of less attractive, right? May be .. ) lets look at the figure below which is more appealing. 

[[File:AdapterPatternForWiki.jpg|thumb|500px|center|A real world example for the Adapter Pattern.]]

 The above example helps readers quickly get across the intent of the pattern than the UML diagram shown below. Looking at the UML diagram now, can help the readers to learn about the precise relationships between the classes in adapter pattern and it makes a lot more sense! 

[[File:AdapterPatternUMLForWiki.jpg|thumb|500px|center|UML diagram for the Adapter Pattern.]]

 

So, this is all what we had to talk about Adapter Pattern. Lets look at other websites and see what they say about Adapter pattern, (probably, the main purpose of the wiki page).
 
 

= Directory of sites =

=== [http://en.wikipedia.org/wiki/Adapter_pattern Adapter Pattern on wikipedia] ===
 Topics Covered: Lists various structures of Adapter Pattern viz., Object Adapter Pattern, Class Adapter Pattern, Runtime Adapter pattern and implementation of Adapter pattern. It provides a few examples for the above structures.

Summary: In computer programming, the adapter pattern (often referred to as the wrapper pattern or simply a wrapper) is a design pattern that translates one interface for a class into a compatible interface. The adapter is also responsible for transforming data into appropriate forms. For instance, if multiple boolean values are stored as a single integer (i.e. flags) but your client requires a 'true'/'false', the adapter would be responsible for extracting the appropriate values from the integer value. Another example is transforming the format of dates (e.g. YYYYMMDD to MM/DD/YYYY or DD/MM/YYYY). The various Adapter pattern structures are as follows
* Object Adapter pattern: 
In this type of adapter pattern, the adapter contains an instance of the class it wraps. In this situation, the adapter makes calls to the instance of the wrapped object. 
* Class Adapter pattern: 
This type of adapter uses multiple polymorphic interfaces to achieve its goal. The adapter is created by implementing or inheriting both the interface that is expected and the interface that is pre-existing. 
* A further form of runtime Adapter pattern: 
This section provides a good example for runtime Adapter pattern. 
* Implementation: 
Provides a basic skeleton of how to implement the adapter pattern.
 
Pros: This wikipedia page works if readers want a quick review of the adapter pattern. Also it provides good references to read more about the Adapter pattern. 
Cons: It doesn't helps to understand the Adapter pattern in depth. The examples provided are not easy to comprehend ( unless you are an experienced developer and not a beginner! ). Its not a good page to refer for the beginners.
 
 

=== [http://msdn.microsoft.com/en-us/library/orm-9780596527730-01-04.aspx Adpater Pattern on MSDN Microsoft Website] ===
 Topics Covered: Role of adapter pattern, Illustrations or examples where adapter pattern is used ,Design and Implementation of adapter pattern, few more kinds of adapters.

Summary: Adapter pattern is a versatile pattern that joins together types that were not designed to work with each other. It is one of those patterns that comes in useful when dealing with legacy code-i.e., code that was written a while ago and to which one might not have access.
* Role: 
The Adapter pattern enables a system to use classes whose interfaces don't quite match its requirements. It is especially useful for off-the-shelf code, for toolkits, and for libraries 
* Illustration: 
Adapter pattern illustration-migration of Mac OS X from a 1998 PowerPC-based iMac to a 2007 Intel-based iMac. This section shows how the adapter pattern has been used to enable Mac OS migration. 
* Design: 
The Adapter pattern's important contribution is that it promotes programming to interfaces. The Client works to a domain-specific standard, which is specified in the ITarget interface. An Adaptee class provides the required functionality, but with a different interface. The Adapter implements the ITarget interface and routes calls from the Client through to the Adaptee, making whatever changes to parameters and return types are necessary to meet the requirements. A Target class that implements the ITarget interface directly could exist, but this is not a necessary part of the pattern. In any case, the Client is aware only of the ITarget interface, and it relies on that for its correct operation. 
* Implementation: 
This section provides an example in C# and how the Adapter, Adaptee, Target and Client all communicate with each other.
* Two way adapters and Pluggable adapters: 
These sections describes the other kinds of adapter with appropriate examples.
 
Pros: This page gives an in-depth explanation of the adapter pattern. It shows how the adapter pattern is implemented in C#. The real world examples makes it easy to grasp the topic. 
Cons: The page might be too long for a quick review. Though it is really good for a beginner, an Intermediate or an expert person in design pattern may not actually want to wade through the entire concept in such a depth. ( unless the person doesn't have much work to do..."eyebrows raised" ).
 
 

=== [http://www.oodesign.com/adapter-pattern.html Adpater Pattern on OODesign.com] ===
 Topics Covered: Motivation for using Adapter pattern, intent behind using the adapter pattern, a UML diagram to explain the adapter pattern ( like we did above, yeah! ) to start with. It also covers the application and implementation of Adapter patterns. Moreover, it provides some really nice examples and specific problems where adapter pattern becomes a good fit to use.

 Summary: The adapter pattern is adapting between classes and objects. Like any adapter in the real world it is used to be an interface, a bridge between two objects. In real world we have adapters for power supplies, adapters for camera memory cards, and so on. 
What about software development? It's the same. Can you imagine an situation when you have some class expecting some type of object and you have an object offering the same features, but exposing a different interface? Of course, you want to use both of them so you don't to implement again one of them, and you don't want to change existing classes, so why not create an adapter...
 
* Intent 
# Convert the interface of a class into another interface clients expect
# Adapter lets classes work together, that could not otherwise because of incompatible interfaces

* Implementation Explains the implementation of the Adapter pattern with the help of a UML diagram.

* Applicability and Examples Adapters are encountered everywhere. From real world adapters to software adapters.
# Non Software Examples of Adapter Patterns: Power Supply Adapters, card readers and adapters, ...
# Software Examples of Adapter Patterns: Wrappers used to adopt 3rd parties libraries and frameworks - most of the applications using third party libraries use adapters as a middle layer between the application and the 3rd party library to decouple the application from the library. If another library has to be used only an adapter for the new library is required without having to change the application code.

* Specific problem and Implementation 
# Objects Adapters - Based on Delegation It uses composition, the Adaptee delegates the calls to Adaptee (opossed to class adapters which extends the Adaptee).
# Class Adapters - Based on (Multiple) Inheritance Class adapters can be implemented in languages supporting multiple inheritance(Java, C# or PHP does not support multiple inheritance). Thus, such adapters can not be easy implemented in Java, C# or VB.NET. Class adapter uses inheritance instead of composition.
# Adapter Pattern and Strategy Pattern Cases when Adapter Pattern can be a better option instead of Strategy pattern ( ok, now that sounds something interesting, doesn't it?)
 
Pros: Helps to learn Adapter pattern in detail. Provides good examples to understand how the pattern works and also give suitable cases where adapter design pattern is most applicable. Good for all readers ( beginners, intermediate and experts ) 
Cons: Doesn't provides enough figures to understand the concept. For readers who endorse figures, not a good page to look out for.
 
 

=== [http://www.codeproject.com/Articles/42915/Adapter-Design-Pattern Adpater Pattern on Codeproject.com] ===
 Topics Covered: Background, Introduction to adapter pattern and its structure, class diagram and implementation of adapter pattern for a scenario.

Summary: This page uses a running example in the background to discuss the design pattern and then further provides a design pattern implementation for that particular example. Moreover, it explains the importance of Adapter Design in system integration when other components have to be adapted by the existing system.
* Background: 
The webpage continues using the running example to describe the earlier design patterns and further gives a scenario to introduce the adapter pattern. 
* Design and implementation 
It gives a class diagram describing the adapter pattern for the example in the background section. Also, this section covers the explanation and implementation of all the classes and interfaces mentioned in the below class diagram:
[[File:AdapterClassOnCodeProject.JPG|thumb|500px|center|A real world example for the Adapter Pattern.]]

 
Pros: This website is useful for intermediate users of design patterns. Some preexisting knowledge of adapter pattern prior to reading this page can help to further understand the topic. The example provided gives a clear view of the design pattern.
 
Cons: A beginner might find not find this page a good base line to start. The code on the page might be difficult for a novice programmer to understand.
 

Alternately, beginners can also refer the webpage on [http://www.codeproject.com/Articles/186003/Adapter-Design-Pattern Adapter Design Pattern] further provided by Codeproject.com 

=== [http://csc.columbusstate.edu/woolbright/java/adapter.html Adpater Pattern on Columbus State University website] ===
 Topics Covered: Introduction to Adapter pattern, Object-Oriented Adapters, an example which implements the Adapter pattern and real world adapters.

Summary: 
* Intrduction: The adapter pattern changes the look of an interface. It takes an interface and adapts it to one the client is expecting.
The Adapter Pattern converts the interface of a class into another interface the client expects.
Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.
 
* Object-Oriented Adapters: 
# Assume your existing system expects interface A.
# You need the system to work with a vendor class that has interface C.
# The solution is an adapter class with interface A for the existing system, and interface C for working with the Vendor class.
 
* The Duck Interface Example: The website provides a good example of the Adapter Design Pattern. The example is as follows: The code shown below provides the Duck Interface: 

public interface Duck {
public void quack();
public void fly();
}

:It is implemented by the MallardDuck class as shown below:

public class MallardDuck implements Duck {
public void quack() {
System.out.println("Quack");
}

public void fly() {
System.out.println("I'm flying");
}
}

:There is another interface called the Turkey Interface:

public interface Turkey { //Turkeys don't quack
public void gobble();
public void fly();
}

:The turkey interface is implemented by the wildTurkey class as shown below:

public class WildTurkey implements Turkey {
public void gobble() {
System.out.println("Gobble gobble");
}

public void fly() {
System.out.println("I'm flying a short distance");
}
}

:And finally comes our showstopper, the Turkey Adapter code as shown below:

public class TurkeyAdapter implements Duck {
Turkey turkey;

public TurkeyAdapter(Turkey turkey) {
this.turkey = turkey;
}

public void quack() {
turkey.gobble();
}

public void fly() {
for(int i=0; i < 5; i++) {
turkey.fly();
}
}
}

:The website also provides a good tester to test the Adapter code. Please refer to the link to see the test driving code. 
 
* Real world Adapters: Following are the examples of real world adapters:
# The old Java Enumeration class had a couple of methods:
## hasMoreElements()
## nextElement()
# The new Java Iterator class has three methods:
## hasNext()
## next()
## remove()

This section provides an EnumerationIterator adapter class that implements the Iterator. Please refer to the link to see the EnumerationIterator Adapter class.
 
 

Pros: 
# A very good example of Adapter Pattern using the Duck Interface, Turkey Interface and the TurkeyAdapter pattern. ( Gosh! Too much of a Turkey used, reminds of Thanksgiving! ).
# Also, the section on real world adapters compliments further understanding of Adapter pattern implementation. Good for Intermediate and Expert users of Design patterns 

Cons: 
# Does not contains enough content to understand Adapter pattern from scratch.
# Also, not suitable for beginners. Though the code provided is lucid and self explanatory, it is not complimented with explanatory texts and this may cause some problems for beginners to understand the code.
# One more thing to observe here is the font size! ( Not good for readers who are adapted to small or medium font size ).
 

=== [http://sourcemaking.com/design_patterns/adapter Adpater Pattern on Sourcemaking.com] ===

 Topics Covered: Intent of Adapter Pattern, Explanation of the pattern, structure of the pattern, example, rule of thumb for adapter pattern.

Summary: Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces. This webpage gives a basic idea of adapter pattern and gives examples of the pattern in various programming languages.

* Intent: 
The need and purpose of adapter pattern. 
* Problem and Discussion: 
An “off the shelf” component offers compelling functionality that you would like to reuse, but its “view of the world” is not compatible with the philosophy and architecture of the system currently being developed. This section tells the problems and how adapter pattern helps solve them. 
* Structure: 
Class diagrams showing the different structures of adapter pattern. 
* Example: 
The Adapter pattern allows otherwise incompatible classes to work together by converting the interface of one class into an interface expected by the clients. Socket wrenches provide an example of the Adapter. 
* Check list and Rule of thumb: 
These sections describe when and how adapter pattern is useful. It also describes the various things to keep in mind when working with adapter pattern. 
* Adapter Code examples: 
Links to examples of Adapter pattern implemented in various languages.
 
Pros: A good place to study the adapter pattern from scratch. The examples of code in different languages lets us compare the implementation across all these languages. The links contain easy to understand code making it simple for beginners.
 
Cons: Hmmm, now this webpage can be qualified as one of the better pages to learn about Adapter patterns. Since we couldn't find any shortcomings of this web page we leave it as an exercise for curious readers!
 

=== [http://www.blackwasp.co.uk/Adapter.aspx Adapter Pattern on blackwasp.com] ===
 Topics Covered: What is adapter pattern, implementing adapter pattern, example of adapter pattern.

Summary: This page explained the adapter pattern in brief and then gives good example for implementing the adapter pattern and testing the adapter. The adapter pattern is a Gang of Four design pattern. This is a structural pattern as it defines a manner for creating relationships between classes. The adapter design pattern is used to provide a link between two otherwise incompatible types by wrapping the "adaptee" with a class that supports the interface required by the client.
* What is adapter pattern: 
The adapter pattern is introduced with the example of personnel system and intranet system. It helps build up the example in the implementation part 
* Implementation: 
An implementation of the adapter with client, target, adaptee and adapter is shown.

[[File:AdapterForBlackWasp.png|thumb|350px|center|Adapter pattern implementation.]]
 
* Example and testing adapter: 
The example of intranet and personnel system discussed in the introduction is implemented in C# code. Also how to test the adapter is shown.
 
Pros: This page is useful for beginners. It introduces an example and shows how to implement it in code. This implementation helps further understand the theory partin practical use. 
Cons: It focuses more on example than on the theory behind adapter pattern.
 
 

= Further Readings =

[http://www.codeproject.com/Articles/342082/Understanding-and-Implementing-the-Adapter-Pattern Understanding and Implementing the Adapter Pattern]. 
[http://www.allapplabs.com/java_design_patterns/adapter_pattern.htm Adapter Pattern in Java]. 
[http://groovy.codehaus.org/Adapter+Pattern Flavors of Adapter Pattern]. 
[http://javapapers.com/design-patterns/adapter-pattern/ Implementing Adapter Pattern].

File:AdapterForBlackWasp.png

2012-11-20T03:36:24Z

Mrkamat: Reference: http://www.blackwasp.co.uk/Adapter.aspx

Reference:

http://www.blackwasp.co.uk/Adapter.aspx

CSC/ECE 517 Fall 2012

2012-11-18T10:00:12Z

Mrkamat:

*[[CSC/ECE_517_Fall_2012/Table_Of_Contents]]
*[[CSC/ECE 517 Fall 2012/ch1 n xx]]
*[[CSC/ECE 517 Fall 2012/ch1 1w1 rk]]
*[[CSC/ECE 517 Fall 2012/ch1 1w20 pp]]
*[[CSC/ECE 517 Fall 2012/ch1 1w5 su]]
*[[CSC/ECE 517 Fall 2012/ch1 1w6 pp]]
*[[CSC/ECE 517 Fall 2012/ch1 1w4 aj]]
*[[CSC/ECE 517 Fall 2012/ch1 1w7 am]]
*[[CSC/ECE 517 Fall 2012/ch1 1w8 aa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w9 av]]
*[[CSC/ECE 517 Fall 2012/ch1 1w10 pk]]
*[[CSC/ECE 517 Fall 2012/ch1 1w11 ap]]
*[[CSC/ECE 517 Fall 2012/ch1a 1w12 mv]]
*[[CSC/ECE 517 Fall 2012/ch1 1w14 gv]]
*[[CSC/ECE 517 Fall 2012/ch1 1w17 ir]]
*[[CSC/ECE 517 Fall 2012/ch1 1w18 as]]
*[[CSC/ECE 517 Fall 2012/ch1 1w22 an]]
*[[CSC/ECE 517 Fall 2012/ch1 1w21 aa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w21 wi]]
*[[CSC/ECE 517 Fall 2012/ch1 1w31 sa]]
*[[CSC/ECE 517 Fall 2012/ch1a 1w16 br]]
*[[CSC/ECE 517 Fall 2012/ch1a 1w23 as]]
*[[CSC/ECE 517 Fall 2012/ch1 1w24 nr]]
*[[CSC/ECE 517 Fall 2012/ch1 1w15 rt]]
*[[CSC/ECE 517 Fall 2012/ch1 1w3 pl]]
*[[CSC/ECE 517 Fall 2012/ch1 1w32 cm]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w5 dp]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w37 ss]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w67 ks]]

*[[CSC/ECE 517 Fall 2012/ch1 1w27 ms]]
*[[CSC/ECE 517 Fall 2012/ch1 1w29 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w33 op]]
*[[CSC/ECE 517 Fall 2012/ch1 1w19 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w34 vd]]
*[[CSC/ECE 517 Fall 2012/ch1 1w35 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w30 rp]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w58 am]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w47 sk]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w69 mv]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w44 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w45 is]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w53 kc]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w40 ar]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w39 sn]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w54 go]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w56 ms]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w64 nn]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w66 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w40 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w42 js]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w46 sm]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w71 gs]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w63 dv]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w55 ms]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w57 mp]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w52 an]]
*[[CSC/ECE_517_Fall_2012/ch1b 1w38 nm]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w60 ac]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w62 rb]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w29 st]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w3_sm]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w30 an]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w17 pt]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w31 up]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w9 ms]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w19 is]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w26 aj]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w5 dp]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w16 dp]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w8 vp]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w18 as]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w3 jm]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w23 sr]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w11_aa]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w15 rr]]
*[[CSC/ECE 517 Fall 2012/ch2a 2w33 pv]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w20_aa]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w14_bb]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w21_ap]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w13_sm]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w4_sa]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w25_nr]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w12_sv]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w7_ma]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w6_ar]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w32_mk]]
*[[CSC/ECE_517_Fall_2012/ch2a_2w10_rc]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w70_sm]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w67_sk]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w40_sn]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w22_sk]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w-1w65_am]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w59_bc]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w60_ns]]
*[[CSC/ECE 517 Fall 2012/ch2b 2w47 am]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w69_as]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w39_ka]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w36_av]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w37_ms]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w43_iv]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w53_iv]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w63_sp]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w49_ps]]
*[[CSC/ECE 517 Fall 2012/ch2b_2w52_sj]]

CSC/ECE 517 Fall 2012/ch2b 2w47 am

2012-11-18T09:48:48Z

Mrkamat: /* Adpater Pattern on Codeproject.com */

='''Adapter Pattern, a directory of sites'''=

This wiki page provides a directory of sites for Adapter Design Pattern that will help readers to know what each website contains, why should readers refer one website over another and a list of examples that readers can look up to understand the Adapter Pattern.

__TOC__

= Introduction =

Sometimes, objects just don't fit together as they should. A class may have changed, or an object turns out to be just too difficult to work with. At such times, adapter design pattern comes to the rescue. Adapter pattern lets you adapt what an object or class has to offer so that another object or class can make use of it. It also helps when classes can't work together because of incompatible interfaces.

Since we are huge fans of visual approach, lets understand the adapter pattern with the help of a diagram. Hold on! Before going in to the UML diagram ( which is kind of less attractive, right? May be .. ) lets look at the figure below which is more appealing. 

[[File:AdapterPatternForWiki.jpg|thumb|500px|center|A real world example for the Adapter Pattern.]]

 The above example helps readers quickly get across the intent of the pattern than the UML diagram shown below. Looking at the UML diagram now, can help the readers to learn about the precise relationships between the classes in adapter pattern and it makes a lot more sense! 

[[File:AdapterPatternUMLForWiki.jpg|thumb|500px|center|UML diagram for the Adapter Pattern.]]

 

So, this is all what we had to talk about Adapter Pattern. Lets look at other websites and see what they say about Adapter pattern, (which is probably, the main purpose of the wiki page).
 
 

= Directory of sites =

=== [http://en.wikipedia.org/wiki/Adapter_pattern Adapter Pattern on wikipedia] ===
 Topics Covered: Lists various structures of Adapter Pattern viz., Object Adapter Pattern, Class Adapter Pattern, Runtime Adapter pattern and implementation of Adapter pattern. It provides a few examples for the above structures.

Summary: In computer programming, the adapter pattern (often referred to as the wrapper pattern or simply a wrapper) is a design pattern that translates one interface for a class into a compatible interface. The adapter is also responsible for transforming data into appropriate forms. For instance, if multiple boolean values are stored as a single integer (i.e. flags) but your client requires a 'true'/'false', the adapter would be responsible for extracting the appropriate values from the integer value. Another example is transforming the format of dates (e.g. YYYYMMDD to MM/DD/YYYY or DD/MM/YYYY). The various Adapter pattern structures are as follows
* Object Adapter pattern: 
In this type of adapter pattern, the adapter contains an instance of the class it wraps. In this situation, the adapter makes calls to the instance of the wrapped object. 
* Class Adapter pattern: 
This type of adapter uses multiple polymorphic interfaces to achieve its goal. The adapter is created by implementing or inheriting both the interface that is expected and the interface that is pre-existing. 
* A further form of runtime Adapter pattern: 
This section provides a good example for runtime Adapter pattern. 
* Implementation: 
Provides a basic skeleton of how to implement the adapter pattern.
 
Pros: This wikipedia page works if readers want a quick review of the adapter pattern. Also it provides good references to read more about the Adapter pattern. 
Cons: It doesn't helps to understand the Adapter pattern in depth. The examples provided are not easy to comprehend ( unless you are an experienced developer and not a beginner! ). Its not a good page to refer for the beginners.
 
 

=== [http://msdn.microsoft.com/en-us/library/orm-9780596527730-01-04.aspx Adpater Pattern on MSDN Microsoft Website] ===
 Topics Covered: Role of adapter pattern, Illustrations or examples where adapter pattern is used ,Design and Implementation of adapter pattern, few more kinds of adapters.

Summary: Adapter pattern is a versatile pattern that joins together types that were not designed to work with each other. It is one of those patterns that comes in useful when dealing with legacy code-i.e., code that was written a while ago and to which one might not have access.
* Role: 
The Adapter pattern enables a system to use classes whose interfaces don't quite match its requirements. It is especially useful for off-the-shelf code, for toolkits, and for libraries 
* Illustration: 
Adapter pattern illustration-migration of Mac OS X from a 1998 PowerPC-based iMac to a 2007 Intel-based iMac. This section shows how the adapter pattern has been used to enable Mac OS migration. 
* Design: 
The Adapter pattern's important contribution is that it promotes programming to interfaces. The Client works to a domain-specific standard, which is specified in the ITarget interface. An Adaptee class provides the required functionality, but with a different interface. The Adapter implements the ITarget interface and routes calls from the Client through to the Adaptee, making whatever changes to parameters and return types are necessary to meet the requirements. A Target class that implements the ITarget interface directly could exist, but this is not a necessary part of the pattern. In any case, the Client is aware only of the ITarget interface, and it relies on that for its correct operation. 
* Implementation: 
This section provides an example in C# and how the Adapter, Adaptee, Target and Client all communicate with each other.
* Two way adapters and Pluggable adapters: 
These sections describes the other kinds of adapter with appropriate examples.
 
Pros: This page gives an in-depth explanation of the adapter pattern. It shows how the adapter pattern is implemented in C#. The real world examples makes it easy to grasp the topic. 
Cons: The page might be too long for a quick review. Though it is really good for a beginner, an Intermediate or an expert person in design pattern may not actually want to wade through the entire concept in such a depth. ( unless the person doesn't have much work to do, "eyebrows raised" ).
 
 

=== [http://www.oodesign.com/adapter-pattern.html Adpater Pattern on OODesign.com] ===
 Topics Covered: Motivation for using Adapter pattern, intent behind using the adapter pattern, a UML diagram to explain the adapter pattern ( like we did above, yeah! ) to start with. It also covers the application and implementation of Adapter patterns. Moreover, it provides some really nice examples and specific problems where adapter pattern becomes a good fit to use.

 Summary: The adapter pattern is adapting between classes and objects. Like any adapter in the real world it is used to be an interface, a bridge between two objects. In real world we have adapters for power supplies, adapters for camera memory cards, and so on. 
What about software development? It's the same. Can you imagine an situation when you have some class expecting some type of object and you have an object offering the same features, but exposing a different interface? Of course, you want to use both of them so you don't to implement again one of them, and you don't want to change existing classes, so why not create an adapter...
 
* Intent 
# Convert the interface of a class into another interface clients expect
# Adapter lets classes work together, that could not otherwise because of incompatible interfaces

* Implementation Explains the implementation of the Adapter pattern with the help of a UML diagram.

* Applicability and Examples Adapters are encountered everywhere. From real world adapters to software adapters.
# Non Software Examples of Adapter Patterns: Power Supply Adapters, card readers and adapters, ...
# Software Examples of Adapter Patterns: Wrappers used to adopt 3rd parties libraries and frameworks - most of the applications using third party libraries use adapters as a middle layer between the application and the 3rd party library to decouple the application from the library. If another library has to be used only an adapter for the new library is required without having to change the application code.

* Specific problem and Implementation 
# Objects Adapters - Based on Delegation It uses composition, the Adaptee delegates the calls to Adaptee (opossed to class adapters which extends the Adaptee).
# Class Adapters - Based on (Multiple) Inheritance Class adapters can be implemented in languages supporting multiple inheritance(Java, C# or PHP does not support multiple inheritance). Thus, such adapters can not be easy implemented in Java, C# or VB.NET. Class adapter uses inheritance instead of composition.
# Adapter Pattern and Strategy Pattern Cases when Adapter Pattern can be a better option instead of Strategy pattern ( ok, now that sounds something interesting, doesn't it?)
 
Pros: Helps to learn Adapter pattern in detail. Provides good examples to understand how the pattern works and also give suitable cases where adapter design pattern is most applicable. Good for all readers ( beginners, intermediate and experts ) 
Cons: Doesn't provides enough figures to understand the concept. For readers who endorse figures, not a good page to look out for.
 
 

=== [http://www.codeproject.com/Articles/42915/Adapter-Design-Pattern Adpater Pattern on Codeproject.com] ===
 Topics Covered: Background, Introduction to adapter pattern and its structure, class diagram and implementation of adapter pattern for a scenario.

Summary: This page uses a running example in the background to discuss the design pattern and then further provides a design pattern implementation for that particular example. Moreover, it explains the importance of Adapter Design in system integration when other components have to be adapted by the existing system.
* Background: 
The webpage continues using the running example to describe the earlier design patterns and further gives a scenario to introduce the adapter pattern. 
* Design and implementation 
It gives a class diagram describing the adapter pattern for the example in the background section. Also, this section covers the explanation and implementation of all the classes and interfaces mentioned in the below class diagram:
[[File:AdapterClassOnCodeProject.JPG|thumb|500px|center|A real world example for the Adapter Pattern.]]

 
Pros: This website is useful for intermediate users of design patterns. Some preexisting knowledge of adapter pattern prior to reading this page can help to further understand the topic. The example provided gives a clear view of the design pattern.
 
Cons: A beginner might find not find this page a good base line to start. The code on the page might be difficult for a novice programmer to understand.
 

Further one more webpage on codeproject.com for beginners. [http://www.codeproject.com/Articles/186003/Adapter-Design-Pattern Adapter Design Pattern] 

=== [http://csc.columbusstate.edu/woolbright/java/adapter.html Adpater Pattern on Columbus State University website] ===
 Topics Covered: Introduction to Adapter pattern, Object-Oriented Adapters, an example which implements the Adapter pattern and real world adapters.

Summary: 
* Intrduction: The adapter pattern changes the look of an interface. It takes an interface and adapts it to one the client is expecting.
The Adapter Pattern converts the interface of a class into another interface the client expects.
Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.
 
* Object-Oriented Adapters: 
# Assume your existing system expects interface A.
# You need the system to work with a vendor class that has interface C.
# The solution is an adapter class with interface A for the existing system, and interface C for working with the Vendor class.
 
* The Duck Interface Example: The website provides a good example of the Adapter Design Pattern. The example is as follows: The code shown below provides the Duck Interface: 

public interface Duck {
public void quack();
public void fly();
}

:It is implemented by the MallardDuck class as shown below:

public class MallardDuck implements Duck {
public void quack() {
System.out.println("Quack");
}

public void fly() {
System.out.println("I'm flying");
}
}

:There is another interface called the Turkey Interface:

public interface Turkey { //Turkeys don't quack
public void gobble();
public void fly();
}

:The turkey interface is implemented by the wildTurkey class as shown below:

public class WildTurkey implements Turkey {
public void gobble() {
System.out.println("Gobble gobble");
}

public void fly() {
System.out.println("I'm flying a short distance");
}
}

:And finally comes our showstopper, the Turkey Adapter code as shown below:

public class TurkeyAdapter implements Duck {
Turkey turkey;

public TurkeyAdapter(Turkey turkey) {
this.turkey = turkey;
}

public void quack() {
turkey.gobble();
}

public void fly() {
for(int i=0; i < 5; i++) {
turkey.fly();
}
}
}

:The website also provides a good tester to test the Adapter code. Please refer to the link to see the test driving code. 
 
* Real world Adapters: Following are the examples of real world adapters:
# The old Java Enumeration class had a couple of methods:
## hasMoreElements()
## nextElement()
# The new Java Iterator class has three methods:
## hasNext()
## next()
## remove()

This section provides an EnumerationIterator adapter class that implements the Iterator. Please refer to the link to see the EnumerationIterator Adapter class.
 
 

Pros: 
# A very good example of Adapter Pattern using the Duck Interface, Turkey Interface and the TurkeyAdapter pattern. ( Gosh! Too much of a Turkey used, reminds of Thanksgiving! ).
# Also, the section on real world adapters compliments further understanding of Adapter pattern implementation. Good for Intermediate and Expert users of Design patterns 

Cons: 
# Does not contains enough content to understand Adapter pattern from scratch.
# Also, not suitable for beginners. Though the code provided is lucid and self explanatory, it is not complimented with explanatory texts and this may cause some problems for beginners to understand the code.
# One more thing to observe here is the font size! ( Not good for readers who are adapted to small or medium font size ).
 

=== [http://sourcemaking.com/design_patterns/adapter Adpater Pattern on Sourcemaking.com] ===

 Topics Covered: Intent of Adapter Pattern, Explanation of the pattern, structure of the pattern, example, rule of thumb for adapter pattern.

Summary: Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces. This webpage gives a basic idea of adapter pattern and gives examples of the pattern in various programming languages.

* Intent: 
The need and purpose of adapter pattern. 
* Problem and Discussion: 
An “off the shelf” component offers compelling functionality that you would like to reuse, but its “view of the world” is not compatible with the philosophy and architecture of the system currently being developed. This section tells the problems and how adapter pattern helps solve them. 
* Structure: 
Class diagrams showing the different structures of adapter pattern. 
* Example: 
The Adapter pattern allows otherwise incompatible classes to work together by converting the interface of one class into an interface expected by the clients. Socket wrenches provide an example of the Adapter. 
* Check list and Rule of thumb: 
These sections describe when and how adapter pattern is useful. It also describes the various things to keep in mind when working with adapter pattern. 
* Adapter Code examples: 
Links to examples of Adapter pattern implemented in various languages.
 
Pros: A good place to study the adapter pattern from scratch. The examples of code in different languages lets us compare the implementation across all these languages. The links contain easy to understand code making it simple for beginners.
 
Cons: Hmmm, now this webpage can be qualified as one of the better pages to learn about Adapter patterns. Since we couldn't find any shortcomings of this web page we leave it as an exercise for curious readers!
 

= Further Readings =

[http://www.codeproject.com/Articles/342082/Understanding-and-Implementing-the-Adapter-Pattern Understanding and Implementing the Adapter Pattern]. 
[http://www.allapplabs.com/java_design_patterns/adapter_pattern.htm Adapter Pattern in Java]. 
[http://groovy.codehaus.org/Adapter+Pattern Flavors of Adapter Pattern]. 
[http://javapapers.com/design-patterns/adapter-pattern/ Implementing Adapter Pattern].

CSC/ECE 517 Fall 2012/ch2b 2w47 am

2012-11-18T09:48:13Z

Mrkamat: /* Adpater Pattern on Codeproject.com */

='''Adapter Pattern, a directory of sites'''=

This wiki page provides a directory of sites for Adapter Design Pattern that will help readers to know what each website contains, why should readers refer one website over another and a list of examples that readers can look up to understand the Adapter Pattern.

__TOC__

= Introduction =

Sometimes, objects just don't fit together as they should. A class may have changed, or an object turns out to be just too difficult to work with. At such times, adapter design pattern comes to the rescue. Adapter pattern lets you adapt what an object or class has to offer so that another object or class can make use of it. It also helps when classes can't work together because of incompatible interfaces.

Since we are huge fans of visual approach, lets understand the adapter pattern with the help of a diagram. Hold on! Before going in to the UML diagram ( which is kind of less attractive, right? May be .. ) lets look at the figure below which is more appealing. 

[[File:AdapterPatternForWiki.jpg|thumb|500px|center|A real world example for the Adapter Pattern.]]

 The above example helps readers quickly get across the intent of the pattern than the UML diagram shown below. Looking at the UML diagram now, can help the readers to learn about the precise relationships between the classes in adapter pattern and it makes a lot more sense! 

[[File:AdapterPatternUMLForWiki.jpg|thumb|500px|center|UML diagram for the Adapter Pattern.]]

 

So, this is all what we had to talk about Adapter Pattern. Lets look at other websites and see what they say about Adapter pattern, (which is probably, the main purpose of the wiki page).
 
 

= Directory of sites =

=== [http://en.wikipedia.org/wiki/Adapter_pattern Adapter Pattern on wikipedia] ===
 Topics Covered: Lists various structures of Adapter Pattern viz., Object Adapter Pattern, Class Adapter Pattern, Runtime Adapter pattern and implementation of Adapter pattern. It provides a few examples for the above structures.

Summary: In computer programming, the adapter pattern (often referred to as the wrapper pattern or simply a wrapper) is a design pattern that translates one interface for a class into a compatible interface. The adapter is also responsible for transforming data into appropriate forms. For instance, if multiple boolean values are stored as a single integer (i.e. flags) but your client requires a 'true'/'false', the adapter would be responsible for extracting the appropriate values from the integer value. Another example is transforming the format of dates (e.g. YYYYMMDD to MM/DD/YYYY or DD/MM/YYYY). The various Adapter pattern structures are as follows
* Object Adapter pattern: 
In this type of adapter pattern, the adapter contains an instance of the class it wraps. In this situation, the adapter makes calls to the instance of the wrapped object. 
* Class Adapter pattern: 
This type of adapter uses multiple polymorphic interfaces to achieve its goal. The adapter is created by implementing or inheriting both the interface that is expected and the interface that is pre-existing. 
* A further form of runtime Adapter pattern: 
This section provides a good example for runtime Adapter pattern. 
* Implementation: 
Provides a basic skeleton of how to implement the adapter pattern.
 
Pros: This wikipedia page works if readers want a quick review of the adapter pattern. Also it provides good references to read more about the Adapter pattern. 
Cons: It doesn't helps to understand the Adapter pattern in depth. The examples provided are not easy to comprehend ( unless you are an experienced developer and not a beginner! ). Its not a good page to refer for the beginners.
 
 

=== [http://msdn.microsoft.com/en-us/library/orm-9780596527730-01-04.aspx Adpater Pattern on MSDN Microsoft Website] ===
 Topics Covered: Role of adapter pattern, Illustrations or examples where adapter pattern is used ,Design and Implementation of adapter pattern, few more kinds of adapters.

Summary: Adapter pattern is a versatile pattern that joins together types that were not designed to work with each other. It is one of those patterns that comes in useful when dealing with legacy code-i.e., code that was written a while ago and to which one might not have access.
* Role: 
The Adapter pattern enables a system to use classes whose interfaces don't quite match its requirements. It is especially useful for off-the-shelf code, for toolkits, and for libraries 
* Illustration: 
Adapter pattern illustration-migration of Mac OS X from a 1998 PowerPC-based iMac to a 2007 Intel-based iMac. This section shows how the adapter pattern has been used to enable Mac OS migration. 
* Design: 
The Adapter pattern's important contribution is that it promotes programming to interfaces. The Client works to a domain-specific standard, which is specified in the ITarget interface. An Adaptee class provides the required functionality, but with a different interface. The Adapter implements the ITarget interface and routes calls from the Client through to the Adaptee, making whatever changes to parameters and return types are necessary to meet the requirements. A Target class that implements the ITarget interface directly could exist, but this is not a necessary part of the pattern. In any case, the Client is aware only of the ITarget interface, and it relies on that for its correct operation. 
* Implementation: 
This section provides an example in C# and how the Adapter, Adaptee, Target and Client all communicate with each other.
* Two way adapters and Pluggable adapters: 
These sections describes the other kinds of adapter with appropriate examples.
 
Pros: This page gives an in-depth explanation of the adapter pattern. It shows how the adapter pattern is implemented in C#. The real world examples makes it easy to grasp the topic. 
Cons: The page might be too long for a quick review. Though it is really good for a beginner, an Intermediate or an expert person in design pattern may not actually want to wade through the entire concept in such a depth. ( unless the person doesn't have much work to do, "eyebrows raised" ).
 
 

=== [http://www.oodesign.com/adapter-pattern.html Adpater Pattern on OODesign.com] ===
 Topics Covered: Motivation for using Adapter pattern, intent behind using the adapter pattern, a UML diagram to explain the adapter pattern ( like we did above, yeah! ) to start with. It also covers the application and implementation of Adapter patterns. Moreover, it provides some really nice examples and specific problems where adapter pattern becomes a good fit to use.

 Summary: The adapter pattern is adapting between classes and objects. Like any adapter in the real world it is used to be an interface, a bridge between two objects. In real world we have adapters for power supplies, adapters for camera memory cards, and so on. 
What about software development? It's the same. Can you imagine an situation when you have some class expecting some type of object and you have an object offering the same features, but exposing a different interface? Of course, you want to use both of them so you don't to implement again one of them, and you don't want to change existing classes, so why not create an adapter...
 
* Intent 
# Convert the interface of a class into another interface clients expect
# Adapter lets classes work together, that could not otherwise because of incompatible interfaces

* Implementation Explains the implementation of the Adapter pattern with the help of a UML diagram.

* Applicability and Examples Adapters are encountered everywhere. From real world adapters to software adapters.
# Non Software Examples of Adapter Patterns: Power Supply Adapters, card readers and adapters, ...
# Software Examples of Adapter Patterns: Wrappers used to adopt 3rd parties libraries and frameworks - most of the applications using third party libraries use adapters as a middle layer between the application and the 3rd party library to decouple the application from the library. If another library has to be used only an adapter for the new library is required without having to change the application code.

* Specific problem and Implementation 
# Objects Adapters - Based on Delegation It uses composition, the Adaptee delegates the calls to Adaptee (opossed to class adapters which extends the Adaptee).
# Class Adapters - Based on (Multiple) Inheritance Class adapters can be implemented in languages supporting multiple inheritance(Java, C# or PHP does not support multiple inheritance). Thus, such adapters can not be easy implemented in Java, C# or VB.NET. Class adapter uses inheritance instead of composition.
# Adapter Pattern and Strategy Pattern Cases when Adapter Pattern can be a better option instead of Strategy pattern ( ok, now that sounds something interesting, doesn't it?)
 
Pros: Helps to learn Adapter pattern in detail. Provides good examples to understand how the pattern works and also give suitable cases where adapter design pattern is most applicable. Good for all readers ( beginners, intermediate and experts ) 
Cons: Doesn't provides enough figures to understand the concept. For readers who endorse figures, not a good page to look out for.
 
 

=== [http://www.codeproject.com/Articles/42915/Adapter-Design-Pattern Adpater Pattern on Codeproject.com] ===
 Topics Covered: Background, Introduction to adapter pattern and its structure, class diagram and implementation of adapter pattern for a scenario.

Summary: This page uses a running example in the background to discuss the design pattern and then further provides a design pattern implementation for that particular example. Moreover, it explains the importance of Adapter Design in system integration when other components have to be adapted by the existing system.
* Background: 
The webpage continues using the running example to describe the earlier design patterns and further gives a scenario to introduce the adapter pattern. 
* Design and implementation 
It gives a class diagram describing the adapter pattern for the example in the background section. Also, this section covers the explanation and implementation of all the classes and interfaces mentioned in the below class diagram:
[[File:AdapterClassOnCodeProject.JPG|thumb|500px|center|A real world example for the Adapter Pattern.]]

 
Pros: This website is useful for intermediate users of design patterns. Some preexisting knowledge of adapter pattern prior to reading this page can help to further understand the topic. The example provided gives a clear view of the design pattern.
 
Cons: A beginner might find not find this page a good base line to start. The code on the page might be difficult for a novice programmer to understand.
 

Further one more site on codeproject.com for beginners. [http://www.codeproject.com/Articles/186003/Adapter-Design-Pattern Adapter Design Pattern] 

=== [http://csc.columbusstate.edu/woolbright/java/adapter.html Adpater Pattern on Columbus State University website] ===
 Topics Covered: Introduction to Adapter pattern, Object-Oriented Adapters, an example which implements the Adapter pattern and real world adapters.

Summary: 
* Intrduction: The adapter pattern changes the look of an interface. It takes an interface and adapts it to one the client is expecting.
The Adapter Pattern converts the interface of a class into another interface the client expects.
Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.
 
* Object-Oriented Adapters: 
# Assume your existing system expects interface A.
# You need the system to work with a vendor class that has interface C.
# The solution is an adapter class with interface A for the existing system, and interface C for working with the Vendor class.
 
* The Duck Interface Example: The website provides a good example of the Adapter Design Pattern. The example is as follows: The code shown below provides the Duck Interface: 

public interface Duck {
public void quack();
public void fly();
}

:It is implemented by the MallardDuck class as shown below:

public class MallardDuck implements Duck {
public void quack() {
System.out.println("Quack");
}

public void fly() {
System.out.println("I'm flying");
}
}

:There is another interface called the Turkey Interface:

public interface Turkey { //Turkeys don't quack
public void gobble();
public void fly();
}

:The turkey interface is implemented by the wildTurkey class as shown below:

public class WildTurkey implements Turkey {
public void gobble() {
System.out.println("Gobble gobble");
}

public void fly() {
System.out.println("I'm flying a short distance");
}
}

:And finally comes our showstopper, the Turkey Adapter code as shown below:

public class TurkeyAdapter implements Duck {
Turkey turkey;

public TurkeyAdapter(Turkey turkey) {
this.turkey = turkey;
}

public void quack() {
turkey.gobble();
}

public void fly() {
for(int i=0; i < 5; i++) {
turkey.fly();
}
}
}

:The website also provides a good tester to test the Adapter code. Please refer to the link to see the test driving code. 
 
* Real world Adapters: Following are the examples of real world adapters:
# The old Java Enumeration class had a couple of methods:
## hasMoreElements()
## nextElement()
# The new Java Iterator class has three methods:
## hasNext()
## next()
## remove()

This section provides an EnumerationIterator adapter class that implements the Iterator. Please refer to the link to see the EnumerationIterator Adapter class.
 
 

Pros: 
# A very good example of Adapter Pattern using the Duck Interface, Turkey Interface and the TurkeyAdapter pattern. ( Gosh! Too much of a Turkey used, reminds of Thanksgiving! ).
# Also, the section on real world adapters compliments further understanding of Adapter pattern implementation. Good for Intermediate and Expert users of Design patterns 

Cons: 
# Does not contains enough content to understand Adapter pattern from scratch.
# Also, not suitable for beginners. Though the code provided is lucid and self explanatory, it is not complimented with explanatory texts and this may cause some problems for beginners to understand the code.
# One more thing to observe here is the font size! ( Not good for readers who are adapted to small or medium font size ).
 

=== [http://sourcemaking.com/design_patterns/adapter Adpater Pattern on Sourcemaking.com] ===

 Topics Covered: Intent of Adapter Pattern, Explanation of the pattern, structure of the pattern, example, rule of thumb for adapter pattern.

Summary: Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces. This webpage gives a basic idea of adapter pattern and gives examples of the pattern in various programming languages.

* Intent: 
The need and purpose of adapter pattern. 
* Problem and Discussion: 
An “off the shelf” component offers compelling functionality that you would like to reuse, but its “view of the world” is not compatible with the philosophy and architecture of the system currently being developed. This section tells the problems and how adapter pattern helps solve them. 
* Structure: 
Class diagrams showing the different structures of adapter pattern. 
* Example: 
The Adapter pattern allows otherwise incompatible classes to work together by converting the interface of one class into an interface expected by the clients. Socket wrenches provide an example of the Adapter. 
* Check list and Rule of thumb: 
These sections describe when and how adapter pattern is useful. It also describes the various things to keep in mind when working with adapter pattern. 
* Adapter Code examples: 
Links to examples of Adapter pattern implemented in various languages.
 
Pros: A good place to study the adapter pattern from scratch. The examples of code in different languages lets us compare the implementation across all these languages. The links contain easy to understand code making it simple for beginners.
 
Cons: Hmmm, now this webpage can be qualified as one of the better pages to learn about Adapter patterns. Since we couldn't find any shortcomings of this web page we leave it as an exercise for curious readers!
 

= Further Readings =

[http://www.codeproject.com/Articles/342082/Understanding-and-Implementing-the-Adapter-Pattern Understanding and Implementing the Adapter Pattern]. 
[http://www.allapplabs.com/java_design_patterns/adapter_pattern.htm Adapter Pattern in Java]. 
[http://groovy.codehaus.org/Adapter+Pattern Flavors of Adapter Pattern]. 
[http://javapapers.com/design-patterns/adapter-pattern/ Implementing Adapter Pattern].

CSC/ECE 517 Fall 2012/ch2b 2w47 am

2012-11-18T08:55:11Z

Mrkamat: /* Further Readings */

='''Adapter Pattern, a directory of sites'''=

This wiki page provides a directory of sites for Adapter Design Pattern that will help readers to know what each website contains, why should readers refer one website over another and a list of examples that readers can look up to understand the Adapter Pattern.

__TOC__

= Introduction =

Sometimes, objects just don't fit together as they should. A class may have changed, or an object turns out to be just too difficult to work with. At such times, adapter design pattern comes to the rescue. Adapter pattern lets you adapt what an object or class has to offer so that another object or class can make use of it. It also helps when classes can't work together because of incompatible interfaces.

Since we are huge fans of visual approach, lets understand the adapter pattern with the help of a diagram. Hold on! Before going in to the UML diagram ( which is kind of less attractive, right? May be .. ) lets look at the figure below which is more appealing. 

[[File:AdapterPatternForWiki.jpg|thumb|500px|center|A real world example for the Adapter Pattern.]]

 The above example helps readers quickly get across the intent of the pattern than the UML diagram shown below. Looking at the UML diagram now, can help the readers to learn about the precise relationships between the classes in adapter pattern and it makes a lot more sense! 

[[File:AdapterPatternUMLForWiki.jpg|thumb|500px|center|UML diagram for the Adapter Pattern.]]

 

So, this is all what we had to talk about Adapter Pattern. Lets look at other websites and see what they say about Adapter pattern, (which is probably, the main purpose of the wiki page).
 
 

= Directory of sites =

=== [http://en.wikipedia.org/wiki/Adapter_pattern Adapter Pattern on wikipedia] ===
 Topics Covered: Lists various structures of Adapter Pattern viz., Object Adapter Pattern, Class Adapter Pattern, Runtime Adapter pattern and implementation of Adapter pattern. It provides a few examples for the above structures.

Summary: In computer programming, the adapter pattern (often referred to as the wrapper pattern or simply a wrapper) is a design pattern that translates one interface for a class into a compatible interface. The adapter is also responsible for transforming data into appropriate forms. For instance, if multiple boolean values are stored as a single integer (i.e. flags) but your client requires a 'true'/'false', the adapter would be responsible for extracting the appropriate values from the integer value. Another example is transforming the format of dates (e.g. YYYYMMDD to MM/DD/YYYY or DD/MM/YYYY). The various Adapter pattern structures are as follows
* Object Adapter pattern: 
In this type of adapter pattern, the adapter contains an instance of the class it wraps. In this situation, the adapter makes calls to the instance of the wrapped object. 
* Class Adapter pattern: 
This type of adapter uses multiple polymorphic interfaces to achieve its goal. The adapter is created by implementing or inheriting both the interface that is expected and the interface that is pre-existing. 
* A further form of runtime Adapter pattern: 
This section provides a good example for runtime Adapter pattern. 
* Implementation: 
Provides a basic skeleton of how to implement the adapter pattern.
 
Pros: This wikipedia page works if readers want a quick review of the adapter pattern. Also it provides good references to read more about the Adapter pattern. 
Cons: It doesn't helps to understand the Adapter pattern in depth. The examples provided are not easy to comprehend ( unless you are an experienced developer and not a beginner! ). Its not a good page to refer for the beginners.
 
 

=== [http://msdn.microsoft.com/en-us/library/orm-9780596527730-01-04.aspx Adpater Pattern on MSDN Microsoft Website] ===
 Topics Covered: Role of adapter pattern, Illustrations or examples where adapter pattern is used ,Design and Implementation of adapter pattern, few more kinds of adapters.

Summary: Adapter pattern is a versatile pattern that joins together types that were not designed to work with each other. It is one of those patterns that comes in useful when dealing with legacy code-i.e., code that was written a while ago and to which one might not have access.
* Role: 
The Adapter pattern enables a system to use classes whose interfaces don't quite match its requirements. It is especially useful for off-the-shelf code, for toolkits, and for libraries 
* Illustration: 
Adapter pattern illustration-migration of Mac OS X from a 1998 PowerPC-based iMac to a 2007 Intel-based iMac. This section shows how the adapter pattern has been used to enable Mac OS migration. 
* Design: 
The Adapter pattern's important contribution is that it promotes programming to interfaces. The Client works to a domain-specific standard, which is specified in the ITarget interface. An Adaptee class provides the required functionality, but with a different interface. The Adapter implements the ITarget interface and routes calls from the Client through to the Adaptee, making whatever changes to parameters and return types are necessary to meet the requirements. A Target class that implements the ITarget interface directly could exist, but this is not a necessary part of the pattern. In any case, the Client is aware only of the ITarget interface, and it relies on that for its correct operation. 
* Implementation: 
This section provides an example in C# and how the Adapter, Adaptee, Target and Client all communicate with each other.
* Two way adapters and Pluggable adapters: 
These sections describes the other kinds of adapter with appropriate examples.
 
Pros: This page gives an in-depth explanation of the adapter pattern. It shows how the adapter pattern is implemented in C#. The real world examples makes it easy to grasp the topic. 
Cons: The page might be too long for a quick review. Though it is really good for a beginner, an Intermediate or an expert person in design pattern may not actually want to wade through the entire concept in such a depth. ( unless the person doesn't have much work to do, "eyebrows raised" ).
 
 

=== [http://www.oodesign.com/adapter-pattern.html Adpater Pattern on OODesign.com] ===
 Topics Covered: Motivation for using Adapter pattern, intent behind using the adapter pattern, a UML diagram to explain the adapter pattern ( like we did above, yeah! ) to start with. It also covers the application and implementation of Adapter patterns. Moreover, it provides some really nice examples and specific problems where adapter pattern becomes a good fit to use.

 Summary: The adapter pattern is adapting between classes and objects. Like any adapter in the real world it is used to be an interface, a bridge between two objects. In real world we have adapters for power supplies, adapters for camera memory cards, and so on. 
What about software development? It's the same. Can you imagine an situation when you have some class expecting some type of object and you have an object offering the same features, but exposing a different interface? Of course, you want to use both of them so you don't to implement again one of them, and you don't want to change existing classes, so why not create an adapter...
 
* Intent 
# Convert the interface of a class into another interface clients expect
# Adapter lets classes work together, that could not otherwise because of incompatible interfaces

* Implementation Explains the implementation of the Adapter pattern with the help of a UML diagram.

* Applicability and Examples Adapters are encountered everywhere. From real world adapters to software adapters.
# Non Software Examples of Adapter Patterns: Power Supply Adapters, card readers and adapters, ...
# Software Examples of Adapter Patterns: Wrappers used to adopt 3rd parties libraries and frameworks - most of the applications using third party libraries use adapters as a middle layer between the application and the 3rd party library to decouple the application from the library. If another library has to be used only an adapter for the new library is required without having to change the application code.

* Specific problem and Implementation 
# Objects Adapters - Based on Delegation It uses composition, the Adaptee delegates the calls to Adaptee (opossed to class adapters which extends the Adaptee).
# Class Adapters - Based on (Multiple) Inheritance Class adapters can be implemented in languages supporting multiple inheritance(Java, C# or PHP does not support multiple inheritance). Thus, such adapters can not be easy implemented in Java, C# or VB.NET. Class adapter uses inheritance instead of composition.
# Adapter Pattern and Strategy Pattern Cases when Adapter Pattern can be a better option instead of Strategy pattern ( ok, now that sounds something interesting, doesn't it?)
 
Pros: Helps to learn Adapter pattern in detail. Provides good examples to understand how the pattern works and also give suitable cases where adapter design pattern is most applicable. Good for all readers ( beginners, intermediate and experts ) 
Cons: Doesn't provides enough figures to understand the concept. For readers who endorse figures, not a good page to look out for.
 
 

=== [http://www.codeproject.com/Articles/42915/Adapter-Design-Pattern Adpater Pattern on Codeproject.com] ===
 Topics Covered: Background, Introduction to adapter pattern and its structure, class diagram and implementation of adapter pattern for a scenario.

Summary: This page uses a running example in the background to discuss the design pattern and then further provides a design pattern implementation for that particular example. Moreover, it explains the importance of Adapter Design in system integration when other components have to be adapted by the existing system.
* Background: 
The webpage continues using the running example to describe the earlier design patterns and further gives a scenario to introduce the adapter pattern. 
* Design and implementation 
It gives a class diagram describing the adapter pattern for the example in the background section. Also, this section covers the explanation and implementation of all the classes and interfaces mentioned in the below class diagram:
[[File:AdapterClassOnCodeProject.JPG|thumb|500px|center|A real world example for the Adapter Pattern.]]

 
Pros: This website is useful for intermediate users of design patterns. Some preexisting knowledge of adapter pattern prior to reading this page can help to further understand the topic. The example provided gives a clear view of the design pattern.
 
Cons: A beginner might find not find this page a good base line to start. The code on the page might be difficult for a novice programmer to understand.
 

=== [http://csc.columbusstate.edu/woolbright/java/adapter.html Adpater Pattern on Columbus State University website] ===
 Topics Covered: Introduction to Adapter pattern, Object-Oriented Adapters, an example which implements the Adapter pattern and real world adapters.

Summary: 
* Intrduction: The adapter pattern changes the look of an interface. It takes an interface and adapts it to one the client is expecting.
The Adapter Pattern converts the interface of a class into another interface the client expects.
Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.

=== [http://sourcemaking.com/design_patterns/adapter Adpater Pattern on Sourcemaking.com] ===

 Topics Covered: Intent of Adapter Pattern, Explanation of the pattern, structure of the pattern, example, rule of thumb for adapter pattern.

Summary: Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces. This webpage gives a basic idea of adapter pattern and gives examples of the pattern in various programming languages.

* Intent: 
The need and purpose of adapter pattern. 
* Problem and Discussion: 
An “off the shelf” component offers compelling functionality that you would like to reuse, but its “view of the world” is not compatible with the philosophy and architecture of the system currently being developed. This section tells the problems and how adapter pattern helps solve them. 
* Structure: 
Class diagrams showing the different structures of adapter pattern. 
* Example: 
The Adapter pattern allows otherwise incompatible classes to work together by converting the interface of one class into an interface expected by the clients. Socket wrenches provide an example of the Adapter. 
* Check list and Rule of thumb: 
These sections describe when and how adapter pattern is useful. It also describes the various things to keep in mind when working with adapter pattern. 
* Adapter Code examples: 
Links to examples of Adapter pattern implemented in various languages.
 
Pros: A good place to study the adapter pattern from scratch. The examples of code in different languages lets us compare the implementation across all these languages. The links contain easy to understand code making it simple for beginners.
 
Cons: Hmmm, now this webpage can be qualified as one of the better pages to learn about Adapter patterns. Since we couldn't find any shortcomings of this web page we leave it as an exercise for curious readers!
 

= Further Readings =

[http://www.codeproject.com/Articles/342082/Understanding-and-Implementing-the-Adapter-Pattern Understanding and Implementing the Adapter Pattern]. 
[http://www.allapplabs.com/java_design_patterns/adapter_pattern.htm Adapter Pattern in Java]. 
[http://groovy.codehaus.org/Adapter+Pattern Flavors of Adapter Pattern]. 
[http://javapapers.com/design-patterns/adapter-pattern/ Implementing Adapter Pattern].

CSC/ECE 517 Fall 2012/ch2b 2w47 am

2012-11-18T08:54:50Z

Mrkamat: /* Further Readings */

='''Adapter Pattern, a directory of sites'''=

This wiki page provides a directory of sites for Adapter Design Pattern that will help readers to know what each website contains, why should readers refer one website over another and a list of examples that readers can look up to understand the Adapter Pattern.

__TOC__

= Introduction =

Sometimes, objects just don't fit together as they should. A class may have changed, or an object turns out to be just too difficult to work with. At such times, adapter design pattern comes to the rescue. Adapter pattern lets you adapt what an object or class has to offer so that another object or class can make use of it. It also helps when classes can't work together because of incompatible interfaces.

Since we are huge fans of visual approach, lets understand the adapter pattern with the help of a diagram. Hold on! Before going in to the UML diagram ( which is kind of less attractive, right? May be .. ) lets look at the figure below which is more appealing. 

[[File:AdapterPatternForWiki.jpg|thumb|500px|center|A real world example for the Adapter Pattern.]]

 The above example helps readers quickly get across the intent of the pattern than the UML diagram shown below. Looking at the UML diagram now, can help the readers to learn about the precise relationships between the classes in adapter pattern and it makes a lot more sense! 

[[File:AdapterPatternUMLForWiki.jpg|thumb|500px|center|UML diagram for the Adapter Pattern.]]

 

So, this is all what we had to talk about Adapter Pattern. Lets look at other websites and see what they say about Adapter pattern, (which is probably, the main purpose of the wiki page).
 
 

= Directory of sites =

=== [http://en.wikipedia.org/wiki/Adapter_pattern Adapter Pattern on wikipedia] ===
 Topics Covered: Lists various structures of Adapter Pattern viz., Object Adapter Pattern, Class Adapter Pattern, Runtime Adapter pattern and implementation of Adapter pattern. It provides a few examples for the above structures.

Summary: In computer programming, the adapter pattern (often referred to as the wrapper pattern or simply a wrapper) is a design pattern that translates one interface for a class into a compatible interface. The adapter is also responsible for transforming data into appropriate forms. For instance, if multiple boolean values are stored as a single integer (i.e. flags) but your client requires a 'true'/'false', the adapter would be responsible for extracting the appropriate values from the integer value. Another example is transforming the format of dates (e.g. YYYYMMDD to MM/DD/YYYY or DD/MM/YYYY). The various Adapter pattern structures are as follows
* Object Adapter pattern: 
In this type of adapter pattern, the adapter contains an instance of the class it wraps. In this situation, the adapter makes calls to the instance of the wrapped object. 
* Class Adapter pattern: 
This type of adapter uses multiple polymorphic interfaces to achieve its goal. The adapter is created by implementing or inheriting both the interface that is expected and the interface that is pre-existing. 
* A further form of runtime Adapter pattern: 
This section provides a good example for runtime Adapter pattern. 
* Implementation: 
Provides a basic skeleton of how to implement the adapter pattern.
 
Pros: This wikipedia page works if readers want a quick review of the adapter pattern. Also it provides good references to read more about the Adapter pattern. 
Cons: It doesn't helps to understand the Adapter pattern in depth. The examples provided are not easy to comprehend ( unless you are an experienced developer and not a beginner! ). Its not a good page to refer for the beginners.
 
 

=== [http://msdn.microsoft.com/en-us/library/orm-9780596527730-01-04.aspx Adpater Pattern on MSDN Microsoft Website] ===
 Topics Covered: Role of adapter pattern, Illustrations or examples where adapter pattern is used ,Design and Implementation of adapter pattern, few more kinds of adapters.

Summary: Adapter pattern is a versatile pattern that joins together types that were not designed to work with each other. It is one of those patterns that comes in useful when dealing with legacy code-i.e., code that was written a while ago and to which one might not have access.
* Role: 
The Adapter pattern enables a system to use classes whose interfaces don't quite match its requirements. It is especially useful for off-the-shelf code, for toolkits, and for libraries 
* Illustration: 
Adapter pattern illustration-migration of Mac OS X from a 1998 PowerPC-based iMac to a 2007 Intel-based iMac. This section shows how the adapter pattern has been used to enable Mac OS migration. 
* Design: 
The Adapter pattern's important contribution is that it promotes programming to interfaces. The Client works to a domain-specific standard, which is specified in the ITarget interface. An Adaptee class provides the required functionality, but with a different interface. The Adapter implements the ITarget interface and routes calls from the Client through to the Adaptee, making whatever changes to parameters and return types are necessary to meet the requirements. A Target class that implements the ITarget interface directly could exist, but this is not a necessary part of the pattern. In any case, the Client is aware only of the ITarget interface, and it relies on that for its correct operation. 
* Implementation: 
This section provides an example in C# and how the Adapter, Adaptee, Target and Client all communicate with each other.
* Two way adapters and Pluggable adapters: 
These sections describes the other kinds of adapter with appropriate examples.
 
Pros: This page gives an in-depth explanation of the adapter pattern. It shows how the adapter pattern is implemented in C#. The real world examples makes it easy to grasp the topic. 
Cons: The page might be too long for a quick review. Though it is really good for a beginner, an Intermediate or an expert person in design pattern may not actually want to wade through the entire concept in such a depth. ( unless the person doesn't have much work to do, "eyebrows raised" ).
 
 

=== [http://www.oodesign.com/adapter-pattern.html Adpater Pattern on OODesign.com] ===
 Topics Covered: Motivation for using Adapter pattern, intent behind using the adapter pattern, a UML diagram to explain the adapter pattern ( like we did above, yeah! ) to start with. It also covers the application and implementation of Adapter patterns. Moreover, it provides some really nice examples and specific problems where adapter pattern becomes a good fit to use.

 Summary: The adapter pattern is adapting between classes and objects. Like any adapter in the real world it is used to be an interface, a bridge between two objects. In real world we have adapters for power supplies, adapters for camera memory cards, and so on. 
What about software development? It's the same. Can you imagine an situation when you have some class expecting some type of object and you have an object offering the same features, but exposing a different interface? Of course, you want to use both of them so you don't to implement again one of them, and you don't want to change existing classes, so why not create an adapter...
 
* Intent 
# Convert the interface of a class into another interface clients expect
# Adapter lets classes work together, that could not otherwise because of incompatible interfaces

* Implementation Explains the implementation of the Adapter pattern with the help of a UML diagram.

* Applicability and Examples Adapters are encountered everywhere. From real world adapters to software adapters.
# Non Software Examples of Adapter Patterns: Power Supply Adapters, card readers and adapters, ...
# Software Examples of Adapter Patterns: Wrappers used to adopt 3rd parties libraries and frameworks - most of the applications using third party libraries use adapters as a middle layer between the application and the 3rd party library to decouple the application from the library. If another library has to be used only an adapter for the new library is required without having to change the application code.

* Specific problem and Implementation 
# Objects Adapters - Based on Delegation It uses composition, the Adaptee delegates the calls to Adaptee (opossed to class adapters which extends the Adaptee).
# Class Adapters - Based on (Multiple) Inheritance Class adapters can be implemented in languages supporting multiple inheritance(Java, C# or PHP does not support multiple inheritance). Thus, such adapters can not be easy implemented in Java, C# or VB.NET. Class adapter uses inheritance instead of composition.
# Adapter Pattern and Strategy Pattern Cases when Adapter Pattern can be a better option instead of Strategy pattern ( ok, now that sounds something interesting, doesn't it?)
 
Pros: Helps to learn Adapter pattern in detail. Provides good examples to understand how the pattern works and also give suitable cases where adapter design pattern is most applicable. Good for all readers ( beginners, intermediate and experts ) 
Cons: Doesn't provides enough figures to understand the concept. For readers who endorse figures, not a good page to look out for.
 
 

=== [http://www.codeproject.com/Articles/42915/Adapter-Design-Pattern Adpater Pattern on Codeproject.com] ===
 Topics Covered: Background, Introduction to adapter pattern and its structure, class diagram and implementation of adapter pattern for a scenario.

Summary: This page uses a running example in the background to discuss the design pattern and then further provides a design pattern implementation for that particular example. Moreover, it explains the importance of Adapter Design in system integration when other components have to be adapted by the existing system.
* Background: 
The webpage continues using the running example to describe the earlier design patterns and further gives a scenario to introduce the adapter pattern. 
* Design and implementation 
It gives a class diagram describing the adapter pattern for the example in the background section. Also, this section covers the explanation and implementation of all the classes and interfaces mentioned in the below class diagram:
[[File:AdapterClassOnCodeProject.JPG|thumb|500px|center|A real world example for the Adapter Pattern.]]

 
Pros: This website is useful for intermediate users of design patterns. Some preexisting knowledge of adapter pattern prior to reading this page can help to further understand the topic. The example provided gives a clear view of the design pattern.
 
Cons: A beginner might find not find this page a good base line to start. The code on the page might be difficult for a novice programmer to understand.
 

=== [http://csc.columbusstate.edu/woolbright/java/adapter.html Adpater Pattern on Columbus State University website] ===
 Topics Covered: Introduction to Adapter pattern, Object-Oriented Adapters, an example which implements the Adapter pattern and real world adapters.

Summary: 
* Intrduction: The adapter pattern changes the look of an interface. It takes an interface and adapts it to one the client is expecting.
The Adapter Pattern converts the interface of a class into another interface the client expects.
Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.

=== [http://sourcemaking.com/design_patterns/adapter Adpater Pattern on Sourcemaking.com] ===

 Topics Covered: Intent of Adapter Pattern, Explanation of the pattern, structure of the pattern, example, rule of thumb for adapter pattern.

Summary: Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces. This webpage gives a basic idea of adapter pattern and gives examples of the pattern in various programming languages.

* Intent: 
The need and purpose of adapter pattern. 
* Problem and Discussion: 
An “off the shelf” component offers compelling functionality that you would like to reuse, but its “view of the world” is not compatible with the philosophy and architecture of the system currently being developed. This section tells the problems and how adapter pattern helps solve them. 
* Structure: 
Class diagrams showing the different structures of adapter pattern. 
* Example: 
The Adapter pattern allows otherwise incompatible classes to work together by converting the interface of one class into an interface expected by the clients. Socket wrenches provide an example of the Adapter. 
* Check list and Rule of thumb: 
These sections describe when and how adapter pattern is useful. It also describes the various things to keep in mind when working with adapter pattern. 
* Adapter Code examples: 
Links to examples of Adapter pattern implemented in various languages.
 
Pros: A good place to study the adapter pattern from scratch. The examples of code in different languages lets us compare the implementation across all these languages. The links contain easy to understand code making it simple for beginners.
 
Cons: Hmmm, now this webpage can be qualified as one of the better pages to learn about Adapter patterns. Since we couldn't find any shortcomings of this web page we leave it as an exercise for curious readers!
 

= Further Readings =

[http://www.codeproject.com/Articles/342082/Understanding-and-Implementing-the-Adapter-Pattern Understanding and Implementing the Adapter Pattern].
[http://www.allapplabs.com/java_design_patterns/adapter_pattern.htm Adapter Pattern in Java].
[http://groovy.codehaus.org/Adapter+Pattern Flavors of Adapter Pattern].
[http://javapapers.com/design-patterns/adapter-pattern/ Implementing Adapter Pattern].

CSC/ECE 517 Fall 2012/ch2b 2w47 am

2012-11-18T08:45:10Z

Mrkamat:

='''Adapter Pattern, a directory of sites'''=

This wiki page provides a directory of sites for Adapter Design Pattern that will help readers to know what each website contains, why should readers refer one website over another and a list of examples that readers can look up to understand the Adapter Pattern.

__TOC__

= Introduction =

Sometimes, objects just don't fit together as they should. A class may have changed, or an object turns out to be just too difficult to work with. At such times, adapter design pattern comes to the rescue. Adapter pattern lets you adapt what an object or class has to offer so that another object or class can make use of it. It also helps when classes can't work together because of incompatible interfaces.

Since we are huge fans of visual approach, lets understand the adapter pattern with the help of a diagram. Hold on! Before going in to the UML diagram ( which is kind of less attractive, right? May be .. ) lets look at the figure below which is more appealing. 

[[File:AdapterPatternForWiki.jpg|thumb|500px|center|A real world example for the Adapter Pattern.]]

 The above example helps readers quickly get across the intent of the pattern than the UML diagram shown below. Looking at the UML diagram now, can help the readers to learn about the precise relationships between the classes in adapter pattern and it makes a lot more sense! 

[[File:AdapterPatternUMLForWiki.jpg|thumb|500px|center|UML diagram for the Adapter Pattern.]]

 

So, this is all what we had to talk about Adapter Pattern. Lets look at other websites and see what they say about Adapter pattern, (which is probably, the main purpose of the wiki page).
 
 

= Directory of sites =

=== [http://en.wikipedia.org/wiki/Adapter_pattern Adapter Pattern on wikipedia] ===
 Topics Covered: Lists various structures of Adapter Pattern viz., Object Adapter Pattern, Class Adapter Pattern, Runtime Adapter pattern and implementation of Adapter pattern. It provides a few examples for the above structures.

Summary: In computer programming, the adapter pattern (often referred to as the wrapper pattern or simply a wrapper) is a design pattern that translates one interface for a class into a compatible interface. The adapter is also responsible for transforming data into appropriate forms. For instance, if multiple boolean values are stored as a single integer (i.e. flags) but your client requires a 'true'/'false', the adapter would be responsible for extracting the appropriate values from the integer value. Another example is transforming the format of dates (e.g. YYYYMMDD to MM/DD/YYYY or DD/MM/YYYY). The various Adapter pattern structures are as follows
* Object Adapter pattern: 
In this type of adapter pattern, the adapter contains an instance of the class it wraps. In this situation, the adapter makes calls to the instance of the wrapped object. 
* Class Adapter pattern: 
This type of adapter uses multiple polymorphic interfaces to achieve its goal. The adapter is created by implementing or inheriting both the interface that is expected and the interface that is pre-existing. 
* A further form of runtime Adapter pattern: 
This section provides a good example for runtime Adapter pattern. 
* Implementation: 
Provides a basic skeleton of how to implement the adapter pattern.
 
Pros: This wikipedia page works if readers want a quick review of the adapter pattern. Also it provides good references to read more about the Adapter pattern. 
Cons: It doesn't helps to understand the Adapter pattern in depth. The examples provided are not easy to comprehend ( unless you are an experienced developer and not a beginner! ). Its not a good page to refer for the beginners.
 
 

=== [http://msdn.microsoft.com/en-us/library/orm-9780596527730-01-04.aspx Adpater Pattern on MSDN Microsoft Website] ===
 Topics Covered: Role of adapter pattern, Illustrations or examples where adapter pattern is used ,Design and Implementation of adapter pattern, few more kinds of adapters.

Summary: Adapter pattern is a versatile pattern that joins together types that were not designed to work with each other. It is one of those patterns that comes in useful when dealing with legacy code-i.e., code that was written a while ago and to which one might not have access.
* Role: 
The Adapter pattern enables a system to use classes whose interfaces don't quite match its requirements. It is especially useful for off-the-shelf code, for toolkits, and for libraries 
* Illustration: 
Adapter pattern illustration-migration of Mac OS X from a 1998 PowerPC-based iMac to a 2007 Intel-based iMac. This section shows how the adapter pattern has been used to enable Mac OS migration. 
* Design: 
The Adapter pattern's important contribution is that it promotes programming to interfaces. The Client works to a domain-specific standard, which is specified in the ITarget interface. An Adaptee class provides the required functionality, but with a different interface. The Adapter implements the ITarget interface and routes calls from the Client through to the Adaptee, making whatever changes to parameters and return types are necessary to meet the requirements. A Target class that implements the ITarget interface directly could exist, but this is not a necessary part of the pattern. In any case, the Client is aware only of the ITarget interface, and it relies on that for its correct operation. 
* Implementation: 
This section provides an example in C# and how the Adapter, Adaptee, Target and Client all communicate with each other.
* Two way adapters and Pluggable adapters: 
These sections describes the other kinds of adapter with appropriate examples.
 
Pros: This page gives an in-depth explanation of the adapter pattern. It shows how the adapter pattern is implemented in C#. The real world examples makes it easy to grasp the topic. 
Cons: The page might be too long for a quick review. Though it is really good for a beginner, an Intermediate or an expert person in design pattern may not actually want to wade through the entire concept in such a depth. ( unless the person doesn't have much work to do, "eyebrows raised" ).
 
 

=== [http://www.oodesign.com/adapter-pattern.html Adpater Pattern on OODesign.com] ===
 Topics Covered: Motivation for using Adapter pattern, intent behind using the adapter pattern, a UML diagram to explain the adapter pattern ( like we did above, yeah! ) to start with. It also covers the application and implementation of Adapter patterns. Moreover, it provides some really nice examples and specific problems where adapter pattern becomes a good fit to use.

 Summary: The adapter pattern is adapting between classes and objects. Like any adapter in the real world it is used to be an interface, a bridge between two objects. In real world we have adapters for power supplies, adapters for camera memory cards, and so on. 
What about software development? It's the same. Can you imagine an situation when you have some class expecting some type of object and you have an object offering the same features, but exposing a different interface? Of course, you want to use both of them so you don't to implement again one of them, and you don't want to change existing classes, so why not create an adapter...
 
* Intent 
# Convert the interface of a class into another interface clients expect
# Adapter lets classes work together, that could not otherwise because of incompatible interfaces

* Implementation Explains the implementation of the Adapter pattern with the help of a UML diagram.

* Applicability and Examples Adapters are encountered everywhere. From real world adapters to software adapters.
# Non Software Examples of Adapter Patterns: Power Supply Adapters, card readers and adapters, ...
# Software Examples of Adapter Patterns: Wrappers used to adopt 3rd parties libraries and frameworks - most of the applications using third party libraries use adapters as a middle layer between the application and the 3rd party library to decouple the application from the library. If another library has to be used only an adapter for the new library is required without having to change the application code.

* Specific problem and Implementation 
# Objects Adapters - Based on Delegation It uses composition, the Adaptee delegates the calls to Adaptee (opossed to class adapters which extends the Adaptee).
# Class Adapters - Based on (Multiple) Inheritance Class adapters can be implemented in languages supporting multiple inheritance(Java, C# or PHP does not support multiple inheritance). Thus, such adapters can not be easy implemented in Java, C# or VB.NET. Class adapter uses inheritance instead of composition.
# Adapter Pattern and Strategy Pattern Cases when Adapter Pattern can be a better option instead of Strategy pattern ( ok, now that sounds something interesting, doesn't it?)
 
Pros: Helps to learn Adapter pattern in detail. Provides good examples to understand how the pattern works and also give suitable cases where adapter design pattern is most applicable. Good for all readers ( beginners, intermediate and experts ) 
Cons: Doesn't provides enough figures to understand the concept. For readers who endorse figures, not a good page to look out for.
 
 

=== [http://www.codeproject.com/Articles/42915/Adapter-Design-Pattern Adpater Pattern on Codeproject.com] ===
 Topics Covered: Background, Introduction to adapter pattern and its structure, class diagram and implementation of adapter pattern for a scenario.

Summary: This page uses a running example in the background to discuss the design pattern and then further provides a design pattern implementation for that particular example. Moreover, it explains the importance of Adapter Design in system integration when other components have to be adapted by the existing system.
* Background: 
The webpage continues using the running example to describe the earlier design patterns and further gives a scenario to introduce the adapter pattern. 
* Design and implementation 
It gives a class diagram describing the adapter pattern for the example in the background section. Also, this section covers the explanation and implementation of all the classes and interfaces mentioned in the below class diagram:
[[File:AdapterClassOnCodeProject.JPG|thumb|500px|center|A real world example for the Adapter Pattern.]]

 
Pros: This website is useful for intermediate users of design patterns. Some preexisting knowledge of adapter pattern prior to reading this page can help to further understand the topic. The example provided gives a clear view of the design pattern.
 
Cons: A beginner might find not find this page a good base line to start. The code on the page might be difficult for a novice programmer to understand.
 

=== [http://csc.columbusstate.edu/woolbright/java/adapter.html Adpater Pattern on Columbus State University website] ===
 Topics Covered: Introduction to Adapter pattern, Object-Oriented Adapters, an example which implements the Adapter pattern and real world adapters.

Summary: 
* Intrduction: The adapter pattern changes the look of an interface. It takes an interface and adapts it to one the client is expecting.
The Adapter Pattern converts the interface of a class into another interface the client expects.
Adapter lets classes work together that couldn't otherwise because of incompatible interfaces.

=== [http://sourcemaking.com/design_patterns/adapter Adpater Pattern on Sourcemaking.com] ===

 Topics Covered: Intent of Adapter Pattern, Explanation of the pattern, structure of the pattern, example, rule of thumb for adapter pattern.

Summary: Adapter lets classes work together that couldn’t otherwise because of incompatible interfaces. This webpage gives a basic idea of adapter pattern and gives examples of the pattern in various programming languages.

* Intent: 
The need and purpose of adapter pattern. 
* Problem and Discussion: 
An “off the shelf” component offers compelling functionality that you would like to reuse, but its “view of the world” is not compatible with the philosophy and architecture of the system currently being developed. This section tells the problems and how adapter pattern helps solve them. 
* Structure: 
Class diagrams showing the different structures of adapter pattern. 
* Example: 
The Adapter pattern allows otherwise incompatible classes to work together by converting the interface of one class into an interface expected by the clients. Socket wrenches provide an example of the Adapter. 
* Check list and Rule of thumb: 
These sections describe when and how adapter pattern is useful. It also describes the various things to keep in mind when working with adapter pattern. 
* Adapter Code examples: 
Links to examples of Adapter pattern implemented in various languages.
 
Pros: A good place to study the adapter pattern from scratch. The examples of code in different languages lets us compare the implementation across all these languages. The links contain easy to understand code making it simple for beginers.
 
Cons:

CSC/ECE 517 Fall 2012/ch2b 2w47 am

2012-11-18T06:54:48Z

Mrkamat:

CSC/ECE 517 Fall 2012/ch2b 2w47 am

2012-11-18T06:54:01Z

Mrkamat:

File:AdapterClassOnCodeProject.JPG

2012-11-18T06:53:10Z

Mrkamat: Reference : http://www.codeproject.com/Articles/42915/Adapter-Design-Pattern

Reference :
http://www.codeproject.com/Articles/42915/Adapter-Design-Pattern

CSC/ECE 517 Fall 2012/ch2b 2w47 am

2012-11-18T06:49:02Z

Mrkamat:

CSC/ECE 517 Fall 2012/ch2b 2w47 am

2012-11-18T06:11:16Z

Mrkamat: /* Directory of sites */

CSC/ECE 517 Fall 2012/ch1b 1w58 am

2012-10-10T23:30:55Z

Mrkamat: /* Conclusion */

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use Don't Repeat Yourself [http://en.wikipedia.org/wiki/Don%27t_repeat_yourself (DRY)] principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are [http://ruby.bastardsbook.com/chapters/collections/ Collection] defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc. 
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms means constructs in ruby that mimics [http://en.wikipedia.org/wiki/Functional_programming Functional Programming Language].

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator ===
The times<ref name="Iterators"/> iterator works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output:

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output:

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>"Blocks basics" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

Expression orientation<ref name="saas_video">"SaaS. 3.6 - Ruby Blocks, Iterators, Functional Idioms " http://www.youtube.com/watch?v=bRn91_Zonh4</ref> in ruby refers to the mechanism of applying a series of operation on collections ( e.g. arrays, hashes etc ) without actually modifying the original collection. For example, consider the sort method in ruby. The sort method when called on an array creates a temporary array having the same elements as that of the original array. It then sorts this temporary array and returns that. So, for the code shown below:

a = [ 9, 8, 3, 6, 4]
print a.sort
print a

produces the following output:

[3, 4, 6, 8, 9]
[9, 8, 3, 6, 4]

From the output it is very clear that the original array is not modified while we can still perform a series of operations on the array a. Surprisingly, ruby also performs cascaded operations for ex,

x = ["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]
print x.uniq.reverse
print x

this code gives the following output:

["only", "and", "pancakes", "love", "I"]
["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]

Here, the first operation x.sort removes duplicate occurrences of string "pancakes" from the temporary array which it creates to perform this operation and then the reverse operation reverses that temporary array to print the elements in the reverse order. However, the original array is still not modified and the next print.x statement prints the original array x.

One important thing to note here is that if directly reverse operation is used then the array gets modified. For example, for the code above, if later the programmer directly writes

print x.reverse!
print x

then we get the following output

["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]
["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]

Thus, the array x gets modified. Ruby is indeed crazy, isn't it?

= Functional Idioms =

Functional idioms refers to the various constructs in ruby that mimics Functional Programming Language. Most programmers argue that Ruby is actually an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming Language] and it does not behaves as per the functional programming paradigm. However, though the argument is open ended, Ruby is a [http://en.wikipedia.org/wiki/Programming_paradigm#Multi-paradigm_programming_language multi-paradigm language] that supports a functional style of programming, ( supporting functional style of programming doesn't make the language a Functional Programming language ). Ruby does supports the functional programming behavior of avoiding mutable states [http://en.wikipedia.org/wiki/Immutable_object (Immutable and Mutable Object)]. To make the concept clear, consider the example shown below which uses the iterator "each". This type of iteration in ruby is actually a function because ruby passes a function ( block of code ) to be called on each item in the collection<ref>"Ruby a functional language" http://stackoverflow.com/questions/159797/is-ruby-a-functional-language</ref>.

puts "This is a Pythagorean triple!"
[3, 4, 5].each { |num| print num }

In the above example<ref>"Functional programming in ruby" http://tech.rufy.com/2006/11/functional-programming-in-ruby.html</ref>, the function being passed is { |num| puts num }. In fact, the code shown below accomplishes the same behavior as done above:

puts "This is a Pythagorean triple!"
my_print_function = lambda { |num| print num }
[3, 4, 5].each &my_print_function

Here, in the example shown above, we use the address of "my_print_function" to identify the lines of code that needs to be executed and for each element of the collection execute the function "my_print_function". So, in that respect, we can call the iterator each a functional idiom.

Now, this is very much from the functional programming paradigm, right? ( may be or may be not, lets keep this job for the debaters! ) Readers are encouraged to please refer [http://khelll.com/blog/ruby/ruby-and-functional-programming here] for further understanding of functional idioms.

 
For curious readers, both the above code produces the following output:

This is a Pythagorean triple!
[3, 4, 5]

 

= Conclusion =

Ruby provides such a flexible approach to use iterators as compared to C++ and Java that it is worth learning these iterators and to try out them while writing code ( or just for fun if programmers want to!). In ruby the iterator is simply a method that calls yield and passes control to a block of code associated with this iterator method. Unlike Java and C++, ruby does not requires the need to generate helper classes to carry the iterator state thus making it a transparent language. A beginner in ruby may think that the working of a block and yield is magical but actually, it is not! ( the wiki page just explains this magical behavior, right? ). As programmers keeps working on iterators, blocks and functional idioms they understand how easy it is to define your behavior without having the overhead of extra utilities. And this makes ruby programming so easy because you concentrate on getting the job done, not on building [http://en.wikipedia.org/wiki/Scaffold_%28programming%29 scaffolding] to support the language itself.<ref>"Ruby Blocks, Iterators and containers" http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html</ref>
 

= Topical References =
<references/>

 

= Further Reading =
[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : Ruby loops and iterators.

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks.

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

[http://www.devarticles.com/c/a/Ruby-on-Rails/Iterators-in-Ruby/ Ruby cookbook] : More about Ruby iterators.

[http://khelll.com/blog/ruby/ruby-and-functional-programming/ Functional Idioms] : Functional idioms explained.

CSC/ECE 517 Fall 2012/ch1b 1w58 am

2012-10-10T23:29:47Z

Mrkamat: /* Functional Idioms */

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use Don't Repeat Yourself [http://en.wikipedia.org/wiki/Don%27t_repeat_yourself (DRY)] principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are [http://ruby.bastardsbook.com/chapters/collections/ Collection] defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc. 
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms means constructs in ruby that mimics [http://en.wikipedia.org/wiki/Functional_programming Functional Programming Language].

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator ===
The times<ref name="Iterators"/> iterator works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output:

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output:

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>"Blocks basics" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

Expression orientation<ref name="saas_video">"SaaS. 3.6 - Ruby Blocks, Iterators, Functional Idioms " http://www.youtube.com/watch?v=bRn91_Zonh4</ref> in ruby refers to the mechanism of applying a series of operation on collections ( e.g. arrays, hashes etc ) without actually modifying the original collection. For example, consider the sort method in ruby. The sort method when called on an array creates a temporary array having the same elements as that of the original array. It then sorts this temporary array and returns that. So, for the code shown below:

a = [ 9, 8, 3, 6, 4]
print a.sort
print a

produces the following output:

[3, 4, 6, 8, 9]
[9, 8, 3, 6, 4]

From the output it is very clear that the original array is not modified while we can still perform a series of operations on the array a. Surprisingly, ruby also performs cascaded operations for ex,

x = ["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]
print x.uniq.reverse
print x

this code gives the following output:

["only", "and", "pancakes", "love", "I"]
["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]

Here, the first operation x.sort removes duplicate occurrences of string "pancakes" from the temporary array which it creates to perform this operation and then the reverse operation reverses that temporary array to print the elements in the reverse order. However, the original array is still not modified and the next print.x statement prints the original array x.

One important thing to note here is that if directly reverse operation is used then the array gets modified. For example, for the code above, if later the programmer directly writes

print x.reverse!
print x

then we get the following output

["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]
["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]

Thus, the array x gets modified. Ruby is indeed crazy, isn't it?

= Functional Idioms =

Functional idioms refers to the various constructs in ruby that mimics Functional Programming Language. Most programmers argue that Ruby is actually an [http://en.wikipedia.org/wiki/Object-oriented_programming Object Oriented Programming Language] and it does not behaves as per the functional programming paradigm. However, though the argument is open ended, Ruby is a [http://en.wikipedia.org/wiki/Programming_paradigm#Multi-paradigm_programming_language multi-paradigm language] that supports a functional style of programming, ( supporting functional style of programming doesn't make the language a Functional Programming language ). Ruby does supports the functional programming behavior of avoiding mutable states [http://en.wikipedia.org/wiki/Immutable_object (Immutable and Mutable Object)]. To make the concept clear, consider the example shown below which uses the iterator "each". This type of iteration in ruby is actually a function because ruby passes a function ( block of code ) to be called on each item in the collection<ref>"Ruby a functional language" http://stackoverflow.com/questions/159797/is-ruby-a-functional-language</ref>.

puts "This is a Pythagorean triple!"
[3, 4, 5].each { |num| print num }

In the above example<ref>"Functional programming in ruby" http://tech.rufy.com/2006/11/functional-programming-in-ruby.html</ref>, the function being passed is { |num| puts num }. In fact, the code shown below accomplishes the same behavior as done above:

puts "This is a Pythagorean triple!"
my_print_function = lambda { |num| print num }
[3, 4, 5].each &my_print_function

Here, in the example shown above, we use the address of "my_print_function" to identify the lines of code that needs to be executed and for each element of the collection execute the function "my_print_function". So, in that respect, we can call the iterator each a functional idiom.

Now, this is very much from the functional programming paradigm, right? ( may be or may be not, lets keep this job for the debaters! ) Readers are encouraged to please refer [http://khelll.com/blog/ruby/ruby-and-functional-programming here] for further understanding of functional idioms.

 
For curious readers, both the above code produces the following output:

This is a Pythagorean triple!
[3, 4, 5]

 

= Conclusion =

Ruby provides such a flexible approach to use iterators as compared to C++ and Java that it is worth learning these iterators and to try out them while writing code ( or just for fun if programmers want to!). In ruby the iterator is simply a method that calls yield and passes control to a block of code associated with this iterator method. Unlike Java and C++, ruby does not requires the need to generate helper classes to carry the iterator state thus making it a transparent language. A beginner in ruby may think that the working of a block and yield is magical but actually, it is not! ( the wiki page just explains this magical behavior, right? ). As programmers keeps working on iterators, blocks and functional idioms they understand how easy it is to define your behavior without having the overhead of extra utilities. And this makes ruby programming so easy because you concentrate on getting the job done, not on building scaffolding to support the language itself.<ref>"Ruby Blocks, Iterators and containers" http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html</ref>
 

= Topical References =
<references/>

 

= Further Reading =
[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : Ruby loops and iterators.

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks.

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

[http://www.devarticles.com/c/a/Ruby-on-Rails/Iterators-in-Ruby/ Ruby cookbook] : More about Ruby iterators.

[http://khelll.com/blog/ruby/ruby-and-functional-programming/ Functional Idioms] : Functional idioms explained.

CSC/ECE 517 Fall 2012/ch1b 1w58 am

2012-10-10T23:25:03Z

Mrkamat: /* Introduction */

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use Don't Repeat Yourself [http://en.wikipedia.org/wiki/Don%27t_repeat_yourself (DRY)] principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are [http://ruby.bastardsbook.com/chapters/collections/ Collection] defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc. 
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms means constructs in ruby that mimics [http://en.wikipedia.org/wiki/Functional_programming Functional Programming Language].

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator ===
The times<ref name="Iterators"/> iterator works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output:

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output:

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>"Blocks basics" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

Expression orientation<ref name="saas_video">"SaaS. 3.6 - Ruby Blocks, Iterators, Functional Idioms " http://www.youtube.com/watch?v=bRn91_Zonh4</ref> in ruby refers to the mechanism of applying a series of operation on collections ( e.g. arrays, hashes etc ) without actually modifying the original collection. For example, consider the sort method in ruby. The sort method when called on an array creates a temporary array having the same elements as that of the original array. It then sorts this temporary array and returns that. So, for the code shown below:

a = [ 9, 8, 3, 6, 4]
print a.sort
print a

produces the following output:

[3, 4, 6, 8, 9]
[9, 8, 3, 6, 4]

From the output it is very clear that the original array is not modified while we can still perform a series of operations on the array a. Surprisingly, ruby also performs cascaded operations for ex,

x = ["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]
print x.uniq.reverse
print x

this code gives the following output:

["only", "and", "pancakes", "love", "I"]
["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]

Here, the first operation x.sort removes duplicate occurrences of string "pancakes" from the temporary array which it creates to perform this operation and then the reverse operation reverses that temporary array to print the elements in the reverse order. However, the original array is still not modified and the next print.x statement prints the original array x.

One important thing to note here is that if directly reverse operation is used then the array gets modified. For example, for the code above, if later the programmer directly writes

print x.reverse!
print x

then we get the following output

["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]
["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]

Thus, the array x gets modified. Ruby is indeed crazy, isn't it?

= Functional Idioms =

Functional idioms refers to the various constructs in ruby that mimics Functional Programming Language. Most programmers argue that Ruby is actually an Object Oriented Programming Language and it does not behaves as per the functional programming paradigm. However, though the argument is open ended, Ruby is a multi-paradigm language that supports a functional style of programming, ( supporting functional style of programming doesn't make the language a Functional Programming language ). Ruby does supports the functional programming behavior of avoiding mutable states. To make the concept clear, consider the example shown below which uses the iterator "each". This type of iteration in ruby is actually a function because ruby passes a function ( block of code ) to be called on each item in the collection<ref>"Ruby a functional language" http://stackoverflow.com/questions/159797/is-ruby-a-functional-language</ref>.

puts "This is a Pythagorean triple!"
[3, 4, 5].each { |num| print num }

In the above example<ref>"Functional programming in ruby" http://tech.rufy.com/2006/11/functional-programming-in-ruby.html</ref>, the function being passed is { |num| puts num }. In fact, the code shown below accomplishes the same behavior as done above:

puts "This is a Pythagorean triple!"
my_print_function = lambda { |num| print num }
[3, 4, 5].each &my_print_function

Here, in the example shown above, we use the address of "my_print_function" to identify the lines of code that needs to be executed and for each element of the collection execute the function "my_print_function". So, in that respect, we can call the iterator each a functional idiom.

Now, this is very much from the functional programming paradigm, right? ( may be or may be not, lets keep this job for the debaters! ) Readers are encouraged to please refer [http://khelll.com/blog/ruby/ruby-and-functional-programming here] for further understanding of functional idioms.

 
For curious readers, both the above code produces the following output:

This is a Pythagorean triple!
[3, 4, 5]

 

= Conclusion =

Ruby provides such a flexible approach to use iterators as compared to C++ and Java that it is worth learning these iterators and to try out them while writing code ( or just for fun if programmers want to!). In ruby the iterator is simply a method that calls yield and passes control to a block of code associated with this iterator method. Unlike Java and C++, ruby does not requires the need to generate helper classes to carry the iterator state thus making it a transparent language. A beginner in ruby may think that the working of a block and yield is magical but actually, it is not! ( the wiki page just explains this magical behavior, right? ). As programmers keeps working on iterators, blocks and functional idioms they understand how easy it is to define your behavior without having the overhead of extra utilities. And this makes ruby programming so easy because you concentrate on getting the job done, not on building scaffolding to support the language itself.<ref>"Ruby Blocks, Iterators and containers" http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html</ref>
 

= Topical References =
<references/>

 

= Further Reading =
[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : Ruby loops and iterators.

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks.

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

[http://www.devarticles.com/c/a/Ruby-on-Rails/Iterators-in-Ruby/ Ruby cookbook] : More about Ruby iterators.

[http://khelll.com/blog/ruby/ruby-and-functional-programming/ Functional Idioms] : Functional idioms explained.

CSC/ECE 517 Fall 2012/ch1b 1w58 am

2012-10-10T23:22:32Z

Mrkamat: /* Introduction */

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use Don't Repeat Yourself [http://en.wikipedia.org/wiki/Don%27t_repeat_yourself (DRY)] principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are [http://ruby.bastardsbook.com/chapters/collections/ Collection] defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc. 
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms means constructs in ruby that mimics Functional Programming Language.

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator ===
The times<ref name="Iterators"/> iterator works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output:

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output:

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>"Blocks basics" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

Expression orientation<ref name="saas_video">"SaaS. 3.6 - Ruby Blocks, Iterators, Functional Idioms " http://www.youtube.com/watch?v=bRn91_Zonh4</ref> in ruby refers to the mechanism of applying a series of operation on collections ( e.g. arrays, hashes etc ) without actually modifying the original collection. For example, consider the sort method in ruby. The sort method when called on an array creates a temporary array having the same elements as that of the original array. It then sorts this temporary array and returns that. So, for the code shown below:

a = [ 9, 8, 3, 6, 4]
print a.sort
print a

produces the following output:

[3, 4, 6, 8, 9]
[9, 8, 3, 6, 4]

From the output it is very clear that the original array is not modified while we can still perform a series of operations on the array a. Surprisingly, ruby also performs cascaded operations for ex,

x = ["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]
print x.uniq.reverse
print x

this code gives the following output:

["only", "and", "pancakes", "love", "I"]
["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]

Here, the first operation x.sort removes duplicate occurrences of string "pancakes" from the temporary array which it creates to perform this operation and then the reverse operation reverses that temporary array to print the elements in the reverse order. However, the original array is still not modified and the next print.x statement prints the original array x.

One important thing to note here is that if directly reverse operation is used then the array gets modified. For example, for the code above, if later the programmer directly writes

print x.reverse!
print x

then we get the following output

["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]
["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]

Thus, the array x gets modified. Ruby is indeed crazy, isn't it?

= Functional Idioms =

Functional idioms refers to the various constructs in ruby that mimics Functional Programming Language. Most programmers argue that Ruby is actually an Object Oriented Programming Language and it does not behaves as per the functional programming paradigm. However, though the argument is open ended, Ruby is a multi-paradigm language that supports a functional style of programming, ( supporting functional style of programming doesn't make the language a Functional Programming language ). Ruby does supports the functional programming behavior of avoiding mutable states. To make the concept clear, consider the example shown below which uses the iterator "each". This type of iteration in ruby is actually a function because ruby passes a function ( block of code ) to be called on each item in the collection<ref>"Ruby a functional language" http://stackoverflow.com/questions/159797/is-ruby-a-functional-language</ref>.

puts "This is a Pythagorean triple!"
[3, 4, 5].each { |num| print num }

In the above example<ref>"Functional programming in ruby" http://tech.rufy.com/2006/11/functional-programming-in-ruby.html</ref>, the function being passed is { |num| puts num }. In fact, the code shown below accomplishes the same behavior as done above:

puts "This is a Pythagorean triple!"
my_print_function = lambda { |num| print num }
[3, 4, 5].each &my_print_function

Here, in the example shown above, we use the address of "my_print_function" to identify the lines of code that needs to be executed and for each element of the collection execute the function "my_print_function". So, in that respect, we can call the iterator each a functional idiom.

Now, this is very much from the functional programming paradigm, right? ( may be or may be not, lets keep this job for the debaters! ) Readers are encouraged to please refer [http://khelll.com/blog/ruby/ruby-and-functional-programming here] for further understanding of functional idioms.

 
For curious readers, both the above code produces the following output:

This is a Pythagorean triple!
[3, 4, 5]

 

= Conclusion =

Ruby provides such a flexible approach to use iterators as compared to C++ and Java that it is worth learning these iterators and to try out them while writing code ( or just for fun if programmers want to!). In ruby the iterator is simply a method that calls yield and passes control to a block of code associated with this iterator method. Unlike Java and C++, ruby does not requires the need to generate helper classes to carry the iterator state thus making it a transparent language. A beginner in ruby may think that the working of a block and yield is magical but actually, it is not! ( the wiki page just explains this magical behavior, right? ). As programmers keeps working on iterators, blocks and functional idioms they understand how easy it is to define your behavior without having the overhead of extra utilities. And this makes ruby programming so easy because you concentrate on getting the job done, not on building scaffolding to support the language itself.<ref>"Ruby Blocks, Iterators and containers" http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html</ref>
 

= Topical References =
<references/>

 

= Further Reading =
[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : Ruby loops and iterators.

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks.

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

[http://www.devarticles.com/c/a/Ruby-on-Rails/Iterators-in-Ruby/ Ruby cookbook] : More about Ruby iterators.

[http://khelll.com/blog/ruby/ruby-and-functional-programming/ Functional Idioms] : Functional idioms explained.

CSC/ECE 517 Fall 2012/ch1b 1w58 am

2012-10-10T23:21:23Z

Mrkamat:

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use Don't Repeat Yourself [http://en.wikipedia.org/wiki/Don%27t_repeat_yourself (DRY)] principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc. 
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms means constructs in ruby that mimics Functional Programming Language.

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator ===
The times<ref name="Iterators"/> iterator works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output:

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output:

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>"Blocks basics" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

Expression orientation<ref name="saas_video">"SaaS. 3.6 - Ruby Blocks, Iterators, Functional Idioms " http://www.youtube.com/watch?v=bRn91_Zonh4</ref> in ruby refers to the mechanism of applying a series of operation on collections ( e.g. arrays, hashes etc ) without actually modifying the original collection. For example, consider the sort method in ruby. The sort method when called on an array creates a temporary array having the same elements as that of the original array. It then sorts this temporary array and returns that. So, for the code shown below:

a = [ 9, 8, 3, 6, 4]
print a.sort
print a

produces the following output:

[3, 4, 6, 8, 9]
[9, 8, 3, 6, 4]

From the output it is very clear that the original array is not modified while we can still perform a series of operations on the array a. Surprisingly, ruby also performs cascaded operations for ex,

x = ["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]
print x.uniq.reverse
print x

this code gives the following output:

["only", "and", "pancakes", "love", "I"]
["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]

Here, the first operation x.sort removes duplicate occurrences of string "pancakes" from the temporary array which it creates to perform this operation and then the reverse operation reverses that temporary array to print the elements in the reverse order. However, the original array is still not modified and the next print.x statement prints the original array x.

One important thing to note here is that if directly reverse operation is used then the array gets modified. For example, for the code above, if later the programmer directly writes

print x.reverse!
print x

then we get the following output

["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]
["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]

Thus, the array x gets modified. Ruby is indeed crazy, isn't it?

= Functional Idioms =

Functional idioms refers to the various constructs in ruby that mimics Functional Programming Language. Most programmers argue that Ruby is actually an Object Oriented Programming Language and it does not behaves as per the functional programming paradigm. However, though the argument is open ended, Ruby is a multi-paradigm language that supports a functional style of programming, ( supporting functional style of programming doesn't make the language a Functional Programming language ). Ruby does supports the functional programming behavior of avoiding mutable states. To make the concept clear, consider the example shown below which uses the iterator "each". This type of iteration in ruby is actually a function because ruby passes a function ( block of code ) to be called on each item in the collection<ref>"Ruby a functional language" http://stackoverflow.com/questions/159797/is-ruby-a-functional-language</ref>.

puts "This is a Pythagorean triple!"
[3, 4, 5].each { |num| print num }

In the above example<ref>"Functional programming in ruby" http://tech.rufy.com/2006/11/functional-programming-in-ruby.html</ref>, the function being passed is { |num| puts num }. In fact, the code shown below accomplishes the same behavior as done above:

puts "This is a Pythagorean triple!"
my_print_function = lambda { |num| print num }
[3, 4, 5].each &my_print_function

Here, in the example shown above, we use the address of "my_print_function" to identify the lines of code that needs to be executed and for each element of the collection execute the function "my_print_function". So, in that respect, we can call the iterator each a functional idiom.

Now, this is very much from the functional programming paradigm, right? ( may be or may be not, lets keep this job for the debaters! ) Readers are encouraged to please refer [http://khelll.com/blog/ruby/ruby-and-functional-programming here] for further understanding of functional idioms.

 
For curious readers, both the above code produces the following output:

This is a Pythagorean triple!
[3, 4, 5]

 

= Conclusion =

Ruby provides such a flexible approach to use iterators as compared to C++ and Java that it is worth learning these iterators and to try out them while writing code ( or just for fun if programmers want to!). In ruby the iterator is simply a method that calls yield and passes control to a block of code associated with this iterator method. Unlike Java and C++, ruby does not requires the need to generate helper classes to carry the iterator state thus making it a transparent language. A beginner in ruby may think that the working of a block and yield is magical but actually, it is not! ( the wiki page just explains this magical behavior, right? ). As programmers keeps working on iterators, blocks and functional idioms they understand how easy it is to define your behavior without having the overhead of extra utilities. And this makes ruby programming so easy because you concentrate on getting the job done, not on building scaffolding to support the language itself.<ref>"Ruby Blocks, Iterators and containers" http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html</ref>
 

= Topical References =
<references/>

 

= Further Reading =
[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : Ruby loops and iterators.

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks.

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

[http://www.devarticles.com/c/a/Ruby-on-Rails/Iterators-in-Ruby/ Ruby cookbook] : More about Ruby iterators.

[http://khelll.com/blog/ruby/ruby-and-functional-programming/ Functional Idioms] : Functional idioms explained.

CSC/ECE 517 Fall 2012/ch1b 1w58 am

2012-10-10T23:20:19Z

Mrkamat:

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use Don't Repeat Yourself (DRY) principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc. 
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms means constructs in ruby that mimics Functional Programming Language.

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator ===
The times<ref name="Iterators"/> iterator works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output:

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output:

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>"Blocks basics" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

Expression orientation<ref name="saas_video">"SaaS. 3.6 - Ruby Blocks, Iterators, Functional Idioms " http://www.youtube.com/watch?v=bRn91_Zonh4</ref> in ruby refers to the mechanism of applying a series of operation on collections ( e.g. arrays, hashes etc ) without actually modifying the original collection. For example, consider the sort method in ruby. The sort method when called on an array creates a temporary array having the same elements as that of the original array. It then sorts this temporary array and returns that. So, for the code shown below:

a = [ 9, 8, 3, 6, 4]
print a.sort
print a

produces the following output:

[3, 4, 6, 8, 9]
[9, 8, 3, 6, 4]

From the output it is very clear that the original array is not modified while we can still perform a series of operations on the array a. Surprisingly, ruby also performs cascaded operations for ex,

x = ["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]
print x.uniq.reverse
print x

this code gives the following output:

["only", "and", "pancakes", "love", "I"]
["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]

Here, the first operation x.sort removes duplicate occurrences of string "pancakes" from the temporary array which it creates to perform this operation and then the reverse operation reverses that temporary array to print the elements in the reverse order. However, the original array is still not modified and the next print.x statement prints the original array x.

One important thing to note here is that if directly reverse operation is used then the array gets modified. For example, for the code above, if later the programmer directly writes

print x.reverse!
print x

then we get the following output

["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]
["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]

Thus, the array x gets modified. Ruby is indeed crazy, isn't it?

= Functional Idioms =

Functional idioms refers to the various constructs in ruby that mimics Functional Programming Language. Most programmers argue that Ruby is actually an Object Oriented Programming Language and it does not behaves as per the functional programming paradigm. However, though the argument is open ended, Ruby is a multi-paradigm language that supports a functional style of programming, ( supporting functional style of programming doesn't make the language a Functional Programming language ). Ruby does supports the functional programming behavior of avoiding mutable states. To make the concept clear, consider the example shown below which uses the iterator "each". This type of iteration in ruby is actually a function because ruby passes a function ( block of code ) to be called on each item in the collection<ref>"Ruby a functional language" http://stackoverflow.com/questions/159797/is-ruby-a-functional-language</ref>.

puts "This is a Pythagorean triple!"
[3, 4, 5].each { |num| print num }

In the above example<ref>"Functional programming in ruby" http://tech.rufy.com/2006/11/functional-programming-in-ruby.html</ref>, the function being passed is { |num| puts num }. In fact, the code shown below accomplishes the same behavior as done above:

puts "This is a Pythagorean triple!"
my_print_function = lambda { |num| print num }
[3, 4, 5].each &my_print_function

Here, in the example shown above, we use the address of "my_print_function" to identify the lines of code that needs to be executed and for each element of the collection execute the function "my_print_function". So, in that respect, we can call the iterator each a functional idiom.

Now, this is very much from the functional programming paradigm, right? ( may be or may be not, lets keep this job for the debaters! ) Readers are encouraged to please refer [http://khelll.com/blog/ruby/ruby-and-functional-programming here] for further understanding of functional idioms.

 
For curious readers, both the above code produces the following output:

This is a Pythagorean triple!
[3, 4, 5]

 

= Conclusion =

Ruby provides such a flexible approach to use iterators as compared to C++ and Java that it is worth learning these iterators and to try out them while writing code ( or just for fun if programmers want to!). In ruby the iterator is simply a method that calls yield and passes control to a block of code associated with this iterator method. Unlike Java and C++, ruby does not requires the need to generate helper classes to carry the iterator state thus making it a transparent language. A beginner in ruby may think that the working of a block and yield is magical but actually, it is not! ( the wiki page just explains this magical behavior, right? ). As programmers keeps working on iterators, blocks and functional idioms they understand how easy it is to define your behavior without having the overhead of extra utilities. And this makes ruby programming so easy because you concentrate on getting the job done, not on building scaffolding to support the language itself.<ref>"Ruby Blocks, Iterators and containers" http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html</ref>
 

= Topical References =
<references/>

 

= Further Reading =
[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : Ruby loops and iterators.

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks.

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

[http://www.devarticles.com/c/a/Ruby-on-Rails/Iterators-in-Ruby/ Ruby cookbook] : More about Ruby iterators.

[http://khelll.com/blog/ruby/ruby-and-functional-programming/ Functional Idioms] : Functional idioms explained.

CSC/ECE 517 Fall 2012/ch1b 1w58 am

2012-10-04T02:54:55Z

Mrkamat: /* Functional Idioms */

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>"Blocks basics" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

Expression orientation<ref name="saas_video">"SaaS. 3.6 - Ruby Blocks, Iterators, Functional Idioms " http://www.youtube.com/watch?v=bRn91_Zonh4</ref> in ruby refers to the mechanism of applying a series of operation on collections ( e.g. arrays, hashes etc ) without actually modifying the original collection. For example, consider the sort method in ruby. The sort method when called on an array creates a temporary array having the same elements as that of the original array. It then sorts this temporary array and returns that. So, for the code shown below:

a = [ 9, 8, 3, 6, 4]
print a.sort
print a

produces the following output:

[3, 4, 6, 8, 9]
[9, 8, 3, 6, 4]

From the output it is very clear that the original array is not modified while we can still perform a series of operations on the array a. Surprisingly, ruby also performs cascaded operations for ex,

x = ["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]
print x.uniq.reverse
print x

this code gives the following output:

["only", "and", "pancakes", "love", "I"]
["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]

Here, the first operation x.sort removes duplicate occurrences of string "pancakes" from the temporary array which it creates to perform this operation and then the reverse operation reverses that temporary array to print the elements in the reverse order. However, the original array is still not modified and the next print.x statement prints the original array x.

One important thing to note here is that if directly reverse operation is used then the array gets modified. For example, for the code above, if later the programmer directly writes

print x.reverse!
print x

then we get the following output

["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]
["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]

Thus, the array x gets modified. Ruby is indeed crazy, isn't it?

= Functional Idioms =

Functional idioms refers to the various constructs in ruby that mimics Functional Programming Language. Most programmers argue that Ruby is actually an Object Oriented Programming Language and it does not behaves as per the functional programming paradigm. However, though the arguement is open ended, Ruby is a multi-paradigm language that supports a functional style of programming, (supporting functional style of programming doesn't make the language a Functional Programming language ). Ruby does supports the functional programming behavior of avoiding mutable states. To make the concept clear, consider the example shown below which uses the iterator "each". This type of iteration in ruby is actually a function because ruby passes a function ( block of code ) to be called on each item in the collection<ref>"Ruby a functional language" http://stackoverflow.com/questions/159797/is-ruby-a-functional-language</ref>.

puts "This is a pythagorean triple!"
[3, 4, 5].each { |num| print num }

In the above example<ref>"Functional programming in ruby" http://tech.rufy.com/2006/11/functional-programming-in-ruby.html</ref>, the function being passed is { |num| puts num }. In fact, the code shown below accomplishes the same behavior as done above:

puts "This is a pythagorean triple!"
my_print_function = lambda { |num| print num }
[3, 4, 5].each &my_print_function

Here, in the example shown above, we use the address of "my_print_function" to identify the lines of code that needs to be executed and for each element of the collection execute the function "my_print_function". So, in that respect, we can call the iterator each a functional idiom.

Now, this is very much from the functional programming paradigm, right? ( may be or may be not, lets keep this job for the debaters!). Readers are encouraged to please refer to [http://khelll.com/blog/ruby/ruby-and-functional-programming this] for further understanding of functional idioms.

For curious readers, both the above code produces the following output:

This is a pythagorean triple!
[3, 4, 5]

= Conclusion =

Ruby provides such a flexible approach to use iterators as compared to C++ and Java that it is worth learning these iterators and try out them while writing code ( or just for fun if programmers want to!). In ruby the iterator is simply a method that calls yield and passes control to a block of code associated with this iterator method. Unlike Java and C++, ruby does not requires the need to generate helper classes to carry the iterator state thus making it a transparent language. A beginner in ruby may think that the working of a block and yield is magical but actually, it is not! ( the wiki page just explains this magical behavior, right? ). As programmers keeps working on iterators, blocks and functional idioms they understand how easy it is to define your behavior without having the overhead of extra utilities. And this makes ruby programming so easy because you concentrate on getting the job done, not on building scaffolding to support the language itself.<ref>"Ruby Blocks, Iterators and containers" http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html</ref>

= Topical References =
<references/>

= Further Reading =
[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : Ruby loops and iterators.

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks.

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

[http://www.devarticles.com/c/a/Ruby-on-Rails/Iterators-in-Ruby/ Ruby cookbook] : More about Ruby iterators.

[http://khelll.com/blog/ruby/ruby-and-functional-programming/ Functional Idioms] : Functional idioms explained.

CSC/ECE 517 Fall 2012/ch1b 1w58 am

2012-10-04T02:51:18Z

Mrkamat: /* Functional Idioms */

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>"Blocks basics" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

Expression orientation<ref name="saas_video">"SaaS. 3.6 - Ruby Blocks, Iterators, Functional Idioms " http://www.youtube.com/watch?v=bRn91_Zonh4</ref> in ruby refers to the mechanism of applying a series of operation on collections ( e.g. arrays, hashes etc ) without actually modifying the original collection. For example, consider the sort method in ruby. The sort method when called on an array creates a temporary array having the same elements as that of the original array. It then sorts this temporary array and returns that. So, for the code shown below:

a = [ 9, 8, 3, 6, 4]
print a.sort
print a

produces the following output:

[3, 4, 6, 8, 9]
[9, 8, 3, 6, 4]

From the output it is very clear that the original array is not modified while we can still perform a series of operations on the array a. Surprisingly, ruby also performs cascaded operations for ex,

x = ["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]
print x.uniq.reverse
print x

this code gives the following output:

["only", "and", "pancakes", "love", "I"]
["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]

Here, the first operation x.sort removes duplicate occurrences of string "pancakes" from the temporary array which it creates to perform this operation and then the reverse operation reverses that temporary array to print the elements in the reverse order. However, the original array is still not modified and the next print.x statement prints the original array x.

One important thing to note here is that if directly reverse operation is used then the array gets modified. For example, for the code above, if later the programmer directly writes

print x.reverse!
print x

then we get the following output

["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]
["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]

Thus, the array x gets modified. Ruby is indeed crazy, isn't it?

= Functional Idioms =

Functional idioms refers to the various constructs in ruby that mimics Functional Programming Language. Most programmers argue that Ruby is actually an Object Oriented Programming Language and it does not behaves as per the functional programming paradigm. However, though the arguement is open ended, Ruby is a multi-paradigm language that supports a functional style of programming, (supporting functional style of programming doesn't make the language a Functional Programming language ). Ruby does supports the functional programming behavior of avoiding mutable states. To make the concept clear, consider the example shown below which uses the iterator "each". This type of iteration in ruby is actually a function because ruby passes a function ( block of code ) to be called on each item in the collection<ref>http://stackoverflow.com/questions/159797/is-ruby-a-functional-language</ref>.

puts "This is a pythagorean triple!"
[3, 4, 5].each { |num| print num }

In the above example<ref>http://tech.rufy.com/2006/11/functional-programming-in-ruby.html</ref>, the function being passed is { |num| puts num }. In fact, the code shown below accomplishes the same behavior as done above:

puts "This is a pythagorean triple!"
my_print_function = lambda { |num| print num }
[3, 4, 5].each &my_print_function

Here, in the example shown above, we use the address of "my_print_function" to identify the lines of code that needs to be executed and for each element of the collection execute the function "my_print_function". So, in that respect, we can call the iterator each a functional idiom.

Now, this is very much from the functional programming paradigm, right? ( may be or may be not, lets keep this job for the debaters!). Readers are encouraged to please refer to [http://khelll.com/blog/ruby/ruby-and-functional-programming this] for further understanding of functional idioms.

For curious readers, both the above code produces the following output:

This is a pythagorean triple!
[3, 4, 5]

= Conclusion =

Ruby provides such a flexible approach to use iterators as compared to C++ and Java that it is worth learning these iterators and try out them while writing code ( or just for fun if programmers want to!). In ruby the iterator is simply a method that calls yield and passes control to a block of code associated with this iterator method. Unlike Java and C++, ruby does not requires the need to generate helper classes to carry the iterator state thus making it a transparent language. A beginner in ruby may think that the working of a block and yield is magical but actually, it is not! ( the wiki page just explains this magical behavior, right? ). As programmers keeps working on iterators, blocks and functional idioms they understand how easy it is to define your behavior without having the overhead of extra utilities. And this makes ruby programming so easy because you concentrate on getting the job done, not on building scaffolding to support the language itself.<ref>"Ruby Blocks, Iterators and containers" http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html</ref>

= Topical References =
<references/>

= Further Reading =
[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : Ruby loops and iterators.

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks.

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

[http://www.devarticles.com/c/a/Ruby-on-Rails/Iterators-in-Ruby/ Ruby cookbook] : More about Ruby iterators.

[http://khelll.com/blog/ruby/ruby-and-functional-programming/ Functional Idioms] : Functional idioms explained.

CSC/ECE 517 Fall 2012

2012-10-04T02:41:38Z

Mrkamat:

*[[CSC/ECE 517 Fall 2012/ch1 n xx]]
*[[CSC/ECE 517 Fall 2012/ch1 1w1 rk]]
*[[CSC/ECE 517 Fall 2012/ch1 1w20 pp]]
*[[CSC/ECE 517 Fall 2012/ch1 1w5 su]]
*[[CSC/ECE 517 Fall 2012/ch1 1w6 pp]]
*[[CSC/ECE 517 Fall 2012/ch1 1w4 aj]]
*[[CSC/ECE 517 Fall 2012/ch1 1w7 am]]
*[[CSC/ECE 517 Fall 2012/ch1 1w8 aa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w9 av]]
*[[CSC/ECE 517 Fall 2012/ch1 1w10 pk]]
*[[CSC/ECE 517 Fall 2012/ch1 1w11 ap]]
*[[CSC/ECE 517 Fall 2012/ch1a 1w12 mv]]
*[[CSC/ECE 517 Fall 2012/ch1 1w14 gv]]
*[[CSC/ECE 517 Fall 2012/ch1 1w17 ir]]
*[[CSC/ECE 517 Fall 2012/ch1 1w18 as]]
*[[CSC/ECE 517 Fall 2012/ch1 1w22 an]]
*[[CSC/ECE 517 Fall 2012/ch1 1w21 aa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w21 wi]]
*[[CSC/ECE 517 Fall 2012/ch1 1w31 sa]]
*[[CSC/ECE 517 Fall 2012/ch1a 1w16 br]]
*[[CSC/ECE 517 Fall 2012/ch1a 1w23 as]]
*[[CSC/ECE 517 Fall 2012/ch1 1w24 nr]]
*[[CSC/ECE 517 Fall 2012/ch1 1w15 rt]]
*[[CSC/ECE 517 Fall 2012/ch1 1w3 pl]]
*[[CSC/ECE 517 Fall 2012/ch1 1w32 cm]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w37 ss]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w67 ks]]

*[[CSC/ECE 517 Fall 2012/ch1 1w27 ms]]
*[[CSC/ECE 517 Fall 2012/ch1 1w29 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w33 op]]
*[[CSC/ECE 517 Fall 2012/ch1 1w19 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w34 vd]]
*[[CSC/ECE 517 Fall 2012/ch1 1w35 sa]]
*[[CSC/ECE 517 Fall 2012/ch1 1w30 rp]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w58 am]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w47 sk]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w69 mv]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w44 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w45 is]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w53 kc]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w40 ar]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w39 sn]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w54 go]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w56 ms]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w64 nn]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w66 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w40 as]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w42 js]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w46 sm]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w71 gs]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w63 dv]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w55 ms]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w57 mp]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w52 an]]
*[[CSC/ECE_517_Fall_2012/ch1b 1w38 nm]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w60 ac]]
*[[CSC/ECE 517 Fall 2012/ch1b 1w62 rb]]

CSC/ECE 517 Fall 2012/ch1b 1w58 am

2012-10-04T02:39:36Z

Mrkamat: /* Further Reading */

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>"Blocks basics" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

Expression orientation<ref name="saas_video">"SaaS. 3.6 - Ruby Blocks, Iterators, Functional Idioms " http://www.youtube.com/watch?v=bRn91_Zonh4</ref> in ruby refers to the mechanism of applying a series of operation on collections ( e.g. arrays, hashes etc ) without actually modifying the original collection. For example, consider the sort method in ruby. The sort method when called on an array creates a temporary array having the same elements as that of the original array. It then sorts this temporary array and returns that. So, for the code shown below:

a = [ 9, 8, 3, 6, 4]
print a.sort
print a

produces the following output:

[3, 4, 6, 8, 9]
[9, 8, 3, 6, 4]

From the output it is very clear that the original array is not modified while we can still perform a series of operations on the array a. Surprisingly, ruby also performs cascaded operations for ex,

x = ["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]
print x.uniq.reverse
print x

this code gives the following output:

["only", "and", "pancakes", "love", "I"]
["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]

Here, the first operation x.sort removes duplicate occurrences of string "pancakes" from the temporary array which it creates to perform this operation and then the reverse operation reverses that temporary array to print the elements in the reverse order. However, the original array is still not modified and the next print.x statement prints the original array x.

One important thing to note here is that if directly reverse operation is used then the array gets modified. For example, for the code above, if later the programmer directly writes

print x.reverse!
print x

then we get the following output

["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]
["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]

Thus, the array x gets modified. Ruby is indeed crazy, isn't it?

= Functional Idioms =

Functional idioms refers to the various constructs in ruby that mimics Functional Programming Language. Most programmers argue that Ruby is actually an Object Oriented Programming Language and it does not behaves as per the functional programming paradigm. However, thought the argue is open ended, Ruby is a multi-paradigm language that supports a functional style of programming, (supporting functional style of programming doesn't make the language a Functional Programming language ). Ruby does supports the functional programming behavior of avoiding mutable states. To make the concept clear, consider the example shown below which uses the iterator "each". This type of iteration in ruby is actually a function because ruby passes a function ( block of code ) to be called on each item in the collection<ref>http://stackoverflow.com/questions/159797/is-ruby-a-functional-language</ref>.

puts "This is a pythagorean triple!"
[3, 4, 5].each { |num| print num }

In the above example<ref>http://tech.rufy.com/2006/11/functional-programming-in-ruby.html</ref>, the function being passed is { |num| puts num }. In fact, the code shown below accomplishes the same behavior as done above:

puts "This is a pythagorean triple!"
my_print_function = lambda { |num| print num }
[3, 4, 5].each &my_print_function

Here, in the example shown above, we use the address of "my_print_function" to identify the lines of code that needs to be executed and for each element of the collection execute the function "my_print_function". So, in that respect, we can call the iterator each a functional idiom.

Now, this is very much from the functional programming paradigm, right? ( may be or may be not, lets keep this job for the debaters!). Readers are encouraged to please refer to [http://khelll.com/blog/ruby/ruby-and-functional-programming this] for further understanding of functional idioms.

For curious readers, both the above code produces the following output:

This is a pythagorean triple!
[3, 4, 5]

= Conclusion =

Ruby provides such a flexible approach to use iterators as compared to C++ and Java that it is worth learning these iterators and try out them while writing code ( or just for fun if programmers want to!). In ruby the iterator is simply a method that calls yield and passes control to a block of code associated with this iterator method. Unlike Java and C++, ruby does not requires the need to generate helper classes to carry the iterator state thus making it a transparent language. A beginner in ruby may think that the working of a block and yield is magical but actually, it is not! ( the wiki page just explains this magical behavior, right? ). As programmers keeps working on iterators, blocks and functional idioms they understand how easy it is to define your behavior without having the overhead of extra utilities. And this makes ruby programming so easy because you concentrate on getting the job done, not on building scaffolding to support the language itself.<ref>"Ruby Blocks, Iterators and containers" http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html</ref>

= Topical References =
<references/>

= Further Reading =
[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : Ruby loops and iterators.

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks.

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

[http://www.devarticles.com/c/a/Ruby-on-Rails/Iterators-in-Ruby/ Ruby cookbook] : More about Ruby iterators.

[http://khelll.com/blog/ruby/ruby-and-functional-programming/ Functional Idioms] : Functional idioms explained.

CSC/ECE 517 Fall 2012/ch1b 1w58 am

2012-10-04T02:38:49Z

Mrkamat: /* Functional Idioms */

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>"Blocks basics" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

Expression orientation<ref name="saas_video">"SaaS. 3.6 - Ruby Blocks, Iterators, Functional Idioms " http://www.youtube.com/watch?v=bRn91_Zonh4</ref> in ruby refers to the mechanism of applying a series of operation on collections ( e.g. arrays, hashes etc ) without actually modifying the original collection. For example, consider the sort method in ruby. The sort method when called on an array creates a temporary array having the same elements as that of the original array. It then sorts this temporary array and returns that. So, for the code shown below:

a = [ 9, 8, 3, 6, 4]
print a.sort
print a

produces the following output:

[3, 4, 6, 8, 9]
[9, 8, 3, 6, 4]

From the output it is very clear that the original array is not modified while we can still perform a series of operations on the array a. Surprisingly, ruby also performs cascaded operations for ex,

x = ["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]
print x.uniq.reverse
print x

this code gives the following output:

["only", "and", "pancakes", "love", "I"]
["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]

Here, the first operation x.sort removes duplicate occurrences of string "pancakes" from the temporary array which it creates to perform this operation and then the reverse operation reverses that temporary array to print the elements in the reverse order. However, the original array is still not modified and the next print.x statement prints the original array x.

One important thing to note here is that if directly reverse operation is used then the array gets modified. For example, for the code above, if later the programmer directly writes

print x.reverse!
print x

then we get the following output

["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]
["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]

Thus, the array x gets modified. Ruby is indeed crazy, isn't it?

= Functional Idioms =

Functional idioms refers to the various constructs in ruby that mimics Functional Programming Language. Most programmers argue that Ruby is actually an Object Oriented Programming Language and it does not behaves as per the functional programming paradigm. However, thought the argue is open ended, Ruby is a multi-paradigm language that supports a functional style of programming, (supporting functional style of programming doesn't make the language a Functional Programming language ). Ruby does supports the functional programming behavior of avoiding mutable states. To make the concept clear, consider the example shown below which uses the iterator "each". This type of iteration in ruby is actually a function because ruby passes a function ( block of code ) to be called on each item in the collection<ref>http://stackoverflow.com/questions/159797/is-ruby-a-functional-language</ref>.

puts "This is a pythagorean triple!"
[3, 4, 5].each { |num| print num }

In the above example<ref>http://tech.rufy.com/2006/11/functional-programming-in-ruby.html</ref>, the function being passed is { |num| puts num }. In fact, the code shown below accomplishes the same behavior as done above:

puts "This is a pythagorean triple!"
my_print_function = lambda { |num| print num }
[3, 4, 5].each &my_print_function

Here, in the example shown above, we use the address of "my_print_function" to identify the lines of code that needs to be executed and for each element of the collection execute the function "my_print_function". So, in that respect, we can call the iterator each a functional idiom.

Now, this is very much from the functional programming paradigm, right? ( may be or may be not, lets keep this job for the debaters!). Readers are encouraged to please refer to [http://khelll.com/blog/ruby/ruby-and-functional-programming this] for further understanding of functional idioms.

For curious readers, both the above code produces the following output:

This is a pythagorean triple!
[3, 4, 5]

= Conclusion =

Ruby provides such a flexible approach to use iterators as compared to C++ and Java that it is worth learning these iterators and try out them while writing code ( or just for fun if programmers want to!). In ruby the iterator is simply a method that calls yield and passes control to a block of code associated with this iterator method. Unlike Java and C++, ruby does not requires the need to generate helper classes to carry the iterator state thus making it a transparent language. A beginner in ruby may think that the working of a block and yield is magical but actually, it is not! ( the wiki page just explains this magical behavior, right? ). As programmers keeps working on iterators, blocks and functional idioms they understand how easy it is to define your behavior without having the overhead of extra utilities. And this makes ruby programming so easy because you concentrate on getting the job done, not on building scaffolding to support the language itself.<ref>"Ruby Blocks, Iterators and containers" http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html</ref>

= Topical References =
<references/>

= Further Reading =
[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : Ruby loops and iterators.

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks.

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

[http://www.devarticles.com/c/a/Ruby-on-Rails/Iterators-in-Ruby/ Ruby cookbook] : More about Ruby iterators.

CSC/ECE 517 Fall 2012/ch1b 1w58 am

2012-10-04T02:37:54Z

Mrkamat:

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>"Blocks basics" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

Expression orientation<ref name="saas_video">"SaaS. 3.6 - Ruby Blocks, Iterators, Functional Idioms " http://www.youtube.com/watch?v=bRn91_Zonh4</ref> in ruby refers to the mechanism of applying a series of operation on collections ( e.g. arrays, hashes etc ) without actually modifying the original collection. For example, consider the sort method in ruby. The sort method when called on an array creates a temporary array having the same elements as that of the original array. It then sorts this temporary array and returns that. So, for the code shown below:

a = [ 9, 8, 3, 6, 4]
print a.sort
print a

produces the following output:

[3, 4, 6, 8, 9]
[9, 8, 3, 6, 4]

From the output it is very clear that the original array is not modified while we can still perform a series of operations on the array a. Surprisingly, ruby also performs cascaded operations for ex,

x = ["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]
print x.uniq.reverse
print x

this code gives the following output:

["only", "and", "pancakes", "love", "I"]
["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]

Here, the first operation x.sort removes duplicate occurrences of string "pancakes" from the temporary array which it creates to perform this operation and then the reverse operation reverses that temporary array to print the elements in the reverse order. However, the original array is still not modified and the next print.x statement prints the original array x.

One important thing to note here is that if directly reverse operation is used then the array gets modified. For example, for the code above, if later the programmer directly writes

print x.reverse!
print x

then we get the following output

["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]
["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]

Thus, the array x gets modified. Ruby is indeed crazy, isn't it?

= Functional Idioms =

Functional idioms refers to the various constructs in ruby that mimics Functional Programming Language. Most programmers argue that Ruby is actually an Object Oriented Programming Language and it does not behaves as per the functional programming paradigm. However, thought the argue is open ended, Ruby is a multi-paradigm language that supports a functional style of programming, (supporting functional style of programming doesn't make the language a Functional Programming language ). Ruby does supports the functional programming behavior of avoiding mutable states. To make the concept clear, consider the example shown below which uses the iterator "each". This type of iteration in ruby is actually a function because ruby passes a function ( block of code ) to be called on each item in the collection.

puts "This is a pythagorean triple!"
[3, 4, 5].each { |num| print num }

In the above example, the function being passed is { |num| puts num }. In fact, the code shown below accomplishes the same behavior as done above:

puts "This is a pythagorean triple!"
my_print_function = lambda { |num| print num }
[3, 4, 5].each &my_print_function

Here, in the example shown above, we use the address of "my_print_function" to identify the lines of code that needs to be executed and for each element of the collection execute the function "my_print_function". So, in that respect, we can call the iterator each a functional idiom.

Now, this is very much from the functional programming paradigm, right? ( may be or may be not, lets keep this job for the debaters!). Readers are encouraged to please refer to [http://khelll.com/blog/ruby/ruby-and-functional-programming this] for further understanding of functional idioms.

For curious readers, both the above code produces the following output:

This is a pythagorean triple!
[3, 4, 5]

= Conclusion =

Ruby provides such a flexible approach to use iterators as compared to C++ and Java that it is worth learning these iterators and try out them while writing code ( or just for fun if programmers want to!). In ruby the iterator is simply a method that calls yield and passes control to a block of code associated with this iterator method. Unlike Java and C++, ruby does not requires the need to generate helper classes to carry the iterator state thus making it a transparent language. A beginner in ruby may think that the working of a block and yield is magical but actually, it is not! ( the wiki page just explains this magical behavior, right? ). As programmers keeps working on iterators, blocks and functional idioms they understand how easy it is to define your behavior without having the overhead of extra utilities. And this makes ruby programming so easy because you concentrate on getting the job done, not on building scaffolding to support the language itself.<ref>"Ruby Blocks, Iterators and containers" http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html</ref>

= Topical References =
<references/>

= Further Reading =
[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : Ruby loops and iterators.

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks.

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

[http://www.devarticles.com/c/a/Ruby-on-Rails/Iterators-in-Ruby/ Ruby cookbook] : More about Ruby iterators.

CSC/ECE 517 Fall 2012/ch1b 1w58 am

2012-10-04T02:33:57Z

Mrkamat: /* Functional Idioms */

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>"Blocks basics" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

Expression orientation<ref name="saas_video">"SaaS. 3.6 - Ruby Blocks, Iterators, Functional Idioms " http://www.youtube.com/watch?v=bRn91_Zonh4</ref> in ruby refers to the mechanism of applying a series of operation on collections ( e.g. arrays, hashes etc ) without actually modifying the original collection. For example, consider the sort method in ruby. The sort method when called on an array creates a temporary array having the same elements as that of the original array. It then sorts this temporary array and returns that. So, for the code shown below:

a = [ 9, 8, 3, 6, 4]
print a.sort
print a

produces the following output:

[3, 4, 6, 8, 9]
[9, 8, 3, 6, 4]

From the output it is very clear that the original array is not modified while we can still perform a series of operations on the array a. Surprisingly, ruby also performs cascaded operations for ex,

x = ["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]
print x.uniq.reverse
print x

this code gives the following output:

["only", "and", "pancakes", "love", "I"]
["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]

Here, the first operation x.sort removes duplicate occurrences of string "pancakes" from the temporary array which it creates to perform this operation and then the reverse operation reverses that temporary array to print the elements in the reverse order. However, the original array is still not modified and the next print.x statement prints the original array x.

One important thing to note here is that if directly reverse operation is used then the array gets modified. For example, for the code above, if later the programmer directly writes

print x.reverse!
print x

then we get the following output

["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]
["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]

Thus, the array x gets modified. Ruby is indeed crazy, isn't it?

= Functional Idioms =

Functional idioms refers to the various constructs in ruby that mimics Functional Programming Language. Most programmers argue that Ruby is actually an Object Oriented Programming Language and it does not behaves as per the functional programming paradigm. However, thought the argue is open ended, Ruby is a multi-paradigm language that supports a functional style of programming, (supporting functional style of programming doesn't make the language a Functional Programming language ). Ruby does supports the functional programming behavior of avoiding mutable states. To make the concept clear, consider the example shown below which uses the iterator "each". This type of iteration in ruby is actually a function because ruby passes a function ( block of code ) to be called on each item in the collection.

puts "This is a pythagorean triple!"
[3, 4, 5].each { |num| print num }

In the above example, the function being passed is { |num| puts num }. In fact, the code shown below accomplishes the same behavior as done above:

puts "This is a pythagorean triple!"
my_print_function = lambda { |num| print num }
[3, 4, 5].each &my_print_function

Here, in the example shown above, we use the address of "my_print_function" to identify the lines of code that needs to be executed and for each element of the collection execute the function "my_print_function". So, in that respect, we can call the iterator each a functional idiom.

Now, this is very much from the functional programming paradigm, right? ( may be or may be not, lets keep this job for the debaters!). Readers are encouraged to please refer to <a ref="http://khelll.com/blog/ruby/ruby-and-functional-programming/" /> for further understanding of functional idioms.

For curious readers, both the above code produces the following output:

This is a pythagorean triple!
[3, 4, 5]

= Conclusion =

Ruby provides such a flexible approach to use iterators as compared to C++ and Java that it is worth learning these iterators and try out them while writing code ( or just for fun if programmers want to!). In ruby the iterator is simply a method that calls yield and passes control to a block of code associated with this iterator method. Unlike Java and C++, ruby does not requires the need to generate helper classes to carry the iterator state thus making it a transparent language. A beginner in ruby may think that the working of a block and yield is magical but actually, it is not! ( the wiki page just explains this magical behavior, right? ). As programmers keeps working on iterators, blocks and functional idioms they understand how easy it is to define your behavior without having the overhead of extra utilities. And this makes ruby programming so easy because you concentrate on getting the job done, not on building scaffolding to support the language itself.<ref>"Ruby Blocks, Iterators and containers" http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html</ref>

= Topical References =
<references/>

= Further Reading =
[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : Ruby loops and iterators.

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks.

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

[http://www.devarticles.com/c/a/Ruby-on-Rails/Iterators-in-Ruby/ Ruby cookbook] : More about Ruby iterators.

CSC/ECE 517 Fall 2012/ch1b 1w58 am

2012-10-04T02:23:45Z

Mrkamat: Created page with "='''Ruby Blocks, Iterators, Functional Idioms'''= This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. __TOC__ = In..."

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>"Blocks basics" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

Expression orientation<ref name="saas_video">"SaaS. 3.6 - Ruby Blocks, Iterators, Functional Idioms " http://www.youtube.com/watch?v=bRn91_Zonh4</ref> in ruby refers to the mechanism of applying a series of operation on collections ( e.g. arrays, hashes etc ) without actually modifying the original collection. For example, consider the sort method in ruby. The sort method when called on an array creates a temporary array having the same elements as that of the original array. It then sorts this temporary array and returns that. So, for the code shown below:

a = [ 9, 8, 3, 6, 4]
print a.sort
print a

produces the following output:

[3, 4, 6, 8, 9]
[9, 8, 3, 6, 4]

From the output it is very clear that the original array is not modified while we can still perform a series of operations on the array a. Surprisingly, ruby also performs cascaded operations for ex,

x = ["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]
print x.uniq.reverse
print x

this code gives the following output:

["only", "and", "pancakes", "love", "I"]
["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]

Here, the first operation x.sort removes duplicate occurrences of string "pancakes" from the temporary array which it creates to perform this operation and then the reverse operation reverses that temporary array to print the elements in the reverse order. However, the original array is still not modified and the next print.x statement prints the original array x.

One important thing to note here is that if directly reverse operation is used then the array gets modified. For example, for the code above, if later the programmer directly writes

print x.reverse!
print x

then we get the following output

["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]
["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]

Thus, the array x gets modified. Ruby is indeed crazy, isn't it?

= Functional Idioms =

Functional idioms refers to the various constructs in ruby that mimics Functional Programming Language. Most programmers argue that Ruby is actually an Object Oriented Programming Language and it does not behaves as per the functional programming paradigm. However, thought the argue is open ended, Ruby is a multi-paradigm language that supports a functional style of programming, (supporting functional style of programming doesn't make the language a Functional Programming language ). Ruby does supports the functional programming behavior of avoiding mutable states. To make the concept clear, consider the example shown below which uses the iterator "each". This type of iteration in ruby is actually a function because ruby passes a function ( block of code ) to be called on each item in the collection.

puts "This is a pythagorean triple!"
[3, 4, 5].each { |num| print num }

In the above example, the function being passed is { |num| puts num }. In fact, the code shown below accomplishes the same behavior as done above:

puts "This is a pythagorean triple!"
my_print_function = lambda { |num| print num }
[3, 4, 5].each &my_print_function

Here, in the example shown above, we use the address of "my_print_function" to identify the lines of code that needs to be executed and for each element of the collection execute the function "my_print_function". So, in that respect, we can call the iterator each a functional idiom.

Now, this is very much from the functional programming paradigm, right? ( may be or may be not, lets keep this job for the debaters!). Readers are encouraged to please refer to ___ for further understanding of functional idioms.

For curious readers, both the above code produces the following output:

This is a pythagorean triple!
[3, 4, 5]

= Conclusion =

Ruby provides such a flexible approach to use iterators as compared to C++ and Java that it is worth learning these iterators and try out them while writing code ( or just for fun if programmers want to!). In ruby the iterator is simply a method that calls yield and passes control to a block of code associated with this iterator method. Unlike Java and C++, ruby does not requires the need to generate helper classes to carry the iterator state thus making it a transparent language. A beginner in ruby may think that the working of a block and yield is magical but actually, it is not! ( the wiki page just explains this magical behavior, right? ). As programmers keeps working on iterators, blocks and functional idioms they understand how easy it is to define your behavior without having the overhead of extra utilities. And this makes ruby programming so easy because you concentrate on getting the job done, not on building scaffolding to support the language itself.<ref>"Ruby Blocks, Iterators and containers" http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html</ref>

= Topical References =
<references/>

= Further Reading =
[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : Ruby loops and iterators.

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks.

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

[http://www.devarticles.com/c/a/Ruby-on-Rails/Iterators-in-Ruby/ Ruby cookbook] : More about Ruby iterators.

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T23:56:48Z

Mrkamat: /* Conclusion */

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>"Blocks basics" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

Expression orientation<ref name="saas_video">"SaaS. 3.6 - Ruby Blocks, Iterators, Functional Idioms " http://www.youtube.com/watch?v=bRn91_Zonh4</ref> in ruby refers to the mechanism of applying a series of operation on collections ( e.g. arrays, hashes etc ) without actually modifying the original collection. For example, consider the sort method in ruby. The sort method when called on an array creates a temporary array having the same elements as that of the original array. It then sorts this temporary array and returns that. So, for the code shown below:

a = [ 9, 8, 3, 6, 4]
print a.sort
print a

produces the following output:

[3, 4, 6, 8, 9]
[9, 8, 3, 6, 4]

From the output it is very clear that the original array is not modified while we can still perform a series of operations on the array a. Surprisingly, ruby also performs cascaded operations for ex,

x = ["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]
print x.uniq.reverse
print x

this code gives the following output:

["only", "and", "pancakes", "love", "I"]
["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]

Here, the first operation x.sort removes duplicate occurrences of string "pancakes" from the temporary array which it creates to perform this operation and then the reverse operation reverses that temporary array to print the elements in the reverse order. However, the original array is still not modified and the next print.x statement prints the original array x.

One important thing to note here is that if directly reverse operation is used then the array gets modified. For example, for the code above, if later the programmer directly writes

print x.reverse!
print x

then we get the following output

["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]
["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]

Thus, the array x gets modified. Ruby is indeed crazy, isn't it?

= Conclusion =

Ruby provides such a flexible approach to use iterators as compared to C++ and Java that it is worth learning these iterators and try out them while writing code ( or just for fun if programmers want to!). In ruby the iterator is simply a method that calls yield and passes control to a block of code associated with this iterator method. Unlike Java and C++, ruby does not requires the need to generate helper classes to carry the iterator state thus making it a transparent language. A beginner in ruby may think that the working of a block and yield is magical but actually, it is not! ( the wiki page just explains this magical behavior, right? ). As programmers keeps working on iterators, blocks and functional idioms they understand how easy it is to define your behavior without having the overhead of extra utilities. And this makes ruby programming so easy because you concentrate on getting the job done, not on building scaffolding to support the language itself.<ref>"Ruby Blocks, Iterators and containers" http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html</ref>

= Topical References =
<references/>

= Further Reading =
[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : Ruby loops and iterators.

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks.

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

[http://www.devarticles.com/c/a/Ruby-on-Rails/Iterators-in-Ruby/ Ruby cookbook] : More about Ruby iterators.

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T23:31:05Z

Mrkamat: /* Blocks */

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>"Blocks basics" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

Expression orientation<ref name="saas_video">"SaaS. 3.6 - Ruby Blocks, Iterators, Functional Idioms " http://www.youtube.com/watch?v=bRn91_Zonh4</ref> in ruby refers to the mechanism of applying a series of operation on collections ( e.g. arrays, hashes etc ) without actually modifying the original collection. For example, consider the sort method in ruby. The sort method when called on an array creates a temporary array having the same elements as that of the original array. It then sorts this temporary array and returns that. So, for the code shown below:

a = [ 9, 8, 3, 6, 4]
print a.sort
print a

produces the following output:

[3, 4, 6, 8, 9]
[9, 8, 3, 6, 4]

From the output it is very clear that the original array is not modified while we can still perform a series of operations on the array a. Surprisingly, ruby also performs cascaded operations for ex,

x = ["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]
print x.uniq.reverse
print x

this code gives the following output:

["only", "and", "pancakes", "love", "I"]
["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]

Here, the first operation x.sort removes duplicate occurrences of string "pancakes" from the temporary array which it creates to perform this operation and then the reverse operation reverses that temporary array to print the elements in the reverse order. However, the original array is still not modified and the next print.x statement prints the original array x.

One important thing to note here is that if directly reverse operation is used then the array gets modified. For example, for the code above, if later the programmer directly writes

print x.reverse!
print x

then we get the following output

["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]
["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]

Thus, the array x gets modified. Ruby is indeed crazy, isn't it?

= Topical References =
<references/>

= Further Reading =
[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : Ruby loops and iterators.

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks.

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

[http://www.devarticles.com/c/a/Ruby-on-Rails/Iterators-in-Ruby/ Ruby cookbook] : More about Ruby iterators.

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T23:30:19Z

Mrkamat: /* Expression Orientation */

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

Expression orientation<ref name="saas_video">"SaaS. 3.6 - Ruby Blocks, Iterators, Functional Idioms " http://www.youtube.com/watch?v=bRn91_Zonh4</ref> in ruby refers to the mechanism of applying a series of operation on collections ( e.g. arrays, hashes etc ) without actually modifying the original collection. For example, consider the sort method in ruby. The sort method when called on an array creates a temporary array having the same elements as that of the original array. It then sorts this temporary array and returns that. So, for the code shown below:

a = [ 9, 8, 3, 6, 4]
print a.sort
print a

produces the following output:

[3, 4, 6, 8, 9]
[9, 8, 3, 6, 4]

From the output it is very clear that the original array is not modified while we can still perform a series of operations on the array a. Surprisingly, ruby also performs cascaded operations for ex,

x = ["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]
print x.uniq.reverse
print x

this code gives the following output:

["only", "and", "pancakes", "love", "I"]
["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]

Here, the first operation x.sort removes duplicate occurrences of string "pancakes" from the temporary array which it creates to perform this operation and then the reverse operation reverses that temporary array to print the elements in the reverse order. However, the original array is still not modified and the next print.x statement prints the original array x.

One important thing to note here is that if directly reverse operation is used then the array gets modified. For example, for the code above, if later the programmer directly writes

print x.reverse!
print x

then we get the following output

["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]
["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]

Thus, the array x gets modified. Ruby is indeed crazy, isn't it?

= Topical References =
<references/>

= Further Reading =
[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : Ruby loops and iterators.

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks.

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

[http://www.devarticles.com/c/a/Ruby-on-Rails/Iterators-in-Ruby/ Ruby cookbook] : More about Ruby iterators.

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T23:28:09Z

Mrkamat: /* Expression Orientation */

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

Expression orientation<ref name="saas_video">http://www.youtube.com/watch?v=bRn91_Zonh4</ref> in ruby refers to the mechanism of applying a series of operation on collections ( e.g. arrays, hashes etc ) without actually modifying the original collection. For example, consider the sort method in ruby. The sort method when called on an array creates a temporary array having the same elements as that of the original array. It then sorts this temporary array and returns that. So, for the code shown below:

a = [ 9, 8, 3, 6, 4]
print a.sort
print a

produces the following output:

[3, 4, 6, 8, 9]
[9, 8, 3, 6, 4]

From the output it is very clear that the original array is not modified while we can still perform a series of operations on the array a. Surprisingly, ruby also performs cascaded operations for ex,

x = ["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]
print x.uniq.reverse
print x

this code gives the following output:

["only", "and", "pancakes", "love", "I"]
["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]

Here, the first operation x.sort removes duplicate occurrences of string "pancakes" from the temporary array which it creates to perform this operation and then the reverse operation reverses that temporary array to print the elements in the reverse order. However, the original array is still not modified and the next print.x statement prints the original array x.

One important thing to note here is that if directly reverse operation is used then the array gets modified. For example, for the code above, if later the programmer directly writes

print x.reverse!
print x

then we get the following output

["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]
["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]

Thus, the array x gets modified. Ruby is indeed crazy, isn't it?

= Topical References =
<references/>

= Further Reading =
[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : Ruby loops and iterators.

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks.

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

[http://www.devarticles.com/c/a/Ruby-on-Rails/Iterators-in-Ruby/ Ruby cookbook] : More about Ruby iterators.

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T23:27:30Z

Mrkamat: /* Further Reading */

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

Expression orientation in ruby refers to the mechanism of applying a series of operation on collections ( e.g. arrays, hashes etc ) without actually modifying the original collection. For example, consider the sort method in ruby. The sort method when called on an array creates a temporary array having the same elements as that of the original array. It then sorts this temporary array and returns that. So, for the code shown below:

a = [ 9, 8, 3, 6, 4]
print a.sort
print a

produces the following output:

[3, 4, 6, 8, 9]
[9, 8, 3, 6, 4]

From the output it is very clear that the original array is not modified while we can still perform a series of operations on the array a. Surprisingly, ruby also performs cascaded operations for ex,

x = ["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]
print x.uniq.reverse
print x

this code gives the following output:

["only", "and", "pancakes", "love", "I"]
["I", "love", "pancakes", "pancakes", "and", "only", "pancakes"]

Here, the first operation x.sort removes duplicate occurrences of string "pancakes" from the temporary array which it creates to perform this operation and then the reverse operation reverses that temporary array to print the elements in the reverse order. However, the original array is still not modified and the next print.x statement prints the original array x.

One important thing to note here is that if directly reverse operation is used then the array gets modified. For example, for the code above, if later the programmer directly writes

print x.reverse!
print x

then we get the following output

["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]
["pancakes", "only", "and", "pancakes", "pancakes", "love", "I"]

Thus, the array x gets modified. Ruby is indeed crazy, isn't it?

= Topical References =
<references/>

= Further Reading =
[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : Ruby loops and iterators.

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks.

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

[http://www.devarticles.com/c/a/Ruby-on-Rails/Iterators-in-Ruby/ Ruby cookbook] : More about Ruby iterators.

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T23:14:33Z

Mrkamat: /* Further Reading */

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

= Topical References =
<references/>

= Further Reading =
[http://www.youtube.com/watch?v=bRn91_Zonh4 Youtube Saas Video] : Saas Video for the topic.

[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : Ruby loops and iterators.

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks.

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

[http://www.devarticles.com/c/a/Ruby-on-Rails/Iterators-in-Ruby/ Ruby cookbook] : More about Ruby iterators.

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T23:13:57Z

Mrkamat: /* Further Reading */

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

= Topical References =
<references/>

= Further Reading =
[http://www.youtube.com/watch?v=bRn91_Zonh4 Youtube Saas Video] : Saas Video for the topic

[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : More about loops and iterators in ruby

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

[http://www.devarticles.com/c/a/Ruby-on-Rails/Iterators-in-Ruby/ Ruby cookbook] : More about Ruby iterators.

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T22:59:03Z

Mrkamat: /* Further Reading */

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

= Topical References =
<references/>

= Further Reading =
[http://www.youtube.com/watch?v=bRn91_Zonh4 Youtube Saas Video] : Saas Video for the topic

[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : More about loops and iterators in ruby

[http://allaboutruby.wordpress.com/2006/01/20/ruby-blocks-101/ Ruby block basics] : Basics about ruby blocks

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T22:46:26Z

Mrkamat: /* Blocks */

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"/> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Expression Orientation =

= Topical References =
<references/>

= Further Reading =
[http://www.youtube.com/watch?v=bRn91_Zonh4 Youtube Saas Video] : Saas Video for the topic

[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : More about loops and iterators in ruby

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T22:46:02Z

Mrkamat:

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name="own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Topical References =
<references/>

= Further Reading =
[http://www.youtube.com/watch?v=bRn91_Zonh4 Youtube Saas Video] : Saas Video for the topic

[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : More about loops and iterators in ruby

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T22:38:39Z

Mrkamat: /* Further Reading */

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name=own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Topical References =
<references/>

= Further Reading =
[http://www.youtube.com/watch?v=bRn91_Zonh4 Youtube Saas Video] : Saas Video for the topic

[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html Loops and Iterators] : More about loops and iterators in ruby

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html Iterators and Blocks] : Read more about blocks and iterators.

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T22:37:36Z

Mrkamat: /* Further Reading */

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name=own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Topical References =
<references/>

= Further Reading =
[http://www.youtube.com/watch?v=bRn91_Zonh4] : Saas Video for the topic

[http://www.wellho.net/solutions/ruby-conditionals-loops-and-iterators-in-ruby.html] : More about loops and iterators in ruby

[http://www.ruby-doc.org/docs/ProgrammingRuby/html/tut_containers.html] : Read more about blocks and iterators.

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T22:26:35Z

Mrkamat:

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref name="blocks">"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block<ref name="blocks"> consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax<ref>"More Afvanced ruby" http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered.<ref>http://www.skorks.com/2009/08/more-advanced-ruby-method-arguments-hashes-and-blocks/</ref> A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above<ref name="own_iterate">"Defining your own iterators" http://www.skorks.com/2009/09/using-ruby-blocks-and-rolling-your-own-iterators/</ref>. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator<ref name=own_iterate"/>, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Topical References =
<references/>

= Further Reading =

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T21:43:51Z

Mrkamat:

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref>"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators"/> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered. A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Topical References =
<references/>

= Further Reading =

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T21:42:55Z

Mrkamat:

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref>Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref name ="tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref>"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref name ="tutorial_point_i"/> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered. A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Topical References =
<references/>

= Further Reading =

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T21:40:58Z

Mrkamat:

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref>Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref>"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref>"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref name="Iterators">Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref name="Iterators"/> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref name="Iterators"/> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref name="Iterators"/><ref "tutorial_point_i">"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref name="tutorial_point_i"/> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered. A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Topical References =
<references/>

= Further Reading =

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T21:25:06Z

Mrkamat:

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref>Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref>"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref>"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref>Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref>Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref>Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref>Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref><ref>"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect<ref>"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map<ref>"Ruby for Newbies: Iterators and Blocks" http://net.tutsplus.com/tutorials/ruby/ruby-for-newbies-iterators-and-blocks/</ref> method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered. A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Topical References =
<references/>

= Further Reading =

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T21:13:25Z

Mrkamat:

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref>Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref>"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref>"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator: ===
The times<ref>Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator: ===
The upto<ref>Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator: ===
The above iterators times and upto performs the loop execution in increments of 1. Step<ref>Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator: ===

All collections in Ruby have an each<ref>Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref><ref>"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered. A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Topical References =
<references/>

= Further Reading =

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T21:11:33Z

Mrkamat:

='''Ruby Blocks, Iterators, Functional Idioms'''=

This wiki-page serves as a knowledge source for understanding Ruby Blocks, Iterators, Functional Idioms. 

__TOC__

= Introduction =

Ruby has simplified the way programmers use loops and iterators. Ruby helps programmers to use DRY principle effectively by using blocks and defining iterators over collections.<ref>Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref> This helps in minimizing the development work that programmers often find in any other O-O style programming language. In ruby, these iterators, blocks and functional idioms are explained as:

Iterators are Collection defined methods that helps to iterate over all the elements present in a Collection.<ref>"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref> Ruby Collections are basically objects that store a group of data members of various types. Examples of Collection are arrays, hashes etc.
A block consists of chunks of codes with a name assigned to it.<ref>"Ruby blocks" http://www.tutorialspoint.com/ruby/ruby_blocks.htm</ref> For example,

my_block { puts "Hello World" }

Functional idioms are ... (please feel free to add about functional idioms here and become the author of it :) )

= Iterators =

Iterators in ruby can be written in following ways:

=== The times iterator<ref>Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref>: ===
The times iterators works similar to the for loop used in programming languages. As the name suggests it allows to loop over a chunk of code n number of times. For example:

5.times { puts "Hello Viewers!" }

This code produces the following output:

Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!
Hello Viewers!

Any chunk of code enclosed within the curly braces will execute 5 times in the above example.

=== The upto iterator<ref>Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref>: ===
The upto iterator is also similar to the for loop. However, the difference between times and upto iterator is that, upto allows the programmer to specify the start index m and the end index n of the loop. So, if we define an upto iterator as m.upto(n) { # do some work }, then the code in curly braces will be executed n - m + 1 number of times. For example:

m = 45
n = 48
m.utpo(n) {puts "Hello Viewers! This is really cool, isn't it?"}

This code produces the following output:

Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?
Hello Viewers! This is really cool, isn't it?

Here the loop will be executed 48 - 45 + 1 = 4 number of times. If we had used times than 45.times would have printed the puts statement 45 number of times. Hence it allows us to make loop execution dynamic as compared to the times iterator which is relatively static.

=== The step iterator<ref>Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref>: ===
The above iterators times and upto performs the loop execution in increments of 1. Step iterator allows us to vary the increments of loop execution. It gives the programmers the flexibility to skip a few iterations of the loop if it is required as per the programmers logic. For example, consider the code:

guess_my_string = "HfezlvlbomWyowrqlad"
0.step(guess_my_string.length, 2) {|i| print guess_my_string[i]}

This code produces the following output -

HelloWorld

In the above code, the variable i collects the iteration number and the print statement prints the character of the String guess_my_string at position i. Hence we get the above output.

=== The each iterator<ref>Alan Skorkin. "A wealth of ruby loops and iterators" http://www.skorks.com/2009/09/a-wealth-of-ruby-loops-and-iterators</ref><ref>"Ruby Iterators" http://www.tutorialspoint.com/ruby/ruby_iterators.htm</ref>: ===

All collections in Ruby have an each method defined, that will allow programmers to go over all of the data members in collection for which the each method is called and do some operation with them. For example, consider the code:

example = [82, 117, 98, 121, 32, 105, 115, 32, 103, 114, 101, 97, 116, 33]
example.each {|i| print i.chr }

The above code prints the following output -

Ruby is great!

In the above code the each iterator takes every element of the array example and prints its character equivalent.

The each iterator can also be used for hash traversal. Ruby defines the following methods for hash traversal:
<ol>
<li> each_key 
This method returns a collection of all the keys present in the hash on which the each_key method was called.
</li>
<li> each_value 
This method returns a collection of all the values present in the hash on which the each_value method was called.
</li>
<li> each_pair 
This method returns a collection of all the key, value pairs present in the hash on which the each_pair method was called.
</li>
</ol>
Consider the example which explains the behavior of all the above methods defined for hash.

breakfast_menu = {"Martini" => 4, "apple pie" => 3, "pan cakes" => 5 }

puts "Today's break fast menu -"
breakfast_menu.each_key { |i| puts i }

puts "\nTheir respective prices -"
breakfast_menu.each_value { |i| puts "$#{i}" }

puts "\nThe breakfast menu with their respective prices -"
breakfast_menu.each_pair { |i, j| puts "#{i}: $#{j}" }

The above code produces the following output:

Today's break fast menu -
Martini
apple pie
pan cakes

Their respective prices -
$4
$3
$5

The breakfast menu with their respective prices -
Martini: $4
apple pie: $3
pan cakes: $5

In the above code, breakfast_menu defines a hash. It contains key, value pair. When each_key method is called on breakfast_menu, it prints all the keys present in the hash breakfast_menu. Similarly for each_value. For each_pair it prints all the key value pairs present in the hash. Hence the output.

=== The collect iterator ===

This simply returns all the elements of the collection. The collect method works for arrays as well as hashes. For example:

a = ["ruby", "rails", "ruby on rails"];
b = Array.new
b = a.collect{ |i| i.capitalize}
puts b

This produces the following output:

Ruby
Rails
Ruby on rails

In the above code, a.collect iterates over all the elements of a and returns a collection of all elements in a and assigns it to b

=== The map iterator ===
The map method creates a temporary array and stores in it whatever value is returned from each iteration of the block of code on which the map method is called. Then that temporary array is returned as a collection. For example consider the ruby code

fruits = [ "apple", "banana", "cherry" ]
puts fruits.map { |i| i.reverse }

The above code produces the following output:

elppa
ananab
yrrehc

In the above code the map method iterates over all the elements in fruits and reverse them. These reverse strings are stored in a temporary array which map method uses and returns that array when all the elements in fruits are iterated.

 
In ruby, there are many methods that iterate over a range of values. These iterators are so written that they take a code block as part of their calling syntax and then yield control to that code block. This code block is executed as many times as specified by the iterator. In all of the above examples, the code that is written in curly braces is the block that the iterators yield their control to.

= Blocks =
A Block consists of a chunk of codes with a name assigned to it. Alternately, a block is a code which is passed to the iterator. These blocks can either be defined by enclosing them in curly braces or by using the do...end syntax as shown below

2.times { puts "This is simple a linear block" }

2.times do
puts "This is a block using do..end syntax"
puts "You can add multiple statements inside the do...end syntax"
end

Also, In the curly braces syntax multiple lines of code can be added but they need to be separated with a semicolon.

Block can also take parameters. For example consider the code shown below:

5.times { |i| puts i}

In the above code i is passed as a parameter to the block. Thus any thing between the pipe symbols can be considered as parameters. Multiple parameters can also be passed to a block but they need to be separated with commas. For example,

example = {"one" => 1, "two" => 2, "three" => 3}
example.each_pair { |key, value| puts "#{key} : #{value}"}

In the all the above block examples, an interesting thing to note is that these blocks are not executed until a yield statement is encountered. A block is always invoked from a function having the same name as that of the defined block. For, examples if there is a block with the name myblock, then there should be a function with the name myblock which invokes this block. For example, consider the code shown below:

def block_testing
puts "Inside function block_testing."
yield
puts "Back to block_testing function."
end

block_testing { puts "Yielding, to print within block." }

The code produces the following output:

Inside function block_testing.
Yielding, to print within block.
Back to block_testing function.

In the above code, when the block_testing method executes, it prints the first statement, then yield is encountered and the control is passed to the block_testing block which prints the second statement. After the block finishes execution, the control is once again passed to the block_testing function which prints the third statement.

= Defining your own iterator =
Ruby allows programmers to define their own iterator other than the iterators listed above. For example if a programmer wishes to define an iterator which prints an array in reverse order, then he can do so as shown below:

class Array
def reverse_iterate
if block_given?
current_index = self.size-1
while current_index >= 0
yield self[current_index]
current_index -= 1
end
else
print self.reverse
end
end
end

In order to use the above iterator, we just need to call this iterator on an array as shown below.

puts "Fall break begins in 10 secs ..."
puts [0,1,2,3,4,5,6,7,8,9, 10].reverse_iterate {|i| puts i }
puts ".. yay!! "

The above code produces the following output:

Fall break begins in 10 secs ...
10
9
8
7
6
5
4
3
2
1
0

.. yay!!

In the above code, the reverse_iterator iterates the array in reverse order and prints the array elements as shown in the output.

= Topical References =
<references/>

= Further Reading =

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T21:06:51Z

Mrkamat:

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T21:06:24Z

Mrkamat:

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-10-03T21:05:49Z

Mrkamat:

CSC/ECE 517 Fall 2012/ch1 1w58 am

2012-09-30T08:59:16Z

Mrkamat: /* The Step iterator */