RCR 304: reference/pointer concept

 ref { :<variable> }
 ref { "<assignable-expression>" }
 <obj>.ref
 <obj>.ref.<method>(<arguments>)
 <obj>.ref(:<gmeth>,:<smeth>,<arguments>)
 <obj>.ref([:<gmeth>,<gargs>],[:<pmeth>,<pargs>],<more-args>)
 Reference.new(method(:<gmeth>),method(:<pmeth>))
 Reference.new(proc{<get-code>},proc{|v|<set-code>})

In this implementation, references are dereferenced with the [] and []= methods (equivalent to [0] and [0]= in C):

 <ref>[<optional-args>]         # get what is referenced
 <ref>[<optional-args>]=<value> # set what is referenced

Here are some examples:

 a = ("a".."h").to_a       # ["a", "b", "c", "d", "e", "f", "g", "h"]
 b = a                     # b and a have the same object
 p = ref{:a}               # reference to the variable :a
 q = a.ref                 # reference to the object in a
 r = ref{"a[4]"}           # reference to the assignable expression a[4]
 s = a.ref[4]              # reference to the [4] attribute of a
 t = a.ref.[](4)           # same
 u = a.ref(:"[]",:"[]=",4) # same except set/get method names are explicit
 v = a.ref([:"[]",4],[:"[]=",4]) # same except arguments are explicit
 p[]                       # ["a", "b", "c", "d", "e", "f", "g", "h"]
 p[] = (0..7).to_a         # [0, 1, 2, 3, 4, 5, 6, 7]
 a                         # [0, 1, 2, 3, 4, 5, 6, 7]
 b                         # ["a", "b", "c", "d", "e", "f", "g", "h"]
 q[]                       # ["a", "b", "c", "d", "e", "f", "g", "h"]
 q[] = (-7..0).to_a        # [-7, -6, -5, -4, -3, -2, -1, 0]
 a                         # [0, 1, 2, 3, 4, 5, 6, 7]
 b                         # [-7, -6, -5, -4, -3, -2, -1, 0]
 r[]                       # 4
 r[] = "r"                 # "r"
 a                         # [0, 1, 2, 3, "r", 5, 6, 7]
 b                         # [-7, -6, -5, -4, -3, -2, -1, 0]
 # extra arg is slice length
 s[2]                      # [-3, -2]
 s[2] = ["s"]              # ["s"]
 a                         # [0, 1, 2, 3, "r", 5, 6, 7]
 b                         # [-7, -6, -5, -4, "s", -1, 0]
 t[]                       # "s"
 t[] = "t"                 # "t"
 a                         # [0, 1, 2, 3, "r", 5, 6, 7]
 b                         # [-7, -6, -5, -4, "t", -1, 0]
 u[]                       # "t"
 u[] = "u"                 # "u"
 a                         # [0, 1, 2, 3, "r", 5, 6, 7]
 b                         # [-7, -6, -5, -4, "u", -1, 0]
 v[]                       # "u"
 v[] = "v"                 # "v"
 a                         # [0, 1, 2, 3, "r", 5, 6, 7]
 b                         # [-7, -6, -5, -4, "v", -1, 0]
 # multiple ways to make a reference to lines in stdin/stdout
 lineref = Reference.new(method(:gets),method(:puts))
 lineref = Reference.new(proc{gets},proc{|v|puts(v)})
 line = lineref[] # line = gets
 lineref[]="hello world!" # puts("hello world!")

Other syntax could be used instead. This RCR is for the reference concept, not necessarily the above syntax.

These things below would be other nice-to-have reference features that aren't implementable in Ruby and may require language changes. They are optional to this RCR.

• ability to create more efficient pointer-like references that access variables - global, local, class, instance. These types of references could access the variable directly instead of going through proxy get/set procs as the current implementation does. The methods that make these types of references could be in Kernel (global or any?), Binding (any), and Object (class or instance).

• have some of the built-in classes override the default "ref" to create more efficient references like the variable references mentioned above. Doing this for Array and Hash would avoid the lookup every time the reference is dereferenced. For Hash, in addition to a hash value reference, a hash key reference, and a key/value reference would also be useful.

• Unary reference-of operator: This unary operator could prefix (like C &) or postfix. Postfix might be easier because it could just be another optional suffix character on methods like =, !, and ?. If the character was say "@", the expression xyz[5]@ would get translated to the method []@ (with an arg of 5) of the object xyz which would default to create a reference using the [] and []= methods. The class could override to possibly create a more direct reference to an instance variable. With postfix, xyz@ would be equivalent to ref{:xyz}. With a prefix character ("&"), the syntax would be more known, but it may not fit as well with the ruby parser. &xyz[5] would get translated to the method &[] which would default to making a reference using the [] and []= methods of object xyz with a starting argument of 5. &xyz would be equivalent to ref{:xyz}.

• dereferencing operators: a unary prefix * operator (equivalent to [] above) and a binary *= operator (equivalent to []= above) might be nice.

For reference, here are some languages that support references/pointers ( ):

B, C, C#, C++, Perl, Pascal, BCPL, OCaml, SML, Haskell, Oz, Ada, Pliant

Here are a couple general cases where a reference might be useful:

1. pass-by-reference or pass an lvalue. From what I understand, right now the way you would write/use a Ruby method that modified lvalues would be like this:

 def byvalue(*args)
     # read and modify args
     args
 end
 a,b,c = *byvalue(a,b,c)

With references, you could do this:

 def byref(*args)
     # read and modify args[i][]
 end
 byref(ref{:a},ref{:b},ref{:c})

With this simple variable case, there isn't much advantage, but when you are dealing with something deep within an object, it can offer an advantage:

 a["hi"][3],io.pos = *byvalue(a["hi"][3],io.pos)

vs.

 byref(a["hi"].ref[3],io.ref.pos)

Also, with the byvalue case, you are forced into the assign, whereas byref may choose not to do this assign. Depending on the object, this could even prevent an exception (i.e. IO#pos=).

2. Although not addressed in this implementation, a reference could provide some efficiency when there is some work that could be saved when you get or set the same thing 2 or more times. A primary example of this would be a reference to a hash value. With a good implementation of a reference to a hash value, you would only need to do the hash lookup once (while making the reference). Compare this to what you have now - you do a hash lookup every time you get/set a given hash value. Also consider the case where a custom Hash-like class is made where the lookup may be O(n) or O(log(n)) and a reference that incorporated an index from the lookup could easily be made.

Here is the current source code:

class Reference

    def initialize(getter,setter)
        @getter = getter
        @setter = setter
    end
    def [](*args)
        @getter[*args]
    end
    def []=(*args)
        @setter[*args]
    end

class Binding

    def eval(s,*file_line)
        Kernel.eval(s,self,*file_line)
    end
    def variable_reference(var)
        Reference.new(
            eval("proc { #{var} }"),
            eval("proc {|_v| #{var} = _v }")
        );
    end

class Object

    class ObjectReference < Reference
        def initialize(obj)
            @obj = obj
        end
        def [](*args)
            if args.size==0
                @obj
            else
                method_missing(:"[]",*args)
            end
        end
        def []=(obj)
            if @obj.respond_to?:replace
                @obj.replace(obj)
            else
                @obj.become(obj) # need evil.rb
            end
            @obj
        end
        def method_missing(method,*args)
            get = @obj.method(method)
            set = @obj.method(method.to_s<<"=")
            if args.size>0
                getter = proc { |*a| get[*(args+a)] }
                setter = proc { |*a| set[*(args+a)] }
            else
                getter = get
                setter = set
            end
            Reference.new(getter,setter)
        end
    end
    def reference(*args,&block)
        if block
            args.size==0 or raise(ArgumentError,"no arguments allowed when block given")
            block.binding.variable_reference(block[])
        elsif args.size>0
            get,set,*args = *args
            if get.kind_of?Array
                get,*getargs = *(get+args)
            else
                getargs = args
            end
            set ||= get.to_s<<"="
            if set.kind_of?Array
                set,*setargs = *(set+args)
            else
                setargs = args
            end
            get = self.method(get)
            set = self.method(set)
            if getargs.size>0 then getter = proc { |*a| get[*(getargs+a)] }
            else getter = get
            end
            if setargs.size>0 then setter = proc { |*a| set[*(setargs+a)] }
            else setter = set
            end
            Reference.new(getter,setter)
        else
            ObjectReference.new(self)
        end
    end
    alias ref reference