Bankster library, currency operations.
Bankster library, currency operations.
Default currency unit to be applied when creating Money objects without the currency specified.
Default currency unit to be applied when creating Money objects without the currency specified.
(add-countries registry currency-id country-ids)Associates the given country or countries with a currency. If the currency does not exist, exception is thrown. If the currency exists but differs in any detail from the existing currency from the registry, exception is thrown. If the currency exists and equals to the given in any aspect, country associations are added. Links from other countries to the currency are not removed unless the country is already linked with some other currency; in this case it will be unlinked first.
Associates the given country or countries with a currency. If the currency does not exist, exception is thrown. If the currency exists but differs in any detail from the existing currency from the registry, exception is thrown. If the currency exists and equals to the given in any aspect, country associations are added. Links from other countries to the currency are not removed unless the country is already linked with some other currency; in this case it will be unlinked first.
(add-countries! currency country-ids)Associates the given country (a keyword) or countries (seqable collection of keywords) with a currency in the global registry. If the currency does not exist, exception is thrown. If the currency exists but differs in any detail from the existing currency from the registry, exception is thrown. If the currency exists and equals to the given in any aspect, country associations are added. Links from other countries to the currency are not removed unless the country is already linked with some other currency; in this case it will be unlinked first.
If the currency is nil, returns current state of a global registry (but not a dynamic registry, even if it is set).
Associates the given country (a keyword) or countries (seqable collection of keywords) with a currency in the global registry. If the currency does not exist, exception is thrown. If the currency exists but differs in any detail from the existing currency from the registry, exception is thrown. If the currency exists and equals to the given in any aspect, country associations are added. Links from other countries to the currency are not removed unless the country is already linked with some other currency; in this case it will be unlinked first. If the currency is nil, returns current state of a global registry (but not a dynamic registry, even if it is set).
(add-localized-properties registry currency-id properties)Adds localized properties of a currency to the given registry. Overwrites existing properties.
Adds localized properties of a currency to the given registry. Overwrites existing properties.
(add-localized-props! currency properties)Associates the given currency with a map of localized properties.
If the currency is nil, returns current state of a global registry (but not a dynamic registry, even if it is set).
Associates the given currency with a map of localized properties. If the currency is nil, returns current state of a global registry (but not a dynamic registry, even if it is set).
(add-traits registry currency-id traits)Adds traits for the given currency in the registry (union).
Passing nil or an empty collection is a no-op.
Throws when the currency cannot be resolved in the registry.
Adds traits for the given currency in the registry (union). Passing `nil` or an empty collection is a no-op. Throws when the currency cannot be resolved in the registry.
(add-traits! currency-id traits)Adds traits for the given currency in the global registry. See add-traits.
Adds traits for the given currency in the global registry. See `add-traits`.
(add-weighted-code registry currency-id)Associates the existing currency code with the currency object in the given registry using the currency weight attribute. The given currency-id may be expressed with any object that can be used to get the currency from a registry (internally the unit function is used). Therefore, passing the currency object having a different weight will not cause the weight to be updated since it will be used for identification only.
Currency must exist in the cur-id->cur database of the registry. This function will add an association to the cur-code->curs database. If both, the weight and code are the same, registry is returned as is.
This is a low-level function used to ensure that a code-to-currency mapping is created within a registry. To simply update currency's weight, use the update or update! function.
Associates the existing currency code with the currency object in the given registry using the currency weight attribute. The given currency-id may be expressed with any object that can be used to get the currency from a registry (internally the unit function is used). Therefore, passing the currency object having a different weight will not cause the weight to be updated since it will be used for identification only. Currency must exist in the cur-id->cur database of the registry. This function will add an association to the cur-code->curs database. If both, the weight and code are the same, registry is returned as is. This is a low-level function used to ensure that a code-to-currency mapping is created within a registry. To simply update currency's weight, use the update or update! function.
(asset? c)(asset? c registry)Returns true if the given currency is a kind of asset.
Returns `true` if the given currency is a kind of asset.
(attempt c)(attempt c registry)Soft currency coercion function.
Returns c when it is already an instance of io.randomseed.bankster.Currency.
If c is a definitive currency representation (see Monetary/definitive?), it is
coerced locally using to-currency. Otherwise it attempts to resolve c in a
registry and returns the registered Currency instance or nil when it cannot be
resolved.
This is intended for "non-throwing" code paths (e.g. property predicates) and
complements unit and of-id which may throw when a currency is missing.
Soft currency coercion function. Returns `c` when it is already an instance of `io.randomseed.bankster.Currency`. If `c` is a definitive currency representation (see `Monetary/definitive?`), it is coerced locally using `to-currency`. Otherwise it attempts to resolve `c` in a registry and returns the registered `Currency` instance or `nil` when it cannot be resolved. This is intended for "non-throwing" code paths (e.g. property predicates) and complements `unit` and `of-id` which may throw when a currency is missing.
(attempt* c)(attempt* c registry)Soft currency coercion macro.
Returns c when it is already an instance of io.randomseed.bankster.Currency.
If c is a definitive currency representation (see Monetary/definitive?), it is
coerced locally using to-currency. Otherwise it attempts to resolve c in a
registry and returns the registered Currency instance or nil when it cannot be
resolved.
Unlike unit and of-id, this helper is meant to be used in "non-throwing" code
paths (e.g. property predicates). Argument c is evaluated exactly once.
When registry is not provided, the default registry is used (preferring
io.randomseed.bankster.registry/*default* when bound).
Soft currency coercion macro. Returns `c` when it is already an instance of `io.randomseed.bankster.Currency`. If `c` is a definitive currency representation (see `Monetary/definitive?`), it is coerced locally using `to-currency`. Otherwise it attempts to resolve `c` in a registry and returns the registered `Currency` instance or `nil` when it cannot be resolved. Unlike `unit` and `of-id`, this helper is meant to be used in "non-throwing" code paths (e.g. property predicates). Argument `c` is evaluated exactly once. When `registry` is not provided, the default registry is used (preferring `io.randomseed.bankster.registry/*default*` when bound).
Expresses the scale of a currency which is automatic and not limited to certain decimal places.
Expresses the scale of a currency which is automatic and not limited to certain decimal places.
(auto-scaled? c)(auto-scaled? c registry)Alias for big?.
Alias for big?.
(big? c)(big? c registry)Returns true if the given currency has an automatic scale (decimal places).
Returns `true` if the given currency has an automatic scale (decimal places).
(claim? c)(claim? c registry)Returns true if the given currency is a kind of claim.
Returns `true` if the given currency is a kind of claim.
(clear-weight registry currency-id)Removes an explicit weight entry for the given currency from the registry (defaults to weight 0) and updates all weight-dependent indexes.
Throws when the currency cannot be resolved in the registry.
Removes an explicit weight entry for the given currency from the registry (defaults to weight 0) and updates all weight-dependent indexes. Throws when the currency cannot be resolved in the registry.
(clear-weight! currency-id)Clears an explicit currency weight entry in the global registry. See clear-weight.
Clears an explicit currency weight entry in the global registry. See `clear-weight`.
(code c)(code c registry)(code c _locale registry)Returns a currency code as a string for the given currency object. If the currency identifier is namespaced only the base code (without a namespace) will be returned. Locale argument is ignored.
Returns a currency code as a string for the given currency object. If the currency identifier is namespaced only the base code (without a namespace) will be returned. Locale argument is ignored.
(code-literal arg)Tagged literal handler for Clojure code. Emits compound forms that are going to be evaluated.
Tagged literal handler for Clojure code. Emits compound forms that are going to be evaluated.
(commodity? c)(commodity? c registry)Returns true if the given currency is a kind of commodity currency.
Returns `true` if the given currency is a kind of commodity currency.
(config->registry)(config->registry resource-path)(config->registry resource-path regi)Loads currencies and countries from an EDN file. First argument should be a string with path to the EDN resource file containing registry data, second should be a registry. Returns a registry initialized using values from the EDN file.
Loads currencies and countries from an EDN file. First argument should be a string with path to the EDN resource file containing registry data, second should be a registry. Returns a registry initialized using values from the EDN file.
(countries c)(countries c registry)(countries c _locale registry)Returns a set of country IDs (keywords) for which the given currency is main currency. If there are no countries associated with a currency, returns nil. Locale argument is ignored.
Throws when a currency cannot be resolved in the registry. This lets consumers
distinguish "no countries" (nil) from "unknown currency" (exception).
Returns a set of country IDs (keywords) for which the given currency is main currency. If there are no countries associated with a currency, returns nil. Locale argument is ignored. Throws when a currency cannot be resolved in the registry. This lets consumers distinguish "no countries" (`nil`) from "unknown currency" (exception).
(credit? c)(credit? c registry)Returns true if the given currency is a kind of credit.
Returns `true` if the given currency is a kind of credit.
(crypto? c)(crypto? c registry)Returns true if the given currency is a cryptocurrency. It is just a helper that
check if the domain of a currency equals to :CRYPTO.
Returns `true` if the given currency is a cryptocurrency. It is just a helper that check if the domain of a currency equals to `:CRYPTO`.
(currency? c)(currency? c _registry)Returns true if the given value is a currency. Registry argument is ignored.
Returns `true` if the given value is a currency. Registry argument is ignored.
(data-literal arg)Tagged literal handler for EDN data files. Emits Currency objects or nil values.
Tagged literal handler for EDN data files. Emits Currency objects or nil values.
(decentralised? c)(decentralised? c registry)Alias for decentralized?
Alias for decentralized?
(decentralized? c)(decentralized? c registry)Returns true if the given currency is a kind of decentralized currency. It uses
currency traits database in a registry to find a trait named
:control/decentralized.
Returns `true` if the given currency is a kind of decentralized currency. It uses currency traits database in a registry to find a trait named `:control/decentralized`.
(display-name currency)(display-name currency locale)(display-name currency locale registry)Returns a currency display name as a string for the given currency object and locale. If the locale is not given, a default one is used. Uses global registry if a registry is not given.
The following tactic is applied:
The registry field .cur-id->localized is looked up for the currency ID key. If
it's found then a key with the given locale object (a kind of java.util.Locale)
is obtained. If there is no such key, the default one :* is tried (a keyword). The
resulting value should be a map of localized properties in which an entry under the
key :symbol should exist. Its value will be returned, if found.
If the above method failed and the given currency is ISO-standardized then Java methods will be tried to obtain it.
If the above method failed a currency code will be returned.
A locale can be expressed as java.util.Locale object or any other object (like a
string or a keyword) which can be used to look up the locale.
Returns a currency display name as a string for the given currency object and locale. If the locale is not given, a default one is used. Uses global registry if a registry is not given. The following tactic is applied: - The registry field .cur-id->localized is looked up for the currency ID key. If it's found then a key with the given locale object (a kind of `java.util.Locale`) is obtained. If there is no such key, the default one :* is tried (a keyword). The resulting value should be a map of localized properties in which an entry under the key `:symbol` should exist. Its value will be returned, if found. - If the above method failed and the given currency is ISO-standardized then Java methods will be tried to obtain it. - If the above method failed a currency code will be returned. A locale can be expressed as `java.util.Locale` object or any other object (like a string or a keyword) which can be used to look up the locale.
(display-name-native currency)(display-name-native currency registry)Like display-name but for ISO-standardized currencies uses locale assigned to the first country where a currency is the default. When locale is given it is ignored.
Like display-name but for ISO-standardized currencies uses locale assigned to the first country where a currency is the default. When locale is given it is ignored.
(domain c)(domain c registry)(domain c _locale registry)Returns currency domain as a keyword. For currencies added with simple
identifiers (without a namespace) and numerical IDs present it will be
:ISO-4217. For currencies with namespace-qualified identifiers it will be the
upper-cased namespace name (e.g. :CRYPTO) set during creation of a currency
object. Locale argument is ignored.
Returns currency domain as a keyword. For currencies added with simple identifiers (without a namespace) and numerical IDs present it will be `:ISO-4217`. For currencies with namespace-qualified identifiers it will be the upper-cased namespace name (e.g. `:CRYPTO`) set during creation of a currency object. Locale argument is ignored.
(experimental? c)(experimental? c registry)Returns true if the given currency is a kind of experimental currency.
Returns `true` if the given currency is a kind of experimental currency.
(fiat? c)(fiat? c registry)Returns true if the given currency is a kind of fiat currency.
Returns `true` if the given currency is a kind of fiat currency.
(fiduciary? c)(fiduciary? c registry)Returns true if the given currency is a kind of fiduciary currency.
Returns `true` if the given currency is a kind of fiduciary currency.
(formatter currency)(formatter currency locale)(formatter currency locale registry)Returns currency formatter as java.text.DecimalFormat instance for the given
currency and locale. If locale is not given the default one will be used. Due to
caching strategy it is advised to express locale with a keyword.
The formatter is a mutable clone of Java data structure.
In case of currencies other than ISO-standardized (and predefined in Java) the currency field of this formatter will be set to the currency of XXX.
Returns currency formatter as `java.text.DecimalFormat` instance for the given currency and locale. If locale is not given the default one will be used. Due to caching strategy it is advised to express locale with a keyword. The formatter is a mutable clone of Java data structure. In case of currencies other than ISO-standardized (and predefined in Java) the currency field of this formatter will be set to the currency of XXX.
(formatter-extended currency)(formatter-extended currency locale)(formatter-extended currency locale opts)(formatter-extended currency
locale
{:keys [scale rounding-mode grouping grouping-size
negative-prefix negative-suffix positive-prefix
positive-suffix always-sep-dec currency-symbol-fn
min-fraction-digits max-fraction-digits
min-integer-digits max-integer-digits]
:as opts}
registry)Returns a currency formatter as java.text.DecimalFormat instance for the given
currency, customizable with the given opts map. If the locale is not given then the
default one will be used. Due to caching strategy it is advised to express locale
with a keyword.
The formatter is a mutable clone of Java data structure.
In case of currencies other than ISO-standardized (and predefined in Java) the currency field of this formatter will be set to the currency of XXX.
Options map can have the following keys:
:rounding-mode - RoundingMode, rounding mode to apply when scaling:grouping - Boolean, if true then grouping will be used:grouping-size - integer, size of a group when grouping:negative-prefix - String, negative prefix to use:negative-suffix - String, negative suffix to use:positive-prefix - String, positive prefix to use:positive-suffix - String, positive suffix to use:always-sep-dec - Boolean, if true then the decimal separator will always be shown:currency-symbol-fn - a function used on a bankster/Currency object to get its symbol as a string:min-fraction-digits - integer, the minimum number of digits allowed in the fraction portion of an amount:min-integer-digits - integer, the minimum number of digits allowed in the integer portion of an amount:max-fraction-digits - integer, the maximum number of digits allowed in the fraction portion of an amount:max-integer-digits - integer, the maximum number of digits allowed in the integer portion of an amount:scale - sets both :min-fraction-digits and :max-fraction-digits to the same value.When choosing different currency, all parameters of a formatter are initially set to that currency. Additionally re-scaling may take place for the amount if scales are different.
The function assigned to the :currency-symbol-fn should take 3 arguments:
currency, locale and registry.
It is advised to express locale using a keyword when huge amount of operations is expected.
Returns a currency formatter as `java.text.DecimalFormat` instance for the given currency, customizable with the given opts map. If the locale is not given then the default one will be used. Due to caching strategy it is advised to express locale with a keyword. The formatter is a mutable clone of Java data structure. In case of currencies other than ISO-standardized (and predefined in Java) the currency field of this formatter will be set to the currency of XXX. Options map can have the following keys: - `:rounding-mode` - RoundingMode, rounding mode to apply when scaling - `:grouping` - Boolean, if true then grouping will be used - `:grouping-size` - integer, size of a group when grouping - `:negative-prefix` - String, negative prefix to use - `:negative-suffix` - String, negative suffix to use - `:positive-prefix` - String, positive prefix to use - `:positive-suffix` - String, positive suffix to use - `:always-sep-dec` - Boolean, if true then the decimal separator will always be shown - `:currency-symbol-fn` - a function used on a bankster/Currency object to get its symbol as a string - `:min-fraction-digits` - integer, the minimum number of digits allowed in the fraction portion of an amount - `:min-integer-digits` - integer, the minimum number of digits allowed in the integer portion of an amount - `:max-fraction-digits` - integer, the maximum number of digits allowed in the fraction portion of an amount - `:max-integer-digits` - integer, the maximum number of digits allowed in the integer portion of an amount - `:scale` - sets both `:min-fraction-digits` and `:max-fraction-digits` to the same value. When choosing different currency, all parameters of a formatter are initially set to that currency. Additionally re-scaling may take place for the amount if scales are different. The function assigned to the `:currency-symbol-fn` should take 3 arguments: currency, locale and registry. It is advised to express locale using a keyword when huge amount of operations is expected.
(funds? c)(funds? c registry)Returns true if the given currency is a kind of funds/settlement currency.
Returns `true` if the given currency is a kind of funds/settlement currency.
(has-country? c)(has-country? c registry)Returns true if the given currency has at least one country for which it is an
official currency.
Returns `true` if the given currency has at least one country for which it is an official currency.
(has-domain? c)(has-domain? c registry)(has-domain? c ns)(has-domain? c ns registry)Returns true if the given currency c has its domain defined (when only currency
and optional registry is given). If ns is given it returns true if the currency
has its domain set to be the exact keyword given.
Returns `true` if the given currency `c` has its domain defined (when only currency and optional registry is given). If `ns` is given it returns `true` if the currency has its domain set to be the exact keyword given.
(has-kind? c)(has-kind? c registry)(has-kind? c tag registry)Returns true if the given currency c has its kind defined (when only currency
and optional registry is given). If tag is given it returns true if the
currency has its kind set to be the exact keyword given.
Returns `true` if the given currency `c` has its kind defined (when only currency and optional registry is given). If `tag` is given it returns `true` if the currency has its kind set to be the exact keyword given.
(has-numeric-id? c)(has-numeric-id? c registry)Returns true if the given currency has a numeric ID.
Returns `true` if the given currency has a numeric ID.
(has-trait? c)(has-trait? c registry)(has-trait? c tag)(has-trait? c tag registry)Returns true if the given currency c has any trait defined (when only currency
and optional registry is given). If tag is given it returns true if the
currency has one of its traits set to be the exact keyword given.
Traits are registry attributes (stored in Registry/:cur-id->traits). Any :traits
extension field present on ad-hoc Currency values is ignored.
Returns `true` if the given currency `c` has any trait defined (when only currency and optional registry is given). If `tag` is given it returns `true` if the currency has one of its traits set to be the exact keyword given. Traits are registry attributes (stored in `Registry/:cur-id->traits`). Any `:traits` extension field present on ad-hoc `Currency` values is ignored.
(in-domain? ns c)(in-domain? ns c registry)Returns true if the given currency has a domain set to the first given argument.
Returns `true` if the given currency has a domain set to the first given argument.
(info c)(info c registry)(info c _locale registry)Returns a map describing the given currency, including registry-associated properties when available.
Base fields come from the currency's map representation (via into {}) and include
any extension fields. When a registry can be consulted (default or explicitly
passed), this function also adds:
:countries - a set of associated country IDs,:localized - a localized properties map (locale keywords, including :*),:traits - a set of associated traits.Returns nil when the given value points to a registry currency but cannot be
resolved. Locale argument is ignored.
Returns a map describing the given currency, including registry-associated
properties when available.
Base fields come from the currency's map representation (via `into {}`) and include
any extension fields. When a registry can be consulted (default or explicitly
passed), this function also adds:
- `:countries` - a set of associated country IDs,
- `:localized` - a localized properties map (locale keywords, including `:*`),
- `:traits` - a set of associated traits.
Returns `nil` when the given value points to a registry currency but cannot be
resolved. Locale argument is ignored.(iso-legacy? c)(iso-legacy? c registry)Returns true if the given currency was an official currency but is now considered a
legacy currency having an identifier compliant with the ISO standard. It is just a
helper which checks if the :domain field of a currency equals to
:ISO-4217-LEGACY.
Returns `true` if the given currency was an official currency but is now considered a legacy currency having an identifier compliant with the ISO standard. It is just a helper which checks if the `:domain` field of a currency equals to `:ISO-4217-LEGACY`.
(iso-possible? c)(iso-possible? c registry)Returns true if the given value is a possible ISO-4217 currency: can be used to
get an ISO currency from a registry, can be used to create ISO currency on its own,
or is an ISO currency.
This predicate is semantically wide. If the string or keyword alone cannot be used
to create a valid, ad-hoc ISO currency but it can get an ISO currency from a
registry, then the function will return true. Same for certain numbers: if they
cannot be used to create an ISO currency on their own (since there is no ID) but
can be used to look one up in a registry (treating a number as an ISO-4217 code),
they will be positively tested as possible values for currency creation (if there
was a hit).
If registry is not given or is nil, the default one is used.
Returns `true` if the given value is a possible ISO-4217 currency: can be used to get an ISO currency from a registry, can be used to create ISO currency on its own, or is an ISO currency. This predicate is semantically wide. If the string or keyword alone cannot be used to create a valid, ad-hoc ISO currency but it can get an ISO currency from a registry, then the function will return `true`. Same for certain numbers: if they cannot be used to create an ISO currency on their own (since there is no ID) but can be used to look one up in a registry (treating a number as an ISO-4217 code), they will be positively tested as possible values for currency creation (if there was a hit). If `registry` is not given or is `nil`, the default one is used.
(iso-strict-code? kid)Returns true when the given currency code, expressed as keyword, is exactly a
3-character, simple keyword consisting only of uppercase letters in range of
A-Z. Otherwise it returns false.
Returns `true` when the given currency code, expressed as keyword, is exactly a 3-character, simple keyword consisting only of uppercase letters in range of A-Z. Otherwise it returns `false`.
(iso-strict? c)(iso-strict? c registry)Returns true if the given currency is an official currency which is currently in
use (not a legacy money) and its both identifier and numerical identifier is
compliant with the ISO standard.
Returns `true` if the given currency is an official currency which is currently in use (not a legacy money) and its both identifier and numerical identifier is compliant with the ISO standard.
(iso? c)(iso? c registry)Returns true if the given currency is classified as ISO because its kind is set to
:iso or its descendants. It may include not just current ISO currencies but also
legacy ones. See also io.randomseed.bankster.currency/iso-strict?.
Returns `true` if the given currency is classified as ISO because its kind is set to `:iso` or its descendants. It may include not just current ISO currencies but also legacy ones. See also `io.randomseed.bankster.currency/iso-strict?`.
(java currency)(java currency registry)For ISO-standardized currency, returns corresponding java.util.Currency object. If
the currency does not exist, is not ISO (its :domain is not :ISO-4217), has a
different scale (fraction digits), or a different numeric code, nil is returned.
For ISO-standardized currency, returns corresponding `java.util.Currency` object. If the currency does not exist, is not ISO (its `:domain` is not `:ISO-4217`), has a different scale (fraction digits), or a different numeric code, `nil` is returned.
A set of Java currencies (instances of java.util.Currency, including obsolete
currencies).
A set of Java currencies (instances of `java.util.Currency`, including obsolete currencies).
(kind c)(kind c registry)(kind c _locale registry)Returns currency kind. It is a keyword which describes origin of its value. Currently known top-level kinds are:
:iso - ISO-4217 currencies, funds, commodities, special markers.:virtual - Virtual units (stable tokens, credits, native tokens, special).:currency - Meta: currency-like units; parent for :fiduciary money.:asset - Meta: value-bearing units (:assets, :claims, :stable, reference-based).:fiat - Meta umbrella: fiat-related tags (issuer fiats vs fiat-as-anchor).:funds - Meta: funds, settlement units, units of account.:commodity - Meta: commodity-based units and commodity anchoring.:special - Meta: special-purpose markers (:experimental, :test, :null).The function may return nil if the currency is a no-currency. Locale argument is
ignored. To list all known kinds use kinds.
Returns currency kind. It is a keyword which describes origin of its value. Currently known top-level kinds are: - `:iso` - ISO-4217 currencies, funds, commodities, special markers. - `:virtual` - Virtual units (stable tokens, credits, native tokens, special). - `:currency` - Meta: currency-like units; parent for `:fiduciary` money. - `:asset` - Meta: value-bearing units (`:assets`, `:claims`, `:stable`, reference-based). - `:fiat` - Meta umbrella: fiat-related tags (issuer fiats vs fiat-as-anchor). - `:funds` - Meta: funds, settlement units, units of account. - `:commodity` - Meta: commodity-based units and commodity anchoring. - `:special` - Meta: special-purpose markers (`:experimental`, `:test`, `:null`). The function may return `nil` if the currency is a no-currency. Locale argument is ignored. To list all known kinds use `kinds`.
(kinds)(kinds registry)Returns a map of all registered currency kinds as keys and their ancestors as
sets. It will not contain ad-hoc kinds that wasn't added to a registry's
hierarchy. Uses the given registry or a global one.
Returns a map of all registered currency kinds as keys and their ancestors as sets. It will not contain ad-hoc kinds that wasn't added to a registry's hierarchy. Uses the given `registry` or a global one.
(legacy? c)(legacy? c registry)Alias for iso-legacy?
Alias for iso-legacy?
(localized-properties c)(localized-properties c registry)Returns a map of localized properties for the given currency. Locale objects are translated back to their keyword representations.
Throws when a currency cannot be resolved in the registry. Returns nil when there
are no localized properties for the currency.
Returns a map of localized properties for the given currency. Locale objects are translated back to their keyword representations. Throws when a currency cannot be resolved in the registry. Returns `nil` when there are no localized properties for the currency.
(localized-property property currency-id)(localized-property property currency-id locale)(localized-property property currency-id locale registry)Gets the localized property of a currency from the given registry and locale. If the registry is not given, the global one will be used. If the locale is not given, the default locale for the environment will be used. Locale can be expressed as a Locale object or any object which can be used to identify the locale (e.g. a keyword or a string).
Throws when a currency cannot be resolved in the registry. Returns nil when the
property is not present for the currency or when the currency has no localized
properties.
Localized properties are maps keyed by currency identifiers, containing another maps keyed by locale objects. There is a special key :* which identifies default properties used when there are no properties in locale-keyed maps.
Let's take a hypothetical entry of a registry database .cur-id->localized:
{:XXX {#object[java.util.Locale 0x3f5af72f "en_US"] {:symbol "$"}}
{#object[java.util.Locale 0x3f5af72f "en"] {:symbol "X$"}
{:* {:symbol "ABC"}}
(localized-property :symbol :XXX :en_US) will return $.(localized-property :symbol :XXX :en_GB) will return X$.(localized-property :symbol :XXX :pl_PL) will return ABC.The first is self-explanatory.
The second falls back to en because the function will re-try the language
part (en) alone when the property was not found. The same method is repeatedly
applied to other components of a locale (variant, script and extensions – if
any). So for the locale identified by th_TH_TH_#u-nu-thai the following keys will
be tried:
th_TH_TH_#u-nu-thai,th_TH_TH_#u-nu,th_TH_TH_#u,th_TH_TH,th_TH and th.The third example renders ABC because there is an entry of :symbol in the
default properties map under the key :*.
Please note that functions for getting particular properties may apply additional steps to obtain them. For instance, the display-name function will first call the localized-property and if it fails it will fall back to Java methods (if the currency is ISO-standardized). If that will fail too then it will return a currency code.
Gets the localized property of a currency from the given registry and locale. If the
registry is not given, the global one will be used. If the locale is not given, the
default locale for the environment will be used. Locale can be expressed as a
Locale object or any object which can be used to identify the locale (e.g. a keyword
or a string).
Throws when a currency cannot be resolved in the registry. Returns `nil` when the
property is not present for the currency or when the currency has no localized
properties.
Localized properties are maps keyed by currency identifiers, containing another
maps keyed by locale objects. There is a special key :* which identifies default
properties used when there are no properties in locale-keyed maps.
Let's take a hypothetical entry of a registry database `.cur-id->localized`:
```clojure
{:XXX {#object[java.util.Locale 0x3f5af72f "en_US"] {:symbol "$"}}
{#object[java.util.Locale 0x3f5af72f "en"] {:symbol "X$"}
{:* {:symbol "ABC"}}
```
* Calling `(localized-property :symbol :XXX :en_US)` will return `$`.
* Calling `(localized-property :symbol :XXX :en_GB)` will return `X$`.
* Calling `(localized-property :symbol :XXX :pl_PL)` will return `ABC`.
The first is self-explanatory.
The second falls back to `en` because the function will re-try the language
part (`en`) alone when the property was not found. The same method is repeatedly
applied to other components of a locale (variant, script and extensions – if
any). So for the locale identified by `th_TH_TH_#u-nu-thai` the following keys will
be tried:
- `th_TH_TH_#u-nu-thai`,
- `th_TH_TH_#u-nu`,
- `th_TH_TH_#u`,
- `th_TH_TH`,
- `th_TH` and `th`.
The third example renders `ABC` because there is an entry of `:symbol` in the
default properties map under the key `:*`.
Please note that functions for getting particular properties may apply additional
steps to obtain them. For instance, the display-name function will first call the
localized-property and if it fails it will fall back to Java methods (if the
currency is ISO-standardized). If that will fail too then it will return a currency
code.(map->new m)Creates a new currency record from a map.
Creates a new currency record from a map.
(metal? c)(metal? c registry)Returns true if the given currency is a kind of precious metal.
Returns `true` if the given currency is a kind of precious metal.
The Monetary protocol describes basic operations on currencies. It uses single dispatch to allow currencies to be expressed with different kinds of data (keywords, symbols, strings, native Currency objects etc.).
Methods prefixed with to- are cheap, local, and registry-free coercions.
Methods resolve and resolve-all consult a registry to map hints to concrete
registered currencies.
The Monetary protocol describes basic operations on currencies. It uses single dispatch to allow currencies to be expressed with different kinds of data (keywords, symbols, strings, native Currency objects etc.). Methods prefixed with `to-` are cheap, local, and registry-free coercions. Methods `resolve` and `resolve-all` consult a registry to map hints to concrete registered currencies.
(to-code-str this)Coerces a currency representation to a currency code string.
Registry-free. Must not intern keywords. Typically the upper-cased name part
without a namespace (e.g. "USDT").
Coerces a currency representation to a currency code string. Registry-free. Must not intern keywords. Typically the upper-cased name part without a namespace (e.g. `"USDT"`).
(present? id)(present? id registry)Returns true if the registry contains a currency consistent with id.
If id is a plain identifier (e.g. a keyword), this behaves as a simple presence
test: it returns true when any currency resolves from that identifier.
If id is a currency-like object, this performs a field match against the
registered io.randomseed.bankster.Currency:
id and are fields of Currency
participate in the match,Examples:
id is a number, only the numeric currency identifier must match.id is a java.util.Currency, the currency ID/code, scale (fraction digits),
and numeric ISO identifier must all match the registered currency.If registry is not provided, the global registry is used, preferring the dynamic
io.randomseed.bankster.registry/*default* when bound.
Returns `true` if the registry contains a currency consistent with `id`. If `id` is a plain identifier (e.g. a keyword), this behaves as a simple presence test: it returns `true` when any currency resolves from that identifier. If `id` is a currency-like object, this performs a *field match* against the registered `io.randomseed.bankster.Currency`: - only fields that can be derived from `id` *and* are fields of `Currency` participate in the match, - all such derived fields must match exactly. Examples: - If `id` is a number, only the numeric currency identifier must match. - If `id` is a `java.util.Currency`, the currency ID/code, scale (fraction digits), and numeric ISO identifier must all match the registered currency. If `registry` is not provided, the global registry is used, preferring the dynamic `io.randomseed.bankster.registry/*default*` when bound.
(definitive? this)Returns true when the given value is a definitive currency representation: it
carries enough information (either explicitly or by type implication) to create a
currency and to make negative property checks meaningful for the attributes it
determines (e.g. when domain is not :ISO-4217 then it is definitely not an ISO
currency).
For map-based currency specifications, definitiveness is expressed by the presence
of keys for core attributes (domain, scale, numeric id). Key presence is
significant: an explicitly present key with a nil value means "specified as
nil" and should be trusted.
Currency kind is treated as an optional classification attribute. If present in
a representation, it is trusted; if absent, it remains unknown (not inferred).
This method is registry-free.
Returns `true` when the given value is a *definitive* currency representation: it carries enough information (either explicitly or by type implication) to create a currency and to make negative property checks meaningful for the attributes it determines (e.g. when `domain` is not `:ISO-4217` then it is definitely not an ISO currency). For map-based currency specifications, definitiveness is expressed by the presence of keys for core attributes (domain, scale, numeric id). Key presence is significant: an explicitly present key with a `nil` value means "specified as nil" and should be trusted. Currency `kind` is treated as an optional classification attribute. If present in a representation, it is trusted; if absent, it remains unknown (not inferred). This method is registry-free.
(to-map this)Coerces a currency representation to a map of currency fields.
Registry-free. Returns a map (possibly partial) or nil.
Coerces a currency representation to a map of currency fields. Registry-free. Returns a map (possibly partial) or `nil`.
(to-id-str this)Coerces a currency representation to a currency identifier string.
Registry-free. Must not intern keywords. Intended for security-sensitive code paths where the input may be untrusted.
Suggested canonical form:
"PLN"),/ + upper-case name
(e.g. "crypto/USDT" or "CrYpTo/USDT").Coerces a currency representation to a currency identifier string. Registry-free. Must not intern keywords. Intended for security-sensitive code paths where the input may be untrusted. Suggested canonical form: - unqualified IDs: upper-case name (e.g. `"PLN"`), - qualified IDs: original namespace + `/` + upper-case name (e.g. `"crypto/USDT"` or `"CrYpTo/USDT"`).
(to-code this)Coerces a currency representation to a currency code (unqualified keyword).
Registry-free. May return nil if the code cannot be derived.
Coerces a currency representation to a currency code (unqualified keyword). Registry-free. May return `nil` if the code cannot be derived.
(of-id id)(of-id id registry)Returns a currency object for the given ID and registry.
If the registry is not given, it will use the default registry (will first try a
registry bound to the io.randomseed.bankster.registry/*default* dynamic
variable, then the global registry).
The currency is always taken from a registry (on a basis of the extracted ID) even
if a Currency or currency-like object was given, with one exception: if
registry is explicitly set to nil then a Currency object will be returned as
is (or created out of currency-like object and returned) without consulting any
registry.
Returns a currency object for the given ID and registry. If the registry is not given, it will use the default registry (will first try a registry bound to the `io.randomseed.bankster.registry/*default*` dynamic variable, then the global registry). The currency is always taken from a registry (on a basis of the extracted ID) even if a `Currency` or currency-like object was given, with one exception: if `registry` is explicitly set to `nil` then a `Currency` object will be returned as is (or created out of currency-like object and returned) without consulting any registry.
(to-id this)Coerces a currency representation to a currency identifier (keyword).
Registry-free. May return nil if the identifier cannot be derived.
Coerces a currency representation to a currency identifier (keyword). Registry-free. May return `nil` if the identifier cannot be derived.
(unit id)(unit id registry)Returns a Currency object for the given ID, currency code, numeric ID, or
a currency-like object.
If a Currency record is passed and registry:
nil,then the registry will NOT be consulted and the Currency object will be returned
as-is.
If a non-nil registry is passed, it will be consulted to find the exact match.
For currency identifiers (keywords, strings, numbers) it will resolve them from
the registry.
For currency maps, unit treats the map as a registry lookup specification: it
will query the registry using meaningful keys present in the map (a mask-like
match). If more than one currency matches, the best match is selected by weight
(smallest weight wins). If no currency matches, an exception will be thrown. Use
resolve-all to obtain all matches.
For Currency objects all fields must be exact except :domain and :kind which
may be nil to act as wildcards. Only if the currency exists in the registry, the
Currency record will be returned.
If the registry is consulted and the currency does not exist in a registry, an exception will be thrown.
Returns a `Currency` object for the given ID, currency code, numeric ID, or a currency-like object. If a `Currency` record is passed and `registry`: - is not given (unary arity), or - is explicitly set to `nil`, then the registry will NOT be consulted and the `Currency` object will be returned as-is. If a non-`nil` `registry` is passed, it will be consulted to find the exact match. For currency identifiers (keywords, strings, numbers) it will resolve them from the registry. For currency maps, `unit` treats the map as a *registry lookup specification*: it will query the registry using meaningful keys present in the map (a mask-like match). If more than one currency matches, the best match is selected by weight (smallest weight wins). If no currency matches, an exception will be thrown. Use `resolve-all` to obtain all matches. For `Currency` objects all fields must be exact except `:domain` and `:kind` which may be `nil` to act as wildcards. Only if the currency exists in the registry, the `Currency` record will be returned. If the registry is consulted and the currency does not exist in a registry, an exception will be thrown.
(to-numeric-id this)Coerces a currency representation to its numeric identifier (ISO 4217 numeric code, when available).
Registry-free. Implementations should return a number when it can be derived,
otherwise they may return nil or a sentinel numeric value.
Coerces a currency representation to its numeric identifier (ISO 4217 numeric code, when available). Registry-free. Implementations should return a number when it can be derived, otherwise they may return `nil` or a sentinel numeric value.
(defined? id)(defined? id registry)Returns true if any currency can be resolved from id in the registry.
id may be:
io.randomseed.bankster.Currency (looked up by its :id),java.util.Currency (looked up by its currency code converted to a keyword),This is an existence check only. It may return true even when id is a
currency-like object whose properties do not match the registered currency.
If registry is not provided, the global registry is used, preferring the dynamic
io.randomseed.bankster.registry/*default* when bound.
Returns `true` if *any* currency can be resolved from `id` in the registry. `id` may be: - a keyword (looked up as-is and, when namespaced, also by its unqualified name), - an `io.randomseed.bankster.Currency` (looked up by its `:id`), - a `java.util.Currency` (looked up by its currency code converted to a keyword), - a number (looked up as a numeric currency identifier). This is an existence check only. It may return `true` even when `id` is a currency-like object whose properties do not match the registered currency. If `registry` is not provided, the global registry is used, preferring the dynamic `io.randomseed.bankster.registry/*default*` when bound.
(to-currency this)Coerces a currency representation to a Currency object without consulting a
registry.
Returns a Currency instance or nil when it cannot be constructed.
Coerces a currency representation to a `Currency` object without consulting a registry. Returns a `Currency` instance or `nil` when it cannot be constructed.
(resolve-all this)(resolve-all this registry)Resolves a currency representation to all matching registered currencies by consulting a registry.
When registry is nil, the default registry is used (preferring
io.randomseed.bankster.registry/*default* when bound). Returns a set of resolved
currencies or nil when nothing matches.
Resolves a currency representation to all matching registered currencies by consulting a registry. When `registry` is `nil`, the default registry is used (preferring `io.randomseed.bankster.registry/*default*` when bound). Returns a set of resolved currencies or `nil` when nothing matches.
(id id)(id id registry)Returns a unique identifier of the given currency as a keyword. The currency can
be expressed as a Currency object, a keyword, a string, or any other object which
can be handled by the io.randomseed.bankster.currency/unit.
The role of the default registry is advisory. If the registry argument is not
given (or it is nil) then the ID will be returned regardless of whether the
currency exists in a registry, by simply converting it to a keyword or getting a
field from a currency-like object. Still, the default registry will be consulted to
resolve possible currency code. For example: if BTC is a currency code of a
registered currency identified as :crypto/BTC then the resulting value for :BTC
will be :crypto/BTC; but for :BLABLA (which does not exist in a registry) the
resulting value will be :BLABLA.
If a registry is given (non-nil), then trying to use a non-existing currency will
cause an exception to be thrown.
Returns a unique identifier of the given currency as a keyword. The currency can be expressed as a `Currency` object, a keyword, a string, or any other object which can be handled by the `io.randomseed.bankster.currency/unit`. The role of the default registry is advisory. If the registry argument is not given (or it is `nil`) then the ID will be returned regardless of whether the currency exists in a registry, by simply converting it to a keyword or getting a field from a currency-like object. Still, the default registry will be consulted to resolve possible currency code. For example: if `BTC` is a currency code of a registered currency identified as `:crypto/BTC` then the resulting value for `:BTC` will be `:crypto/BTC`; but for `:BLABLA` (which does not exist in a registry) the resulting value will be `:BLABLA`. If a registry is given (non-`nil`), then trying to use a non-existing currency will cause an exception to be thrown.
(resolve this)(resolve this registry)Resolves a currency representation to a registered Currency by consulting a
registry.
When registry is nil, the default registry is used (preferring
io.randomseed.bankster.registry/*default* when bound). Returns the resolved
Currency or nil when it cannot be resolved.
Resolves a currency representation to a registered `Currency` by consulting a registry. When `registry` is `nil`, the default registry is used (preferring `io.randomseed.bankster.registry/*default*` when bound). Returns the resolved `Currency` or `nil` when it cannot be resolved.
(name currency)(name currency locale)(name currency locale registry)Alias for display-name.
Alias for display-name.
(name-native currency)(name-native currency registry)Alias for display-name-native.
Alias for display-name-native.
(new id)(new id numeric-id)(new id numeric-id scale)(new id numeric-id scale kind)(new id numeric-id scale kind domain)(new id numeric-id scale kind domain weight)Alias for new-currency.
Alias for new-currency.
(new-currency id)(new-currency id numeric-id)(new-currency id numeric-id scale)(new-currency id numeric-id scale kind)(new-currency id numeric-id scale kind domain)(new-currency id numeric-id scale kind domain weight)Creates new currency record from values passed as arguments.
Identifier casing rules:
:pln -> :PLN,
:crypto/usdt -> :crypto/USDT).ISO-4217, which is treated
case-insensitively and always stripped).When the given id has the ISO-4217 namespace (case insensitive), it will be
stripped of it.
When the namespace ISO-4217 was removed from the ID, the domain will be set to
:ISO-4217, unless the domain argument is given and it is not nil.
In short: setting ISO-4217 namespace in id will always cause it to be removed,
and a new currency will be treated as if it was an ISO currency, unless the domain
was explicitly given.
Domain property will also be automatically set to :ISO-4217 when:
domain was not given (or is nil) and was not set automatically,numeric-id is given and is greater than 0,id is a simple keyword (after potential stripping the ISO namespace)
and consists of exactly 3 uppercase letters from A to Z only.Setting the domain manually to :ISO-4217 (with domain argument or by setting a
namespace of id to ISO-4217) will cause the currency to be treated as an ISO
currency without any checks regarding its scale or numerical identifier. Use with
caution. This is intended for applications requiring high elasticity.
Creates new currency record from values passed as arguments. Identifier casing rules: - Currency *name* (code) is canonicalized to upper-case (`:pln` -> `:PLN`, `:crypto/usdt` -> `:crypto/USDT`). - Namespace casing is preserved as provided (except `ISO-4217`, which is treated case-insensitively and always stripped). When the given `id` has the `ISO-4217` namespace (case insensitive), it will be stripped of it. When the namespace `ISO-4217` was removed from the ID, the domain will be set to `:ISO-4217`, unless the `domain` argument is given and it is not `nil`. In short: setting `ISO-4217` namespace in `id` will always cause it to be removed, and a new currency will be treated as if it was an ISO currency, unless the domain was explicitly given. Domain property will also be automatically set to `:ISO-4217` when: - `domain` was not given (or is `nil`) and was not set automatically, - `numeric-id` is given and is greater than 0, - the given `id` is a simple keyword (after potential stripping the ISO namespace) and consists of exactly 3 uppercase letters from A to Z only. Setting the domain manually to `:ISO-4217` (with `domain` argument or by setting a namespace of `id` to `ISO-4217`) will cause the currency to be treated as an ISO currency without any checks regarding its scale or numerical identifier. Use with caution. This is intended for applications requiring high elasticity.
Expresses the value of currency's numeric ID which does not exist.
Expresses the value of currency's numeric ID which does not exist.
(none? c)(none? c registry)Returns true if the given currency does not exist, or there is no currency (value
is nil, false, an empty collection), or it is a pseudo-currency with its kind
set to :NULL or its descendants.
Returns `true` if the given currency does not exist, or there is no currency (value is `nil`, `false`, an empty collection), or it is a pseudo-currency with its kind set to `:NULL` or its descendants.
(nr c)(nr c registry)(nr c _locale registry)Returns currency numeric ID as a long number. For currencies without an assigned number it will return nil. Locale argument is ignored.
Returns currency numeric ID as a long number. For currencies without an assigned number it will return nil. Locale argument is ignored.
(ns c)(ns c registry)(ns c locale registry)Alias for domain.
Alias for domain.
(ns-code c)(ns-code c registry)(ns-code c _locale registry)Returns a currency code as a string for the given currency object. If the currency identifier is namespaced the namespace will be used as a prefix and slash character as a separator. Locale argument is ignored.
Returns a currency code as a string for the given currency object. If the currency identifier is namespaced the namespace will be used as a prefix and slash character as a separator. Locale argument is ignored.
(null? c)(null? c registry)Returns true if the given currency is a kind of null currency.
Returns `true` if the given currency is a kind of null currency.
(numeric c)(numeric c registry)(numeric c locale registry)Alias for nr.
Alias for nr.
(numeric-id c)(numeric-id c registry)(numeric-id c locale registry)Alias for nr.
Alias for nr.
(of currency)(of currency registry)Returns a currency for the given value by querying the given registry or a global
registry, which may be shadowed by the value of
io.randomseed.bankster.registry/*default* (see ``io.randomseed.bankster.registry/with`` orwith-registry`).
Returns a currency for the given value by querying the given registry or a global registry, which may be shadowed by the value of `io.randomseed.bankster.registry/*default* (see ``io.randomseed.bankster.registry/with`` or `with-registry`).
(of-country country-id)(of-country country-id registry)(of-country country-id _locale registry)Returns a currency for the given country identified by a country ID (which should be a keyword). If there is no currency or country of the given ID does not exist, returns nil. Locale argument is ignored.
Returns a currency for the given country identified by a country ID (which should be a keyword). If there is no currency or country of the given ID does not exist, returns nil. Locale argument is ignored.
(of-domain? domain c)(of-domain? domain c registry)Checks if a domain of the given currency c equals to the one given as a first
argument domain or if it belongs to a domain (checked with clojure.core/isa?).
Checks if a domain of the given currency `c` equals to the one given as a first argument `domain` or if it belongs to a `domain` (checked with `clojure.core/isa?`).
(of-kind? kind c)(of-kind? kind c registry)Checks if a kind of the given currency c equals to the one given as a second
argument kind or if it belongs to a kind (checked with clojure.core/isa?).
Checks if a kind of the given currency `c` equals to the one given as a second argument `kind` or if it belongs to a `kind` (checked with `clojure.core/isa?`).
(of-trait? tag c)(of-trait? tag c registry)Checks if any trait of the given currency c equals to the one given as a second
argument tag, or if it belongs to a tag (checked with clojure.core/isa?).
Checks if any trait of the given currency `c` equals to the one given as a second argument `tag`, or if it belongs to a `tag` (checked with `clojure.core/isa?`).
(official? c)(official? c registry)Alias for iso-strict?
Alias for iso-strict?
(peg? c)(peg? c registry)Returns true if the given currency is a kind of PEG currency.
Returns `true` if the given currency is a kind of PEG currency.
(possible? c)(possible? c registry)Returns true if the given value is a possible currency: can be used to get a
currency from a registry, can be used to create currency on its own, or is a
currency.
This predicate is semantically wide. If the string or keyword alone can be used to
create a valid, ad-hoc currency with automatic scale, and without any properties
except identifier, then it will return true. Same for certain numbers: if they
cannot be used to create a currency on their own (since there is no ID) but can be
used to look one up in a registry (treating a number as an ISO-4217 code), they
will be positively tested as possible values for currency creation (if there was a
hit).
If registry is not given or is nil, the default one is used.
Returns `true` if the given value is a possible currency: can be used to get a currency from a registry, can be used to create currency on its own, or is a currency. This predicate is semantically wide. If the string or keyword alone can be used to create a valid, ad-hoc currency with automatic scale, and without any properties except identifier, then it will return `true`. Same for certain numbers: if they cannot be used to create a currency on their own (since there is no ID) but can be used to look one up in a registry (treating a number as an ISO-4217 code), they will be positively tested as possible values for currency creation (if there was a hit). If `registry` is not given or is `nil`, the default one is used.
(real? c)(real? c registry)Returns true if the given currency is a kind of real currency (has its :kind set
to :currency or its descendants.
Returns `true` if the given currency is a kind of real currency (has its `:kind` set to `:currency` or its descendants.
(referenced? c)(referenced? c registry)Returns true if the given currency is a kind of referenced currency.
Returns `true` if the given currency is a kind of referenced currency.
(register registry currency)(register registry currency country-ids)(register registry currency update-mode?)(register registry currency country-ids update-mode?)(register registry currency country-ids localized-properties)(register registry currency country-ids localized-properties update-mode?)Adds a currency and optional, associated country mappings and/or localized properties to the given registry. Returns updated registry.
The optional country-ids argument should be a sequence of keywords (however, if a single keyword is given it will be converted to a single-element sequence) with country codes which should be associated with the given currency.
The optional localized-properties argument should be a map of localized properties of the given currency. See the Data Structures documentation section for more information.
If the update mode is enabled then all of the existing countries associated with the currency are removed and replaced with the provided ones. To simply add new countries, use add-countries. Also note that update mode removes localized properties so new one must be provided.
Adds a currency and optional, associated country mappings and/or localized properties to the given registry. Returns updated registry. The optional country-ids argument should be a sequence of keywords (however, if a single keyword is given it will be converted to a single-element sequence) with country codes which should be associated with the given currency. The optional localized-properties argument should be a map of localized properties of the given currency. See the Data Structures documentation section for more information. If the update mode is enabled then all of the existing countries associated with the currency are removed and replaced with the provided ones. To simply add new countries, use add-countries. Also note that update mode removes localized properties so new one must be provided.
(register! currency)(register! currency country-id-or-update?)(register! currency country-id localized-properties update?)Adds currency and (optional) country to the global registry. Returns updated registry. When the currency is nil, returns current state of the global, shared registry (but not a dynamic registry, even if it is set).
Adds currency and (optional) country to the global registry. Returns updated registry. When the currency is nil, returns current state of the global, shared registry (but not a dynamic registry, even if it is set).
(remove-countries registry country-ids)Removes countries from the given registry. Also unlinks constrained currencies in proper locations. Returns updated registry.
Removes countries from the given registry. Also unlinks constrained currencies in proper locations. Returns updated registry.
(remove-countries! country-ids)Removes country (a keyword) or countries (seqable collection of keywords) from the global registry. Automatically removes currency constraints when necessary. Returns updated registry.
If the country-ids is nil, returns current state of a global registry (but not a dynamic registry, even if it is set).
Removes country (a keyword) or countries (seqable collection of keywords) from the global registry. Automatically removes currency constraints when necessary. Returns updated registry. If the country-ids is nil, returns current state of a global registry (but not a dynamic registry, even if it is set).
(remove-localized-properties registry currency-id)Removes localized properties assigned to a currency in a registry. Returns updated registry. Expects currency ID (or equivalent) to be passed as a second argument.
Removes localized properties assigned to a currency in a registry. Returns updated registry. Expects currency ID (or equivalent) to be passed as a second argument.
(remove-localized-props! currency)Removes localized properties of the given currency from the global registry.
If the currency is nil, returns current state of a global registry (but not a dynamic registry, even if it is set).
Removes localized properties of the given currency from the global registry. If the currency is nil, returns current state of a global registry (but not a dynamic registry, even if it is set).
(remove-traits registry currency-id traits)Removes traits for the given currency in the registry.
Passing nil or an empty collection is a no-op. Removes the registry entry if it
becomes empty.
Throws when the currency cannot be resolved in the registry.
Removes traits for the given currency in the registry. Passing `nil` or an empty collection is a no-op. Removes the registry entry if it becomes empty. Throws when the currency cannot be resolved in the registry.
(remove-traits! currency-id traits)Removes traits for the given currency in the global registry. See remove-traits.
Removes traits for the given currency in the global registry. See `remove-traits`.
(same-ids? a b)(same-ids? a b registry)Returns true when two currency representations refer to the same currency ID.
Contract:
false when IDs cannot be established),registry set to nil means: use the default registry,Currency values are never treated as registry references.Returns `true` when two currency representations refer to the same currency ID. Contract: - symmetric (argument order does not matter), - non-throwing (returns `false` when IDs cannot be established), - `registry` set to `nil` means: use the default registry, - `Currency` values are never treated as registry references.
(sc c)(sc c registry)(sc c _locale registry)Returns currency scale (decimal places) as a number. For currencies without the
assigned decimal places it will return nil (the value of auto-scaled). Locale
argument is ignored.
Returns currency scale (decimal places) as a number. For currencies without the assigned decimal places it will return `nil` (the value of auto-scaled). Locale argument is ignored.
(scale c)(scale c registry)(scale c locale registry)Alias for sc.
Alias for sc.
(set-default! c)Sets default currency by altering io.randomseed.bankster.currency/*default*
dynamic variable.
Sets default currency by altering `io.randomseed.bankster.currency/*default*` dynamic variable.
(set-default-registry!)(set-default-registry! resource-path)(set-default-registry! resource-path & more)Sets default, global registry using a global configuration file and optional user's configuration file. The highlighted version of a registry will be sourced from the last configuration used.
Sets default, global registry using a global configuration file and optional user's configuration file. The highlighted version of a registry will be sourced from the last configuration used.
(set-traits registry currency-id traits)Sets traits for the given currency in the registry.
Traits are stored as a registry attribute under Registry/:cur-id->traits
(currency ID -> set of keywords). Passing nil or an empty collection removes the
traits entry.
Throws when the currency cannot be resolved in the registry.
Sets traits for the given currency in the registry. Traits are stored as a registry attribute under `Registry/:cur-id->traits` (currency ID -> set of keywords). Passing `nil` or an empty collection removes the traits entry. Throws when the currency cannot be resolved in the registry.
(set-traits! currency-id traits)Sets traits for the given currency in the global registry. See set-traits.
Sets traits for the given currency in the global registry. See `set-traits`.
(set-weight registry currency-id weight)Sets currency weight in the given registry and updates all weight-dependent indexes.
Weight is stored as a registry attribute under Registry/:cur-id->weight (currency
ID -> int weight). Setting weight to 0 keeps an explicit 0 entry (presence in the
map is meaningful). Use clear-weight to remove the explicit entry (default 0).
Throws when the currency cannot be resolved in the registry.
Sets currency weight in the given registry and updates all weight-dependent indexes. Weight is stored as a registry attribute under `Registry/:cur-id->weight` (currency ID -> int weight). Setting weight to 0 keeps an explicit 0 entry (presence in the map is meaningful). Use `clear-weight` to remove the explicit entry (default 0). Throws when the currency cannot be resolved in the registry.
(set-weight! currency-id weight)Sets currency weight in the global registry. See set-weight.
Sets currency weight in the global registry. See `set-weight`.
(special? c)(special? c registry)Returns true if the given currency is a kind of special currency.
Returns `true` if the given currency is a kind of special currency.
(stable? c)(stable? c registry)Returns true if the given currency is a kind of stable currency.
Returns `true` if the given currency is a kind of stable currency.
(staked? c)(staked? c registry)Returns true if the given currency is a kind of staked currency.
Returns `true` if the given currency is a kind of staked currency.
(standard? c)(standard? c registry)Alias for iso-strict?
Alias for iso-strict?
(symbol currency)(symbol currency locale)(symbol currency locale registry)Returns a currency symbol as a string for the given currency object and locale. If the locale is not given, a default one is used. Uses global registry if a registry is not given.
The following tactic is applied:
The registry field .cur-id->localized is looked up for the currency ID key. If
it's found then a key with the given locale object (a kind of java.util.Locale) is
obtained. If there is no such key, the default one :* is tried (a keyword). The
resulting value should be a map of localized properties in which an entry under the
key :symbol should exist. Its value will be returned, if found.
If the above method failed and the given currency is ISO-standardized then Java methods will be tried to obtain it.
A locale can be expressed as java.util.Locale object or any other object (like a
string or a keyword) which can be used to look up the locale.
Returns a currency symbol as a string for the given currency object and locale. If the locale is not given, a default one is used. Uses global registry if a registry is not given. The following tactic is applied: - The registry field .cur-id->localized is looked up for the currency ID key. If it's found then a key with the given locale object (a kind of `java.util.Locale`) is obtained. If there is no such key, the default one :* is tried (a keyword). The resulting value should be a map of localized properties in which an entry under the key `:symbol` should exist. Its value will be returned, if found. - If the above method failed and the given currency is ISO-standardized then Java methods will be tried to obtain it. A locale can be expressed as `java.util.Locale` object or any other object (like a string or a keyword) which can be used to look up the locale.
(symbol-native currency)(symbol-native currency registry)Like symbol but for ISO-standardized currencies uses locale assigned to the first country where a currency is the default. When locale is given it is ignored.
Like symbol but for ISO-standardized currencies uses locale assigned to the first country where a currency is the default. When locale is given it is ignored.
(test? c)(test? c registry)Returns true if the given currency is a kind of test currency.
Returns `true` if the given currency is a kind of test currency.
(unregister registry currency)Removes a currency from the given registry. Also removes country mappings and all localized properties associated with a currency. Returns updated registry.
Numeric-ID indexes:
:cur-nr->curs (shared numeric IDs bucket):cur-nr->cur to the canonical currency (first in bucket), or removes the
numeric entry if bucket becomes empty.Removes a currency from the given registry. Also removes country mappings and all localized properties associated with a currency. Returns updated registry. Numeric-ID indexes: - removes the currency from `:cur-nr->curs` (shared numeric IDs bucket) - updates `:cur-nr->cur` to the canonical currency (first in bucket), or removes the numeric entry if bucket becomes empty.
(unregister! currency)Removes currency from the global registry. Automatically removes country constraints when necessary and localized properties associated with a currency. Returns updated registry.
If the currency is nil, returns current state of a global registry (but not a dynamic registry, even if it is set).
Removes currency from the global registry. Automatically removes country constraints when necessary and localized properties associated with a currency. Returns updated registry. If the currency is nil, returns current state of a global registry (but not a dynamic registry, even if it is set).
(unset-default!)Sets default currency to nil by altering io.randomseed.bankster.currency/*default*
dynamic variable.
Sets default currency to nil by altering `io.randomseed.bankster.currency/*default*` dynamic variable.
(update registry currency)(update registry currency country-ids)(update registry currency country-ids localized-properties-map)Replaces a currency in the given registry by a new one, preserving localized properties, relation to countries and code if not explicitly given. Returns updated registry. If the currency does not exist in a registry yet, it will be registered.
Replaces a currency in the given registry by a new one, preserving localized properties, relation to countries and code if not explicitly given. Returns updated registry. If the currency does not exist in a registry yet, it will be registered.
(update! currency)(update! currency country-ids)(update! currency country-ids localized-properties-map)Replaces a currency in the global, shared registry by a new one, preserving localized properties, relation to countries and code if not explicitly given. Returns updated registry. If the currency does not exist in a registry yet, it will be registered.
Replaces a currency in the global, shared registry by a new one, preserving localized properties, relation to countries and code if not explicitly given. Returns updated registry. If the currency does not exist in a registry yet, it will be registered.
(val-auto-scaled*? scale)Returns true if the given scale is equal to auto-scaled.
Returns `true` if the given scale is equal to auto-scaled.
(val-auto-scaled? scale)Returns true if the given scale is equal to auto-scaled.
Returns `true` if the given scale is equal to auto-scaled.
(virtual? c)(virtual? c registry)Returns true if the given currency is a kind of virtual currency.
Returns `true` if the given currency is a kind of virtual currency.
(weight c)(weight c registry)(weight c _locale registry)Returns weight of the given currency (used to resolve conflicts when getting currencies having conflicting currency codes).
Returns weight of the given currency (used to resolve conflicts when getting currencies having conflicting currency codes).
(with currency & body)Sets a default currency in a lexical context of the body.
Sets a default currency in a lexical context of the body.
(with-attempt c registry binding & body)Evaluates c and tries to coerce it to a Currency.
If coercion succeeds, binds the resulting currency to the given symbol and
evaluates body, returning its result. If coercion fails, returns false.
Uses attempt* for coercion (non-throwing).
The binding name can be given either as a symbol or as a single-element vector
(mirroring if-some style):
(with-attempt x registry c (.id c)) (with-attempt x registry [c] (.id c))
Evaluates `c` and tries to coerce it to a `Currency`. If coercion succeeds, binds the resulting currency to the given symbol and evaluates `body`, returning its result. If coercion fails, returns `false`. Uses `attempt*` for coercion (non-throwing). The binding name can be given either as a symbol or as a single-element vector (mirroring `if-some` style): (with-attempt x registry c (.id c)) (with-attempt x registry [c] (.id c))
(with-registry registry & body)Sets a registry in a lexical context of the body to be used instead of a global one
in functions which require the registry and it was not passed as an argument. Has
the same effect as registry/with.
Sets a registry in a lexical context of the body to be used instead of a global one in functions which require the registry and it was not passed as an argument. Has the same effect as `registry/with`.
(with-weight c weight)Returns a currency with weight set.
Weight is stored in currency metadata and does not participate in = / hash
semantics of Currency.
NOTE: Unlike currency constructors (which treat weight as an optional hint),
with-weight is an explicit setter: it records the weight even when it is 0.
Returns a currency with `weight` set. Weight is stored in currency metadata and does not participate in `=` / `hash` semantics of `Currency`. NOTE: Unlike currency constructors (which treat weight as an optional hint), `with-weight` is an explicit setter: it records the weight even when it is 0.
(wrapped? c)(wrapped? c registry)Returns true if the given currency is a kind of wrapped currency.
Returns `true` if the given currency is a kind of wrapped currency.
cljdoc builds & hosts documentation for Clojure/Script libraries
| Ctrl+k | Jump to recent docs |
| ← | Move to previous article |
| → | Move to next article |
| Ctrl+/ | Jump to the search field |