[feature] xml_parser: added case default
[feature] xml_parser: more tag patterns
<tagname ... (like before)
<_ ... (any tag)
<(TrxParser) ... (parser)
<{parserExpr} ... (expression of a parser)
<x=... ... (with binding)
<...:... ... (a pattern for the namespace, and one for the name)
[feature] xml_parser: added & and ! prefixes

TODO: do the same for classic_syntax/xml_parser.trx
[enhance] xml_parser: allow bindings for & prefixed patterns
[feature] xml_parser: allow | in tag patterns

e.g. <b | u | i ... >
[fix] @xml syntax: do not take care of xhtml specific things

e.g. allows to write @xml(<br>blah</br>)
[fix] xml_parser: binding on a node pattern was not working

e.g. case a=<b />: <>{a}</>
was outputing "unbound a"
[enhance] xml_parser: allow "string {with_opa}" in tag patterns

e.g.
x = "br"
case <"{x}" ... />

/!\ since bindings are done before checking, you can actually do something like this:
case <"http://{x}.org":x=_ />
which will accept, e.g., <opalang xmlns="http://opalang.org" />
but not <opalang xmlns="http://br.org" />
[fix] js_syntax, xml_parser: fix parsing of embedded parsers

was not working: xml_parser { case (case <a />: "foo"): "bar" }
hope it doesn't break something else
[fix] stdlib: List.split_between was missing a case

If [l] has between [min] and [max], we would return {none}
[feature] xml_parser: more patterns for attributes

Each xml tag has an attribute list.
An attribute is a triple (namespace, name, value), written namespace:name = value.
You can now match an (unordered) attribute list with a (ordered) list of attribute patterns.
An attribute pattern is either:
1. a normal attribute pattern namespace_pattern : name_pattern = value_pattern
namespace_pattern, name_pattern, and value_pattern are like newly introduced tag name patterns, i.e., an optional binding followed by _ (any) or a disjunction (separator |) of
some_name or "some string with {opa insertions}" or {an opa expression representing a parser}, or (a string parser)
Unlike tag name patterns, binding are made with := instead of =
= value_pattern is optional, as well as namespace_pattern :
If name_pattern is a simple name, the value is bound to this name (like it was done previously)
2. a prefixed attribute pattern
If not prefixed, a matched attribute pattern removes the attribute from the remaining attribute list
If prefixed with &, the pattern will not remove the matched attribute
If prefixed with !, !pattern will match only if pattern would not match (no binding is allowed)
3. a suffixed attribute pattern: a pattern followed by a suffix (?, +, *, {x}, or {x,y})
No binding is accepted except at the beginning to bind the whole list (or the option for ?)
4. any attribute: .

Complex examples:
We want to match an element <a ... /> with the following attributes:
- no attributes: <a !. />
- exactly one attribute: <a . !. />
- only attributes from namespace ns: <a "{ns}":_* !. />
- two attributes x and y having the same value: <a x y="{x}" />
- an attribute x, and bind y to the other attributes: <a x y:=.* />
- an attribute x, and bind y to all the attributes (x included): <a &x y:=.* />
- an attribute b starting with a and having a c in the third position: <a &b=("a" .*) &b=(.."c".*) />

/!\ This will break any weird xml_parser such as
<t a={x} a={y}>
because now, matched attributes are eaten

/!\ Greedy, no backtracking
<a x:=_ "{x}" /> can match <a b="c" c="d" /> only if you are lucky.
The order of the attributes is not guaranted, hence
x:=_ can match either b="c" (binding x to "b") or c="d" (binding x to "c")
{x} can only match the other attribute, since the first one has been eaten
[enhance] stdlib: Xmlns.to_string was not able to handle all (non-xhtml) xml fragments
[feature] stdlib: Rule.of_simple_sum_type
[enhance] xml_parser: allow trx-parser-based attribute patterns to bind variables

E.g. <a x=(y=some_parser) />: print(y)
would fail with "y is unbound", and now works

This is however limited to single patterns.
<a x=(y=some_parser)|(y=some_parser) />
will still give "y is unbound".

/!\ Since attributes are bound before matching its value, the following patterns are equivalent:
<a x="{x}" />
<a x=_ />
Indeed, "{x}" refers to the value of the attribute x.
Todo: we should produce a warning in such a case.
[fix] xml_parser: previous commit was allowing to backtrack on attribute
matching, which was not the intented result.
If backtracking is wanted, it should probably be done differently.
[feature] stdlib: OpaValue.default_with_hints
[enhance] xml_parser: handles suffixes on attribute patterns

Examples:
<a x:=_="a"* />: x will be the list of all attributes having value "a"
<a x? />: x will be an option (some will contain the value of the attribute)

For +, *, and {}, only one binding is allowed, at the beginning, the result will be a list of attributes.
For ?, namespace, name, and value bindings are allowed and result to options
[fix] xhtml syntax was not allowing attribute names starting with (but different than) href

E.g. <a hreflang="fr" ...>, whereas in XHTML standard, was not allowed
[fix] to_xhtml: avoid stupid runtime errors like
Can't make an xml with {args : list(Xml.attribute); content : list(xml(xhtml_specific_attributes ,xhtml_specific_extensions)); namespace : string; specific_attributes : option(xhtml_specific_attributes); tag : string; xmlns : list(Xml.binding)} / {content_unsafe : string} / {fragment : list(xml(xhtml_specific_attributes ,xhtml_specific_extensions))} / {text : string} / {xml_dialect : option(xhtml_specific_extensions)}}
Merge pull request #148 from mbouaziz/master

Enhanced xml parsers