def create_proc
  a = 10
  b = 20
  ->(c) { a + b + c } # A sample proc
end

my_proc = create_proc
# Create a proc that takes one argument (c) and closes over a and b.
# Note: For the binding to capture local variables like 'a' and 'b',
# they must be referenced by a Proc defined in the same scope.
# A simple `proc {}` or `->{}` might not capture them as expected
# unless they are used within that proc.
# To ensure 'a' and 'b' are part of the environment captured by the binding
# from `my_proc.binding`, we ensure `my_proc` itself uses them or is defined
# in a scope where they are present and then `binding` is called on a proc
# that has access to this environment.

# Let's define a new proc specifically for getting a binding
# that captures the desired local variables.
local_var_scope_proc = nil
a_val = 1
b_val = 2
local_var_scope_proc = -> {
  # 'a_val' and 'b_val' are now in this proc's lexical scope
}
bind = local_var_scope_proc.binding

# Continuing from the previous example:
# Variables 'a_val', 'b_val', and 'local_var_scope_proc' are expected.
p bind.local_variables
# Expected output (order may vary):
# => [:a_val, :b_val, :local_var_scope_proc, :bind]
# Note: The binding itself and other variables defined in the
# same scope might also be listed.

p bind.local_variable_get(:a_val)  # => 1
p bind.local_variable_get(:b_val)  # => 2

bind.local_variable_set(:a_val, 100)
p bind.local_variable_get(:a_val)  # => 100

# This also affects evaluation within the binding
p bind.eval("a_val + b_val")          # => 102 (100 + 2)

# Define some variables in a scope
def get_binding_for_eval
  x = 5
  y = 10
  proc {}.binding # Create a binding in this scope
end

eval_bind = get_binding_for_eval
p eval_bind.eval("x * y")      # => 50
p eval_bind.eval("self")       # Shows the receiver of the proc

# Assuming __FILE__ is "test.rb" and this line is line 50
my_lambda = -> { } # This proc is defined at [__FILE__, __LINE__]
location_binding = my_lambda.binding

# This requires mruby-proc-ext
if location_binding.respond_to?(:source_location)
  p location_binding.source_location # => ["test.rb", 50] (approximately)
else
  puts "Binding#source_location not available. Is mruby-proc-ext included?"
end

def execution_binding
  name = "Ruby"
  # The proc must be created in the scope where variables exist
  # and it doesn't necessarily need to *use* them for them to be available in the binding.
  # However, the most reliable way to ensure they are part of the environment
  # is if the proc is created in that environment.
  binding_proc = proc {} # This proc is created in the current scope
  binding_proc.binding   # Returns a binding for this scope
end

b = execution_binding
p b.local_variables.sort  # => [:b, :binding_proc, :name] (or similar)
p b.local_variable_get(:name) # => "Ruby"
b.local_variable_set(:name, "mruby")
p b.eval("name") # => "mruby"