callback

v0.1.0

callback v0.1.0 Callback

Link to this section Summary

Types

callback()

A generic callback form with any amount of arguments

callback(arg1, result)

An explicit callback form expecting 1 argument of the provided type, and returning a result of the provided type

callback(arg1, arg2, result)

An explicit callback form expecting 2 arguments of the provided type, and returning a result of the provided type

mfa(arity)

A module-function-arity tuple with an explicit arity

mfp()

A module-function-parameter tuple

Functions

call(fun, inputs \\ [], input_requirement \\ :required)

Call the provided callback with the given inputs

is_callback(callback)

Returns true if term is a callback; otherwise returns false

Link to this section Types

Link to this type callback() 
callback() :: (... -> any()) | mfa() | mfp()

A generic callback form with any amount of arguments.

Link to this type callback(arg1, result) 
callback(arg1, result) :: (arg1 -> result) | mfa(1) | mfp()

An explicit callback form expecting 1 argument of the provided type, and returning a result of the provided type.

Link to this type callback(arg1, arg2, result) 
callback(arg1, arg2, result) :: (arg1, arg2 -> result) | mfa(2) | mfp()

An explicit callback form expecting 2 arguments of the provided type, and returning a result of the provided type.

Link to this type mfa(arity) 
mfa(arity) :: {module(), atom(), arity}

A module-function-arity tuple with an explicit arity.

Link to this type mfp() 
mfp() ::
  {module(), atom(), list()}
  | {module(), atom(), list(), nil | non_neg_integer() | [non_neg_integer()]}

A module-function-parameter tuple.

This either contains a list of parameters that will be passed to the function, and any input parameters will be added following those parameters. Or an input index or list of indexes will be provided (in which case those inputs will be inserted into the parameter list at those positions). Or nil inputs, if no inputs should be included, this however is only applicable to calls where the input requirements :optional.

{ Foo, :bar, [:a, :b] }
# If the callback is not passing any inputs then this function will
# be called as:
Foo.bar(:a, :b)
# If the callback is passing in 1 input ("hello"), then this function
# will be called as:
Foo.bar(:a, :b, "hello")
# If the callback is passing in 2 inputs ("hello", "world"), then this
# function will be called as:
Foo.bar(:a, :b, "hello", "world")

{ Foo, :bar, [:a, :b], 0 }
# If the callback is not passing any inputs then this function will
# be called as:
Foo.bar(:a, :b)
# If the callback is passing in 1 input ("hello"), then this function
# will be called as:
Foo.bar("hello", :a, :b)
# If the callback is passing in 2 inputs ("hello", "world"), then this
# function will be called as:
Foo.bar("hello", "world", :a, :b)

{ Foo, :bar, [:a, :b], [0, 2] }
# If the callback is not passing any inputs then this function will
# be called as:
Foo.bar(:a, :b)
# If the callback is passing in 1 input ("hello"), then this function
# will be called as:
Foo.bar("hello", :a, :b)
# If the callback is passing in 2 inputs ("hello", "world"), then this
# function will be called as:
Foo.bar("hello", :a, "world", :b)

{ Foo, :bar, [:a, :b], nil }
# If the callback is not passing any inputs then this function will
# be called as:
Foo.bar(:a, :b)
# If the callback is passing in 1 input ("hello"), then this function
# will be called as:
Foo.bar(:a, :b)
# If the callback is passing in 2 inputs ("hello", "world"), then this
# function will be called as:
Foo.bar(:a, :b)

Link to this section Functions

Link to this function call(fun, inputs \\ [], input_requirement \\ :required) 
call(callback(), list(), :required | :optional) :: any()

Call the provided callback with the given inputs.

The inputs to the callback are required by default but can otherwise be made optional by passing :optional as the input_requirement.

Link to this macro is_callback(callback) (macro)

Returns true if term is a callback; otherwise returns false.

Allowed in guard tests.