Is there a way to redefine []=+ in ruby

Question

I am trying to write a simple DSL (against Redis) and I would like to define []+= myself

I have

def []=(key,val)
  @redis.zadd(@name,val,key)
end

and I would like to define

def []+=(key,val)
  @redis.zincrby(@name,val,key)
end

But my understanding is that Ruby provides the "[]+=" operator automaticallygiven []=

Is there a way to over-ride this behavior Obviously I don't want this because I would not be able to, say, run this in pipeline mode

Answer 1

No, <operator>= can not be redefined in Ruby.

You can try to get really fancy and wrap your return values in classes that delegate to the actual value. This way, they behave like the actual value, but you can play tricks, for instance with +.

Here's a simple example:

require 'delegate'
module Redis
  class Set
    class Value < SimpleDelegator
      def +(val)
        Increment.new(self, val)
      end
    end

    class Increment < SimpleDelegator
      attr_reader :increment
      def initialize(source, increment)
        super(source.__getobj__ + increment)
        @increment = increment
      end
    end

    def [](key)
      Value.new(@redis.not_sure_what(@name, key))
    end

    def []=(key,val)
      if val.is_a?(Increment)
        @redis.zincrby(@name,val.increment,key)
      else
        @redis.zadd(@name,val,key)
      end
    end
  end
end

This is just a starting point. You'll have to be more careful than this, for example by checking the key is the same. In my simplistic example, redis[:foo] = redis[:bar] + 1 would actually be equivalent to redis[:foo] += 1...

Answer 2

Nope. x[y] += z expands to exactly x[y] = x[y] + z:

class << (object = Object.new)
  def [](key)
    puts "[#{key.inspect}]"
    key
  end

  def []=(key, value)
    puts "[#{key.inspect}] = #{value.inspect}"
    value
  end
end

# These are all equivalent
object['See?'] += " It's impossible."
object['See?'] = object['See?'] + " It's impossible."
object.[]=('See?', object.[]('See?').+(" It's impossible."))

# They all produce the same output:
# ["See?"]
# ["See?"] = "See? It's impossible."
# => "See? It's impossible."

You will have to create a separate method.