Evaluator for a mini-Ruby in Haskell

[Daniel Berger]

Maybe I need to rethink my view of Haskell after all:

http://community.moertel.com/ss/space/start/2005-03-25/1#Writing_a_simple_Ruby_evaluator

Regards,

Dan

 

[Phil Tomson]

Maybe I need to rethink my view of Haskell after all:

http://community.moertel.com/ss/space/start/2005-03-25/1#Writing_a_simple_Ruby_evaluator

Interesting.

Anyone care to comment on the analysis of 'retry' there? He presents the
following code for a do-it-yourself while loop:

def my_while(cond)
break unless cond
yield
retry
end

i = 0 my_while i < 10 do print i i += 1 end

# output: 0123456789


And offers this analysis:

"This is where the Pickaxe II let me down. It said, "retry will
reevaluate
any arguments to the iterator before restarting it." Yes, clearly, that
is what is happening. But how is it happening and what exactly does that
simple English statement really mean?

So, after thinking about it, I concluded that what is going on is that a
function call in Ruby works like this. Given a function f, a block b, and
arguments xs, the call f(xs){b} means this:

1. let k be the current continuation (i.e., just before the call)
2. bind xs to f's formal arguments
3. bind b internally to the current block
4. evaluate the body of f

Now, if inside of f's body we encounter a retry, the evaluator basically
calls k (with a nil argument, I expect). This jumps back to step 2, from
which evaluation continues. Any side effects up to this point are
retained (so we could have previously incremented i, for example), which
is what allows the code within the function body eventually to choose an
execution path which does not contain a retry expression, and thus avoid
looping forever."


Phil

 

[gabriele renzi]

Daniel Berger ha scritto:

Maybe I need to rethink my view of Haskell after all:

http://community.moertel.com/ss/space/start/2005-03-25/1#Writing_a_simple_Ruby_evaluator

yeah, i was surprised too from:
"I must say that I really like Ruby's semantics. So far, I find it to be
a seriously cool programming language."
I would'nt expect this static functional guys to like ruby

 

[Robert Klemme]

Hmmm... break works find for me in 1.8.2. Time to upgrade?

Yeah, maybe.

How about:

def my_while(cond)
return @ret unless cond
@ret = yield
retry
end

Not thread safe. And I think also not nesting safe.

Cheers

robert

 

[Phil Tomson]

Yeah, maybe.


Not thread safe. And I think also not nesting safe.

Yes, I know. Did you see my later post? I don't think it made it from
the newsgroup to the mailing list.

Here's the code:

class Whiler
def initialize
@ret = nil
end

def while(cond)
break @ret unless cond
@ret = yield
retry
end
end

outer = Whiler.new
inner = Whiler.new

i=0
outer.while i<5 do
puts "i: #{i}"
j=0
inner.while j<5 do
puts " j: #{j}"
j+=1
end
i+=1
end

A bit cumbersome, perhaps, but it is definately nestable and should be
threadsafe as well.

Phil

 

[Phil Tomson]

We've been having this discussion about defining your own while loop in a
thread about Haskell and I thought I'd change the subject in case people
who had no interest in Haskell were avoiding it ;-)

Yes, I know. Did you see my later post? I don't think it made it from
the newsgroup to the mailing list.

Here's the code to make it nestable and threadsafe:

class Whiler
def initialize
@ret = nil
end

def while(cond)
break @ret unless cond
@ret = yield
retry
end
end

outer = Whiler.new
inner = Whiler.new

i=0
outer.while i<5 do
puts "i: #{i}"
j=0
inner.while j<5 do
puts " j: #{j}"
j+=1
end
i+=1
end

A bit cumbersome, perhaps, but it is definately nestable and should be
threadsafe as well.

Actually, I figured out a way to make it much more natural:

Change Whiler to accept an optional condition in it's constructor like
so:

class Whiler
def initialize(cond=nil)
@ret = nil
@cond = cond
end
def while(cond=@cond)
break @ret unless cond
@ret = yield
retry
end
end


Define the my_while top-level method like so:

def my_while(cond,&block)
Whiler.new(cond).methodwhile).call(&block)
end


Now the user of my_while doesn't need to know that a Whiler class even
exists. Usage example:

i = 0
my_while(i<10) do
puts i
j=0
my_while(j<10) do
puts " j: #{j}"
j+=1
end
i+=1
end


I think there are some implications for DSLs (Domain Specific Languages)
in this example.
The my_while method as defined above (the last one) hides some Ruby
language details from the user of my_while so that my_while can appear like a
natural looping construct. I've created DSLs for people who had
no idea they were using Ruby underneath; this sort of thing is
necessary so they don't feel as though they are obliged to learn
Ruby to use the DSL.

Another example of why Ruby is so good for creating DSLs. ;-)


Phil

 

[Robert Klemme]

We've been having this discussion about defining your own while loop in a
thread about Haskell and I thought I'd change the subject in case people
who had no interest in Haskell were avoiding it ;-)

Yes, I saw it - but too late.

Actually, I figured out a way to make it much more natural:

Change Whiler to accept an optional condition in it's constructor like
so:

class Whiler
def initialize(cond=nil)
@ret = nil
@cond = cond
end
def while(cond=@cond)
break @ret unless cond
@ret = yield
retry
end
end


Define the my_while top-level method like so:

def my_while(cond,&block)
Whiler.new(cond).methodwhile).call(&block)
end


Now the user of my_while doesn't need to know that a Whiler class even
exists. Usage example:

i = 0
my_while(i<10) do
puts i
j=0
my_while(j<10) do
puts " j: #{j}"
j+=1
end
i+=1
end

This is nice!

I think there are some implications for DSLs (Domain Specific Languages)
in this example.
The my_while method as defined above (the last one) hides some Ruby
language details from the user of my_while so that my_while can appear
like a
natural looping construct. I've created DSLs for people who had
no idea they were using Ruby underneath; this sort of thing is
necessary so they don't feel as though they are obliged to learn
Ruby to use the DSL.

Another example of why Ruby is so good for creating DSLs. ;-)

+2

Kind regards

robert

 

[Relm]

Actually, I figured out a way to make it much more natural:

Change Whiler to accept an optional condition in it's constructor like
so:

class Whiler
def initialize(cond=nil)
@ret = nil
@cond = cond
end
def while(cond=@cond)
break @ret unless cond
@ret = yield
retry
end
end


Define the my_while top-level method like so:

def my_while(cond,&block)
Whiler.new(cond).methodwhile).call(&block)
end

This new my_while doesn't seem to return the last block. The following
snippet outputs nil values instead of "outer" and "inner":

i = 0
x = nil
y = nil

x = my_while(i<10) do
j=0
y = my_while(j<10) do
j+=1
"inner"
end
i+=1
"outer"
end

puts x
puts y

This makes your original my_while thread-safe. It was already safe for
nesting.

def my_while(cond)
@ret ||= {}
key = Thread.current
return @ret.delete(key) unless cond
@ret[key] = yield
retry
end

 

[Phil Tomson]

This new my_while doesn't seem to return the last block. The following
snippet outputs nil values instead of "outer" and "inner":

i = 0
x = nil
y = nil

x = my_while(i<10) do
j=0
y = my_while(j<10) do
j+=1
"inner"
end
i+=1
"outer"
end

puts x
puts y

Hmmm... I'm seeing the same thing you are, but I'm not sure why.
Anyone got any ideas?

This makes your original my_while thread-safe. It was already safe for
nesting.

def my_while(cond)
@ret ||= {}
key = Thread.current
return @ret.delete(key) unless cond
@ret[key] = yield
retry
end

That'll work.

Phil

 

[Phil Tomson]

Hmmm... I'm seeing the same thing you are, but I'm not sure why.
Anyone got any ideas?

Ah, I see the problem now. my_while calls Whiler.new every time it is
called of course, thus creating a new Whiler object each time. The last
time through each loop, the condition is false when Whiler.new is
called and thus @ret is nil because my_while returns before getting to
the '@ret = yield'. Definately problematic. You can see the problem by
adding a 'puts' to the Whiler constructor like so:

class Whiler
def initialize(cond=nil)
puts "Whiler::new(#{cond})"
@ret = nil
@cond = cond
end
end

This makes your original my_while thread-safe. It was already safe for
nesting.

def my_while(cond)
@ret ||= {}
key = Thread.current
return @ret.delete(key) unless cond
@ret[key] = yield
retry
end

This is probably the best bet for being both threadsafe and nestable.

Phil