wreck.api

Liking cljdoc? Tell your friends :D

All platforms.

The public API of wreck.

Notes:

Apart from passing through nil, this library does minimal argument checking, since the rules for regexes vary from platform to platform, and it is a first class requirement that callers be allowed to construct platform specific regexes if they wish.
As a result, all functions have the potential to throw platform-specific exceptions if the resulting regex is syntactically invalid.
- On the JVM, these will typically be instances of the java.util.regex.PatternSyntaxException class.
- On JavaScript, these will typically be a js/SyntaxError.
Platform specific behaviour is particularly notable for short / empty regexes, such as #"{}" (an error on the JVM, fine but nonsensical on JS) and #"{1}" (ironically, fine but nonsensical on the JVM, but an error on JS). 🤡
Furthemore, JavaScript fundamentally doesn't support lossless round-tripping of RegExp objects to Strings and back, something this library relies upon and does extensively. The library makes a best effort to correct JavaScript's problematic implementation, but because it's fundamentally lossy there are some cases that (on ClojureScript only) may change your regexes in unexpected (though probably not semantically significant) ways.
Regex flags are supported to the best ability of the library, but please carefully review the usage notes in README.md for various caveats when flags are used.

The public API of [`wreck`](https://github.com/pmonks/wreck).

Notes:

* Apart from passing through `nil`, this library does minimal argument
  checking, since the rules for regexes vary from platform to platform, and it
  is a first class requirement that callers be allowed to construct platform
  specific regexes if they wish.
* As a result, all functions have the potential to throw platform-specific
  exceptions if the resulting regex is syntactically invalid.
  * On the JVM, these will typically be instances of the
    `java.util.regex.PatternSyntaxException` class.
  * On JavaScript, these will typically be a `js/SyntaxError`.
* Platform specific behaviour is particularly notable for short / empty
  regexes, such as `#"{}"` (an error on the JVM, fine but
  nonsensical on JS) and `#"{1}"` (ironically, fine but nonsensical on the
  JVM, but an error on JS).  🤡
* Furthemore, JavaScript fundamentally doesn't support lossless round-tripping
  of `RegExp` objects to `String`s and back, something this library relies
  upon and does extensively.  The library makes a best effort to correct
  JavaScript's problematic implementation, but because it's fundamentally
  lossy there are some cases that (on ClojureScript only) may change your
  regexes in unexpected (though _probably_ not semantically significant) ways.
* Regex flags are supported to the best ability of the library, but please
  carefully review the [usage notes in README.md](https://github.com/pmonks/wreck?tab=readme-ov-file#regex-flags)
  for various caveats when flags are used.

raw docstring

='^clj/s

(=' _)

(=' re1 re2)

(=' re1 re2 & more)

Equality for regexes, defined by having equal string representations and flags (including flags that cannot be embedded).

Notes:

Functionally equivalent regexes (e.g. #"..." and #".{3}" are not considered ='.
Some regexes may not be =' initially due to differing flag sets, but after being run through embed-flags may become =', due to non-embeddable flags being silently dropped (see embed-flags for details).

Equality for regexes, defined by having equal string representations and
flags (including flags that cannot be embedded).

Notes:

* Functionally equivalent regexes (e.g. `#"..."` and `#".{3}"` are _not_
  considered `='`.
* Some regexes may not be `='` initially due to differing flag sets, but after
  being run through [[embed-flags]] may become `='`, due to non-embeddable
  flags being silently dropped (see [[embed-flags]] for details).

source raw docstring

alt^clj/s

(alt & res)

Returns a regex that will match any one of res, via alternation.

Notes:

Duplicate elements in res will only appear once in the result.
Does not wrap the result in a group, which, because alternation has the lowest precedence in regexes, runs the risk of behaving unexpectedly if the result is then combined with further regexes. tl;dr - one of the grouping variants should almost always be preferred.

Returns a regex that will match any one of `res`, via alternation.

Notes:

* Duplicate elements in `res` will only appear once in the result.
* Does _not_ wrap the result in a group, which, [because alternation has the
  lowest precedence in regexes](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html#tag_09_04_08),
  runs the risk of behaving unexpectedly if the result is then combined with
  further regexes.
  tl;dr - one of the grouping variants should _almost always_ be preferred.

source raw docstring

alt-cg^clj/s

(alt-cg & res)

alt then cg.

[[alt]] then [[cg]].

source raw docstring

alt-grp^clj/s

(alt-grp & res)

alt then grp.

[[alt]] then [[grp]].

source raw docstring

alt-ncg^clj/s

(alt-ncg nm & res)

alt then ncg.

[[alt]] then [[ncg]].

source raw docstring

and'^clj/s

(and' a b)

(and' a b s)

Returns an 'and' regex that will match a and b in any order, and with the separator regex (if provided) between them. This is implemented as ASB|BSA, which means that A and B must be distinct (must not match the same text).

Notes:

May optimise the expression (via de-duplication in alt).
Does not wrap the result in a group, which, because alternation has the lowest precedence in regexes, runs the risk of behaving unexpectedly if the result is then combined with further regexes. tl;dr - one of the grouping variants should almost always be preferred.

Returns an 'and' regex that will match `a` and `b` in any order, and with the
`s`eparator regex (if provided) between them.  This is implemented as
`ASB|BSA`, which means that A and B must be distinct (must not match the same
text).

Notes:

* May optimise the expression (via de-duplication in [[alt]]).
* Does _not_ wrap the result in a group, which, [because alternation has the
  lowest precedence in regexes](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html#tag_09_04_08),
  runs the risk of behaving unexpectedly if the result is then combined with
  further regexes.
  tl;dr - one of the grouping variants should _almost always_ be preferred.

source raw docstring

and-cg^clj/s

(and-cg a b)

(and-cg a b s)

and' then cg.

Notes:

Unlike most other -cg fns, this one does not accept any number of res.
May optimise the expression (via de-duplication in alt).

[[and']] then [[cg]].

Notes:

* Unlike most other `-cg` fns, this one does _not_ accept any number of res.
* May optimise the expression (via de-duplication in [[alt]]).

source raw docstring

and-grp^clj/s

(and-grp a b)

(and-grp a b s)

and' then grp.

Notes:

Unlike most other -grp fns, this one does not accept any number of res.
May optimise the expression (via de-duplication in alt).

[[and']] then [[grp]].

Notes:

* Unlike most other `-grp` fns, this one does _not_ accept any number of res.
* May optimise the expression (via de-duplication in [[alt]]).

source raw docstring

and-ncg^clj/s

(and-ncg nm a b)

(and-ncg nm a b s)

and' then ncg.

Notes:

Unlike most other -ncg fns, this one does not accept any number of res.
May optimise the expression (via de-duplication in alt).

[[and']] then [[ncg]].

Notes:

* Unlike most other `-ncg` fns, this one does _not_ accept any number of res.
* May optimise the expression (via de-duplication in [[alt]]).

source raw docstring

cg^clj/s

(cg & res)

As for grp, but uses a capturing group.

As for [[grp]], but uses a capturing group.

source raw docstring

embed-flags^clj/s

(embed-flags re)

Embeds any flags found in re at the start of re in a non-capturing group (to ensure scoping), returning a new regex. Returns re if re contains no flags or is nil.

For example, on the JVM #"(?i)[abc]+" would become #"(?i:[abc]+)".

Similarly, on ClojureScript (doto (js/RegExp.) (.compile "[abc]+" "i")) would also become #"(?i:[abc]+)".

Note:

flags-grp is almost always a better choice than this function! embed-flags is primarily intended for internal use by wreck, but may be useful in those rare cases where Clojure(Script) code receives a 3rd party regex, wishes to use it as part of composing a larger regex, doesn't know if it contains flags or not, and doesn't care that non-embeddable flags will be silently dropped.
⚠️ On the JVM, ungrouped embedded flags in the middle of re will be moved to the beginning of the regex. This may alter the semantics of the regex - for example a(?i)b will become (?i:ab), which means that a will be matched case-insensitively by the result, which is not the same as the original (which matches lower-case a only). This is an unavoidable consequence of how the JVM regex engine reports flags. If you really need to use embedded flag(s) midway through a regex, use flags-grp to ensure proper scoping of the flag(s).
⚠️ On the JVM, the programmatic flags LITERAL and CANON_EQ have no embeddable equivalent, and will be silently dropped by this function. Use has-non-embeddable-flags? if you need to check for the presence of these flags (e.g. in a 3rd party regex).
⚠️ On JavaScript, only the flags ims can be embedded. All other flags will be silently dropped by this function. Use has-non-embeddable-flags? if you need to check for the presence of these flags (e.g. in a 3rd party regex).

Embeds any flags found in `re` at the start of `re` in a non-capturing group
(to ensure scoping), returning a new regex.  Returns `re` if `re` contains no
flags or is `nil`.

For example, on the JVM `#"(?i)[abc]+"` would become `#"(?i:[abc]+)"`.

Similarly, on ClojureScript `(doto (js/RegExp.) (.compile "[abc]+" "i"))`
would also become `#"(?i:[abc]+)"`.

Note:

* **[[flags-grp]] is almost always a better choice than this function!**
  `embed-flags` is primarily intended for internal use by `wreck`, but may be
  useful in those rare cases where Clojure(Script) code receives a 3rd party
  regex, wishes to use it as part of composing a larger regex, doesn't
  know if it contains flags or not, and doesn't care that non-embeddable flags
  will be silently dropped.
* ⚠️ On the JVM, ungrouped embedded flags in the middle of `re` will be moved
  to the beginning of the regex.  This may alter the semantics of the regex -
  for example `a(?i)b` will become `(?i:ab)`, which means that `a` will be
  matched case-insensitively by the result, which is _not_ the same as the
  original (which matches lower-case `a` only).  This is an unavoidable
  consequence of how the JVM regex engine reports flags.  If you really need
  to use embedded flag(s) midway through a regex, use [[flags-grp]] to ensure
  proper scoping of the flag(s).
* ⚠️ On the JVM, the programmatic flags `LITERAL` and `CANON_EQ` have no
  embeddable equivalent, and will be silently dropped by this function.  Use
  [[has-non-embeddable-flags?]] if you need to check for the presence of
  these flags (e.g. in a 3rd party regex).
* ⚠️ On JavaScript, only the flags `ims` can be embedded.  All other flags
  will be silently dropped by this function.  Use
  [[has-non-embeddable-flags?]] if you need to check for the presence of these
  flags (e.g. in a 3rd party regex).

source raw docstring

empty?'^clj/s

(empty?' re)

Is re nil or (=' #"")?

Notes:

Takes flags (if any) into account.

Is `re` `nil` or `(=' #"")`?

Notes:

* Takes flags (if any) into account.

source raw docstring

esc^clj/s

(esc s)

Escapes s (a String) for use in a regex, returning a String.

Notes:

unlike most other fns in this namespace, this one does not support a regex as an input, nor return a regex as an output

Escapes `s` (a `String`) for use in a regex, returning a `String`.

Notes:

* unlike most other fns in this namespace, this one does _not_ support a regex
  as an input, nor return a regex as an output

source raw docstring

exn^clj/s

(exn n re)

Returns a regex where re will match exactly n times.

Returns a regex where `re` will match exactly `n` times.

source raw docstring

exn-cg^clj/s

(exn-cg n & res)

cg then exn.

[[cg]] then [[exn]].

source raw docstring

exn-grp^clj/s

(exn-grp n & res)

grp then exn.

[[grp]] then [[exn]].

source raw docstring

exn-ncg^clj/s

(exn-ncg nm n & res)

ncg then exn.

[[ncg]] then [[exn]].

source raw docstring

flags-grp^clj/s

(flags-grp flgs & res)

As for grp, but prefixes the group with flgs (a String). Returns nil if flgs is nil or empty. Throws if flgs contains an invalid flag character, including those that (ClojureScript only) cannot be embedded.

Notes:

If you must use regex flags, it is STRONGLY RECOMMENDED that you use this function! Programmatically set flags and ungrouped embedded flags (e.g. (?i)) have no explicit scope and so cannot be reliably used to compose larger regexes. wreck makes a best effort to always convert such 'unscoped' flags into their embedded equivalents when composing larger regexes (via embed-flags), but using flag groups explicitly in the first place is easier to reason about and avoids potential footguns.
Removes any ungrouped embedded flags in re (e.g. (?i)ab), but unlike embed-flags does not check that they appear in flgs.
⚠️ On the JVM, ungrouped embedded flags in the middle of re will also be removed, which may alter the semantics of the regex.
⚠️ On JavaScript, only the flags ims can be embedded (this is a limitation of the JavaScript regex engine). Other flags will result in a js/SyntaxError being thrown.
For the JVM, see the 'special constructs' section of the java.util.regex.Pattern JavaDoc for the set of valid flag characters.
For JavaScript, see the RegExp flags reference for the set of valid flag characters.

As for [[grp]], but prefixes the group with `flgs` (a `String`). Returns
`nil` if `flgs` is `nil` or empty.  Throws if `flgs` contains an invalid flag
character, including those that (ClojureScript only) cannot be embedded.

Notes:

* If you must use regex flags, **it is STRONGLY RECOMMENDED that you use this
  function!**  Programmatically set flags and ungrouped embedded flags (e.g.
  `(?i)`) have no explicit scope and so cannot be reliably used to compose
  larger regexes.  `wreck` makes a best effort to always convert such
  'unscoped' flags into their embedded equivalents when composing larger
  regexes (via [[embed-flags]]), but using flag groups explicitly in the
  first place is easier to reason about and avoids potential footguns.
* Removes any ungrouped embedded flags in `re` (e.g. `(?i)ab`), but unlike
  [[embed-flags]] does _not_ check that they appear in `flgs`.
* ⚠️ On the JVM, ungrouped embedded flags _in the middle of `re`_ will also be
  removed, which may alter the semantics of the regex.
* ⚠️ On JavaScript, only the flags `ims` can be embedded (this is a limitation
  of the JavaScript regex engine).  Other flags will result in a
  `js/SyntaxError` being thrown.
* For the JVM, see the ['special constructs' section of the
  `java.util.regex.Pattern` JavaDoc](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/regex/Pattern.html#special)
  for the set of valid flag characters.
* For JavaScript, see the [`RegExp` flags reference](https://www.w3schools.com/js/js_regexp_flags.asp)
  for the set of valid flag characters.

source raw docstring

grp^clj/s

(grp & res)

As for join, but encloses the joined res into a single non-capturing group.

As for [[join]], but encloses the joined `res` into a single non-capturing
group.

source raw docstring

has-non-embeddable-flags?^clj/s

(has-non-embeddable-flags? re)

Does re have non-embeddable flags?

Notes:

On the JVM, the only non-embeddable flags are the programmatic flags LITERAL and CANON_EQ.
On JavaScript, this is every flag except i, m, and s.

Does `re` have non-embeddable flags?

Notes:

* On the JVM, the only non-embeddable flags are the programmatic flags
  `LITERAL` and `CANON_EQ`.
* On JavaScript, this is every flag _except_ `i`, `m`, and `s`.

source raw docstring

join^clj/s

(join & res)

Returns a regex that is all of the res joined together. Each element in res can be a regex, a String or something that can be turned into a String (including numbers, etc.). Returns nil when no res are provided, or they're all nil.

Notes:

⚠️ In ClojureScript be cautious about using numbers in these calls, since JavaScript's number handling is a 🤡show. See the unit tests for examples.

Returns a regex that is all of the `res` joined together. Each element in
`res` can be a regex, a `String` or something that can be turned into a
`String` (including numbers, etc.).  Returns `nil` when no `res` are provided,
or they're all `nil`.

Notes:

* ⚠️ In ClojureScript be cautious about using numbers in these calls, since
  JavaScript's number handling is a 🤡show.  See the unit tests for examples.

source raw docstring

n2m^clj/s

(n2m n m re)

Returns a regex where re will match from n to m times.

Returns a regex where `re` will match from `n` to `m` times.

source raw docstring

n2m-cg^clj/s

(n2m-cg n m & res)

cg then n2m.

[[cg]] then [[n2m]].

source raw docstring

n2m-grp^clj/s

(n2m-grp n m & res)

grp then n2m.

[[grp]] then [[n2m]].

source raw docstring

n2m-ncg^clj/s

(n2m-ncg nm n m & res)

ncg then n2m.

[[ncg]] then [[n2m]].

source raw docstring

ncg^clj/s

(ncg nm & res)

As for grp, but uses a named capturing group named nm. Returns nil if nm is nil or blank. Throws if nm is an invalid name for a named capturing group (alphanumeric only, must start with an alphabetical character, must be unique within the regex).

As for [[grp]], but uses a named capturing group named `nm`.  Returns `nil` if
`nm` is `nil` or blank. Throws if `nm` is an invalid name for a named capturing
group (alphanumeric only, must start with an alphabetical character, must be
unique within the regex).

source raw docstring

nom^clj/s

(nom n re)

Returns a regex where re will match n or more times.

Returns a regex where `re` will match `n` or more times.

source raw docstring

nom-cg^clj/s

(nom-cg n & res)

cg then nom.

[[cg]] then [[nom]].

source raw docstring

nom-grp^clj/s

(nom-grp n & res)

grp then nom.

[[grp]] then [[nom]].

source raw docstring

nom-ncg^clj/s

(nom-ncg nm n & res)

ncg then nom.

[[ncg]] then [[nom]].

source raw docstring

oom^clj/s

(oom re)

Returns a regex where re will match one or more times.

Returns a regex where `re` will match one or more times.

source raw docstring

oom-cg^clj/s

(oom-cg & res)

cg then oom.

[[cg]] then [[oom]].

source raw docstring

oom-grp^clj/s

(oom-grp & res)

grp then oom.

[[grp]] then [[oom]].

source raw docstring

oom-ncg^clj/s

(oom-ncg nm & res)

ncg then oom.

[[ncg]] then [[oom]].

source raw docstring

opt^clj/s

(opt re)

Returns a regex where re is optional.

Returns a regex where `re` is optional.

source raw docstring

opt-cg^clj/s

(opt-cg & res)

cg then opt.

[[cg]] then [[opt]].

source raw docstring

opt-grp^clj/s

(opt-grp & res)

grp then opt.

[[grp]] then [[opt]].

source raw docstring

opt-ncg^clj/s

(opt-ncg nm & res)

ncg then opt.

[[ncg]] then [[opt]].

source raw docstring

or'^clj/s

(or' a b)

(or' a b s)

Returns an 'inclusive or' regex that will match a or b, or both, in any order, and with the separator regex (if provided) between them. This is implemented as ASB|BSA|A|B, which means that A and B must be distinct (must not match the same text).

Notes:

May optimise the expression (via de-duplication in alt).
Does not wrap the result in a group, which, because alternation has the lowest precedence in regexes, runs the risk of behaving unexpectedly if the result is then combined with further regexes. tl;dr - one of the grouping variants should almost always be preferred.

Returns an 'inclusive or' regex that will match `a` or `b`, or both, in any
order, and with the `s`eparator regex (if provided) between them.  This is
implemented as `ASB|BSA|A|B`, which means that A and B must be distinct (must
not match the same text).

Notes:

* May optimise the expression (via de-duplication in [[alt]]).
* Does _not_ wrap the result in a group, which, [because alternation has the
  lowest precedence in regexes](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html#tag_09_04_08),
  runs the risk of behaving unexpectedly if the result is then combined with
  further regexes.
  tl;dr - one of the grouping variants should _almost always_ be preferred.

source raw docstring

or-cg^clj/s

(or-cg a b)

(or-cg a b s)

or' then cg.

Notes:

Unlike most other -cg fns, this one does not accept any number of res.
May optimise the expression (via de-duplication in alt).

[[or']] then [[cg]].

Notes:

* Unlike most other `-cg` fns, this one does _not_ accept any number of res.
* May optimise the expression (via de-duplication in [[alt]]).

source raw docstring

or-grp^clj/s

(or-grp a b)

(or-grp a b s)

or' then grp.

Notes:

Unlike most other -grp fns, this one does not accept any number of res.
May optimise the expression (via de-duplication in alt).

[[or']] then [[grp]].

Notes:

* Unlike most other `-grp` fns, this one does _not_ accept any number of res.
* May optimise the expression (via de-duplication in [[alt]]).

source raw docstring

or-ncg^clj/s

(or-ncg nm a b)

(or-ncg nm a b s)

or' then ncg.

Notes:

Unlike most other -ncg fns, this one does not accept any number of res.
May optimise the expression (via de-duplication in alt).

[[or']] then [[ncg]].

Notes:

* Unlike most other `-ncg` fns, this one does _not_ accept any number of res.
* May optimise the expression (via de-duplication in [[alt]]).

source raw docstring

qot^clj/s

(qot re)

Quotes re (anything that can be accepted by join), returning a regex.

Quotes `re` (anything that can be accepted by [[join]]), returning a regex.

source raw docstring

str'^clj/s

(str' o)

Returns the String representation of o, with special handling for RegExp objects on ClojureScript in an attempt to correct JavaScript's APPALLING default stringification.

Notes:

Embeds flags (as per embed-flags).

Returns the `String` representation of `o`, with special handling for
`RegExp` objects on ClojureScript in an attempt to correct JavaScript's
**APPALLING** default stringification.

Notes:

* Embeds flags (as per [[embed-flags]]).

source raw docstring

xor'^clj/s

(xor' a b)

Returns an 'exclusive or' regex that will match a or b, but not both. This is identical to alt called with 2 arguments, and is provided as a convenience for those who might be building up large logic based regexes and would prefer to use more easily understood logical operator names throughout.

Notes:

May optimise the expression (via de-duplication in alt).
Does not wrap the result in a group, which, because alternation has the lowest precedence in regexes, runs the risk of behaving unexpectedly if the result is then combined with further regexes. tl;dr - one of the grouping variants should almost always be preferred.

Returns an 'exclusive or' regex that will match `a` or `b`, but _not_ both.
This is identical to [[alt]] called with 2 arguments, and is provided as a
convenience for those who might be building up large logic based regexes and
would prefer to use more easily understood logical operator names throughout.

Notes:

* May optimise the expression (via de-duplication in [[alt]]).
* Does _not_ wrap the result in a group, which, [because alternation has the
  lowest precedence in regexes](https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html#tag_09_04_08),
  runs the risk of behaving unexpectedly if the result is then combined with
  further regexes.
  tl;dr - one of the grouping variants should _almost always_ be preferred.

source raw docstring

xor-cg^clj/s

(xor-cg a b)

xor' then cg.

Notes:

Unlike most other -cg fns, this one does not accept any number of res.
May optimise the expression (via de-duplication in alt).

[[xor']] then [[cg]].

Notes:

* Unlike most other `-cg` fns, this one does _not_ accept any number of res.
* May optimise the expression (via de-duplication in [[alt]]).

source raw docstring

xor-grp^clj/s

(xor-grp a b)

xor' then grp.

Notes:

Unlike most other -grp fns, this one does not accept any number of res.
May optimise the expression (via de-duplication in alt).

[[xor']] then [[grp]].

Notes:

* Unlike most other `-grp` fns, this one does _not_ accept any number of res.
* May optimise the expression (via de-duplication in [[alt]]).

source raw docstring

xor-ncg^clj/s

(xor-ncg nm a b)

xor' then ncg.

Notes:

Unlike most other -ncg fns, this one does not accept any number of res.
May optimise the expression (via de-duplication in alt).

[[xor']] then [[ncg]].

Notes:

* Unlike most other `-ncg` fns, this one does _not_ accept any number of res.
* May optimise the expression (via de-duplication in [[alt]]).

source raw docstring

zom^clj/s

(zom re)

Returns a regex where re will match zero or more times.

Returns a regex where `re` will match zero or more times.

source raw docstring

zom-cg^clj/s

(zom-cg & res)

cg then zom.

[[cg]] then [[zom]].

source raw docstring

zom-grp^clj/s

(zom-grp & res)

grp then zom.

[[grp]] then [[zom]].

source raw docstring

zom-ncg^clj/s

(zom-ncg nm & res)

ncg then zom.

[[ncg]] then [[zom]].

source raw docstring

cljdoc builds & hosts documentation for Clojure/Script libraries

Keyboard shortcuts

`Ctrl`+`k`	Jump to recent docs
`←`	Move to previous article
`→`	Move to next article
`Ctrl`+`/`	Jump to the search field

Raise an issue Browse cljdoc source Chat on Slack

× close

wreck.api

='clj/s

altclj/s

alt-cgclj/s

alt-grpclj/s

alt-ncgclj/s

and'clj/s

and-cgclj/s

and-grpclj/s

and-ncgclj/s

cgclj/s

embed-flagsclj/s

empty?'clj/s

escclj/s

exnclj/s

exn-cgclj/s

exn-grpclj/s

exn-ncgclj/s

flags-grpclj/s

grpclj/s

has-non-embeddable-flags?clj/s

joinclj/s

n2mclj/s

n2m-cgclj/s

n2m-grpclj/s

n2m-ncgclj/s

ncgclj/s

nomclj/s

nom-cgclj/s

nom-grpclj/s

nom-ncgclj/s

oomclj/s

oom-cgclj/s

oom-grpclj/s

oom-ncgclj/s

optclj/s

opt-cgclj/s

opt-grpclj/s

opt-ncgclj/s

or'clj/s

or-cgclj/s

or-grpclj/s

or-ncgclj/s

qotclj/s

str'clj/s

xor'clj/s

xor-cgclj/s

xor-grpclj/s

xor-ncgclj/s

zomclj/s

zom-cgclj/s

zom-grpclj/s

zom-ncgclj/s

='^clj/s

alt^clj/s

alt-cg^clj/s

alt-grp^clj/s

alt-ncg^clj/s

and'^clj/s

and-cg^clj/s

and-grp^clj/s

and-ncg^clj/s

cg^clj/s

embed-flags^clj/s

empty?'^clj/s

esc^clj/s

exn^clj/s

exn-cg^clj/s

exn-grp^clj/s

exn-ncg^clj/s

flags-grp^clj/s

grp^clj/s

has-non-embeddable-flags?^clj/s

join^clj/s

n2m^clj/s

n2m-cg^clj/s

n2m-grp^clj/s

n2m-ncg^clj/s

ncg^clj/s

nom^clj/s

nom-cg^clj/s

nom-grp^clj/s

nom-ncg^clj/s

oom^clj/s

oom-cg^clj/s

oom-grp^clj/s

oom-ncg^clj/s

opt^clj/s

opt-cg^clj/s

opt-grp^clj/s

opt-ncg^clj/s

or'^clj/s

or-cg^clj/s

or-grp^clj/s

or-ncg^clj/s

qot^clj/s

str'^clj/s

xor'^clj/s

xor-cg^clj/s

xor-grp^clj/s

xor-ncg^clj/s

zom^clj/s

zom-cg^clj/s

zom-grp^clj/s

zom-ncg^clj/s