### ----------------------------------------------------
### -- App::Rak
### -- Licenses: Artistic-2.0
### -- Authors: Elizabeth Mattijsen
### -- File: README.md
### ----------------------------------------------------
### -- Chunk 2 of 3
 all possible matches. Can be used to tweak search results, before letting it loose to get all possible results.

Special values that are allowed to produce all possible results are `∞` (aka `221E INFINITY`), `*` and `Inf`.

--formula=[none]
----------------

Only applicable if `--csv-per-line` has been specified. If specified, indicates the action to be taken when a field starts with an equal sign (indicating a formula of some kind in many spreadsheets). The following values are recognized:

<table class="pod-table">
<thead><tr>
<th>type</th> <th>action</th>
</tr></thead>
<tbody>
<tr> <td>none</td> <td>take not action, just pass on</td> </tr> <tr> <td>die</td> <td>throw an exception</td> </tr> <tr> <td>diag</td> <td>report line and position where formula was found</td> </tr> <tr> <td>empty</td> <td>replace the formula by an empty string</td> </tr>
</tbody>
</table>

--frequencies
-------------

Flag. If specified, will produce a frequency table of the matches with the most frequent match first. Default is `False`. See also `--unique`. Usually used in conjunction with `--matches-only` and/or `Callable` patterns returning something other than True/False/Nil/Empty.

--gid=condition
---------------

If specified, indicates the `Callable` that should return True to include a file in the selection of files to be checked. The numeric `gid` of the file will be passed as the only argument. Can also be specified as a single numeric argument. See also `--group`.

```bash
# show files of which the numeric group id is greater than 20
$ rak --find --gid='* > 20'

# show files of which the numeric group id is 20
$ rak --find --gid=20
```

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--group=condition
-----------------

If specified, indicates the `Callable` that should return True to include a file in the selection of files to be checked. The name of the group associated with the `gid` of the file will be passed as the only argument.

Can also be specified as a list of comma separated names to (not) select on. To select all names **except** the listed named, prefix with a `!`.

See also `--gid`. Requires the [P5getgrnam](https://raku.land/zef:lizmat/P5getgrnam) module to be installed.

```bash
# files of which the name associated with the user id starts with underscore
$ rak --find --group='*.starts-with("_")'

# show files of which the group is "staff"
$ rak --find --group=staff

# show files of which the group is NOT "staff"
$ rak --find --group='!staff'
```

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--group-matches
---------------

Flag. Indicate whether matches of a file should be grouped together by mentioning the filename only once (instead of on every line). Defaults to `True` if a human is watching, else `False`.

--hard-links=condition
----------------------

If specified, indicates the `Callable` that should return True to include a file in the selection of files to be checked. The number of hard-links to the file on the filesystem, will be passed as the only argument.

--has-setgid
------------

Flag. If specified, will only select files that do have the SETGID bit set in their attributes. Use negation `--/has-setgid` to only select files that do **not** have the SETGID bit set.

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--has-setuid
------------

Flag. If specified, will only select files that do have the SETUID bit set in their attributes. Use negation `--/has-setuid` to only select files that do **not** have the SETUID bit set.

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--headers
---------

Only applicable when `--csv-per-line` is also specified. It defaults to "auto". It can have the following values:

  * --headers

Boolean True, same as "auto"

  * --/headers

Boolean False, assume comma separator and no header line, produce a list of column values for each line in the CSV file.

  * --headers=auto

Automatically determine separator, first line is header with column names, produce a hash with values keyed to column names for each line in the CSV file.

  * --headers=skip

Assume the first line is a header, but skip it. Produce a lust of column values for each line in the CSV file.

  * --headers=uc

Same as "auto", but uppercase the column names found in the header line.

  * --headers=lc

Same as "auto", but lowercase the column names found in the header line.

  * --headers='<a b c>'

Specifies a list of column names to associate with columns, in order. Assumes no header line is available.

  * --headers=':a<foo>, :b<bar>'

Indicates a list of `Pair`s with column name mapping to use instead of the column names found in the header line of the CSV file.

  * --headers='code'

Any Raku code that produces one of the above values. Also supports a `Map` or `Hash` instead of a list of `Pair`s.

```bash
# Use uppercase column names
$ rak --csv-per-line --headers=uc '{.<FOO> if .<BAR> eq "foo"}' info.csv

# Use alternate column names in order of columns
$ rak --csv-per-line --headers='<a b>' '{.<a> if .<n> eq "foo"}' info.csv

# Use alternate column names using mapping
$ rak --csv-per-line --headers=':foo<a>, :bar<b>' '{.<a> if .<n> eq "foo"}' info.csv
```

--help[=area-of-interest]
-------------------------

Show argument documentation, possibly extended by giving the area of interest, which are:

  * argument

  * code

  * content

  * debugging

  * examples

  * faq

  * filesystem

  * general

  * haystack

  * item

  * listing

  * option

  * pattern

  * philosophy

  * resource

  * result

  * special

  * string

If no area of interest is given, then the overview will be shown.

Any pattern specification will be used to search the help subjects, and only show the logical paragraphs with matches.

--highlight
-----------

Flag. Indicate whether the pattern should be highlighted in the line in which it was found. Defaults to `True` if a human is watching (aka STDOUT connected to a terminal), or `--highlight-before` or `highlight-after` are explicitely specified, or `False` otherwise.

--highlight--after[=string]
---------------------------

Indicate the string that should be used at the end of the pattern found in a line. Specifying implies `--highlight`ing implicitely. If `--highlight` or `--highlight-before` are explicitely specified, will default to whatever is specified with `--highlight-before`, or to the ANSI code to end **bold**.

--highlight--before[=string]
----------------------------

Indicate the string that should be used at the end of the pattern found in a line. Specifying implies `--highlight`ing implicitly. If `highlight` is explicitely specified, will default to the terminal code to start **bold**.

--human
-------

Flag. Indicate that search results should be presented in a human readable manner. This means: filenames shown on a separate line, line numbers shown, and highlighting performed. Defaults to `True` if `STDOUT` is a TTY (aka, someone is actually watching the search results), otherwise defaults to `False`.

--ignorecase
------------

Flag. If specified, indicates that any matching using a literal string or a regex, should be done case insensitively. Default is `False`.

--ignoremark
------------

Flag. If specified, indicates that any matching using a literal string or a regex, should be done without consideration of any accents. Default is `False`.

--inode=condition
-----------------

If specified, indicates the `Callable` that should return True to include a file in the selection of files to be checked. The inode number of the file on the filesystem, will be passed as the only argument.

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--invert-match
--------------

Flag. If specified, will negate the result of any match if it has a logical meaning:

<table class="pod-table">
<thead><tr>
<th>given value</th> <th>result</th>
</tr></thead>
<tbody>
<tr> <td>True</td> <td>False</td> </tr> <tr> <td>False</td> <td>True</td> </tr> <tr> <td>Nil</td> <td>True</td> </tr> <tr> <td>Empty</td> <td>True</td> </tr> <tr> <td>none of the above</td> <td>just that</td> </tr>
</tbody>
</table>

--is-empty
----------

Flag. If specified, will only select files that do not contain any data. Use negation `--/is-empty` to only select files that **do** contain data. Special case of `--filesize`.

--is-executable
---------------

Flag. If specified, will only select files that can be executed by the current user. Use negation `--/is-executable` to only select files that are **not** executable by the current user.

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--is-group-executable
---------------------

Flag. If specified, will only select files that can be executed by members of the group of the owner. Use negation `--/is-group-executable` to only select files that are **not** executable by the members of the group of the owner.

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--is-group-readable
-------------------

Flag. If specified, will only select files that can be read by members of the group of the owner. Use negation `--/is-group-readable` to only select files that are **not** readable by the members of the group of the owner.

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--is-group-writable
-------------------

Flag. If specified, will only select files that can be written to by members of the group of the owner. Use negation `--/is-group-writable` to only select files that are **not** writable by the members of the group of the owner.

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--is-moarvm
-----------

Flag. If specified, will only select files that appear to be MoarVM bytecode files. Defaults to `False`.

--is-owned-by-group
-------------------

Flag. If specified, will only select files that are owned by the group of the current user. Use negation `--/is-owned-by-group` to only select files that are **not** owned by the group of the current user.

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--is-owned-by-user
------------------

Flag. If specified, will only select files that are owned by current user. Use negation `--/is-owned-by-user` to only select files that are **not** owned by the current user.

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--is-owner-executable
---------------------

Flag. If specified, will only select files that can be executed by the owner. Use negation `--/is-owner-executable` to only select files that are **not** executable by the owner.

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--is-owner-readable
-------------------

Flag. If specified, will only select files that can be read by the owner. Use negation `--/is-owner-readable` to only select files that are **not** readable by the owner.

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--is-owner-writable
-------------------

Flag. If specified, will only select files that can be written to by the owner. Use negation `--/is-owner-writable` to only select files that are **not** writable by the owner.

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--is-pdf
--------

Flag. If specified, will only select files that appear to be PDF files. Defaults to `False`.

--is-readable
-------------

Flag. If specified, will only select files that can be read by the current user. Use negation `--/is-readable` to only select files that are **not** readable by the current user.

--is-sticky
-----------

Flag. If specified, will only select files that do have the STICKY bit set in their attributes. Use negation `--/is-sticky` to only select files that do **not** have the STICKY bit set.

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--is-symbolic-link
------------------

Flag. If specified, will only select files that are symbolic links. Use negation `--/is-symbolic-link` to only select files that are **not** symbolic links.

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--is-text
---------

Flag. If specified, will only select files that appear to contain text (rather than binary data). Defaults to `True` if no other file filter has been specified, and `--find` is not specified either. Use negation `--/is-text` to only select files with binary data.

Note: support for searching for binary data is not yet implemented, so `--/is-text` can only be used in conjunction with --find.

--is-world-executable
---------------------

Flag. If specified, will only select files that can be executed by anybody. Use negation `--/is-group-executable` to only select files that are **not** executable by anybody.

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--is-world-readable
-------------------

Flag. If specified, will only select files that can be read by anybody. Use negation `--/is-world-readable` to only select files that are **not** readable by anybody.

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--is-world-writable
-------------------

Flag. If specified, will only select files that can be written to by anybody. Use negation `--/is-world-writable` to only select files that can **not** be written to by anybody.

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--is-writable
-------------

Flag. If specified, will only select files that can be written to by the current user. Use negation `--/is-writable` to only select files that can **not** be written to by the current user.

--json-per-elem
---------------

Flag. Only makes sense if the pattern is a `Callable`. If specified, indicates that each selected file will be interpreted as JSON, and if valid, will then produce all elements of the outermost data structure to the pattern for introspection. If the data structure is a hash, then key/value `Pair`s will be produced.

If the Callable returns `True`, the stringification of the element will be produced. If the returned value is a string, that string will be produced. For example when searching the list of modules in the zef ecosystem (which consists of an array of hashes):

```bash
# Show all defined "auth" values of top elemens in JSON file
$ rak '{ .<auth> // False }' META.json --json-per-elem
```

--json-per-file
---------------

Flag. Only makes sense if the pattern is a `Callable`. If specified, indicates that each selected file will be interpreted as JSON, and if valid, will then be given to the pattern for introspection. If the Callable returns `True`, the filename will be produced. If anything else is returned, then the stringification of that object will be produced. For example:

```bash
# show the "auth" value from all JSON files
$ rak '*<auth> // False' --json-per-file
```

--json-per-line
---------------

Flag. Only makes sense if the pattern is a `Callable`. If specified, indicates that each line from the selected files will be interpreted as JSON, and if valid, will then be given to the pattern for introspection. If the Callable returns `True`, the filename and line number will be produced. If the returned value is anything else, then the stringification of that object will be be produced. For example:

```bash
# show the "auth" value from the JSON blob on each line
$ rak '{ $_ with .<auth> }' --json-per-line
```

--keep-meta
-----------

Flag. Only applicable if `--csv-per-line` has been specified. If specified, indicates that meta-information will be kept for each field, by presenting each field as a `CSV::Field|https://github.com/Tux/CSV/blob/master/doc/Text-CSV.md#csvfield` object rather than as a string. The most important methods that can be called on a `CSV::Field` object are:

<table class="pod-table">
<thead><tr>
<th>method</th> <th>meaning</th>
</tr></thead>
<tbody>
<tr> <td>is-quoted</td> <td>field was quoted</td> </tr> <tr> <td>is-binary</td> <td>field contains undecodable data</td> </tr> <tr> <td>is-utf8</td> <td>field contains decodable data beyond ASCII</td> </tr> <tr> <td>is-formula</td> <td>field looks like it contains a spreadsheet formula</td> </tr>
</tbody>
</table>

--list-custom-options
---------------------

Flag. If specified as the only option, will list all additional options previously saved with `--save`.

```bash
# show all of the custom options
$ rak --list-custom-options
fs: --'follow-symlinks'
im: --ignorecase --ignoremark
```

--list-expanded-options
-----------------------

Flag. If specified, will show all actual options being activated after having been recursively expanded, and then exit. Intended as a debugging aid if you have many custom options defined.

```bash
# show how custom option "--im" expands
$ rak --im --list-expanded-options
--ignorecase --ignoremark
```

--list-known-extensions
-----------------------

Flag. If specified, will show all known extension groups and the extensions they represent. Intended as an informational aid.

```bash
# show the filename extensions that "rak" knows about
$ rak --list-known-extensions
       #c: c h hdl
     #c++: cpp cxx hpp hxx
  #config: ini
     #cro: (none) crotmp
     #csv: (none) csv psv tsv
    #html: htm html css
      #js: js ts tsx
    #json: json
   #jsonl: jsonl
#markdown: md markdown
    #perl: (none) pl pm t
  #python: py ipynb
       #r: (none) r R Rmd
    #raku: (none) raku rakumod rakutest rakudoc nqp t pm6 pl6 pod6 t6
    #ruby: rb
    #text: (none) txt
      #wl: (none) wl m wlt mt nb
    #yaml: yaml yml
```

--matches-only
--------------

Flag. Indicate whether only the matched pattern should be produced, rather than the line in which the pattern was found. Defaults to `False`. Frequently used in conjunction with `--per-file`. Will show separated by space if multiple matches are found on the same line.

--max-matches-per-file[=N]
--------------------------

Indicate the maximum number of matches that should be produced per file. If specified as a flag, will assume **1** for its value. By default, will produce **all** possible matches in a file.

--mbc
-----

Flag. Indicates that a [`MoarVM::Bytecode`](https://raku.land/zef:lizmat/MoarVM::Bytecode) object should be produced for each MoarVM bytecode file, to be presented to the matcher. Only makes sense if the pattern is a `Callable`. Will also set the `is-moarvm` flag to only select MoarVM bytecode files, unless reading from STDIN.

Requires the [`MoarVM::Bytecode`](https://raku.land/zef:lizmat/MoarVM::Bytecode) Raku module to be installed.

--mbc-frames
------------

Flag. Indicates that the frames in a MoarVM bytecode file should be produced as a [`MoarVM::Bytecode::Frame`](https://raku.land/zef:lizmat/MoarVM::Bytecode#frame) to the matcher. Only makes sense if the pattern is a `Callable`. Will also set the `is-moarvm` flag to only select MoarVM bytecode files, unless reading from STDIN.

Requires the [`MoarVM::Bytecode`](https://raku.land/zef:lizmat/MoarVM::Bytecode) Raku module to be installed.

--mbc-strings
-------------

Flag. Indicates that the strings in the string hap in a MoarVM bytecode file should be produced to the matcher. Will also set the `is-moarvm` flag to only select MoarVM bytecode files, unless reading from STDIN.

Requires the [`MoarVM::Bytecode`](https://raku.land/zef:lizmat/MoarVM::Bytecode) Raku module to be installed.

---meta-modified=condition
--------------------------

If specified, indicates the `Callable` that should return True to include a file in the selection of files to be checked. The modification time of meta information of the file (number of seconds since epoch, as a `Num` value) will be passed as the only argument.

See "CHECKING TIMES ON FILES" for more information about features that can be used inside the `Callable`.

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--mode=condition
----------------

If specified, indicates the `Callable` that should return True to include a file in the selection of files to be checked. The full numeric mode value of the file on the filesystem, will be passed as the only argument.

```bash
# list files with sticky bit set
$ rak --find --mode='{ $_ +& 0o1000 }'
```

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--modifications
---------------

Indicate whether modifications with `--modify-files` and `--rename-files` are allowed. Defaults to `True`, hence it will probably only be actually used in the negation case: `--no-modifications` or `--/modifications`. Intended to be used in cases where there is no complete control over the arguments being specified, e.g. when being used through a web or chat-bot interface.

--modified=condition
--------------------

If specified, indicates the `Callable` that should return True to include a file in the selection of files to be checked. The modification time of the file (number of seconds since epoch, as a `Num` value) will be passed as the only argument.

See "CHECKING TIMES ON FILES" for more information about features that can be used inside the `Callable`.

--modify-files
--------------

Flag. Only makes sense if the specified pattern is a `Callable`. Indicates whether the output of the pattern should be applied to the file in which it was found. Defaults to `False`.

The `Callable` will be called for each file (in sorted order) and each line of the file, giving the line. By default, the line will be presented to the code **without** its line ending. You need to specify `--with-line-endings` if you want to have the line ending also.

The `$*N` dynamic variable is available inside the `Callable` and is initialized to 0 (in case modifications require keeping numeric state between calls). It is then up to the `Callable` to return:

### False

Remove this line from the file. NOTE: this means the exact `False` value.

### True

Keep this line unchanged the file. NOTE: this means the exact `True` value.

### Nil

Keep this line unchanged the file. NOTE: this means the exact `Nil` value.

### Empty

Keep this line unchanged the file. NOTE: this means the exact `Empty` value. This is typically returned as the result of a failed condition. For example, only change the string "foo" into "bar" if the line starts with "#":

```bash
# replace "foo" by "bar" in all files
$ rak '*.subst("foo","bar")' --modify-files

# replace "foo" by "bar" in all comment lines
$ rak '{ .subst("foo","bar") if .starts-with("#") }' --modify-files
```

### any other value

Inserts this value in the file instead of the given line. The value can either be a string, or a list of strings (which would add lines to the file).

--module=Foo
------------

Indicate the Raku module that should be loaded. Only makes sense if the pattern is a `Callable`.

--not=foo
---------

Specify **primary** pattern that should **not** match to produce a hit.

--or=foo
--------

Specify **additional** pattern that should match to produce a hit.

--ornot=foo
-----------

Specify **additional** pattern that should **not** match to produce a hit.

--output-dir=directory
----------------------

Specify the name of the directory to store the results in. For each group, a separate file will be created. Usually used in conjunction with `--classify` or `--categorize`, but can also be used for normal search results. In that case, the basename of a file with results, will be taken as the name of the file to create in that output directory. The directory must **not** exist beforehand.

--output-file=filename
----------------------

Indicate the path of the file in which the result of the search should be placed. Defaults to `STDOUT`.

--pager=name
------------

Indicate the name (and arguments) of a pager program to be used to page through the generated output. Defaults to the `RAK_PAGER` environment variable. If that isn't specified either, then no pager program will be run.

```bash
# use the "more" pager to page the output
$ RAK_PAGER='more -r' rak foo

# use the "less" pager to page the output
$ rak foo --pager='less -r'
```

--paragraph-context
-------------------

Flag. Indicate all lines that are part of the same paragraph **around** any line that matches. Defaults to `False`. Paragraph boundaries are:

  * the start of the file

  * an empty line

  * the end of the file

--passthru
----------

Flag. Indicate whether **all** lines from source should be shown always. Highlighting will still be performed, if so (implicitely) specified.

```bash
# watch a log file, and highlight a IP address 123.45.67.89
$ tail -f ~/access.log | rak --passthru 123.45.67.89
```

--passthru-context
------------------

Flag. Indicate whether **all** lines from source should be produced if at least one line matches. Highlighting will still be performed, if so (implicitely) specified.

--paths=path1,path2
-------------------

Indicates the path specification to be used instead of from any positional arguments. Multiple path specifications should be separated by comma's.

--paths-from=filename
---------------------

Indicate the path of the file to read path specifications from instead of from any positional arguments. "-" can be specified to read path specifications from STDIN.

--pattern=foo
-------------

Alternative way to specify the pattern to search for. If (implicitly) specified, will assume the first positional parameter specified is actually a path specification, rather than a pattern. This allows the pattern to be saved with `--save`, and thus freeze a specific pattern as part of a custom option.

--patterns-from=file
--------------------

Alternative way to specify one or more patterns to search for. Reads the indicated file and interprets each line as a pattern according to the rules (implicitly) set with the `--type` argument. If the file specification is `"-"`, then the patterns will be read from STDIN.

--pdf-info
----------

Flag. Indicates that the meta-info of any PDF file should be produced as single hash to the matcher. Only makes sense if the pattern is a `Callable`. Will also set the `is-pdf` flag to only select PDF files, unless reading from STDIN.

Requires the [`PDF::Extract`](https://raku.land/zef:librasteve/PDF::Extract) Raku module to be installed.

--pdf-per-file
--------------

Flag. Indicates that any PDF file text contents should be produced as single text to the matcher. Will also set the `is-pdf` flag to only select PDF files, unless reading from STDIN.

Requires the [`PDF::Extract`](https://raku.land/zef:librasteve/PDF::Extract) Raku module to be installed.

--pdf-per-line
--------------

Flag. Indicates that any PDF file text contents should be produced as lines to the matcher. Will also set the `is-pdf` flag to only select PDF files, unless reading from STDIN.

Requires the [`PDF::Extract`](https://raku.land/zef:librasteve/PDF::Extract) Raku module to be installed.

--per-file[=code]
-----------------

Indicate whether matching should be done per file, rather than per line. If specified as a flag, will slurp a file with the indicated `--encoding` and present that to the matcher. Optionally takes a `Callable` specification: this will be given an `IO::Path` object of the file: whatever it produces will be presented to the matcher. Usually used in conjunction with `--matches-only` and/or `count-only`.

```bash
# look for foo in only the first 10 lines of each file
$ rak foo --per-file='*.lines(:!chomp).head(10).join'
```

--per-line[=code]
-----------------

Indicate whether matching should be done per line. If specified as a flag, will read lines with the indicated `--encoding` and present each line to the matcher (which is actually the default if no action was specified).i

Optionally takes a `Callable` specification: this will be given an `IO::Path` object of the file: that is then expected to produce lines that will be presented to the matcher.

```bash
# look for foo in only the last 10 lines of each file
$ rak foo --per-line='*.lines.tail(10)'
```

--per-paragraph
---------------

Indicate whether matching should be done per paragraph. It will read lines with the indicated `--encoding`, combine them into paragraphs and present each paragraph to the matcher, with the line number of the start of the paragraphs associated with it.

--progress
----------

Flag. If specified, will produce a progress indicator on STDERR that indicates the number of files checked, number of lines checked and number of matches, updated 5 times per second. Defaults to `False`.

--proximate=[N]
---------------

Indicates whether matched lines should be grouped together that are within N lines of each other. This is useful for visually picking out matches that appear close to other matches. If specified as a flag, indicates a proximation of **1**. Defaults to <0> otherwise (indicating no proximation check should be performed).

--quietly
---------

Flag. Only makes sense if the pattern is a `Callable`. If specified, will catch all **warnings** that are emitted when executing the pattern's `Callable`. Defaults to `False`.

--quote=["]
-----------

Only applicable if `--csv-per-line` has been specified. Indicates the character that should be used for quoting fields. Defaults to **double quote**.

--rak
-----

Flag. Intended for debugging purposes only. When specified, will show the named arguments sent to the `rak` plumbing subroutine just before it isi being called.

--rakudo-all
------------

Indicate that **all** the files recognized by the Rakudo cache (as generated by [`Rakudo::Cache`](https://raku.land/zef:lizmat/Rakudo::Cache)) should be searched.

--rakudo-c
----------

Indicate that the files recognized as `C` programming language files by the Rakudo cache (as generated by [`Rakudo::Cache`](https://raku.land/zef:lizmat/Rakudo::Cache)) should be searched.

--rakudo-doc
------------

Indicate that the files recognized as documentation files by the Rakudo cache (as generated by [`Rakudo::Cache`](https://raku.land/zef:lizmat/Rakudo::Cache)) should be searched.

--rakudo-java
-------------

Indicate that the files recognized as `Java` programming language files by the Rakudo cache (as generated by [`Rakudo::Cache`](https://raku.land/zef:lizmat/Rakudo::Cache)) should be searched.

--rakudo-js
-----------

Indicate that the files recognized as `Javascript` programming language files by the Rakudo cache (as generated by [`Rakudo::Cache`](https://raku.land/zef:lizmat/Rakudo::Cache)) should be searched.

--rakudo-nqp
------------

Indicate that the files recognized as `NQP` related files by the Rakudo cache (as generated by [`Rakudo::Cache`](https://raku.land/zef:lizmat/Rakudo::Cache)) should be searched.

--rakudo-perl
-------------

Indicate that the files recognized as `Perl` programming language files by the Rakudo cache (as generated by [`Rakudo::Cache`](https://raku.land/zef:lizmat/Rakudo::Cache)) should be searched.

--rakudo-raku
-------------

Indicate that the files recognized as `Raku` Programming Language files by the Rakudo cache (as generated by [`Rakudo::Cache`](https://raku.land/zef:lizmat/Rakudo::Cache)) should be searched.

--rakudo-shell
--------------

Indicate that the files recognized as shell scripts / batch files by the Rakudo cache (as generated by [`Rakudo::Cache`](https://raku.land/zef:lizmat/Rakudo::Cache)) should be searched.

--rakudo-test
-------------

Indicate that the files recognized as test related files by the Rakudo cache (as generated by [`Rakudo::Cache`](https://raku.land/zef:lizmat/Rakudo::Cache)) should be searched.

--rakudo-yaml
-------------

Indicate that the files recognized as files containing YAML of some sort by the Rakudo cache (as generated by [`Rakudo::Cache`](https://raku.land/zef:lizmat/Rakudo::Cache)) should be searched.

--recurse-unmatched-dir
-----------------------

Flag. Indicate whether directories that didn't match the `--dir` specification, should be recursed into anyway. Will not produce files from such directories, but may recurse further if directories are encountered. Defaults to `False`.

--recurse-symlinked-dir
-----------------------

Flag. Indicate whether directories that are actually symbolic links, should be recursed into. Defaults to `False`.

NOTE: support of this feature depends on Raku supporting that feature on the current operating system.

--rename-files
--------------

Flag. Only makes sense if the specified pattern is a `Callable`. Feeds all selected files, sorted by absolute path, as `IO::Path` objects to the pattern, and uses the result (if different from the original) as the new name of the file.

The `--dryrun` argument can be used to run through the whole process **except** doing actually any renaming.

The `--verbose` argument can be used to get more verbose feedback on the operation.

The `Callable` will be called for each line, giving the file as an `IO::Path` object. The `$*N` dynamic variable is available inside the `Callable` and is initialized to 0. It is then up to the `Callable` to return:

### False

Don't change the name of the file NOTE: this means the exact `False` value.

### True

Don't change the name of the file. NOTE: this means the exact `True` value.

### Nil

Don't change the name of the file. NOTE: this means the exact `Nil` value.

### Empty

Don't change the name of the file. NOTE: this means the exact `Empty` value. This is typically returned as the result of a failed condition.

### any other value

Use this