Splitting into a one element array

Splitting into a one element array

[Jesper Nygårds]

[-- Attachment #1: Type: text/plain, Size: 977 bytes --]

I am writing a function where I want to split the $LBUFFER on whitespace,
and then handle the last element in the resulting array. My initial attempt
looked like this:

local dir=${${(z)LBUFFER}[-1]}

This works if $LBUFFER contains more than one word, but fails if it is one
word only. I tested the behavior with the following function:

trysplit() {
    local astring="aaa bbb"
    print -l ${=astring}
    print
    print -l ${${=astring}[-1]}
    print
    local cstring="ccc"
    print -l ${=cstring}
    print
    print -l ${${=cstring}[-1]}
}

with this result:

% trysplit
aaa
bbb

bbb

ccc

c

So, my interpretation of the above is that IF the split results in only one
word, the result is not handled as an array with one element, but as a
regular string. And then only the first letter of the $cstring is printed.

Is there some way to handle this that I have missed, or do I need to check
the split result for size, and then treat the one-element case differently?

Re: Splitting into a one element array

[ZyX]

14.09.2015, 23:07, "Jesper Nygårds" <jesper.nygards@gmail.com>:
> I am writing a function where I want to split the $LBUFFER on whitespace,
> and then handle the last element in the resulting array. My initial attempt
> looked like this:
>
> local dir=${${(z)LBUFFER}[-1]}
>
> This works if $LBUFFER contains more than one word, but fails if it is one
> word only. I tested the behavior with the following function:
>
> trysplit() {
>     local astring="aaa bbb"
>     print -l ${=astring}
>     print
>     print -l ${${=astring}[-1]}
>     print
>     local cstring="ccc"
>     print -l ${=cstring}
>     print
>     print -l ${${=cstring}[-1]}
> }
>
> with this result:
>
> % trysplit
> aaa
> bbb
>
> bbb
>
> ccc
>
> c
>
> So, my interpretation of the above is that IF the split results in only one
> word, the result is not handled as an array with one element, but as a
> regular string. And then only the first letter of the $cstring is printed.
>
> Is there some way to handle this that I have missed, or do I need to check
> the split result for size, and then treat the one-element case differently?

I have a workaround for this:

    local -a arr
    arr=( ${(z)LBUFFER} )
    local dir=${arr[-1]}

Re: Splitting into a one element array

[Bart Schaefer]

On Sep 14, 10:06pm, Jesper Nygards wrote:
} Subject: Splitting into a one element array
} I am writing a function where I want to split the $LBUFFER on whitespace,
} and then handle the last element in the resulting array. My initial attempt
} looked like this:
} 
} local dir=${${(z)LBUFFER}[-1]}
} 
} This works if $LBUFFER contains more than one word, but fails if it is one
} word only.

Yes, this is a side-effect of nested expansion working "inside out"; if
if there's nothing for ${(z)...} to split, the result becomes a scalar
before the context one level up is even considered.

For the case of splitting on spaces you can fix this with a subscript
flag as in ${LBUFFER[(w)-1]}, but because (z) splits on syntax rather
than on spaces there's no simple corresponding flag for "subscript on
shell words".

So the most readable way is probably the local array that ZyX suggested,
but if you really want a single nested expansion:

    ${${(z)LBUFFER}[(wps:$'\0':)-1]}

This works because the subscript flag [(w)] is only active when applied
to a scalar, so (ps:$'\0':) only applies when (z) returns a single word,
which won't contain a $'\0' byte so is not split further.

Re: Splitting into a one element array

[Jesper Nygårds]

[-- Attachment #1: Type: text/plain, Size: 1354 bytes --]

Ah yes, now I see. Thank you both!


On Mon, Sep 14, 2015 at 11:46 PM, Bart Schaefer <schaefer@brasslantern.com>
wrote:

> On Sep 14, 10:06pm, Jesper Nygards wrote:
> } Subject: Splitting into a one element array
> } I am writing a function where I want to split the $LBUFFER on whitespace,
> } and then handle the last element in the resulting array. My initial
> attempt
> } looked like this:
> }
> } local dir=${${(z)LBUFFER}[-1]}
> }
> } This works if $LBUFFER contains more than one word, but fails if it is
> one
> } word only.
>
> Yes, this is a side-effect of nested expansion working "inside out"; if
> if there's nothing for ${(z)...} to split, the result becomes a scalar
> before the context one level up is even considered.
>
> For the case of splitting on spaces you can fix this with a subscript
> flag as in ${LBUFFER[(w)-1]}, but because (z) splits on syntax rather
> than on spaces there's no simple corresponding flag for "subscript on
> shell words".
>
> So the most readable way is probably the local array that ZyX suggested,
> but if you really want a single nested expansion:
>
>     ${${(z)LBUFFER}[(wps:$'\0':)-1]}
>
> This works because the subscript flag [(w)] is only active when applied
> to a scalar, so (ps:$'\0':) only applies when (z) returns a single word,
> which won't contain a $'\0' byte so is not split further.
>