| Topic | A Gentle Introduction to Erlang |
| Speaker | Sam Tesla |
| Time | October 2, 7-9pm |
| Location | UNO's Peter Kiewit Institute (PKI) building 1110 South 67th Street Omaha, NE |
class Comparator
def initialize(&default)
if (defined? default)
@compare_block=default
else
@compare_block=lambda { |a,b| a <=> b }
end
end
def compare(a,b)
@compare_block.call(a,b)
end
def to_proc
method(:compare).to_proc
end
def to_comparator
self
end
def then_by(next_aspect)
next_comparator=next_aspect.to_comparator
self.class.new do |a,b|
comparison=compare(a,b)
if (comparison == 0)
next_comparator.compare(a,b)
else
comparison
end
end
end
def reverse
self.class.new do |a,b|
comparison=compare(a,b)
if (comparison == 1)
-1
elsif (comparison == -1)
1
else
0
end
end
end
end
def by(aspect_to_compare)
aspect_to_compare.to_comparator
end
class Symbol
def to_comparator
Comparator.new { |a,b| a.send(self) <=> b.send(self) }
end
end
module Enumerable
def to_comparator
inject do |thus_far, every|
thus_far.to_comparator.then_by(every.to_comparator)
end
end
end
require 'rubyunit'
class SortTest < Test::Unit::TestCase
def test_simple
a=Person.new("blaine", 36)
b=Person.new("blaine", 12)
result=[a,b].sort(&by(:name).then_by(:age))
assert_equal([b,a], result)
end
def test_array
a=Person.new("blaine", 12)
b=Person.new("alice", 12)
result=[a,b].sort(&by([:age, :name]))
assert_equal([b,a], result)
end
def test_reverse
a=Person.new("grue", 123)
b=Person.new("thief", 34)
result=[a,b].sort(&by(:name).reverse)
assert_equal([b,a], result)
result=[a,b].sort(&by(:age).reverse)
assert_equal([a,b], result)
end
end
class Person
attr_reader :name, :age
def initialize(name, age)
@name=name
@age=age
end
end
[1,2,3,4].inject() {|a,b| a + b} # 10
------------------------------------------------------ Enumerable#inject
enum.inject(initial) {| memo, obj | block } => obj
enum.inject {| memo, obj | block } => obj
------------------------------------------------------------------------
Combines the elements of _enum_ by applying the block to an
accumulator value (_memo_) and each element in turn. At each step,
_memo_ is set to the value returned by the block. The first form
lets you supply an initial value for _memo_. The second form uses
the first element of the collection as a the initial value (and
skips that element while iterating).
# Sum some numbers
(5..10).inject {|sum, n| sum + n } #=> 45
# Multiply some numbers
(5..10).inject(1) {|product, n| product * n } #=> 151200
javascript:void(0)
# find the longest word
longest = %w{ cat sheep bear }.inject do |memo,word|
memo.length > word.length ? memo : word
end
longest #=> "sheep"
# find the length of the longest word
longest = %w{ cat sheep bear }.inject(0) do |memo,word|
memo >= word.length ? memo : word.length
end
longest #=> 5
class Symbol
def to_proc
lambda do |this, *arguments|
this.send(*arguments)
end
end
end
def pair(left,right)
lambda do |dyadic|
dyadic.call(left,right)
end
end
def left(pair)
pair.call(lambda {|left,right| left})
end
def right(pair)
pair.call(lambda {|left,right| right})
end
require 'rubyunit'
class WorkspaceTest < Test::Unit::TestCase
def test_simple
a_b=pair('a','b')
assert_equal('a',left(a_b))
assert_equal('b',right(a_b))
end
def test_again
a_b=pair('a', 'b')
c_a_b=pair('c', a_b)
assert_equal('c', left(c_a_b))
assert_equal('a', left(right(c_a_b)))
end
end
module Enumerable
def reduce(empty_return=nil, &dyadic)
to_execute=lambda do |thus_far,every|
to_execute=dyadic
every
end
inject(empty_return) do |thus_far, every|
to_execute.call(thus_far,every)
end
end
end
require 'rubyunit'
class ReduceTest < Test::Unit::TestCase
def test_simple
result=[1,2,3,4,5].reduce {|thus_far,every| thus_far + every}
assert_equal(15, result)
end
def test_empty_nil
result=[].reduce {|result,every| thus_far + every}
assert_nil(result)
end
def test_empty_default
result=[].reduce(0) {|result,every| thus_far + every}
assert_equal(0, result)
end
end
class Symbol
def to_proc
lambda do |*arguments|
arguments.shift.send(self, *arguments)
end
end
end
class SymbolTest < Test::Unit::TestCase
def test_simple
result=[1,2,3,4,5].reduce &:+
assert_equal(15, result)
end
end
the Smalltalk version is a great example of accidental complexity, not essential complexity.
class Person
attr_accessor :name
end
attributeAccessors
^#(name)
Object subclass: #Person
attributeAccessors: 'names'
classVariables: ''
poolDictionaries: ''
category: 'MetaExample'
initialize
self attributeAccessors: 'name'
Smalltalk had (and has) an awesome environment, including incredible tool support. Because the tool is pervasive (literally part of the project itself), Smalltalkers generally shied away from the kind of meta-programming described above because you have to build tool support along with the meta-programmed code. This is a conscious trade off. One of the best things about the Ruby world (up until now) is the lack of tool support, meaning that the tools never constrained (either literally or influentially) what you can do. Fortunately, this level of power in Ruby is pretty ingrained (look at Rails for lots of examples), so even when the tools finally come out, they need to support the incredible things you can do in Ruby.
One of the best things about the Ruby world (up until now) is the lack of tool support
| Topic | Rexx: The Little Known Scripting Language |
| Speaker | Scott Hickey |
| Time | September 4, 7-9pm |
| Location | UNO's Peter Kiewit Institute (PKI) building 1110 South 67th Street Omaha, NE |
Posts
