Ruby - How to associate method with another method - ruby

Question

I'm new to Ruby, and expect to use methods inside of method or associate construct_const method with interpret method. Interpret method should simply return the value for this constant
def construct_const(value)
def interpret()
return #value
end
end
e = construct_const(0)
assert_equal(0, e.interpret)

Answer 1

In your posting, you are using value and #value. I guess this is a typo, since you are not refering value anywhere in your example code, so I assume that you wanted to use value in your interpret method, not #value.
You can define a method on the fly for a certain object using define_singleton_method, i.e.
def construct_const(value)
define_singleton_method(:interpret) { value }
end
With this, if you do then a
e.construct_const
the variable e will then have a new method 'interpret` attached to it.

Answer 2

When you define interpret method inside construct_const you get a :interpret symbol as the result of calling construct_const. Because every statement returns a value defining a method returns the method name.
> def interpret()
> return #value
> end
=> :interpret
So each time you call construct_const you define a method and return its name.
Also, you mismatch a local variable value and an instance variable #value.
You can use lambda or proc to return a function, the function will have call method:
def construct_const(value)
-> { value }
end
> e = construct_const(0)
=> #<Proc:0x000055c060a47f60#(irb):12 (lambda)>
> e.call
=> 0
You can define an anonymous class with a method interpret:
def construct_const(value)
my_class = Class.new do
def initialize(value)
#value = value
end
def interpret
#value # Here you can use an instance variable because it's inside of the anonymous class
end
end
my_class.new(value) # Pass a value to initialize a new instance
end
> e = construct_const(0)
=> #<#<Class:0x0000563663366c68>:0x0000563663366b50 #value=0>
> e.interpret
=> 0
A similar solution but with a predefined class:
class Interpreter
def initialize(value)
#value = value
end
def interpret
#value
end
end
def construct_const(value)
Interpreter.new(value)
end
> e = construct_const(0)
=> #<Interpreter:0x0000563663367b68 #value=0>
> e.interpret
=> 0
A solutions with Struct object:
def construct_const(value)
Struct.new(:interpret).new(value)
end
> e = construct_const(0)
=> #<struct interpret=0>
> e.interpret
=> 0

Answer 3

You've probably had better answers already, but as far as I can see, these seem to work (though I don't really know what I'm doing):
def construct_const(value)
mod = Module.new
mod.module_eval do
define_method :interpret do
value
end
end
obj = Object.new
obj.extend(mod)
obj
end
e = construct_const(0)
=> #<Object:0x00000000084a0e90>
e.interpret
=> 0
def construct_const(value)
obj = Object.new
obj.instance_eval do
#value = value
def interpret
#value
end
end
obj
end
e = construct_const(0)
=> #<Object:0x000000000a369098 #value=0>
e.interpret
=> 0