[scala-bts] #3334: XML comparison between Node and NodeSeq broken

-------------------+--------------------------------------------------------
Reporter: dpp | Owner: scala-xml_team
Type: defect | Status: new
Priority: normal | Component: XML support
Version: | Keywords:
-------------------+--------------------------------------------------------
Changes (by extempore):

* cc: paulp@… (added)

Comment:

"Broken" is what it was before. You left the last line off your old
behavior transcript:
{{{
scala> xml == x2
res1: Boolean = false
}}}
As far as I'm concerned, if we're stuck with this idea of "universal"
equality and one == method which takes an Any, then the absolute minimum
requirement for the standard library is that it not be internally
inconsistent. That way people who want an inconsistent equals can
implement it on top of a consistent one; however there is no way to
implement a consistent one on top of an inconsistent one.

As mentioned elsewhere the old behavior is still available in xml_==.
{{{
scala> x2 xml_== xml
res0: Boolean = true

scala> xml xml_== x2
res1: Boolean = false
}}}
So to the extent I have anything to say about it, this is wontfix.

-------------------+--------------------------------------------------------
Reporter: dpp | Owner: scala-xml_team
Type: defect | Status: new
Priority: normal | Component: XML support
Version: | Keywords:
-------------------+--------------------------------------------------------

Comment(by jeortiz):

If we can't change "equals", perhaps we can change "map".

What if x2 was an Elem instead of a NodeSeq (similar to how str.reverse
returns a String now)? That could solve this problem.

-------------------+--------------------------------------------------------
Reporter: dpp | Owner: scala-xml_team
Type: defect | Status: new
Priority: normal | Component: XML support
Version: | Keywords:
-------------------+--------------------------------------------------------
Changes (by eengbrec):

* cc: erik.engbrecht@… (added)

-------------------+--------------------------------------------------------
Reporter: dpp | Owner: scala-xml_team
Type: defect | Status: new
Priority: normal | Component: XML support
Version: | Keywords:
-------------------+--------------------------------------------------------

Comment(by eengbrec):

This is a little more illuminating:
{{{
scala> val x1 = bar
x1: scala.xml.Elem = bar

scala> val x2 = x1.map( i => i)
x2: scala.xml.NodeSeq = NodeSeq(bar)

scala> x2.getClass
res41: java.lang.Class[_] = class scala.xml.NodeSeq$$anon$1

scala> x1.getClass
res42: java.lang.Class[_] = class scala.xml.Elem

scala> x2(0)
res43: scala.xml.Node = bar

scala> x1 == x2(0)
res44: Boolean = true

scala> x2(0) == x1
res45: Boolean = true

scala>
}}}
So really it looks like the behavior of map has changed, not the behavior
of equals.

-------------------+--------------------------------------------------------
Reporter: dpp | Owner: scala-xml_team
Type: defect | Status: new
Priority: normal | Component: XML support
Version: | Keywords:
-------------------+--------------------------------------------------------

Comment(by eengbrec):

For reference:
http://thread.gmane.org/gmane.comp.lang.scala.internals/2423/focus=2425

-------------------+--------------------------------------------------------
Reporter: dpp | Owner: scala-xml_team
Type: defect | Status: new
Priority: normal | Component: XML support
Version: | Keywords:
-------------------+--------------------------------------------------------

Comment(by extempore):

Replying to [comment:4 eengbrec]:
> So really it looks like the behavior of map has changed, not the
behavior of equals.

OK, but to be clear, the behavior of equals has definitely changed. I
changed it. Since NodeSeq is a Seq and therefore part of the new
collections, the behavior of map has also changed.

-------------------+--------------------------------------------------------
Reporter: dpp | Owner: scala-xml_team
Type: defect | Status: new
Priority: normal | Component: XML support
Version: | Keywords:
-------------------+--------------------------------------------------------

Comment(by extempore):

Replying to [comment:2 jeortiz]:
> What if x2 was an Elem instead of a NodeSeq (similar to how str.reverse
returns a String now)? That could solve this problem.

XMLLike? The mind reels! You know that Elem's grandparent is NodeSeq,
right? Everything is a sequence in XMLtown! So nothing can be Elem
"instead of" NodeSeq.

My effort at undoing the sequence damage was aborted, it was dug in too
deep.

-------------------+--------------------------------------------------------
Reporter: dpp | Owner: scala-xml_team
Type: defect | Status: new
Priority: normal | Component: XML support
Version: | Keywords:
-------------------+--------------------------------------------------------
Changes (by ijuma):

* cc: mlists@… (added)

-------------------+--------------------------------------------------------
Reporter: dpp | Owner: scala-xml_team
Type: defect | Status: closed
Priority: normal | Component: XML support
Version: | Resolution: fixed
Keywords: |
-------------------+--------------------------------------------------------
Changes (by rytz):

* status: new => closed
* resolution: => fixed

Comment:

(In [21675]) close #3338, close #3334, close #3345. review by community.

-------------------+--------------------------------------------------------
Reporter: dpp | Owner: scala-xml_team
Type: defect | Status: reopened
Priority: normal | Component: XML support
Version: | Resolution:
Keywords: |
-------------------+--------------------------------------------------------
Changes (by rytz):

* status: closed => reopened
* resolution: fixed =>

Comment:

mistakenly closed...