[XPath] Functions symmetric to `head()` and `tail()` for sequences and arrays

[dnovatchev]

In Xpath 3.1 we already have head(), tail(), and last()

But there is no function that produces the subsequence of all items of a sequence except the last one. There exists such a function in other programming languages. For example, in Haskell this is the init function.

And the last() function isn't the symmetric opposite of head() -- it doesn't give us the last item in a sequence, just its position. So we need another function: fn:heel() for this.

fn:init($sequence as item()*) as item()*

fn:heel($sequence as item()*) as item()?

init($seq) is a convenient shorthand for subsequence($seq, 1, count($seq) -1)

heel($seq) is a convenient shorthand for slice($seq, -1)

Examples:

fn:init(('a', 'b', 'c')) returns 'a', 'b'

fn:init(('a', 'b')) returns 'a'

fn:init('a') returns ()

fn:init(()) returns ()

fn:heel('a', 'b', 'c') returns 'c'

('a', 'b', 'c') => init() => heel() returns 'b'

It makes sense to have fn:init() and fn:heel() defined on arrays, too.

array:init($array as array(*)) as array(*)

array:heel($array as array(*)) as item()*

Examples:

array:init([1, 2, 3, 4, 5]) returns [1, 2, 3, 4]

array:init([1]) returns []

array:heel([1, 2, 3, (4, 5)]) returns (4, 5)

array:heel([()]) returns () (the empty sequence)

array:init([]) produces error

array:heel([]) produces error

[1, 2, 3, (4, 5)] =>array:heel() => heel() returns 5

I would challenge anyone to re-write the last example in understandable way using fn:slice() 💯

[ChristianGruen]

+1. I proposed this function a while ago (I cannot find out where, though, apart from some remarks on Slack), and I remember that @michaelhkay preferred to name it fn:truncate.

[ChristianGruen]

PS: Analogous to fn:head and other sequence functions, fn:init(()) should return ().

[ChristianGruen]

And PPS (sorry, I’ll be more disciplined next time again) fn:truncate still seems to be mentioned in an example in the current draft of the spec: https://qt4cg.org/branch/master/xpath-functions-40/Overview-diff.html#func-range-to.

I agree with Dimitre, and I’d love to see fn:init (or fn:truncate) readded, as well as e.g. fn:foot to return the last item.

[dnovatchev]

I agree completely with Christian, and indeed, we need a fn:foot, because the existing fn:last doesn't do the symmetric of fn:head, as it is supposed to in other languages, such as Haskell.

[dnovatchev]

I agree completely with Christian, and indeed, we need a fn:foot, because the existing fn:last doesn't do the symmetric of fn:head, as it is supposed to in other languages, such as Haskell.

But the name foot is... E w e . . .

My preferred names are: final, rear or ending.

[ChristianGruen]

Related (quoting Michael Kay, https://app.slack.com/client/T011VK9115Z/C011NLXE4DU/thread/C011NLXE4DU-1605590306.224400):

I proposed foot($s) to get the last item in a sequence, but I'm now leaning towards slice($s, -1) as that packs a lot more power into one function. The second argument can be any sequence of integers, with negative integers counting from the end, so for example slice($s, -$n to -1) gives you the last $n.

[dnovatchev]

Related (quoting Michael Kay, https://app.slack.com/client/T011VK9115Z/C011NLXE4DU/thread/C011NLXE4DU-1605590306.224400):

I proposed foot($s) to get the last item in a sequence, but I'm now leaning towards slice($s, -1) as that packs a lot more power into one function. The second argument can be any sequence of integers, with negative integers counting from the end, so for example slice($s, -$n to -1) gives you the last $n.

. . .
Still, what matters is convenience, brevity and being easy to understand. Thus it would be good to have a function with intuitive name for that.

fn:rear($sequence as item()*) as item()

Is a shorthand for: slice($sequence, -1)

Examples:

('a', 'b', 'c') => rear() produces 'c'

It makes sense to have fn:init() and fn:rear() defined on arrays, too.

array:init($array as array(*)) as array(*)

array:rear($array as array(*)) as item()*

Examples:

array:init([1, 2, 3, 4, 5]) returns [1, 2, 3, 4]

array:rear([1, 2, 3, (4, 5)]) returns (4, 5)

[1, 2, 3, (4, 5)] =>array:rear() => rear() returns 5

I would challenge anyone to re-write the last example in understandable way using fn:slice() 💯

[ChristianGruen]

My impression is that fn:rear and fn:butt are too similar ;) Maybe it should be up to native speakers to make the decision. I’d also prefer a 4-letter-term.

I agree that the syntax of fn:slice is not that intuitive (but it's definitely powerful).

[dnovatchev]

My impression is that fn:rear and fn:butt are too similar ;)

:) A little humor isn't bad

Maybe it should be up to native speakers to make the decision. I’d also prefer a 4-letter-term.

I agree that the syntax of fn:slice is not that intuitive (but it's definitely powerful).

Yes, and I updated the previous comment with examples of rear() on arrays, that are understandable, but would be difficult to assimilate if slice() were used

[dnovatchev]

I updated the issue to include definition for fn:rear() and the array equivalents: array:init() and array:rear()

[adamretter]

Is fn:rear($seq) just a single function for fn:head(fn:reverse($seq)) ?

[martin-honnen]

I understand the proposals but fn:init(()) produces error astonishes me, that (an error) wouldn't happen with subsequence, or would it?

[ChristianGruen]

True. It's only the array functions that should trigger errors (and actually I never understood why array operations and functions were designed to raise range errors).

[michaelhkay]

I'm afraid there's always been tension between the error and no-error philosophies. Personally I tend to the "raise an error" camp - errors are easier to debug than wrong answers, and with XPath the hardest thing of all to debug is the expression that returns an empty sequence and you can't work out why. But the worst problem when you design by committee is that it's very hard to achieve a consistent policy on such things.