Default currency unit to be applied when creating Money objects without the currency specified.

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 (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).

Adds localized properties of a currency to the given registry. Overwrites existing 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 existing currency code with the currency object in the given registry using the value of the .weight field. 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.

Expresses the scale of a currency which is automatic and not limited to certain decimal places.

Alias for big?.

Returns true if the given currency has an automatic scale (decimal places).

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.

Tagged literal handler for Clojure code. Emits compound forms that are going to be evaluated.

Returns true if the given currency is a kind of :COMBANK.

Returns true if the given currency is a kind of :COMMODITY.

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.

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.

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 value is represented by a valid currency object. Registry argument is ignored.

Tagged literal handler for EDN data files. Emits Currency objects or nil values.

Alias for decentralized?

Returns true if the given currency is a kind of :DECENTRALIZED.

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.

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.

Returns currency domain as a keyword. For currencies with simple identifiers 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 a currency object. Locale argument is ignored.

Returns true if the given currency is a kind of :EXPERIMENTAL.

Returns true if the given currency is a kind of :FIAT.

Returns true if the given currency is a kind of :FIDUCIARY.

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 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 true if the given currency has at least one country for which it is an official currency.

Returns true if the given currency has its kind defined.

Returns true if the given currency has a numeric ID.

Returns true if the given currency has a domain set to the first given argument.

Returns true if the given currency is an official currency and its identifier is compliant with ISO standard. It is just a helper which checks if the :domain field of a currency equals :ISO-4217.

For ISO-standardized currency, returns corresponding java.util.Currency object.

Returns currency kind. It is a keyword which describes origin of its value. Currently known kinds are:

• :FIAT – legal tender issued by government or other authority
• :FIDUCIARY - accepted medium of exchange issued by a fiduciary or fiduciaries
• :DECENTRALIZED - accepted medium of exchange issued by a distributed ledger
• :COMBANK - commercial bank money
• :COMMODITY - accepted medium of exchange based on commodities
• :EXPERIMENTAL - pseudo-currency used for testing purposes.

The function may return nil if the currency is a no-currency. Locale argument is ignored.

Returns a kind of the given currency equals to the one given as a second argument.

Returns a map of localized properties for the given currency. Locale objects are translated back to their keyword representations.

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).

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"}}

• 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.

Creates new currency record from a map.

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.).

Alias for display-name.

Alias for display-name-native.

Alias for new-currency.

Creates new currency record from values passed as arguments.

Expresses the value of currency’s numeric ID which does not exist.

Returns currency numeric ID as a long number. For currencies without the assigned number it will return nil. Locale argument is ignored.

Alias for domain.

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.

Alias for nr.

Alias for nr.

Returns a currency for the given value by querying the given registry or a global registry, which may be shadowed by the value of registry/default (see registry/with or with-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.

Alias for iso?

Returns true if the given value is a possible currency representation. If the registry is not given, the global one is used. By possible representation we mean that it is a currency with a keyword identifier or any other data type which can be successfully converted into such using the registry 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 current 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 removed localized properties so new one must be provided.

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).

Removes countries from the given registry. Also unlinks constrained currencies in proper locations. Returns updated registry.

Removes country (a keyword) or countries (seqable collection of keywords) from the global registry. Automatically removes currency constrains 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 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 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).

Returns currency scale (decimal places) as an integer number. For currencies without the assigned decimal places it will return nil (the value of auto-scaled). Locale argument is ignored.

Alias for sc.

Sets default currency by altering *default* dynamic variable.

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.

Alias for iso?

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.

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.

Removes a currency from the given registry. Also removes country and numeric ID constrains when necessary and all localized properties associated with a currency. Returns updated registry.

Please note that removal of a currency which identifier and numeric identifier are the same as already registered currencies, will not only remove the existing currency identified by the ID but will also remove numeric ID from within all currency objects present in a registry.

Removes currency from the global registry. Automatically removes country constrains 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).

Sets default currency to nil by altering *default* dynamic variable.

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 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.

Returns true if the given scale is equal to auto-scaled.

Returns weight of the given currency (used to resolve conflicts when getting currencies having conflicting currency codes).

Sets a default currency in a lexical context of the 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.