From: Robert Klemme <bob.news@...>
Date: 2004-11-04T18:48:48+09:00
Subject: Re: Hashes and Blocks (Syntactical/Feature question)


"Jim Haungs" <jhaungs@acm.org> schrieb im Newsbeitrag
news:1s7jo05tnlpljnvdaim5ptiig8tbjitvsn@4ax.com...
> What's a hashtable with names pointing to code blocks?
> Hmm... Sounds like a class!

Yeah, you can view it that way.

> What you're trying to do is an example of the State pattern, which is
> often implemented with sensibly-named states (as opposed to the
> numbers in the example here). The state names are really method names;

I beg to differ at this point: state names are usually translated to class
names.  Events are translated to methods (see the example below).

> you perform the operation for some state X by sending the X message to
> an instance of the State class.

Again, I'd rephrase that to "you perform some operation Y for state X by
sending the message Y to an instance of X.

> The class can also encapsulate the
> current state of the machine, track state transitions, or whatever.

State transitions are tracked by exchanging the instance.

> And if you need multiple instances of the state machine, you just
> create a new instance of the State class.

Yep.

> With the hash table scheme, the cohesion is poor because the current
> machine state is separated from the operations on that state.

That's true although it's what the OP asked for. :-)

Kind regards

    robert


Example

class Window
  def initialize
    @state = WinClose.new
  end

  # actions
  def look() @state.look end

  # queries
  def open?() @state.open? end

  # transitions
  def open() @state = @state.open end
  def close() @state = @state.close end

private
  class WinOpen
    # actions
    def look() "beautiful landscape" end

    # queries
    def open?() true end

    # transitions
    def open() raise "You can't open an open window"  end
    def close() WinClose.new end
  end

  class WinClose
    # actions
    def look() nil end

    # queries
    def open?() false end

    # transitions
    def open() WinOpen.new  end
    def close() raise "You can't close a closed window" end
  end
end


> On Sat, 30 Oct 2004 14:31:19 +0200, "Robert Klemme" <bob.news@gmx.net>
> wrote:
>
> >
> >"Gavin Sinclair" <gsinclair@soyabean.com.au> schrieb im Newsbeitrag
> >news:193-2098986814.20041030113810@soyabean.com.au...
> >> On Saturday, October 30, 2004, 11:29:20 AM, Pete wrote:
> >>
> >>> I haven't been able to find any documentation on the syntax for a
> >>> certain feature, and am not sure the feature exists.  What I would
like
> >>> to do is add a block of code to a hash, so I could do something like
> >>> this:
> >>
> >>>         state = 0
> >>>         states = {
> >>>                 0 => { puts "State 0"; state = 1 },
> >>>                 1 => { puts "State 1"; state = 0 }
> >>>         }
> >>
> >> It's pretty easy:
> >>
> >>  state = 0
> >>  states = {
> >>    0 => lambda { puts "State 0"; state = 1 },
> >>    ...
> >>  }
> >>
> >>  while a_condition
> >>    states[state].call
> >>  end
> >
> >And you can even define default behavior:
> >
> >state = 0
> >states = Hash.new( lambda { puts "fallback" } ).update(
> >  0 => lambda { puts "State 0"; state = 1 },
> >  1 => lambda { puts "State 1"; state = 0 }
> >)
> >
> >loop do
> >  states[rand 100].call
> >end
> >
> >or even (for individual fallbacks)
> >
> >states = Hash.new { |h,k| h[k] = lambda { puts "fallback for #{k}" } }
> >.update(
> >  0 => lambda { puts "State 0"; state = 1 },
> >  1 => lambda { puts "State 1"; state = 0 }
> >)
> >
> >>> 10.times {|i| states[i].call }
> >State 0
> >State 1
> >fallback for 2
> >fallback for 3
> >fallback for 4
> >fallback for 5
> >fallback for 6
> >fallback for 7
> >fallback for 8
> >fallback for 9
> >=> 10
> >
> >Kind regards
> >
> >    robert
> >
>