Copyright © 2008-2019
Robert W. Hasker

Note 3: [2..Ruby]

Data Types in Ruby

Ranges

Ranges appear in a number of contexts
Simple form: x..y
- "Set" of values from x to y
- Alternative form: x...y (three dots): set including x but not y - intended for array-processing loops

Sample operations:

        nums = -1 .. 42
        nums.min
        nums.max
        (0...32).max    # note need parens
        nums.include?(20)
        nums.include?(90)

Ruby Arrays

Arrays in Ruby are very similar to Java
- Collection of objects
- Index by 0
- Different objects can have different types
- However, array constants are somewhat different
Array constants: specified using square brackets
- a = ['tic', 'tac', 'toe'] - gives an array of 3 items
- b = [1, 1, 2, 3, 5, 8, 13, 21, 34]
Access using index: a[0], a[2], a[3]
Extending an array
- Can just put element at location: a[5] = 'game'
- Can use <<: a << 18; a << [-1, -2]
  - add to end
Other operations on arrays:
- ==, !=, etc.
- +: combine two arrays [4, 5] + [3]
- empty?
  - a.empty?
  - [].empty?
  - predicates typically end with ?
- .join: convert items into a string with given separator:
```
        b.join(', ')
```
- .sort, .sort!: sort array
  - difference: ! version modifies the array, the other just returns the new array
```
        a.sort
        a
        a.sort!
        a
```
- ...and many others - see Array documentation at Ruby-doc.org

Debugging Ruby Code

Simply run with -r debug option:
```
        ruby -r debug gpa.rb
```
This starts program in debug mode
Basic commands:
- l: list
- n: execute next statement
- c: continue (to end or breakpoint)
- help
- s: step; steps into functions
- help
- p (or just typing an expression): prints the expression
- pp pretty prints an expression - helps with large expressions
Core tool: print stuff: puts "X at abc: #{x}"

Classes & Objects

As said before, Ruby is fundamentally an OO language
- all data are objects, including numbers, enumerated values, strings, functions, etc.
  - 3.abs, "xyz".length
- All objects implement .to_s and various other methods (such as key values for hashing)

To create a class:

        # a to-do item
        class Task
          def initialize(descr, duration)
            @descr    = descr
            @duration = duration
          end
          # increase duration by a factor
          def scale(factor)
            @duration *= factor
          end
          def descr
            return @descr
          end
          def duration
            return @duration
          end
        end

Using:
- creating item: t = Task.new("eat", 0.25)
- invoking operation: t.scale(1.5) # eat with friends
- t.descr

Redefine to_s operation:

        class Task
          def to_s
            return @descr + " for " + @duration.to_s + " hr"
          end
        end

Now try: t.to_s

Note:
- Classes are "open" - can add/redefine operations without changing other bits
  - implies that at times during debugging you'll want to simply restart irb
- Class names start with a capital letter
- Method names have lower case initial letter
- class variables start with @
- initialize is a special method that gets called when create object
- create object with classname.new - no parameters if initialize has none:
  - sometask = Task.new("learn ruby", 20)
- methods are public, variables are protected (in the Java sense)
- all methods can be overridden unless explicitly prevented (Java yet again?)

Can inherit with new classes:

        class DayLongTask < Task
          def initialize(descr)
            super(descr, 8.0)
          end
          def to_s
            super + " (all day)"
          end
        end

Example

Simple phone book: name and number, lookup by name
- Solution: phones.rb

More explicit attributes

Attributes: class data that can be accessed from outside the class
descr, duration: methods that exist just to return class members
might also want clients to be able to update duration for themselves; would need to create a setDuration method

Simpler solution: declare readers, writers:

        class Task
          attr_reader :descr, :duration
          attr_writer :duration
          def initialize(descr, duration)
            @descr    = descr
            @duration = duration
          end
          # increase duration by a factor
          def scale(factor)
            @duration *= factor
          end
          def to_s
            return @descr + " for " + @duration.to_s + " hr"
          end
        end

An attribute can also have a writer with no reader
Better way to declare duration:
```
        attr_accessor :duration
```
This implies both a reader and a writer.

Iterating over Collection Elements

Java: can iterate over elements in an array without using an index:

        foreach (ItemType item: someArray)
        {
           item.print();
        }

One difference for Ruby: arrays can have different types of items:

        messed_up = [42, 'why?', ['avogadro', 6.02214086e23], nil]

How to iterate over arrays?
- for loop with index: error-prone
- The equivalent of Java's foreach: apply a "block" to each item:
```
        nums = [-23, 44, 17, 2]
        nums.each { |x| puts x * x * x }
```
A block: a sequence of actions between curly braces
- They can also be between do and end, but curlies are good for now
Executing a block: yield

Example:

        def do_twice
           yield
           yield
        end

        do_twice { puts "echo" }

More general example:

        def doit_again(n)
          for i in 1..n
            yield
          end
        end

        doit_again(10) { puts "bye" }

Each time yield executed, executes corresponding block

yield can take parameters:

        def doit_again(n)
          i = 1
          while i <= n
            yield i
            i += 1
          end
        end
        doit_again(5) { |x| puts x**x }

note this block has a corresponding parameter
blocks are essentially equivalent to Java's anonymous function

Can assign a block to a variable:

        toself = proc { |x| x ** x }    # proc signals don't eval block
        doit_again(8, &toself)          # & specifies this param is the block (must be last)

There's a simpler way: the .each operation on a range:
```
        (1..5).each { puts "hello" }
```
- .each is essentially doit_again written as a member of Array
This is also overloaded to allow a block with a single parameter:
```
        (1..5).each { |count| puts count }
```

.each operation on an array sets up an iterator over all elements; use a block to access each one:

        words = ['fee', 'fi', 'fo', 'fum']
        words.each { |it| puts it }
        words.each { |it| puts it.reverse }

.find: find first meeting some condition

        words.find { |x| x.length == 2 }

Creating an array by mapping operation over an existing array:

        words.map { |w| w + "-" + w.upcase }
        words
        words.map! { |w| w + "-" + w.upcase }
        words

Select items matching a predicate:

        words.select { |x| x.length > 5 }

Note: Ruby programmers tend to use do/end for longer blocks:
```
        words.map do |w|
          tmp = w.downcase
          puts "Lower case word: #{tmp}"
        end
```
but curly braces are better in some editors (you get matching) and are good enough for this course.

Enumerated Values

Use : to create an enumerated value: :red, :yellow, :blue
- faster comparison than strings
- case sensitive: :blue != :Blue
Other than speed, this is more of a documentation issue than a robustness issue
- (unlike other languages such as Java where enumerations help keep programmers from making mistakes)

Where we've already seen symbols being used:

        class Task
          attr_reader :descr, :duration
          attr_writer :duration
          def initialize(descr, duration)
            @descr    = descr
            @duration = duration
          end
          # increase duration by a factor
          def scale(factor)
            @duration *= factor
          end
          def to_s
            return @descr + " for " + @duration.to_s + " hr"
          end
        end

Hashes

Same concept as Java's HashMap - store/lookup by name
- will often use "map" rather than "hash"

A simple map (hash) from fruit to color:

        color_of = {
           'apple'  => 'red',
           'banana' => 'yellow',
           'orange' => 'orange',
           'pear'   => ['green', 'brown', 'yellow'],
           'grape'  => ['green', 'purple']
        }

Lookup: index as in color_of['apple']
Realize apples are multi-colored: color_of['apple'] = ['red', 'green', 'yellow']
Add kumquat: color_of['kumquat'] = 'yellow'
Look up plum: color_of['plum']
Notes
- Types don't have to be the same - could even add numbers to our map: color_of[5] = 'blue'
- items are not in a particular order
Arrays: roughly the same as a map from indices to values:
```
    a = { 0 => 'tic', 1 => 'tac', 2 => 'toe' }
```
- But there are differences: speed, available operations
How would you implement sets in Ruby?
- discuss with a neighbor - what are the pros and cons of your solution?
- Using the library:
```
        require 'set'
        xs = Set.new
        xs << 9 << 5
        xs.include? 42
```
samples/revised-phones.rb: revised version of samples/phones.rb which uses a Hash instead of an array.

Ruby Type System

Java design goal: run anywhere
- Type system: ensure computation gives same result regardless of hardware
- Depend on just-in-time compiler to make things as efficient as possible
- Side-effect:
C/C++ design goal: efficient computation at hardware level
- Type, runtime system: maximize efficiency, keeping programming in control of any resources used
- Do you know another language/environment that has this goal?
Ruby design goal: flexibility
- Type system: duck typing
- Example:
```
        def f(a, b, c)
          (a + b) * c
        end

        f(1, 2, 3)
        f('x', 'y', 3)
  
```
  - Can apply to any data type responding to +, *
  - Win: can reuse computations on almost any sort of data, not just those predicted by the implementer
  - Win: can use an out-of-band value like nil to return "no value"
  - Loss: might apply function in non-meaningful cases, leading to errors
    - Try f('x', 'y', 'z')
  - Practical win: can load data from database, web, treat the data as underlying types
- Is Ruby "weakly typed"?
  - Used as a catch-all for "unsafe"
  - Problem: restrictive types lead to errors:
```
        // Java
        double ave(int[] nums) { ... }

        ...
           int x = (int)ave(xs); // reduced checking
```
  - And what if we want to guarantee a property like primeness? How to capture that in the type system?
  - Issue: can't deliver untested code; types just simplify certain testing
  - Javascript is weakly typed: all numeric data stored as doubles, objects as associative arrays
  - Other win of typing: more efficient code generation

Other Features

Classes all the way down:

        5.class
        5.class.class   # also: Fixnum.class
        5.class.class.class

Finding all operations in an object:

        Fixnum.instance_methods
        Fixnum.instance_methods.sort
        String.instance_methods.sort
        Fixnum.instance_methods false # not including superclasses

All operations on classes:
```
        Class.methods
```
Main
- See end of revised-gpa.rb
  - Variable __FILE__: current file
  - Variable $0: file used to start program
  - if __FILE__ == $0: only true if executing file from command prompt (such as "ruby revised-gpa.rb"
    - [write code printing $0, __FILE__]
  - Could
```
        load 'revised-gpa.rb'
```
    to provide convert_to_numbers to other code
  - require: general purpose mechanism for loading code
    - Might put a test-bed main in the if __FILE__ == $0 code
    - Better: use one of the extensive ruby testing frameworks, especially rspec

Internet support: very strong:

        require 'open-uri'      # use open-uri library
        home = open("http://www.google.com")
        4.times { puts home.gets }

Support for modules, processes/multithreading, unit testing, web apps
- installing packages: gems:
```
        gem install rails
```

Standard input, output

gets: reads from standard input puts: writes to standard output
- Both: file, console, even data from another program
- Standard input & output in Java: System.in, System.out
- | (pipe) - standard output from one program becomes standard input to another
Example: generate.rb writes numbers to standard output:
```
        ruby generate.rb 1.5 3.5 0.25
```

Can send that output to sum:

        ruby generate.rb 1.5 3.5 0.25 | ruby sum.rb

Note where generate.rb sends its errors:
```
        ruby generate.rb -3
```
- $stderr: standard error output
- Note
```
        ruby generate.rb -3 >results.txt
```
  - results.txt is empty; error sent to console
- Generally, standard output is buffered - written in large chunks for speed
- Standard error is not buffered - ensures errors always written right away

Exercises

Use .map, .each, or .select to
- Returns the lengths of the strings in an array
- Return an array of strings where the length of each string is greater than 2
- Compute the sum of an array
- Compute the total number of words in a string where words are separated by white space

Review

Range, Array, Hash
- See Ruby libraries: Array, Hash, String, etc.
Enumerated values
Classes & objects
- inheritance
- attributes
Iterating over collections
- yield, blocks
- .each
- .find, .delete, etc.
Hints on additional language features

Copyright © 2008-2019 Robert W. Hasker