Elixir

v1.3.4

Elixir

Elixir v1.3.4 Protocol View Source

Functions for working with protocols.

Link to this section Summary

Functions

assert_impl!(protocol, base)

Checks if the given module is loaded and is an implementation of the given protocol

assert_protocol!(module)

Checks if the given module is loaded and is protocol

consolidate(protocol, types)

Receives a protocol and a list of implementations and consolidates the given protocol

consolidated?(protocol)

Returns true if the protocol was consolidated

def(signature)

Defines a new protocol function

derive(protocol, module, options \\ [])

Derives the protocol for module with the given options

extract_impls(protocol, paths)

Extracts all types implemented for the given protocol from the given paths

extract_protocols(paths)

Extracts all protocols from the given paths

Link to this section Functions

Link to this function assert_impl!(protocol, base) View Source 
assert_impl!(module, module) :: :ok | no_return

Checks if the given module is loaded and is an implementation of the given protocol.

Returns :ok if so, otherwise raises ArgumentError.

Link to this function assert_protocol!(module) View Source 
assert_protocol!(module) :: :ok | no_return

Checks if the given module is loaded and is protocol.

Returns :ok if so, otherwise raises ArgumentError.

Link to this function consolidate(protocol, types) View Source 
consolidate(module, [module]) ::
  {:ok, binary} |
  {:error, :not_a_protocol} |
  {:error, :no_beam_info}

Receives a protocol and a list of implementations and consolidates the given protocol.

Consolidation happens by changing the protocol impl_for in the abstract format to have fast lookup rules. Usually the list of implementations to use during consolidation are retrieved with the help of extract_impls/2.

It returns the updated version of the protocol bytecode. A given bytecode or protocol implementation can be checked to be consolidated or not by analyzing the protocol attribute:

Protocol.consolidated?(Enumerable)

If the first element of the tuple is true, it means the protocol was consolidated.

This function does not load the protocol at any point nor loads the new bytecode for the compiled module. However each implementation must be available and it will be loaded.

Link to this function consolidated?(protocol) View Source 
consolidated?(module) :: boolean

Returns true if the protocol was consolidated.

Link to this macro def(signature) View Source (macro)

Defines a new protocol function.

Protocols do not allow functions to be defined directly, instead, the regular Kernel.def/* macros are replaced by this macro which defines the protocol functions with the appropriate callbacks.

Link to this macro derive(protocol, module, options \\ []) View Source (macro)

Derives the protocol for module with the given options.

Link to this function extract_impls(protocol, paths) View Source 
extract_impls(module, [charlist | String.t]) :: [atom]

Extracts all types implemented for the given protocol from the given paths.

The paths can be either a charlist or a string. Internally they are worked on as charlists, so passing them as lists avoid extra conversion.

Does not load any of the implementations.

Examples 

# Get Elixir's ebin and retrieve all protocols
iex> path = :code.lib_dir(:elixir, :ebin)
iex> mods = Protocol.extract_impls(Enumerable, [path])
iex> List in mods
true
Link to this function extract_protocols(paths) View Source 
extract_protocols([charlist | String.t]) :: [atom]

Extracts all protocols from the given paths.

The paths can be either a charlist or a string. Internally they are worked on as charlists, so passing them as lists avoid extra conversion.

Does not load any of the protocols.

Examples 

# Get Elixir's ebin and retrieve all protocols
iex> path = :code.lib_dir(:elixir, :ebin)
iex> mods = Protocol.extract_protocols([path])
iex> Enumerable in mods
true