An instance that switches between two implementations

as.rb

module As
  class Proxy
    def initialize(this, mod)
      @this = this
      @mod = mod
    end

    def method_missing(name, *args)
      raise NoMethodError unless @mod.instance_methods.include?(name)
      @mod.instance_method(name).bind_call(@this, *args)
    end
  end

  def as(mod)
    raise NoMethodError unless self.class.ancestors.include?(mod)
    Proxy.new(self, mod)
  end
end

module A
  def call = puts "A"
end

module B
  def call = puts "B"
end

class Foo
  include As
  include A
  include B
end

foo = Foo.new

foo.call #=> B
foo.as(A).call #=> A
foo.as(B).call #=> B