Synopsis Retrieve a slice of a string.
  1. Exp1 [ Exp2 .. Exp4]
  2. Exp1 [ Exp2 , Exp3 .. Exp4]
where Exp2 and Exp4 are optional.
Exp1 Exp2 Exp3 Exp4 Exp1 [ Exp2 .. Exp4 ] or Exp1 [ Exp2 , Exp3 .. Exp4]
str int int int str
Description A String 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 string value S of Exp1. Negative indices count from the end of the string 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 length of S 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 elements S[begin], S[begin+step], S[end - step]. When begin >= end, the elements are listed in reverse order.
Examples Consider the string S = "abcdefghi"; (with size 9) as running example.

Here is a view on L that will help to correlate positive and negative indices:

i 0 1 2 3 4 5 6 7 8
S[i] "a" "b" "c" "d" "e" "f" "g" "h" "i"
-i -9 -8 -7 -6 -5 -4 -3 -2 -1

Some common use cases (with begin <= end):

Slice Means:
S[begin..end] characters with indices begin through end-1
S[begin..] characters with indices begin through the rest of the string
S[..end] characters with indices from the beginning through end-1
S[..] the whole list
S[-1] last element of the string
S[-2..] the last two characters of the string
S[..-2] all characters except the last two.
Let's put this into practice now.
rascal>S = "abcdefghi";
str: "abcdefghi"
Slices with begin < end
str: "bc"
rascal>S[1..];       // empty end => end of string
str: "bcdefghi"
rascal>S[..3];       // empty begin => first character of string
str: "abc"
rascal>S[..];        // both empty => whole string
str: "abcdefghi"
Slices with begin >= end
rascal>S[3..1];      // slice contains characters with indices 3 and 2 (in that order)
str: "dc"
rascal>S[3..3];      // empty slice when begin == end
str: ""
Slices with negative begin or end:
rascal>S[2..-2];     // equivalent to S[2..7]
str: "cdefg"
str: "cdefg"
rascal>S[-4..-2];    // equivalent to S[5..7]
str: "fg"
str: "fg"
Slices with an explicit second index:
str: "bdf"
str: "fdb"
Explore error cases:
|stdin:///|(4,2,<1,4>,<1,6>): IndexOutOfBounds(10)
	at ___SCREEN_INSTANCE___(|stdin:///|(0,8,<1,0>,<1,8>))

|stdin:///|(5,2,<1,5>,<1,7>): IndexOutOfBounds(20)
	at ___SCREEN_INSTANCE___(|stdin:///|(0,9,<1,0>,<1,9>))

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