```Ok, now I understand what you mean. And you are right, for some reason I
totally got off the path I was following initially.
But the problem I'm trying to deal with right now would probably persist
when storing the information inside an object:

I'm currently using the num.step method to iterate from zero to the
length of the ruler, in order to calculate the positions. This creates
multiple types of lines on the same position, e.g.

|         |         |           lines[0]
|    |    |    |    |    |      lines[1]
||||||||||||||||||||||||||||    lines[2]
0    5   10

lines indicate value, e.g. lines[2] = [1..n]

To prevent that, when adding a line (position) to lines, it is necessary
to iterate over the previous array(s), checking if the value-to-be is
already included (enum.include?).

I don't like that approach, although it probably works. I have yet to
experiment with "following the metaphor".

Alternatively, I would have to find a method to generate the positions
directly, like
0, 10, 20, 30
5, 15, 25, 35
1,2,3,4,6,7,8,9, ...

But since the pattern depends on the parameter, I am not sure if a
reasonably short equation could be found.

Another thought that crossed my mind was to define the positions
recursively, e.g. "divide length into n sections, divide those into l
sections, .."
But I have not evaluated the pros and cons of this, regarding usability.
It probably is the same, in the end.

On the other hand, I figure that there is indeed a simple solution to
this.

For now, I'll try to use classes and methods and learn on the way, I'll
eventually find something that works well..

Thanks for the inspiration!

--
Posted via http://www.ruby-forum.com/.

```