26585 2014-08-14 19:32:38 +0000 Proposal: fn:apply 2015-02-10 17:01:41 +0000 1 1 1 Unclassified XPath / XQuery / XSLT Functions and Operators 3.1 Working drafts PC All CLOSED FIXED https://www.w3.org/Bugs/Public/show_bug.cgi?id=26889 https://www.w3.org/Bugs/Public/show_bug.cgi?id=26558 P2 normal --- 1 marc.van.grootel mike christian.gruen cmsmcq leo liam mike r.stapper public-qt-comments oldest_to_newest 110190 0 marc.van.grootel 2014-08-14 19:32:38 +0000 XQuery 3.0 introduced functions that are derived from functional programming. Function items can be passed as arguments to functions like fn:fold-left(). Together they allow a more functional style of coding. Most of these functions can be used to perform map, filter, reduce on sequences. However, one important function that is missing and for which I do not know a reasonable workaround for is "apply" [1]. The wikipedia page shows that many languages have ways to achieve this and Clojure has a function with the same name [2]. In XQuery we can bind a variable to a function item. But when we want to use it we are limited to one argument. $f = function my-add($a,$b,$c) { $a + $b + $c } $args = (1,2,3) $f($args) == $f((1,2,3)) If we had an apply function this would do it. fn:apply($f, $args) == $f(1,2,3) Of course we could rewrite the function my-add to something like: $f = function my-add($seq) { sum($seq) } $f($args) == 6 But this is only practical for a limited number of cases and the function body would need to unpack the sequence, and we also lose the type checking. This limitation also shows with the proposed arrow operator (=>). Someone coming from a language like Clojure, Lisp or Scheme would interpret the following (1,2,3) => $f to mean $f(1,2,3) but in XQuery it would mean $f((1,2,3)) The arrow operator is similar to Clojure's threading operator (->) [3]. Clojure: (-> (1 2 3) f1 f2) == (f2 (f1 1 2 3)) Note that in Clojure -> is a macro which re-writes the form before the compiler will see it. But I digress. XQuery: (1,2,3) => $f1 => $f2 $f2($f1((1,2,3)) Maybe this is a consequence of the fact that sequences cannot be nested, and are effectively flattened. I cannot oversee all the consequences but like a map may contain other maps arrays can be nested so they could be used for "apply" semantics. Currently we have: (1,2,3) => $f $f((1,2,3)) With array apply semantics: [1,2,3] => $f1 => $f2 == $f2($f1(1,2,3)) [(1,2),(3,4)] => $f1 == $f1((1,2),(3,4)) == fn:apply($f1, [(1,2),(3,4)]) On the surface this looks like an elegant solution to me and is closer to the apply semantics in other languages. A particular use case for fn:apply arose when I tried implementing Clojure Ring and Compojure libraries in XQuery. These are comparable to WSGI in Python and Rack in Ruby. Below I simplified things but I hope it illustrates a concrete use case. I have a function for defining a routing handler which maps an HTTP GET request to a handler function. The def-route() signature is function( $method as xs:string, $url-template as xs:string, $params as array(*), $handler as function(*) ) as function(map(*)) as map(*) This means that a route handler function is something that takes a request map as input and produces a response map as output. $handler = function($name, $age) { 'Person: ' || $name || ' (age ' || $age ')' } $route = def-route('GET', '/person/{name}/{age}', ['name', 'age'], $handler) $route(request('GET', '/person/Joe/10')) When a GET request comes in on '/person/Joe/10'. The route-handler $route matches and the 'name' and 'age' parameters are parsed from the URL and added to the request map. The third argument is an array that specifies which keys need to be taken from the request map and builds the $params array: ['Joe', '10']. Finally it can invoke the $handler using fn:apply($handler, $params) or $params => $handler == ['Joe', '10'] => $handler This results in a response('Person: Joe (age 10)') which is then rendered to the browser. Note that the handler does not need to know where to find the parameters because this is set up by the $route handler thus achieving a clean separation of concerns and the possibility of using $handler in other situations because it is not tied to the plumbing/routing logic. As I said earlier, I may not be able to oversee all the consequences as I'm not super intimate with all the specs involved. Or, my pseudo code is confusing. Mea culpa. --Marc [1] http://en.wikipedia.org/wiki/Apply [2] http://clojuredocs.org/clojure_core/clojure.core/apply [3] http://clojuredocs.org/clojure_core/clojure.core/-%3E 110192 1 mike 2014-08-14 20:03:02 +0000 In the past it hasn't been possible to treat the list of arguments of a function as a single value because sequences can't be nested, as you suggest. That difficulty is partly solved by the introduction of arrays. But I think there are considerable difficulties that remain, notably the fact that the arity of a function in XQuery is so much part of its nature. Doing this would be powerful, but a lot of work to do well. 110352 2 1503 r.stapper 2014-08-20 13:44:37 +0000 Created attachment 1503 demo for apply (limited) functionality built in xquery 110353 3 1504 r.stapper 2014-08-20 13:52:31 +0000 Created attachment 1504 apply module built in xquery (limited functionality) The 'APPLY:argument.constructor' function gives problems in xquery. But since the module should be built in java these problems probably can be overcome. 110354 4 r.stapper 2014-08-20 14:03:06 +0000 for inspiration a apply-function built in xquery. The challenge in xquery is the (re-)creation of the argumentlist for the evaluationstring. But if the apply-function would be a part of the xquery-language itself it probably will be built in java. I'm not a java-expert but I wander if the problem that exists on xquery-level also exists on java-level. 110577 5 1505 marc.van.grootel 2014-08-26 07:31:14 +0000 Created attachment 1505 apply with array semantics Rob's example almost worked for me. I have added some extra argument serialization and handling of arrays as described in my proposal. Here's the adapted code. Note that 1) it may now be BaseX specific due to use of map and array modules and 2) I heavily reformatted the code so it matches the other code in my little library and 3) I have done little testing on this so there are probably many potholes. Next attachment will have some unit tests. 110578 6 1506 marc.van.grootel 2014-08-26 07:32:17 +0000 Created attachment 1506 unit tests for apply with array semantics Here are the BaseX specific unit tests. 111389 7 leo 2014-09-11 15:22:04 +0000 The current implementation of the arrow operator in the Working Draft [1] defines it as a syntactic macro: > If `$i` is an item and `f()` is a function, then `$i=>f()` is equivalent > to `f($i)`, and `$i=>f($j)` is equivalent to `f($i, $j)`. I think this is not very elegant and possibly confusing. Since e.g. `local:foo#0` and `local:foo#1` can be completely different functions in XQuery, it is potentially dangerous that in 1 => local:bar() => local:foo() it is not immediately obvious which of them is called. I would propose that the second argument of `=>` should instead be a function item taking one argument. Then `$arg => $f` can be translated into `$f($arg)` directly and the Spec can define it simply as equivalent to: function op:arrow-apply( $arg as item()*, $func as function(item()*) as item()* ) as item()* { $func($arg) }; As a nice bonus this also makes the feature more flexible because the argument to be inserted does not have to be the first one in the function: $file-extension => csv:get-separator() => (tokenize($line, ?))() could be written as $file-extension => csv:get-separator#1 => tokenize($line, ?) Everything that was possible before should still work when adding a "?" at the start of the ArgumentList of each right-hand side of `=>`. The example from the Spec becomes $string => upper-case(?) => normalize-unicode(?) => tokenize(?, "\s+") or (shorter and more elegant): $string => upper-case#1 => normalize-unicode#1 => tokenize(?, "\s+") In conclusion, using function items is more flexible and less confusing, and the syntactic translation scheme makes for only marginally less verbose tyntax. [1] http://www.w3.org/TR/2014/WD-xquery-31-20140424/#id-arrow-operator 112012 8 christian.gruen 2014-09-23 11:29:24 +0000 I copied Leo Wörteler's proposal in an extra issue: https://www.w3.org/Bugs/Public/show_bug.cgi?id=26889 114189 9 liam 2014-10-28 22:02:29 +0000 The WG is considering comment 7 separately (thank you, Christian, for copying it). On the main subsance of this issue, it's possible (I think) that a function like fn:apply($f as function, $args as array) could be defined by F & O in the future, but the Working Groups have not made such a decision now. 115683 10 cmsmcq 2014-11-29 02:27:53 +0000 On the joint call of 25 November I took an action to try to work out a simple use case for the fn:apply() function requested by the OP, as sketched by Michael Kay in [1] and as commented on by John Snelson in [2]. [1] https://lists.w3.org/Archives/Member/w3c-xsl-query/2014Nov/0019.html [2] https://lists.w3.org/Archives/Member/w3c-xsl-query/2014Nov/0026.html I have posted the results separately to the public QT comments list [3], to avoid overburdening a Bugzilla comment. [3] http://lists.w3.org/Archives/Public/public-qt-comments/2014Nov/0115.html In that mail, I provide examples of the use of fn:apply() as sketched in [1] for currying functions, for composing functions, and for use in meta-circular interpreters. The bottom line is that while I agree with Michael Kay and John Snelson that variable-arity functions would be handy, and would make fn:apply() more useful and convenient, I believe that it's useful enough to be included in the spec even without variable-arity functions. 115812 11 mike 2014-12-02 22:40:41 +0000 The proposal to add an fn:apply() function was accepted. The semantics of fn:apply($f, [$a, $b, $c, ...]) are the same as $f($a, $b, $c, ...) but of course the arity does not need to be known statically. 1503 2014-08-20 13:44:37 +0000 2014-08-20 13:44:37 +0000 demo for apply (limited) functionality built in xquery applyDemo.xq text/plain 455 r.stapper aW1wb3J0IG1vZHVsZSBuYW1lc3BhY2UgQVBQTFkgPSAiQVBQTFkiIDsgKDogZHdvcmtzIG9ubHkg Zm9yIGEgc3Vic2V0IG9mIGRhdGEgdHlwZXM6KQoKbGV0ICRmb28yIDo9CmZ1bmN0aW9uKCAkYSwg JGIpCiAgICAgICAgeyAkYSB8fCBzdHJpbmcoICRiKQogICAgICAgIH0KCmxldCAkZm9vMyA6PQpm dW5jdGlvbiggJGEsICRiLCAkYykKICAgICAgICB7ICRhICsgJGIgKyAkYwogICAgICAgIH0KCmxl dCAkZm9vNCA6PQpmdW5jdGlvbiggJGEsICRiLCAkYywgJGQpCiAgICAgICAgeyAkYSB8fCAkYiB8 fCAkYyB8fCAkZAogICAgICAgIH0KCnJldHVybiAoIEFQUExZOmFwcGx5KCAkZm9vMiwgKCAnbnVt YmVyXycsIDIpKQogICAgICAgLCBBUFBMWTphcHBseSggJGZvbzMsICggMSwgMiwgMykpCiAgICAg ICAsIEFQUExZOmFwcGx5KCAkZm9vNCwgKCAiYSIsICJiIiwgImMiLCAiZCIpKQogICAgICAgKQo= 1504 2014-08-20 13:52:31 +0000 2014-08-20 13:52:31 +0000 apply module built in xquery (limited functionality) APPLY.xqm text/plain 1928 r.stapper bW9kdWxlIG5hbWVzcGFjZSBBUFBMWSA9ICJBUFBMWSIgOwoKKDogYnVpbHQgaW4gamF2ZSBhbmQg ZXh0ZW5kIHhxdWVyeSBsYW5ndWFnZTopCmRlY2xhcmUgJXByaXZhdGUgZnVuY3Rpb24gQVBQTFk6 c2VxdWVuY2UuY29uc3RydWN0b3IKICAgICAgKCAkaXRlbXMpCiAgICAgIHsgY29uY2F0KCAiKCAi CiAgICAgICAgICAgICAgLCBzdHJpbmctam9pbiggJGl0ZW1zLCAnLCAnKQogICAgICAgICAgICAg ICwgIikiCiAgICAgICAgICAgICAgKSAKICAgICAgfSA7CgpkZWNsYXJlICVwcml2YXRlIGZ1bmN0 aW9uIEFQUExZOnBhcmFtZXRlckxpc3QuY29uc3RydWN0b3IKICAgICAgKCAkYXJncy5hbW91bnQK ICAgICAgKQogICAgICB7IEFQUExZOnNlcXVlbmNlLmNvbnN0cnVjdG9yKCAoIDEgdG8gJGFyZ3Mu YW1vdW50KSAhIGNvbmNhdCggIiRhcmciLCAuKSkKICAgICAgfSA7CgpkZWNsYXJlICVwcml2YXRl IHZhcmlhYmxlICRBUFBMWTphcmd1bWVudExpc3RDb25zdHJ1Y3Rvci5uYW1lIDo9ICJsb2NhbDph cmd1bWVudExpc3QuY29uc3RydWN0b3IiIDsKCmRlY2xhcmUgJXByaXZhdGUgZnVuY3Rpb24gQVBQ TFk6YXJndW1lbnRMaXN0Q29uc3RydWN0b3IuY29uc3RydWN0b3IKICAgICAgKCAkcGFyYW1hdGVy TGlzdCkKICAgICAgeyBjb25jYXQoICJkZWNsYXJlICVwcml2YXRlIGZ1bmN0aW9uICIKICAgICAg ICAgICAgICAsICRBUFBMWTphcmd1bWVudExpc3RDb25zdHJ1Y3Rvci5uYW1lCiAgICAgICAgICAg ICAgLCAkcGFyYW1hdGVyTGlzdAogICAgICAgICAgICAgICwgInsgZnVuY3Rpb24oICRmKSB7ICRm IgogICAgICAgICAgICAgICwgJHBhcmFtYXRlckxpc3QKICAgICAgICAgICAgICAsICJ9IH0gOyIK ICAgICAgICAgICAgICApCiAgICAgIH0gOwooOiBwcm9ibGVtIGluIHhxdWVyeSBidXQgc2hvdWxk IGJlIGRvLWFibGUgaW4gamF2YTopCmRlY2xhcmUgJXByaXZhdGUgZnVuY3Rpb24gQVBQTFk6YXJn dW1lbnQuY29uc3RydWN0b3IKICAgICAgKCAkYXJnKQogICAgICB7IHR5cGVzd2l0Y2goICRhcmcp CiAgICAgICAgY2FzZSB4czpzdHJpbmcgcmV0dXJuICciJyB8fCBzdHJpbmcoICRhcmcpIHx8ICci JwogICAgICAgIGRlZmF1bHQgICAgICAgIHJldHVybiBzdHJpbmcoICRhcmcpCiAgICAgICAgIAog ICAgICB9IDsKZGVjbGFyZSAlcHJpdmF0ZSBmdW5jdGlvbiBBUFBMWTphcmd1bWVudExpc3QuY29u c3RydWN0b3IKICAgICAgKCAkYXJncy5saXN0KQogICAgICB7IEFQUExZOnNlcXVlbmNlLmNvbnN0 cnVjdG9yKCAkYXJncy5saXN0ICEgQVBQTFk6YXJndW1lbnQuY29uc3RydWN0b3IoIC4pKQogICAg ICB9IDsKCmRlY2xhcmUgJXByaXZhdGUgZnVuY3Rpb24gQVBQTFk6YXJndW1lbnRMaXN0Q29uc3Ry dWN0b3IuY2FsbGVyCiAgICAgICggJGFyZ3VtZW50TGlzdCkKICAgICAgeyBjb25jYXQoICRBUFBM WTphcmd1bWVudExpc3RDb25zdHJ1Y3Rvci5uYW1lCiAgICAgICAgICAgICAgLCAkYXJndW1lbnRM aXN0CiAgICAgICAgICAgICAgKQogICAgICB9IDsKCmRlY2xhcmUgZnVuY3Rpb24gQVBQTFk6YXBw bHkKICAgICAgKCAkZm4sICRhcmdzKSAKICAgICAgeyB4cXVlcnk6ZXZhbCggY29uY2F0KCBBUFBM WTphcmd1bWVudExpc3RDb25zdHJ1Y3Rvci5jb25zdHJ1Y3RvciggQVBQTFk6cGFyYW1ldGVyTGlz dC5jb25zdHJ1Y3RvciggY291bnQoICRhcmdzKSkpCiAgICAgICAgICAgICAgICAgICAgICAgICAg ICwgQVBQTFk6YXJndW1lbnRMaXN0Q29uc3RydWN0b3IuY2FsbGVyICAgICAoIEFQUExZOmFyZ3Vt ZW50TGlzdC5jb25zdHJ1Y3RvciggJGFyZ3MpKQogICAgICAgICAgICAgICAgICAgICAgICAgICAs ICIoIC4pIgogICAgICAgICAgICAgICAgICAgICAgICAgICApCiAgICAgICAgICAgICAgICAgICAs IG1hcHsgJycgOiAkZm59CiAgICAgICAgICAgICAgICAgICApCiAgICAgIH0gOwo= 1505 2014-08-26 07:31:14 +0000 2014-08-26 07:31:14 +0000 apply with array semantics apply.xqm text/plain 2391 marc.van.grootel bW9kdWxlIG5hbWVzcGFjZSBhcHBseSA9ICdodHRwOi8veG9rb21vbGEuY29tL3hxdWVyeS9mb2xk L3V0aWxzL2FwcGx5JzsKCig6fgogOiBBcHBseSBmdW5jdGlvbiAodXNpbmcgeHF1ZXJ5OmV2YWwp IGNvbnRyaWJ1dGVkIGJ5CiA6IFJvYiBTdGFwcGVyIGluIGFuc3dlciB0byBteSBwcm9wb3NhbCBm b3IgYWRkaW5nCiA6IGZuOmFwcGx5IHRvIFhRdWVyeSAzLjEuCiA6CiA6IEBzZWUgaHR0cHM6Ly93 d3cudzMub3JnL0J1Z3MvUHVibGljL3Nob3dfYnVnLmNnaT9pZD0yNjU4NQogOikKCmRlY2xhcmUg JXByaXZhdGUgZnVuY3Rpb24gYXBwbHk6c2VxdWVuY2UoJGl0ZW1zKSB7CiAgICBjb25jYXQoJygn LCBzdHJpbmctam9pbigkaXRlbXMsICcsICcpLCAnKScpIAp9OwoKZGVjbGFyZSAlcHJpdmF0ZSBm dW5jdGlvbiBhcHBseTpwYXJhbWV0ZXItbGlzdCgkYXJnY291bnQpIHsKICAgIGFwcGx5OnNlcXVl bmNlKAogICAgICAgICgxIHRvICRhcmdjb3VudCkgISBjb25jYXQoIiRhcmciLCAuKQogICAgKQp9 OwoKZGVjbGFyZSAlcHJpdmF0ZSB2YXJpYWJsZSAkYXBwbHk6YXJndW1lbnQtbGlzdC1jb25zdHJ1 Y3Rvci1uYW1lIDo9ICdsb2NhbDphcmd1bWVudC1saXN0JzsKCmRlY2xhcmUgJXByaXZhdGUgZnVu Y3Rpb24gYXBwbHk6YXJndW1lbnQtbGlzdC1jb25zdHJ1Y3RvcigkcGFyYW1ldGVyLWxpc3QpIHsK ICAgIGZuOmNvbmNhdCgKICAgICAgICAiZGVjbGFyZSAlcHJpdmF0ZSBmdW5jdGlvbiAiLAogICAg ICAgICRhcHBseTphcmd1bWVudC1saXN0LWNvbnN0cnVjdG9yLW5hbWUsCiAgICAgICAgJHBhcmFt ZXRlci1saXN0LAogICAgICAgICJ7IGZ1bmN0aW9uKCRmKSB7ICRmIiwKICAgICAgICAkcGFyYW1l dGVyLWxpc3QsCiAgICAgICAgIn19OyIKICAgICkKfTsKCmRlY2xhcmUgZnVuY3Rpb24gYXBwbHk6 YXJndW1lbnQoJGFyZykgewogICAgdHlwZXN3aXRjaCAoJGFyZykKICAgICAgICBjYXNlIHhzOnN0 cmluZwogICAgICAgICAgICByZXR1cm4gJyInIHx8IHN0cmluZygkYXJnKSB8fCAnIicKICAgICAg ICBjYXNlIGFycmF5KCopCiAgICAgICAgICAgIHJldHVybiBhcnJheTpzZXJpYWxpemUoJGFyZykK ICAgICAgICBjYXNlIG1hcCgqKQogICAgICAgICAgICByZXR1cm4gbWFwOnNlcmlhbGl6ZSgkYXJn KQogICAgICAgIGNhc2UgeHM6YW55QXRvbWljVHlwZQogICAgICAgICAgICByZXR1cm4gc3RyaW5n KCRhcmcpCiAgICAgICAgY2FzZSBpdGVtKCkrCiAgICAgICAgICAgIHJldHVybiBhcHBseTphcmd1 bWVudC1saXN0KCRhcmcpCiAgICAgICAgZGVmYXVsdAogICAgICAgICAgICByZXR1cm4gc3RyaW5n KCRhcmcpCn07CgpkZWNsYXJlIGZ1bmN0aW9uIGFwcGx5OmFyZ3VtZW50LWxpc3QoJGFyZ3MpIHsK ICAgIGFwcGx5OnNlcXVlbmNlKAogICAgICAgIHR5cGVzd2l0Y2ggKCRhcmdzKQogICAgICAgICAg ICBjYXNlIGFycmF5KCopCiAgICAgICAgICAgICAgICByZXR1cm4gCiAgICAgICAgICAgICAgICAg ICAgZm9yICRpIGluIDEgdG8gYXJyYXk6c2l6ZSgkYXJncykgCiAgICAgICAgICAgICAgICAgICAg ICAgIHJldHVybiBhcHBseTphcmd1bWVudCgkYXJncygkaSkpCiAgICAgICAgICAgIGRlZmF1bHQK ICAgICAgICAgICAgICAgIHJldHVybiAkYXJncyAhIGFwcGx5OmFyZ3VtZW50KC4pCiAgICApCn07 CgpkZWNsYXJlICVwcml2YXRlIGZ1bmN0aW9uIGFwcGx5OmFyZ3VtZW50LWxpc3QtY29uc3RydWN0 b3ItY2FsbGVyKCRhcmd1bWVudC1saXN0KSB7CiAgICBjb25jYXQoCiAgICAgICAgJGFwcGx5OmFy Z3VtZW50LWxpc3QtY29uc3RydWN0b3ItbmFtZSwKICAgICAgICAkYXJndW1lbnQtbGlzdAogICAg KQp9OwoKZGVjbGFyZSBmdW5jdGlvbiBhcHBseTphcHBseSgkZm4sICRhcmdzKSB7CiAgICB4cXVl cnk6ZXZhbCgKICAgICAgICBjb25jYXQoCiAgICAgICAgICAgIGFwcGx5OmFyZ3VtZW50LWxpc3Qt Y29uc3RydWN0b3IoCiAgICAgICAgICAgICAgICBhcHBseTpwYXJhbWV0ZXItbGlzdCgKICAgICAg ICAgICAgICAgICAgICB0eXBlc3dpdGNoICgkYXJncykKICAgICAgICAgICAgICAgICAgICAgICAg Y2FzZSBhcnJheSgqKQogICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0dXJuIGFycmF5OnNp emUoJGFyZ3MpCiAgICAgICAgICAgICAgICAgICAgICAgIGRlZmF1bHQKICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHJldHVybiBjb3VudCgkYXJncykKICAgICAgICAgICAgICAgICkKICAgICAg ICAgICAgKSwKICAgICAgICAgICAgYXBwbHk6YXJndW1lbnQtbGlzdC1jb25zdHJ1Y3Rvci1jYWxs ZXIoCiAgICAgICAgICAgICAgICBhcHBseTphcmd1bWVudC1saXN0KCRhcmdzKSksCiAgICAgICAg ICAgICcoLiknCiAgICAgICAgKSwKICAgICAgICBtYXAgeyAnJzogJGZuIH0KICAgICkKfTsK 1506 2014-08-26 07:32:17 +0000 2014-08-26 07:32:17 +0000 unit tests for apply with array semantics test-apply.xqm text/plain 1604 marc.van.grootel eHF1ZXJ5IHZlcnNpb24gIjMuMCI7CgooOn4KIDogVGVzdHMgZm9yIGFwcGx5IGZ1bmN0aW9uICh1 c2luZyB4cXVlcnk6ZXZhbCkgY29udHJpYnV0ZWQgYnkKIDogUm9iIFN0YXBwZXIgaW4gYW5zd2Vy IHRvIG15IHByb3Bvc2FsIGZvciBhZGRpbmcKIDogYXBwbHkgdG8gWFF1ZXJ5IDMuMS4KIDoKIDog QHNlZSBodHRwczovL3d3dy53My5vcmcvQnVncy9QdWJsaWMvc2hvd19idWcuY2dpP2lkPTI2NTg1 CiA6KQptb2R1bGUgbmFtZXNwYWNlIHRlc3QgPSAnaHR0cDovL3hva29tb2xhLmNvbS94cXVlcnkv Zm9sZC90ZXN0cyc7CgpkZWNsYXJlIGRlZmF1bHQgZnVuY3Rpb24gbmFtZXNwYWNlICdodHRwOi8v eG9rb21vbGEuY29tL3hxdWVyeS9mb2xkL3V0aWxzL2FwcGx5JzsKCmltcG9ydCBtb2R1bGUgbmFt ZXNwYWNlIGFwcGx5ID0gJ2h0dHA6Ly94b2tvbW9sYS5jb20veHF1ZXJ5L2ZvbGQvdXRpbHMvYXBw bHknCiAgICBhdCAnLi4vdXRpbHMvYXBwbHkueHFtJzsgCgpkZWNsYXJlICVwcml2YXRlIGZ1bmN0 aW9uIHRlc3Q6c3VtKCRhLCRiKSB7ICRhICsgJGIgfTsKZGVjbGFyZSAlcHJpdmF0ZSBmdW5jdGlv biB0ZXN0Om11bHQoJGEsJGIpIHsgJGEgKiAkYiB9OwoKZGVjbGFyZSAldW5pdDp0ZXN0IGZ1bmN0 aW9uIHRlc3Q6YXBwbHktY29uY2F0KCkgewogICAgdW5pdDphc3NlcnQtZXF1YWxzKAogICAgICAg IGFwcGx5KAogICAgICAgICAgICBmbjpjb25jYXQjMywgKCdhJywgJ2InLCAnYycpCiAgICAgICAg KSwgCiAgICAgICAgJ2FiYycKICAgICkKfTsKCmRlY2xhcmUgJXVuaXQ6dGVzdCBmdW5jdGlvbiB0 ZXN0OmFwcGx5LWFkZGl0aW9uKCkgewogICAgdW5pdDphc3NlcnQtZXF1YWxzKAogICAgICAgIGFw cGx5KAogICAgICAgICAgICBmdW5jdGlvbigkYSwgJGIsICRjKSB7CiAgICAgICAgICAgICAgICAk YSArICRiICsgJGMKICAgICAgICAgICAgfSwKICAgICAgICAgICAgKDEsIDIsIDMpCiAgICAgICAg KSwgCiAgICAgICAgNgogICAgKQp9OwoKZGVjbGFyZSAldW5pdDp0ZXN0IGZ1bmN0aW9uIHRlc3Q6 YXBwbHktY2FzdC10by1zdHJpbmcoKSB7CiAgICB1bml0OmFzc2VydC1lcXVhbHMoCiAgICAgICAg YXBwbHkoCiAgICAgICAgICAgIGZ1bmN0aW9uKCRhLCAkYikgewogICAgICAgICAgICAgICAgJGEg fHwgZm46c3RyaW5nKCRiKQogICAgICAgICAgICB9LAogICAgICAgICAgICAoJ251bWJlcl8nLCAy KQogICAgICAgICksIAogICAgICAgICdudW1iZXJfMicKICAgICkKfTsKCmRlY2xhcmUgJXVuaXQ6 dGVzdCBmdW5jdGlvbiB0ZXN0OmFwcGx5LWFycmF5KCkgewogICAgdW5pdDphc3NlcnQtZXF1YWxz KAogICAgICAgIGFwcGx5KHRlc3Q6c3VtIzIsIFsyLDRdKSwKICAgICAgICA2CiAgICApCn07Cgpk ZWNsYXJlICV1bml0OnRlc3QgZnVuY3Rpb24gdGVzdDphcHBseS1hcnJheS13aXRoLXNlcSgpIHsK ICAgIHVuaXQ6YXNzZXJ0LWVxdWFscygKICAgICAgICBhcHBseSgKICAgICAgICAgICAgZnVuY3Rp b24oJGEsJGIpIHsKICAgICAgICAgICAgICAgICgkYVsxXSAqICRhWzJdKSArICgkYlsxXSAqICRi WzJdKQogICAgICAgICAgICB9LCBbKDEsMiksKDMsNCldCiAgICAgICAgKSwKICAgICAgICAxNAog ICAgKQp9Owo=