```> From: ts [mailto:decoux / moulon.inra.fr]
[...]
>  but I must verify because I've made very quickly the modification :-)
>
>  For Array#<=> can I do the samething than Array#== because actually it
> send an error message when it find a recursive array
You can do the same thing (this way you also get === of course) - once
you got Array  ``untangled'' you can also define ``untangled" equality
for hashes (you should use a recursion limited hash-value - this effects
the hash value of non-recursive Arrays too (and hash-value of Hashes
them-selves) but its simpler than an ``untangled hash value'' and more
efficient (even for non-recursive Arrays).

I (and hopefully Ben too) try to write something up ...

Christoph

[...]

Ps. In response to Ben's questions the test file b.rb is simply
(note the examples are not representative for the performance on
general array's ...)

--------------
#!/usr/bin/ruby
require 'tangle'
##########################
# Examples
##########################
p ([1,3,3,[3,4],"a"] == [1,3,3,[3,4],"a"])
p ([1,3,3,[3,4],"a"] == [1,3,3,[3,4],"b"])

##########################
a =[1,2,3]; a << a; b =[1,2]; b << b;  a  << a; b << a;
p a - b; p a; p b

##########################
def f(x); [x,x]; end
def g(x); f f f f f f f f x; end
def h(x); g g g g g g g g x; end
def i(x);  h h h h h h h h x; end
def j(x); i i i i  i i i   x;end

p (j(1) == j(1))

class UnOrderedPair
def ==(other)
return false  unless other.kind_of?  UnOrderedPair
return true if id == other.id
# works without id-bag because of the implementation
# of tangle ?
return true if (@l == other.l ) && (@r == other.r)
return  (@l == other.r ) && (@r == other.l)
end
def initialize(ll,rr)
@l = ll; @r = rr
end
protected
end

##########################
# Examples
##########################
l = [3,2,3]; r=[3,2]

pl = UnOrderedPair.new l,r
pr = UnOrderedPair.new r,l

l << pl; r << pr
p pl == pr

##########################
pl = UnOrderedPair.new l,r
pr = UnOrderedPair.new r,r

l << pl; r << pr
p pl == pr
```