articles/ruby-local-variables

[giscus[bot]]

articles/ruby-local-variables

Let’s say you wish to conditionally define a local variable in Ruby. Why would you need that? That’s beside the point, it’s mostly a thought excercise that’s an excuse to learn about a specific corner of Ruby. But, if you still want a real use case, you’re being a bit difficult, but let’s say that you’ve got some metaprogramming code that at some points uses defined?(x) calls to do something based on whether a local variable is defined or not. Yes, it’s very contrived.

https://radanskoric.com/articles/ruby-local-variables

[krschacht]

I found your post while investigating how to dynamically define local variables. I figured out a way, so just sharing for the benefit of all of us on the internet:

module LocalVariableSet
  def local_variable_set(variable, with_value = nil)
    var_module = Module.new do
      define_method(variable.to_sym) do
        TOPLEVEL_BINDING.local_variable_get(variable.to_sym)
      end

      define_method("#{variable}=") do |value|
        TOPLEVEL_BINDING.local_variable_set(variable.to_sym, value)
      end
    end

    extend var_module
    with_value ||= df_get(variable.to_sym)
    TOPLEVEL_BINDING.local_variable_set(variable.to_sym, with_value)
  end

  def local_variable_get(variable)
    TOPLEVEL_BINDING.local_variable_get(variable.to_sym) rescue nil
  end

  def local_variable_defined?(variable)
    !!(TOPLEVEL_BINDING.local_variable_get(variable.to_sym) rescue false)
  end
end

Object.include(LocalVariableSet)

[krschacht]

While it's true that my little hack is not actually setting a local variable. You can extend it to still simulate your situation so that it really does behave like a local variable in every way.

In order to get this code to work:

def foo
  local_variable_set(:x, 1)
  puts x  #  "1"
  x = 2
  puts x  # prints "2"
end

foo # => 1\n2

puts x # => undefined local variable or method `x' for main (NameError)
puts y # => undefined local variable or method `y' for main (NameError)

Just import this module first:

module LocalVariableSet
  def local_variable_set(variable, with_value = nil)
    ivar_name = caller_locations(1,1)[0].label.gsub('<top (required)>', 'top_required').gsub('#', '_') + '_' + variable.to_s
    var_module = Module.new do
      define_method(variable.to_sym) do
        ivar_name = caller_locations(1,1)[0].label.gsub('<top (required)>', 'top_required').gsub('#', '_') + '_' + variable.to_s

        if !instance_variable_defined?("@#{ivar_name}")
          calling_method = caller_locations(1,1)[0].label.gsub('<top (required)>', 'main')
          error_message = "undefined local variable or method '#{variable}' for #{calling_method}"
          e = NameError.new(error_message)
          e.set_backtrace(caller(1))
          raise e
        end
        instance_variable_get("@#{ivar_name}")
      end

      define_method("#{variable}=") do |value|
        ivar_name = caller_locations(1,1)[0].label.gsub('<top (required)>', 'top_required').gsub('#', '_') + '_' + variable.to_s
        instance_variable_set("@#{ivar_name}", value)
      end
    end

    extend var_module
    eval("@#{ivar_name}=#{with_value}")
  end
end
include LocalVariableSet

I wrote this pretty quickly but when I tested it, it works both in the main context (e.g. irb) and it also works within a class in which you want to add support for local_variable_set() set as:

class Tester
  include LocalVariableSet

  def foo
    local_variable_set(:y, 1)
    puts y
  end

  def bar
    puts y # raises
  end
end

[krschacht]

Also, just in case you're curious, I am working on writing a new programming language that I'm implementing in ruby rather than in a lower level language (e.g. ruby is implemented in c). This was why I needed the ability to dynamically declare local variables and even though this is not technically doing it, it simulates the effect closely enough that it solves my problem and would likely work for other motivations that people may have, provided they don't need to use defined?()

But you could even make this module overwrite defined?() to catch calls to that and give you the result that you wanted. I didn't bother to take it that far.

[radanskoric]

Thanks for sharing the motivation, I was wondering about that!

For me it was just an excuse to dig a bit into that part of the VM, sort of a mental exercise. But for what you describe, I can see how just mimicking the right semantics as opposed to actually getting the specific behaviour from the VM is enough.

Are you building an interpreter or taking more of a DSL implemented in ruby approach?

If the former, perhaps you might find useful my implementation of the first project from the excellent Crafting Interpreters. The book implements the first approach (a tree walking interpreter) in Java but I did it in Ruby. The commits follow and reference chapters from the book: https://github.com/radanskoric/ruby_lox

[krschacht]

I'm doing it as a DSL. I'm working hard to stick within the constraints of the ruby syntax so there doesn't have to be any pre-processing. But I'll check out your project. Thanks for sharing that.

[radanskoric]

That sounds very interesting. Please share it when you're ready to show it. :)