Synopsis Retrieve a slice of a node's argument list.
Syntax
1. `Exp1 [ Exp2 .. Exp4]`
2. `Exp1 [ Exp2 , Exp3 .. Exp4]`
where `Exp2` and `Exp4` are optional.
Types
`Exp1` `Exp2` `Exp3` `Exp4` `Exp1 [ Exp2 .. Exp4 ]` or `Exp1 [ Exp2 , Exp3 .. Exp4]`
`node` `int` `int` `int` `list[value]`
Description A Node slice is similar to a list Slice and uses the integer values of `Exp2` and `Exp4` to determine the `begin` (inclusive) and `end` (exclusive) of a slice from the children of the node value `ND` of `Exp1`. Negative indices count from the end of the list of children backwards. Using the second form, an extra index `Exp3` is given that determines the index of the second element in the slice and establishes the `step` between successive elements in the slice. The default `step` is 1. If `end` is smaller than `begin`, the slice is constructed backwards.

Let `Len` be the number of children of `ND` and let `N2`, `N3` and `N4` be the respective values of the expressions `Exp2`, `Exp2` and `Exp2` when they are present.

The slice parameters `begin`, `end`, and `step` are determined as follows:
• `Exp2`:
• If `Exp2` is absent, then `begin = 0`.
• Otherwise, if `N2` >= 0 then `begin = N2` else `begin = N2 + Len`.
• `Exp4`:
• If `Exp4` is absent, then `end = Len`.
• Otherwise, if `N4` >= 0, then `end = N4` else `end = N4 + Len`.
• `Exp3`:
• If `Exp3` is absent, then if `begin < end` then `step = 1` else `step = -1`.
• Otherwise, if `begin < end`, then `step = N3 - begin` else `step = begin - N3`.
Now, the constraints `0 <= begin < Len` and `0 < end < Len` should hold, otherwise the exception `IndexOutOfBounds` is thrown.

The slice consists of the children `ND[begin]`, `ND[begin+step]`, `ND[end - step]`. When `begin >= end`, the elements are listed in reverse order.
Examples Consider the list `ND = "f"(0, "abc", 20, false, 40, [3,4,5], 60, {"a", "b"}, 80);` as running example.

Here is a view on the children of `ND` that will help to correlate positive and negative indices:

`i` 0 1 2 3 4 5 6 7 8
`ND[i]` `0``"abc"``20``false``40``[3,4,5]``60``{"a", "b"}``80`
`-i` -9 -8 -7 -6 -5 -4 -3 -2 -1
Some common use cases (with `begin` <= `end`):

Slice Means:
`ND[begin..end]` children with indices `begin` through `end-1`
`ND[begin..]` children with indices `begin` through the rest of the list of children
`ND[..end]` children with indices from the beginning through `end-1`
`ND[..]` the whole list of children
`ND[-1]` last child of the list of children
`ND[-2..]` the last two children of the list of children
`ND[..-2]` all children except the last two.
Let's put this into practice now.
```rascal>ND = "f"(0, "abc", 20, false, 40, [3,4,5], 60, {"a", "b"}, 80);
node: "f"(
0,
"abc",
20,
false,
40,
[3,4,5],
60,
{"a","b"},
80)
```
Slices with begin < end
```rascal>ND[1..3];
list[value]: ["abc",20]
rascal>ND[1..];       // empty end => end of list of children
list[value]: [
"abc",
20,
false,
40,
[3,4,5],
60,
{"a","b"},
80
]
rascal>ND[..3];       // empty begin => first child of list
list[value]: [0,"abc",20]
rascal>ND[..];        // both empty => whole list of children
list[value]: [
0,
"abc",
20,
false,
40,
[3,4,5],
60,
{"a","b"},
80
]
```
Slices with begin >= end
```rascal>ND[3..1];      // slice contains children with indices 3 and 2 (in that order)
list[value]: [false,20]
rascal>ND[3..3];      // empty slice when begin == end
list[value]: []
```
Slices with negative begin or end:
```rascal>ND[2..-2];     // equivalent to ND[2..7]
list[value]: [
20,
false,
40,
[3,4,5],
60
]
rascal>ND[2..7];
list[value]: [
20,
false,
40,
[3,4,5],
60
]
rascal>ND[-4..-2];    // equivalent to ND[5..7]
list[value]: [
[3,4,5],
60
]
rascal>ND[5..7];
list[value]: [
[3,4,5],
60
]
```
Slices with an explicit second index:
```rascal>ND[1,3..6];
list[value]: [
"abc",
false,
[3,4,5]
]
rascal>ND[5,3..];
list[value]: [
[3,4,5],
false,
"abc"
]
```
Explore error cases:
```rascal>ND[..10];
|stdin:///|(5,2,<1,5>,<1,7>): IndexOutOfBounds(10)
at ___SCREEN_INSTANCE___(|stdin:///|(0,9,<1,0>,<1,9>))

rascal>ND[1..20];
|stdin:///|(6,2,<1,6>,<1,8>): IndexOutOfBounds(20)
at ___SCREEN_INSTANCE___(|stdin:///|(0,10,<1,0>,<1,10>))

```
Is this page unclear, or have you spotted an error? Please add a comment below and help us to improve it. For all other questions and remarks, visit ask.rascal-mpl.org.