One line to print the statement AS WELL AS the evaluated value like in C

ruby-talk
1

i wonder in Ruby, is there a line method to do something like in C

print_val("Array[3] + 1")

and get the printout of

Array[3] + 1 is 3.345

2

kendear wrote:

i wonder in Ruby, is there a line method to do something like in C

print_val("Array[3] + 1")

and get the printout of

Array[3] + 1 is 3.345

Here you go:
def print_val(str)
   puts "#{str} is #{eval(str)}"
end

This should do what you want. Be wary of side effects, though. For example, to display the value of "a += 3" requires evaluation, and that changes the value of "a" (and when you remove this debugging line, your program no longer works the way you expect).

Have fun,
Dan

3

All you need is something like:

puts "myArray[3] + 1 is #{myArray[3] + 1} "

String interpolation. Great stuff.
Of course you have to create that array first to have something in it.

You could also do:

puts "myArray[3] + 1 is " + (myArray[3] + 1).to_s

Lots of ways, but the first one is most succinct.
Ruby is very flexible!
You can even go from this into a DSL with words that evaluate to expressions.

···

On Sep 15, 2007, at 1:51 AM, kendear wrote:

i wonder in Ruby, is there a line method to do something like in C

print_val("Array[3] + 1")

and get the printout of

Array[3] + 1 is 3.345

4

kendear wrote:

i wonder in Ruby, is there a line method to do something like in C

print_val("Array[3] + 1")

and get the printout of

Array[3] + 1 is 3.345

def dbg(&bl)
   s = yield
   puts "#{s} = #{eval(s, bl).inspect}"
end

array=[0,1,2,3]
dbg{"array[3]+1"} # ==> array[3]+1 = 4

It seems a little awkward to use both {...} and "..." around the expression, but the {} allows the #dbg method to capture the binding of the caller.

···

--
        vjoel : Joel VanderWerf : path berkeley edu : 510 665 3407

5

That didn't work for me. I had modify it like so:

foo = [1, 2, 3, 4, 5]
def print_val(str)
   puts "#{str} is #{eval(str, TOPLEVEL_BINDING)}"
end
print_val("foo[3] + 1")

Regards, Morton

···

On Sep 15, 2007, at 7:11 AM, Dan Zwell wrote:

Here you go:
def print_val(str)
  puts "#{str} is #{eval(str)}"
end

6

It works! both for globals and for instance variables...
but what is this call dbg{"n"} using { } instead of ( )
does it have a name? and does any book talk about it?

i guess there is no way to do

dbg(array[3] + 1) or dbg{array[3] + 1} without quoting it as
string huh? C was able to do it due to the preprocessor.

···

On Sep 15, 10:49 am, Joel VanderWerf <vj...@path.berkeley.edu> wrote:

kendear wrote:
> i wonder in Ruby, is there a line method to do something like in C

def dbg(&bl)
   s = yield
   puts "#{s} = #{eval(s, bl).inspect}"
end

array=[0,1,2,3]
dbg{"array[3]+1"} # ==> array[3]+1 = 4

It seems a little awkward to use both {...} and "..." around the
expression, but the {} allows the #dbg method to capture the binding of
the caller.

7

i wonder in Ruby, is there a line method to do something like in C

print_val("Array[3] + 1")

and get the printout of

Array[3] + 1 is 3.345

def print_val(expr,b=binding)
   print( expr, " is ", eval(expr,b).inspect, "\n")
end

irb(main):026:0> a=%{foo bar baz}
=> "foo bar baz"
irb(main):027:0> print_val "a[1]", binding
a[1] is 111
=> nil
irb(main):028:0> print_val "a[1]"
NameError: undefined local variable or method `a' for main:Object
         from (irb):21:in `print_val'
         from (irb):28

You can even omit the "b" argument if you use something like "Binding.of_caller".

Kind regards

  robert

···

On 15.09.2007 19:13, John Joyce wrote:

On Sep 15, 2007, at 1:51 AM, kendear wrote:

         from :0

8

Morton Goldberg wrote:

···

On Sep 15, 2007, at 7:11 AM, Dan Zwell wrote:

Here you go:
def print_val(str)
  puts "#{str} is #{eval(str)}"
end

That didn't work for me. I had modify it like so:

foo = [1, 2, 3, 4, 5]
def print_val(str)
  puts "#{str} is #{eval(str, TOPLEVEL_BINDING)}"
end
print_val("foo[3] + 1")

Regards, Morton

You're right, thanks. When I tested this, I used the first poster's variable name, "Array". So it worked for me, but only because I happened to use a name with global slope.

Dan

9

it works but then if print_val is called inside an instance method,
then it won't work.

···

On Sep 15, 5:22 am, Morton Goldberg <m_goldb...@ameritech.net> wrote:

That didn't work for me. I had modify it like so:

foo = [1, 2, 3, 4, 5]
def print_val(str)
   puts "#{str} is #{eval(str, TOPLEVEL_BINDING)}"
end
print_val("foo[3] + 1")

10

Summercool wrote:

kendear wrote:

i wonder in Ruby, is there a line method to do something like in C

def dbg(&bl)
   s = yield
   puts "#{s} = #{eval(s, bl).inspect}"
end

array=[0,1,2,3]
dbg{"array[3]+1"} # ==> array[3]+1 = 4

It seems a little awkward to use both {...} and "..." around the
expression, but the {} allows the #dbg method to capture the binding of
the caller.

It works! both for globals and for instance variables...
but what is this call dbg{"n"} using { } instead of ( )
does it have a name? and does any book talk about it?

The {..} is just ruby's block notation, just as in "each {...}"

i guess there is no way to do

dbg(array[3] + 1) or dbg{array[3] + 1} without quoting it as
string huh? C was able to do it due to the preprocessor.

Not easy.

Another advantage of using the block notation is that you can disable evaluation with a global flag:

def dbg
   if $debug
     s = yield
     puts "#{s} = #{eval(s, Proc.new).inspect}"
   end
end

If the flag is set, the dbg call is just a method call and a variable test. It doesn't even instantiate a Proc (note that I removed the &bl and added Proc.new).

···

On Sep 15, 10:49 am, Joel VanderWerf <vj...@path.berkeley.edu> wrote:

--
        vjoel : Joel VanderWerf : path berkeley edu : 510 665 3407

11

Using other people's magic try this:

require 'rubygems'
require 'ruby2ruby'

def annotated(&blk)
  # the real magic, thanks ZenSpider :slight_smile:
  lines = blk.to_ruby

  # Turn the results into an array
  lines = lines.split(/\n/)

  # Chop off the proc stuff
  lines = lines[1..-2]

  # Find longest expression in block
  max_width = lines.map { |l| l.size }.max

  # scope result, so we can be polite and return it
  result = nil

  # Process each line, why limit ourselves to one
  lines.each do |line|
    # get the result, be sure to keep the correct binding
    result = eval(line, blk.binding)

    # format and display the output line
    puts "#{line} #{" " * (max_width - line.size)}=> #{result.inspect}"
  end

  result
end

array = [1, 2, 3, 4]
annotated do
  array.map { |v| v * 2 }
  array[3] + 1
end

### Needs better exception handling to be "real"
### pth

···

On 9/15/07, Summercool <Summercoolness@gmail.com> wrote:

It works! both for globals and for instance variables...
but what is this call dbg{"n"} using { } instead of ( )
does it have a name? and does any book talk about it?

i guess there is no way to do