user
Special characters are symbols (single characters or sequences of characters) that have a "special" built-in meaning in the language and typically cannot be used in identifiers.

Escape sequences are methods that the language uses to remove the special meaning from the symbol, enabling it to be used as a normal character, or sequence of characters when this can be done.

Task

List the special characters and show escape sequences in the language.

Other tasks related to string operations:

Metrics

* Array length
* String length
* Copy a string
* Empty string  (assignment)

Counting

* Word frequency
* Letter frequency
* Jewels and stones
* I before E except after C
* Bioinformatics/base count
* Count occurrences of a substring
* Count how many vowels and consonants occur in a string

Remove/replace

* XXXX redacted
* Conjugate a Latin verb
* Remove vowels from a string
* String interpolation (included)
* Strip block comments
* Strip comments from a string
* Strip a set of characters from a string
* Strip whitespace from a string -- top and tail
* Strip control codes and extended characters from a string

Anagrams/Derangements/shuffling

* Word wheel
* ABC problem
* Sattolo cycle
* Knuth shuffle
* Ordered words
* Superpermutation minimisation
* Textonyms (using a phone text pad)
* Anagrams
* Anagrams/Deranged anagrams
* Permutations/Derangements

Find/Search/Determine

* ABC words
* Odd words
* Word ladder
* Semordnilap
* Word search
* Wordiff  (game)
* String matching
* Tea cup rim text
* Alternade words
* Changeable words
* State name puzzle
* String comparison
* Unique characters
* Unique characters in each string
* Extract file extension
* Levenshtein distance
* Palindrome detection
* Common list elements
* Longest common suffix
* Longest common prefix
* Compare a list of strings
* Longest common substring
* Find common directory path
* Words from neighbour ones
* Change e letters to i in words
* Non-continuous subsequences
* Longest common subsequence
* Longest palindromic substrings
* Longest increasing subsequence
* Words containing "the" substring
* Sum of the digits of n is substring of n
* Determine if a string is numeric
* Determine if a string is collapsible
* Determine if a string is squeezable
* Determine if a string has all unique characters
* Determine if a string has all the same characters
* Longest substrings without repeating characters
* Find words which contains all the vowels
* Find words which contain the most consonants
* Find words which contains more than 3 vowels
* Find words whose first and last three letters are equal
* Find words with alternating vowels and consonants

Formatting

* Substring
* Rep-string
* Word wrap
* String case
* Align columns
* Literals/String
* Repeat a string
* Brace expansion
* Brace expansion using ranges
* Reverse a string
* Phrase reversals
* Comma quibbling
* Special characters
* String concatenation
* Substring/Top and tail
* Commatizing numbers
* Reverse words in a string
* Suffixation of decimal numbers
* Long literals, with continuations
* Numerical and alphabetical suffixes
* Abbreviations, easy
* Abbreviations, simple
* Abbreviations, automatic

Song lyrics/poems/Mad Libs/phrases

* Mad Libs
* Magic 8-ball
* 99 bottles of beer
* The Name Game (a song)
* The Old lady swallowed a fly
* The Twelve Days of Christmas

Tokenize

* Text between
* Tokenize a string
* Word break problem
* Tokenize a string with escaping
* Split a character string based on change of character

Sequences

* Show ASCII table
* De Bruijn sequences
* Summarize and say sequence
* Generate lower case ASCII alphabet
assistant
(formerly Perl 6)

Technically speaking, all characters are special in Raku, since
they're all just the result of particular mixes of parse rules.
Nevertheless, some characters may appear to be more special than
others. (However, we will not document any operators here, which
contain plenty of odd characters in Raku.)

Sigils:

```
    $   Item
    @	Positional
    %	Associative
    &	Callable
```

Twigils may occur only after a sigil, and indicate special scoping:

```
    *	Dynamically scoped
    ?	Compile-time constant
    ^	Positional placeholder
    :	Named placeholder
    !	Private attribute
    .	Public attribute/accessor
    ~	Slang
    =	Pod data
    <	Named match from $/
```

Quote characters:

```
    ''	Single quotes
    ""	Double quotes
    //	Regex
    ｢｣	Quotes that allow no interpolation at all
    <>	Quote words
    «»	Shell-style words
```

Escapes within single quotes:

```
    \\	Backslash
    \'	Quote char
```

Escapes within double quotes:

```
    {}	Interpolate results of block
    $	Interpolate item
    @	Interpolate list (requires postcircumfix)
    %	Interpolate hash (requires postcircumfix)
    &	Interpolate call (requires postcircumfix)
    \\	Backslash
    \"	Quote char
    \a	Alarm
    \b	Backspace
    \c	Decimal, control, or named char
    \e	Escape
    \f	Formfeed
    \n	Newline
    \o	Octal char
    \r	Return
    \t	Tab
    \x	Hex char
    \0	Null
```

Escapes within character classes and translations include most of the double-quote backslashes, plus:

```
    ..	range
```

Escapes within regexes include most of the double-quote escapes, plus:

```
    :	Some kind of declaration
    <>	Some kind of assertion
    []	Simple grouping
    ()	Capture grouping
    {}	Side effect block
    .	Any character
    \d	Digit
    \w	Alphanumeric
    \s	Whitespace
    \h	Horizontal whitespace
    \v	Vertical whitespace
    ''	Single quoted string
    ""	Double quoted string
    «	Word initial boundary
    »	Word final boundary
    ^	String start
    ^^	Line start
    $	String end
    $$	Line end
```

Note that all non-alphanumeric characters are reserved for escapes and operators in Raku regexes.

Any lowercase backslash escape in a regex may be uppercased to negate it, hence \N matches anything that is not a newline.