I would recommend:

 1. [xml](http://hackage.haskell.org/package/xml), if your task is simple
 2. [haxml](http://hackage.haskell.org/package/HaXml), if your task is complex
 3. [hxt](http://hackage.haskell.org/package/hxt), if you like arrows
 4. [hexpat][1] if you need high performance
  
  [1]: http://hackage.haskell.org/package/hexpat

HXT&#39;s main problem, aside from the unusual arrow syntax, is performance and memory usage. I have an app that spends 1.2 seconds processing about 1.5MB of XML, consuming about 2.3GB (!) of memory in the process. Libxml2 takes a few milliseconds on the same data. Extracting data via the `css` function and arrow predicates also seems very slow compared to Libxml2.

I would personally recommend HXT *because* it uses arrows, which are a very useful and powerful tool to learn, and an XML parsing library is the perfect use for arrows (they were first invented to solve various parsing problems that monads couldn&#39;t). Arrows are also starting to be used outside of pure functional programming, such as  [Arrowlets in JavaScript](http://www.cs.umd.edu/projects/PL/arrowlets/).

I want to check the type of an Object. How can I do that?

The scenario is I&#39;m getting an object. If that object is of type A then do some operations. If it is of type B then do some operations. Currently the type of the object is C that is parent of A and B.

I have two classes `AViewController` and` BViewController`. The object I&#39;m getting in `UIViewController`. Now how to check whether the object is `AViewController` or `BViewController`?

iPhone how to check the type of an Object?

How can I make this input transparent?

    &lt;input type=&quot;text&quot; class=&quot;foo&quot;&gt;

I&#39;ve tried this but it doesn&#39;t work.

    background:transparent url(../img/transpSmall.png) repeat scroll 0 0;

Is there a pure CSS way to make an input transparent?

I see that there is a few of XML processing libraries in Haskell.

* [HaXml](http://www.haskell.org/HaXml/) seems to be the most popular (according to [dons](http://donsbot.wordpress.com/2009/08/29/haskell-popularity-rankings-september-2009/))
* [HXT](http://www.fh-wedel.de/~si/HXmlToolbox/) seems to be the most advanced (but also the most difficult to learn thanks to arrows)
* [xml](http://hackage.haskell.org/package/xml) which seems to be just the basic parser
* [HXML](http://www.flightlab.com/~joe/hxml/) seems to be abandoned
* tagsoup and tagchup
* libXML and libXML SAX bindings

So, which library to choose if I want it

* to be reasonably powerful (to extract data from XML and to modify XML)
* likely to be supported long time in the future
* to be a “community choice” (default choice)

And while most of the above seem to be sufficient for my current needs, what are the reason to choose one of them over the others?

**UPD 20091222**:

Some notes about licenses:

* BSD or MIT: [hexpat](http://hackage.haskell.org/package/hexpat), [hxt](http://hackage.haskell.org/package/hxt), [libxml](http://hackage.haskell.org/package/libxml), [tagsoup](http://hackage.haskell.org/package/tagsoup), [xml](http://hackage.haskell.org/package/xml)
* LGPL: [HaXml](http://hackage.haskell.org/package/HaXml)
* GPLv2:
* GPLv3: [libxml-sax](http://hackage.haskell.org/package/libxml-sax),  [tagchup](http://hackage.haskell.org/package/tagchup), [tagsoup-ht](http://hackage.haskell.org/package/tagsoup-ht)

Which Haskell XML library to use?

I see that there is a few of XML processing libraries in Haskell.
<ul>
<li><a href="http://www.haskell.org/HaXml/" target="_blank" rel="noopener noreferrer">HaXml</a> seems to be the most popular (according to <a href="http://donsbot.wordpress.com/2009/08/29/haskell-popularity-rankings-september-2009/" target="_blank" rel="noopener noreferrer">dons</a>)</li>
<li><a href="http://www.fh-wedel.de/~si/HXmlToolbox/" target="_blank" rel="noopener noreferrer">HXT</a> seems to be the most advanced (but also the most difficult to learn thanks to arrows)</li>
<li><a href="http://hackage.haskell.org/package/xml" target="_blank" rel="noopener noreferrer">xml</a> which seems to be just the basic parser</li>
<li><a href="http://www.flightlab.com/~joe/hxml/" target="_blank" rel="noopener noreferrer">HXML</a> seems to be abandoned</li>
<li>tagsoup and tagchup</li>
<li>libXML and libXML SAX bindings</li>
</ul>
So, which library to choose if I want it
<ul>
<li>to be reasonably powerful (to extract data from XML and to modify XML)</li>
<li>likely to be supported long time in the future</li>
<li>to be a “community choice” (default choice)</li>
</ul>
And while most of the above seem to be sufficient for my current needs, what are the reason to choose one of them over the others?
UPD 20091222:
Some notes about licenses:
<ul>
<li>BSD or MIT: <a href="http://hackage.haskell.org/package/hexpat" target="_blank" rel="noopener noreferrer">hexpat</a>, <a href="http://hackage.haskell.org/package/hxt" target="_blank" rel="noopener noreferrer">hxt</a>, <a href="http://hackage.haskell.org/package/libxml" target="_blank" rel="noopener noreferrer">libxml</a>, <a href="http://hackage.haskell.org/package/tagsoup" target="_blank" rel="noopener noreferrer">tagsoup</a>, <a href="http://hackage.haskell.org/package/xml" target="_blank" rel="noopener noreferrer">xml</a></li>
<li>LGPL: <a href="http://hackage.haskell.org/package/HaXml" target="_blank" rel="noopener noreferrer">HaXml</a></li>
<li>GPLv2:</li>
<li>GPLv3: <a href="http://hackage.haskell.org/package/libxml-sax" target="_blank" rel="noopener noreferrer">libxml-sax</a>, <a href="http://hackage.haskell.org/package/tagchup" target="_blank" rel="noopener noreferrer">tagchup</a>, <a href="http://hackage.haskell.org/package/tagsoup-ht" target="_blank" rel="noopener noreferrer">tagsoup-ht</a></li>
</ul>

I&#39;m using Java&#39;s built in XML transformer to take a DOM document and print out the resulting XML. The problem is that it isn&#39;t indenting the text at all despite having set the parameter &quot;indent&quot; explicitly.

sample code

    public class TestXML {
     
     public static void main(String args[]) throws Exception {
      ByteArrayOutputStream s;
      
      Document d = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument();
      Transformer t = TransformerFactory.newInstance().newTransformer();
      
      Element a,b;
      
      a = d.createElement(&quot;a&quot;);
      b = d.createElement(&quot;b&quot;);
      
      a.appendChild(b);
      
      d.appendChild(a);
      
      t.setParameter(OutputKeys.INDENT, &quot;yes&quot;);
      
      s = new ByteArrayOutputStream();
      
      t.transform(new DOMSource(d),new StreamResult(s));
      
      System.out.println(new String(s.toByteArray()));
      
     }
    }

result

    &lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;&lt;a&gt;&lt;b/&gt;&lt;/a&gt;

desired result

    &lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot; standalone=&quot;no&quot;?&gt;
    &lt;a&gt;
     &lt;b/&gt;
    &lt;/a&gt;

Thoughts?

Java: How to Indent XML Generated by Transformer

How do I scrape html tables using the XML package?

Take, for example, this wikipedia page on the [Brazilian soccer team][1]. I would like to read it in R and get the &quot;list of all matches Brazil have played against FIFA recognised teams&quot; table as a data.frame. How can I do this?

  [1]: http://en.wikipedia.org/wiki/Brazil_national_football_team

Scraping html tables into R data frames using the XML package

How can I convert an array to a SimpleXML object in PHP?

How to convert array to SimpleXML

Documentation seems to say that it references another element in the schema, but how could it be used - I&#39;ve never seen it in schemas that I have worked with.

Anyone got any nice use cases or something that could explain its use further?


What does the ref attribute on an element in an XSD do?

Suppose I have the following XML:

&lt;!--language: lang-xml--&gt;

    &lt;book category=&quot;CLASSICS&quot;&gt;
      &lt;title lang=&quot;it&quot;&gt;Purgatorio&lt;/title&gt;
      &lt;author&gt;Dante Alighieri&lt;/author&gt;
      &lt;year&gt;1308&lt;/year&gt;
      &lt;price&gt;30.00&lt;/price&gt;
    &lt;/book&gt;

    &lt;book category=&quot;CLASSICS&quot;&gt;
      &lt;title lang=&quot;it&quot;&gt;Inferno&lt;/title&gt;
      &lt;author&gt;Dante Alighieri&lt;/author&gt;
      &lt;year&gt;1308&lt;/year&gt;
      &lt;price&gt;30.00&lt;/price&gt;
    &lt;/book&gt;

    &lt;book category=&quot;CHILDREN&quot;&gt;
      &lt;title lang=&quot;en&quot;&gt;Harry Potter&lt;/title&gt;
      &lt;author&gt;J K. Rowling&lt;/author&gt;
      &lt;year&gt;2005&lt;/year&gt;
      &lt;price&gt;29.99&lt;/price&gt;
    &lt;/book&gt;

    &lt;book category=&quot;WEB&quot;&gt;
      &lt;title lang=&quot;en&quot;&gt;XQuery Kick Start&lt;/title&gt;
      &lt;author&gt;James McGovern&lt;/author&gt;
      &lt;author&gt;Per Bothner&lt;/author&gt;
      &lt;author&gt;Kurt Cagle&lt;/author&gt;
      &lt;author&gt;James Linn&lt;/author&gt;
      &lt;author&gt;Vaidyanathan Nagarajan&lt;/author&gt;
      &lt;year&gt;2003&lt;/year&gt;
      &lt;price&gt;49.99&lt;/price&gt;
    &lt;/book&gt;

    &lt;book category=&quot;WEB&quot;&gt;
      &lt;title lang=&quot;en&quot;&gt;Learning XML&lt;/title&gt;
      &lt;author&gt;Erik T. Ray&lt;/author&gt;
      &lt;year&gt;2003&lt;/year&gt;
      &lt;price&gt;39.95&lt;/price&gt;
    &lt;/book&gt;

I would like to do an xpath that gets back all book nodes that have a title node with a language attribute of &quot;it&quot;. 

My attempt looked something like this:

`//book[title[@lang=&#39;it&#39;]]`

But that didn&#39;t work. I expect to get back the nodes:

&lt;!--language: lang-xml--&gt;

    &lt;book category=&quot;CLASSICS&quot;&gt;
      &lt;title lang=&quot;it&quot;&gt;Purgatorio&lt;/title&gt;
      &lt;author&gt;Dante Alighieri&lt;/author&gt;
      &lt;year&gt;1308&lt;/year&gt;
      &lt;price&gt;30.00&lt;/price&gt;
    &lt;/book&gt;

    &lt;book category=&quot;CLASSICS&quot;&gt;
      &lt;title lang=&quot;it&quot;&gt;Inferno&lt;/title&gt;
      &lt;author&gt;Dante Alighieri&lt;/author&gt;
      &lt;year&gt;1308&lt;/year&gt;
      &lt;price&gt;30.00&lt;/price&gt;
    &lt;/book&gt;

Any hints?


Get nodes where child node contains an attribute

If you&#39;ve bought into the functional programming paradigm, the chances are that you like both Erlang and Haskell.  Both have purely functional cores and other goodness such as lightweight threads that make them a good fit for a multicore world.  But there are some differences too.

Erlang is a commercially proven fault-tolerant language with a mature distribution model.  It has a seemingly unique feature in its ability to upgrade its version at runtime via hot code loading.  (Way cool!)

Haskell, on the otherhand, has the most sophisticated type system of any mainstream language.  (Where I define &#39;mainstream&#39; to be any language that has a published O&#39;Reilly book so Haskell counts.)  Its straightline single threaded performance looks superior to Erlang&#39;s and its lightweight threads look even lighter too.

I am trying to put together a development platform for &lt;i&gt;the rest of my coding life&lt;/i&gt; and was wondering whether it was possible to mix Erlang and Haskell to achieve a best of breed platform.  This question has two parts:

   1. I&#39;d like to use Erlang as a kind of fault tolerant MPI to glue GHC runtime instances together.  There would be one Erlang process per GHC runtime.  If &quot;the impossible happened&quot; and the GHC runtime died, then the Erlang process would detect that somehow and die too.   Erlang&#39;s hot code loading and distribution features would just continue to work.  The GHC runtime could be configured to use just one core, or all cores on the local machine, or any combination in between.   Once the Erlang library was written, the rest of the Erlang level code should be purely boilerplate and automatically generated on a per application basis.  (Perhaps by a Haskell DSL for example.)   How does one achieve at least some of these things?
   2. I&#39;d like Erlang and Haskell to be able to share the same garabage collector.  (This is a much further out idea than 1.)   Languages that run on the JVM and the CLR achieve greater mass by sharing a runtime.  I understand there are technical limitations to running Erlang (hot code loading) and Haskell (higher kinded polymorphism) on either the JVM or the CLR.  But what about unbundling just the garbage collector?  (Sort of the start of a runtime for functional languages.)  Allocation would obviously still have to be really fast, so maybe that bit needs to be statically linked in.  And there should be some mechansim to distinguish the mutable heap from the immutable heap (incuding lazy write once memory) as GHC needs this.  Would it be feasible to modify both HIPE and GHC so that the garbage collectors could share a heap?

Please answer with any experiences (positive or negative), ideas or suggestions.  In fact, any feedback (short of straight abuse!) is welcome.

**Update**

Thanks for all 4 replies to date - each taught me at least one useful thing that I did not know.

Regarding *the rest of coding life* thing - I included it slightly tongue in cheek to spark debate, but it is actually true.  There is a project that I have in mind that I intend to work on until I die, and it needs a stable platform.

In the platform I have proposed above, I would only write Haskell, as the boilerplate Erlang would　be automatically generated.  So how long will Haskell last?  Well Lisp is still with us and doesn&#39;t look like it is going away anytime soon.  Haskell is BSD3 open source and has achieved critical mass.  If programming itself is still around in 50 years time, I would expect Haskell, or some continuous evolution of Haskell, will still be here.

**Update 2** *in response to rvirding&#39;s post*

Agreed - implementing a complete &quot;Erskell/Haslang&quot; universal virtual machine might not be absolutely impossible, but it would certainly be very difficult indeed.  Sharing just the garbage collector level as something like a VM, while still *difficult*, sounds an order of magnitude less difficult to me though.  At the garbage collection model, functional languages must have a lot in common - the unbiquity of immutable data (including thunks) and the requirement for very fast allocation.  So the fact that commonality is bundled tightly with monolithic VMs seems kind of odd.

VMs do help achieve critical mass.  Just look at how &#39;lite&#39; functional languages like F# and Scala have taken off.  Scala may not have the absolute fault tolerance of Erlang, but it offers an escape route for the very many folks who are tied to the JVM.

&gt; While having a single heap makes
&gt; message passing very fast it
&gt; introduces a number of other problems,
&gt; mainly that doing GC becomes more
&gt; difficult as it has to be interactive
&gt; and globally non-interruptive so you
&gt; can&#39;t use the same simpler algorithms
&gt; as the per-process heap model.

Absolutely, that makes perfect sense to me.  The very smart people on the GHC development team appear to be trying to solve part of the problem with a parallel &quot;stop the world&quot; GC.

**[http://research.microsoft.com/en-us/um/people/simonpj/papers/parallel-gc/par-gc-ismm08.pdf][1]**

(Obviously &quot;stop the world&quot; would not fly for general Erlang given its main use case.)  But even in the use cases where &quot;stop the world&quot; is OK, their speedups do not appear to be universal.  So I agree with you, it is unlikely that there is a universally best GC, which is the reason I specified in part 1. of my question that

&gt; The GHC runtime could be configured to
&gt; use just one core, or all cores on the
&gt; local machine, or any combination in
&gt; between.

In that way, for a given use case, I could, after benchmarking, choose to go the Erlang way, and run one GHC runtime (with a singlethreaded GC) plus one Erlang process per core and let Erlang copy memory between cores for good locality.

Alternatively, on a dual processor machine with 4 cores per processor with good memory bandwidth on the processor, benchmarking might suggest that I run one GHC runtime (with a parallel GC) plus one Erlang process per processor.

In both cases, if Erlang and GHC could share a heap, the sharing would probably be bound to a single OS thread running on a single core somehow.  (I am getting out of my depth here, which is why I asked the question.)

I also have another agenda - benchmarking functional languages independently of GC.  Often I read of results of benchmarks of OCaml v GHC v Erlang v ... and wonder how much the results are confounded by the different GCs.  What if choice of GC could be orthogonal to choice of functional language?  How expensive is GC anyway?  See this devil advocates blog post 

**[http://john.freml.in/garbage-collection-harmful][2]**

by my Lisp friend John Fremlin, which he has, charmingly, given his post title &quot;Automated garbage collection is rubbish&quot;.  When John claims that GC is slow and hasn&#39;t really sped up that much, I would like to be able to counter with some numbers. 


  [1]: http://research.microsoft.com/en-us/um/people/simonpj/papers/parallel-gc/par-gc-ismm08.pdf
  [2]: http://john.freml.in/garbage-collection-harmful

Mixing Erlang and Haskell

I have made a file called `time.hs`. It contains a single function that measures the execution time another function.

Is there a way to import the `time.hs` file into another Haskell script?

**I want something like:**

    module Main where
    import C:\Haskell\time.hs
    
    main = do
    	putStrLn &quot;Starting...&quot;
    	time $ print answer
    	putStrLn &quot;Done.&quot;

**Where time is defined in the &#39;time.hs&#39; as:**

    module time where
    Import &lt;necessary modules&gt;
    
    time a = do
    start &lt;- getCPUTime
    v &lt;- a
    end   &lt;- getCPUTime
    let diff = (fromIntegral (end - start)) / (10^12)
    printf &quot;Computation time: %0.3f sec\n&quot; (diff :: Double)
    return v


I don&#39;t know how to import or load a separate `.hs` file. Do I need to compile the `time.hs` file into a module before importing?

How to import a .hs file in Haskell

A classic programming exercise is to write a Lisp/Scheme interpreter in Lisp/Scheme. The power of the full language can be leveraged to produce an interpreter for a subset of the language.

Is there a similar exercise for Haskell? I&#39;d like to implement a subset of Haskell using Haskell as the engine. Of course it *can* be done, but are there any online resources available to look at?

&lt;hr&gt;
Here&#39;s the backstory.

I am exploring the idea of using Haskell as a language to explore some of the concepts in a [Discrete Structures][1] course I am teaching. For this semester I have settled on [Miranda][2], a smaller language that inspired Haskell. Miranda does about 90% of what I&#39;d like it to do, but Haskell does about 2000%. :)

So my idea is to create a language that has exactly the features of Haskell that I&#39;d like and disallows everything else. As the students progress, I can selectively &quot;turn on&quot; various features once they&#39;ve mastered the basics.

Pedagogical &quot;language levels&quot; have been used successfully to teach [Java][3] and [Scheme][4]. By limiting what they can do, you can prevent them from shooting themselves in the foot while they are still mastering the syntax and concepts you are trying to teach. And you can offer better error messages.

  [1]:https://stackoverflow.com/questions/748844/difference-between-discrete-structures-and-discrete-mathematics
  [2]:http://miranda.org.uk
  [3]:http://drjava.org/docs/user/ch08.html
  [4]:http://docs.plt-scheme.org/htdp-langs/index.html

Write a Haskell interpreter in Haskell

In F#, use of the the pipe-forward operator, `|&gt;`, is pretty common.  However, in Haskell I&#39;ve only ever seen function composition, `(.)`, being used.  I understand that they are [related][1], but is there a language reason that pipe-forward isn&#39;t used in Haskell or is it something else?


  [1]: http://blogs.msdn.com/chrsmith/archive/2008/06/14/function-composition.aspx

Haskell composition (.) vs F#&#39;s pipe forward operator (|&gt;)

There is a lot of hype around Haskell, however, it is hard to get information on how it is used in the real world applications. What are the most popular projects / usages of Haskell and why it excels at solving these problems?

What is Haskell used for in the real world?

I&#39;m wondering what the correct way to compare two characters ignoring case that will work for all cultures. Also, is `Comparer&lt;char&gt;.Default` the best way to test two characters without ignoring case? Does this work for surrogate-pairs?

**EDIT**: Added sample `IComparer&lt;char&gt;` implementation

If this helps anyone this is what I&#39;ve decided to use

    public class CaseInsensitiveCharComparer : IComparer&lt;char&gt; {
        private readonly System.Globalization.CultureInfo ci;
        public CaseInsensitiveCharComparer(System.Globalization.CultureInfo ci) {
            this.ci = ci;
        }
        public CaseInsensitiveCharComparer()
            : this(System.Globalization.CultureInfo.CurrentCulture) { }
        public int Compare(char x, char y) {
            return Char.ToUpper(x, ci) - Char.ToUpper(y, ci);
        }
    }
    
    // Prints 3
    Console.WriteLine(&quot;This is a test&quot;.CountChars(&#39;t&#39;, new CaseInsensitiveCharComparer()));


What is the correct way to compare char ignoring case?

Can anyone please make a comparison of `ASP.NET MVC` vs `Spring MVC`. 

Which technology is better in performance, productivity, maintenance, features,...

Regards,
sirmak
 

ASP.NET MVC vs Spring MVC

I am searching for a comparison of different
[continuous integration][1] (CI) Servers (esp. focusing
on .NET) and couldn&#39;t find any.

Therefore I&#39;d like to know what you think about the
different solutions available, what are the pros and cons,
what are the hosting requirements and why CI Server XY is
the Server of your choice.

I am interested in your thoughts on (feel free to comment on
others to):

 - [Hudson][2] 
 - [CruiseControl][3]
 - [CruiseControl.NET][4]
 - [Teamcity][5]
 - CIFactory (uses CruiseControl.NET)

Points of Interest are:

 - Configuration (easy, flexible)
 - Integration with SCM (esp. DSVC like git or hg)
 - Integration with build sytems (MSBuild, NAnt, Rake)
 - Integration with Testing Frameworks
 - Integration with Source Anaylsis (Simian, NDepend, FxCop, NCover etc.)
 - WebInterface/Dashboards
 - Infrastructure requirements

  [1]: http://en.wikipedia.org/wiki/Continuous_integration
  [2]: http://hudson-ci.org/
  [3]: http://cruisecontrol.sourceforge.net/
  [4]: http://www.cruisecontrolnet.org/
  [5]: http://www.jetbrains.com/teamcity


Comparison of CI Servers?

How to &quot;deep&quot;-compare two objects that do not implement the equals method based on their field values in a test?

---

Original Question (closed because lack of precision and thus not fulfilling SO standards), kept for documentation purposes:

I&#39;m trying to write unit tests for a variety of `clone()` operations inside a large project and I&#39;m wondering if there is an existing class somewhere that is capable of taking two objects of the same type, doing a deep comparison, and saying if they&#39;re identical or not?



Is there a Java utility to do a deep comparison of two objects?

Two string variables are set to the same value. `s1 == s2` always returns `True`, but `s1 is s2` sometimes returns `False`.

If I open my Python interpreter and do the same `is` comparison, it succeeds:

    &gt;&gt;&gt; s1 = &#39;text&#39;
    &gt;&gt;&gt; s2 = &#39;text&#39;
    &gt;&gt;&gt; s1 is s2
    True

Why is this?

Content Type	Original Author	Original Content on Stackoverflow
Question	sastanin	View Question on Stackoverflow
Solution 1 - Xml	Don Stewart	View Answer on Stackoverflow
Solution 2 - Xml	Alexander Staubo	View Answer on Stackoverflow
Solution 3 - Xml	Will	View Answer on Stackoverflow

Which Haskell XML library to use?

Xml Problem Overview

Xml Solutions

Solution 1 - Xml

Solution 2 - Xml

Solution 3 - Xml

Is there a pure CSS way to make an input transparent?

iPhone how to check the type of an Object?

Attributions