如何编写使用括号而不是方括号来编辑数组/哈希的方法？

Question

I'm trying to write an internal DSL in Ruby and am running into trouble with implementing a particular syntax. Specifically, if I have an array (or hash) in a class, I'd like to access and edit it with parentheses. For example:

class MyData
  attr_accessor :things
  def initialize
    @things = ['right', 'right', 'wrong']
  end
end

test = MyData.new

# This obviously won't work, but it's the syntax that I want.
test.things(2) = 'right'

I know I can read an element with this syntax by doing:

class MyData
  def things(index)
    @things[index]
  end
end

test = MyData.new
test.things(2) # => 'wrong' 

but actually changing the element is another thing entirely because Ruby just doesn't know what to do with that assignment operator.

The reason I want this strange syntax is because I hope I can use this language to easily convert some Fortran namelist files into a friendly Ruby environment, and Fortran unfortunately indexes arrays with parentheses.

My fear is that this is just one of those situations where I'm trying too hard to make Ruby go against its core syntax and I'll need to actually write a parser. Any thoughts?

Answer 1

The syntax isn't valid Ruby, ergo you cannot do that in Ruby. Period.

You have several options:

1. Change your syntax to something that is valid Ruby:

    class MyData attr_reader :things private attr_writer :things def initialize self.things = %w[right right wrong] end end test = MyData.new test.things[2] = 'right' test.things # => ['right', 'right', 'right'] 

2. Use a language that supports that syntax, like Scala:

    class MyData { var things = scala.collection.mutable.Seq("right", "right", "wrong") } val test = new MyData test.things(2) = "right" test.things // => scala.collection.mutable.Seq[String] = ArrayBuffer(right, right, right) 

3. Create an external DSL, ie one that isn't valid Ruby.

   In fact, it looks like what you have already is a well-defined external DSL, specifically a subset of Fortran. Depending on whether or not you have control over those namelist files, you may even be able to restrict the syntax further to something that is quite trivially parseable with some Regexp s and a bit of text munging.

Answer 2

The call operator () cannot be overloaded so what you want to do technically cannot be done. An option would be to pre-process your DSL to replace parentheses with brackets before you hand it over to Ruby.

Check out this other answer on operator overloading for more info.