Liking cljdoc? Tell your friends :D

methodical.util

Utility functions for performing additional operations on multifns and their components not specified in one of the interfaces. These functions are compositions of those methods.

Utility functions for performing additional operations on multifns and their components not specified in one of the
interfaces. These functions are compositions of those methods.
raw docstring

add-aux-method!clj

(add-aux-method! multifn-var qualifier dispatch-val f)

Destructive version of [[add-aux-method]]. Operates on a var defining a Methodical multifn.

Destructive version of [[add-aux-method]]. Operates on a var defining a Methodical multifn.
sourceraw docstring

add-aux-method-with-unique-keyclj

(add-aux-method-with-unique-key multifn qualifier dispatch-val f unique-key)

Adds an auxiliary method with a unique-key stored in its metadata. This unique key can later be used to remove the auxiliary method with remove-aux-method-with-unique-key. If a method with this key already exists for this qualifier and dispatch value, replaces the original.

Adds an auxiliary method with a `unique-key` stored in its metadata. This unique key can later be used to remove the
auxiliary method with [[remove-aux-method-with-unique-key]]. If a method with this key already exists for this
qualifier and dispatch value, replaces the original.
sourceraw docstring

add-aux-method-with-unique-key!clj

(add-aux-method-with-unique-key! multifn-var
                                 qualifier
                                 dispatch-val
                                 f
                                 unique-key)

Destructive version of add-aux-method-with-unique-key. Operates on a var defining a Methodical multifn.

Destructive version of [[add-aux-method-with-unique-key]]. Operates on a var defining a Methodical multifn.
sourceraw docstring

add-primary-method!clj

(add-primary-method! multifn-var dispatch-val f)

Destructive version of [[add-primary-method]]. Operates on a var defining a Methodical multifn.

Destructive version of [[add-primary-method]]. Operates on a var defining a Methodical multifn.
sourceraw docstring

alter-var-root+clj

(alter-var-root+ multifn-var f & args)

Like [[clojure.core/alter-var-root]], but handles vars that are aliases of other vars, e.g. ones that have been imported via Potemkin [[potemkin/import-vars]].

Like [[clojure.core/alter-var-root]], but handles vars that are aliases of other vars, e.g. ones that have been
imported via Potemkin [[potemkin/import-vars]].
sourceraw docstring

applicable-primary-methodclj

(applicable-primary-method multifn dispatch-val)

Return the primary method that would be use for dispatch-value, including ones from ancestor dispatch values or the default dipsatch value. Method includes ^:dispatch-valueue metadata indicating the actual dispatch value for which the applicable method was defined.

Like primary-method, the method returned will not have any implicit args (such as next-method) bound.

Return the primary method that would be use for `dispatch-value`, including ones from ancestor dispatch values or the
default dipsatch value. Method includes `^:dispatch-valueue` metadata indicating the actual dispatch value for which
the applicable method was defined.

Like `primary-method`, the method returned will not have any implicit args (such as `next-method`) bound.
sourceraw docstring

aux-methodsclj

(aux-methods multifn)
(aux-methods multifn dispatch-val)
(aux-methods multifn qualifier dispatch-val)

Get all auxiliary methods explicitly specified for dispatch-value. This function does not include methods that would otherwise still be applicable (e.g., methods for ancestor dispatch values) -- the methods explicitly defined for this exact match.

  • With 1 arg: methods come back as a map of qualifier -> dispatch value -> [method].
  • With 2 args: methods come back as a map of qualifier -> [method].
  • With 3 args: methods come back as sequence of methods.
Get all auxiliary methods *explicitly specified* for `dispatch-value`. This function does not include methods that
would otherwise still be applicable (e.g., methods for ancestor dispatch values) -- the methods explicitly defined
for this exact match.

 *  With 1 arg: methods come back as a map of `qualifier` -> `dispatch value` -> `[method]`.
 *  With 2 args: methods come back as a map of `qualifier` -> `[method]`.
 *  With 3 args: methods come back as sequence of `methods`.
sourceraw docstring

default-aux-methodsclj

(default-aux-methods multifn)

Get a map of aux qualifer -> methods for the default dispatch value, if any exist.

Get a map of aux qualifer -> methods for the default dispatch value, if any exist.
sourceraw docstring

default-effective-methodclj

(default-effective-method multifn)

Return the effective (combined) method for the default dispatch value, if one can be computed.

Return the effective (combined) method for the default dispatch value, if one can be computed.
sourceraw docstring

default-primary-methodclj

(default-primary-method multifn)

Get the default primary method associated with this mutlifn, if one exists.

Get the default primary method associated with this `mutlifn`, if one exists.
sourceraw docstring

dispatch-fnclj

(dispatch-fn multifn)

Return a function that can be used to calculate dispatch values of given arg(s).

Return a function that can be used to calculate dispatch values of given arg(s).
sourceraw docstring

dispatch-valueclj

(dispatch-value multifn a)
(dispatch-value multifn a b)
(dispatch-value multifn a b c)
(dispatch-value multifn a b c d)
(dispatch-value multifn a b c d & more)

Calculate the dispatch value that multifn will use given args.

Calculate the dispatch value that `multifn` will use given `args`.
sourceraw docstring

effective-dispatch-valueclj

(effective-dispatch-value multifn dispatch-val)

Return the least-specific dispatch value that would return the same effective method as dispatch-value. e.g. if dispatch-value is Integer and the effective method is a result of combining a Object primary method and a Number aux method, the effective dispatch value is Number, since Number is the most specific thing out of the primary and aux methods and would get the same effective method as Integer.

Return the least-specific dispatch value that would return the same effective method as `dispatch-value`. e.g. if
`dispatch-value` is `Integer` and the effective method is a result of combining a `Object` primary method and a
`Number` aux method, the effective dispatch value is `Number`, since `Number` is the most specific thing out of the
primary and aux methods and would get the same effective method as `Integer`.
sourceraw docstring

effective-primary-methodclj

(effective-primary-method multifn dispatch-val)

Build and effective method equivalent that would be used for this dispatch-value if it had no applicable auxiliary methods. Implicit args (such as next-method) will be bound appropriately. Method has ^:dispatch-valueue metadata for the dispatch value with which the most-specific primary method was defined.

Build and effective method equivalent that would be used for this `dispatch-value` if it had no applicable auxiliary
methods. Implicit args (such as `next-method`) will be bound appropriately. Method has `^:dispatch-valueue` metadata
for the dispatch value with which the most-specific primary method was defined.
sourceraw docstring

matching-aux-methodsclj

(matching-aux-methods multifn dispatch-val)
(matching-aux-methods dispatcher method-table dispatch-val)

Return a map of aux method qualifier -> sequence of applicable methods for dispatch-value, sorted from most-specific to least-specific. Methods should have the ^:dispatch-valueue with which they were defined as metadata.

Return a map of aux method qualifier -> sequence of applicable methods for `dispatch-value`, sorted from
most-specific to least-specific. Methods should have the `^:dispatch-valueue` with which they were defined as
metadata.
sourceraw docstring

matching-primary-methodsclj

(matching-primary-methods multifn dispatch-val)
(matching-primary-methods dispatcher method-table dispatch-val)

Return a sequence of applicable primary methods for dispatch-value, sorted from most-specific to least-specific. Methods include the ^:dispatch-valueue with which they were defined as metadata. The standard dispatcher also checks to make sure methods in the sequence are not ambiguously specific, replacing ambiguous methods with ones that will throw an Exception when invoked.

Return a sequence of applicable primary methods for `dispatch-value`, sorted from most-specific to least-specific.
Methods include the `^:dispatch-valueue` with which they were defined as metadata. The standard dispatcher also checks
to make sure methods in the sequence are not ambiguously specific, replacing ambiguous methods with ones that will
throw an Exception when invoked.
sourceraw docstring

multifn?clj

(multifn? x)

True if x is a Methodical multifn (i.e., if it is an instance of StandardMultiFn).

True if `x` is a Methodical multifn (i.e., if it is an instance of `StandardMultiFn`).
sourceraw docstring

prefer-method!clj

(prefer-method! multifn-var dispatch-val-x dispatch-val-y)

Destructive version of [[prefer-method]]. Operates on a var defining a Methodical multifn.

Note that vanilla Clojure [[clojure.core/prefer-method]] is actually itself destructive, so this function is actually the Methodical equivalent of that function. prefer-method! is used by Methodical to differentiate the operation from our nondestructive [[prefer-method]], which returns a copy of the multifn with an altered dispatch table.

Destructive version of [[prefer-method]]. Operates on a var defining a Methodical multifn.

Note that vanilla Clojure [[clojure.core/prefer-method]] is actually itself destructive, so this function is
actually the Methodical equivalent of that function. `prefer-method!` is used by Methodical to differentiate the
operation from our nondestructive [[prefer-method]], which returns a copy of the multifn with an altered dispatch
table.
sourceraw docstring

primary-methodclj

(primary-method multifn dispatch-val)

Get the primary method explicitly specified for dispatch-value. This function does not return methods that would otherwise still be applicable (e.g., methods for ancestor dispatch values) -- just the methods explicitly defined for this exact match. (If you want methods that will be used, including those of ancestors dispatch values, you can use applicable-primary-method or effective-primary-method instead.)

Note that the primary method will not have any implicit args (e.g. next-method) bound the way it normally would when combined into an effective method; you will need to supply this yourself (or pass nil for no next-method).

Get the primary method *explicitly specified* for `dispatch-value`. This function does not return methods that would
otherwise still be applicable (e.g., methods for ancestor dispatch values) -- just the methods explicitly defined
for this exact match. (If you want methods that will be used, including those of ancestors dispatch values, you can
use [[applicable-primary-method]] or [[effective-primary-method]] instead.)

Note that the primary method will not have any implicit args (e.g. `next-method`) bound the way it normally would
when combined into an effective method; you will need to supply this yourself (or pass `nil` for no `next-method`).
sourceraw docstring

remove-all-aux-methodsclj

(remove-all-aux-methods multifn)
(remove-all-aux-methods multifn qualifier)
(remove-all-aux-methods multifn qualifier dispatch-val)

With one arg, remove all auxiliary methods for a multifn. With two args, remove all auxiliary methods for the given qualifier (e.g. :before). With three args, remove all auxiliary methods for a given qualifier and dispatch-value.

With one arg, remove *all* auxiliary methods for a `multifn`. With two args, remove all auxiliary methods for the
given `qualifier` (e.g. `:before`). With three args, remove all auxiliary methods for a given `qualifier` and
`dispatch-value`. 
sourceraw docstring

remove-all-aux-methods!clj

(remove-all-aux-methods! multifn-var)
(remove-all-aux-methods! multifn-var qualifier)
(remove-all-aux-methods! multifn-var qualifier dispatch-val)

Destructive version of remove-all-aux-methods. Operates on a var defining a Methodical multifn.

Destructive version of [[remove-all-aux-methods]]. Operates on a var defining a Methodical multifn.
sourceraw docstring

remove-all-aux-methods-for-dispatch-valclj

(remove-all-aux-methods-for-dispatch-val multifn dispatch-val)

Remove all auxiliary methods for dispatch-value for all qualifiers.

Remove all auxiliary methods for `dispatch-value` for *all* qualifiers.
sourceraw docstring

remove-all-aux-methods-for-dispatch-val!clj

(remove-all-aux-methods-for-dispatch-val! multifn-var dispatch-val)

Destructive version of remove-all-aux-methods-for-dispatch-val. Operates on a var defining a Methodical multifn.

Destructive version of [[remove-all-aux-methods-for-dispatch-val]]. Operates on a var defining a Methodical multifn.
sourceraw docstring

remove-all-methodsclj

(remove-all-methods multifn)

Remove all primary and auxiliary methods, including default implementations.

Remove all primary and auxiliary methods, including default implementations.
sourceraw docstring

remove-all-methods!clj

(remove-all-methods! multifn-var)

Destructive version of remove-all-methods. Operates on a var defining a Methodical multifn.

Destructive version of [[remove-all-methods]]. Operates on a var defining a Methodical multifn.
sourceraw docstring

remove-all-primary-methodsclj

(remove-all-primary-methods multifn)

Remove all primary methods, for all dispatch values (including the default value), for this multifn or method table.

Remove all primary methods, for all dispatch values (including the default value), for this `multifn` or method
table.
sourceraw docstring

remove-all-primary-methods!clj

(remove-all-primary-methods! multifn-var)

Destructive version of remove-all-primary-methods. Operates on a var defining a Methodical multifn.

Destructive version of [[remove-all-primary-methods]]. Operates on a var defining a Methodical multifn.
sourceraw docstring

remove-aux-method!clj

(remove-aux-method! multifn-var qualifier dispatch-val f)

Destructive version of [[remove-aux-method]]. Operates on a var defining a Methodical multifn.

Destructive version of [[remove-aux-method]]. Operates on a var defining a Methodical multifn.
sourceraw docstring

remove-aux-method-with-unique-keyclj

(remove-aux-method-with-unique-key multifn qualifier dispatch-val unique-key)

Remove an auxiliary method that was added by add-aux-method-with-unique-key, if one exists. Returns multifn.

Remove an auxiliary method that was added by [[add-aux-method-with-unique-key]], if one exists. Returns `multifn`.
sourceraw docstring

remove-aux-method-with-unique-key!clj

(remove-aux-method-with-unique-key! multifn-var
                                    qualifier
                                    dispatch-val
                                    unique-key)

Destructive version of remove-aux-method-with-unique-key. Operates on a var defining a Methodical multifn.

Destructive version of [[remove-aux-method-with-unique-key]]. Operates on a var defining a Methodical multifn.
sourceraw docstring

remove-primary-method!clj

(remove-primary-method! multifn-var dispatch-val)

Destructive version of [[remove-primary-method]]. Operates on a var defining a Methodical multifn.

Destructive version of [[remove-primary-method]]. Operates on a var defining a Methodical multifn.
sourceraw docstring

cljdoc is a website building & hosting documentation for Clojure/Script libraries

× close