txt: ## dist_zef-lizmat-App-Rak.md
  ## Chunk 2 of 3
  --group`.
  
  ```
  # 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.
  
  ```
  # 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=''
  
  Specifies a list of column names to associate with columns, in order. Assumes no header line is available.
  
  * --headers=':a, :b'
  
  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.
  
  ```
  # 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:
  
  | given value | result |
  | --- | --- |
  | True | False |
  | False | True |
  | Nil | True |
  | Empty | True |
  | none of the above | just that |
  
  ## --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):
  
  ```
  # 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:
  
  ```
  # 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:
  
  ```
  # 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:
  
  | method | meaning |
  | --- | --- |
  | is-quoted | field was quoted |
  | is-binary | field contains undecodable data |
  | is-utf8 | field contains decodable data beyond ASCII |
  | is-formula | field looks like it contains a spreadsheet formula |
  
  ## --list-custom-options
  
  Flag. If specified as the only option, will list all additional options previously saved with `--save`.
  
  ```
  # 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.
  
  ```
  # 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.
  
  ```
  # 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` 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.
  
  ```
  # 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 "#":
  
  ```
  # 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.
  
  ```
  # 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.
  
  ```
  # 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`.
  
  ```
  # 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.
  
  ```
  # 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 value as the new name of the file. It can either be a string or an `IO::Path` object. Only when the returned value is different from the given value, will a rename actually be attempted. To make this easier on the user, any `Str` returned, will be automatically converted to an `IO::Path` object before being compared using `eqv`.
  
  ```
  # change the extension of all .t files to .rakutest
  $ rak '*.subst(/ \.t $/,".rakutest")' --rename-files
  
  # Rename files with 3 digits word bounded with an interval of 10
  $ rak '*.subst(/ << \d ** 3 >> /, { ($*N += 10).fmt("%03d") })' --rename-files
  
  ```
  
  Note that files that are under git revision control will be renamed using `git mv`: if that fails for any reason, a normal rename will be performed.
  
  ## --repository=dir
  
  Indicate the directory that should be searched for Raku module loading. Only makes sense if the pattern is executable code.
  
  ## --save=shortcut-name
  
  Save all options with the given name in the configuration file (`~/.rak-config.json`), and exit with a message that these options have been saved with the given name.
  
  This feature can used to both create shortcuts for specific (long) options, or just as a convenient way to combine often used options, or both.
  
  ```
  # save options as "--im"
  $ rak --ignorecase --ignoremark --save=im
  Saved option '--im' as: --ignorecase --ignoremark
  
  # can use shortcut to --ignorecase --ignoremark
  $ rak foo --im
  
  # save options as "--rsd"
  $ rak --recurse-symlinked-dir --save=rsd
  Saved option '--rsd' as: --recurse-symlinked-dir
  
  # save as "--B" with a default of '---'
  $ rak --break='[---]' --save=B
  Saved option '--B' as: --break='[---]'
  
  # save as "--P" requiring a value
  $ rak --pattern=! --save=P
  Saved option '--P' as: --pattern='!'
  
  # remove shortcut "--foo"
  $ rak --save=foo
  Removed configuration for 'foo'
  
  ```
  
  Any options can be accessed as if it is a standard option. Please note that no validity checking on the options is being performed at the moment of saving, as validity may depend on other options having been specified.
  
  One option can be marked as requiring a value to be specified (with "!") or have a default value (with "[default-value]").
  
  To remove a saved set of options, use `--save`=foo as the only option to remove the "foo" set of options.
  
  ## --sep=,
  
  Only applicable if `--csv-per-line` has been specified. Indicates the character to indicate the field separator. Defaults to the **comma**.
  
  ## --show-blame
  
  Flag. Indicate whether to show `git blame` information for matching lines if possible, instead of just the line. Defaults to `False`.
  
  Requires that the [`Git::Blame::File`](https://raku.land/zef:lizmat/Git::Blame::File) module is installed.
  
  ## --show-item-number
  
  Flag. Indicate whether item numbers should be shown. Defaults to `True`.
  
  ## --show-filename
  
  Flag. Indicate whether filenames should be shown