Elixir v0.12.4

Default callbacks for applications

Utilities for defining behaviour intefaces

This module provide macros and operators for bitwise operators. These macros can be used in guards

Utilities for managing code compilation, code evaluation and code loading

This module specifies the Dict API expected to be implemented by different dictionaries. It also provides functions that redirect to the underlying Dict, allowing a developer to work with different Dict implementations using one API

Default implementations for some required functions in the Dict module

EEx stands for Embedded Elixir. It allows you to embed Elixir code inside a string in a robust way:

An abstract engine that, when used with the TransformerEngine, allows a developer to access assigns using @ as syntax

This is the basic EEx engine that ships with Elixir. An engine needs to implement two functions:

An engine meant for end-user usage that includes EEx.AssignsEngine and other conveniences. Read EEx.AssignsEngine for examples

An abstract engine that is meant to be used and built upon in other modules. This engine implements the EEx.Engine behaviour and provides a transform overridable directive that allows a developer to customize the expression returned by the engine

Provides a set of algorithms that enumerate over collections according to the Enumerable protocol:

Basic unit testing framework for Elixir

This module contains a set of assertion functions that are imported by default into your test cases

Defines ExUnit Callbacks

Functionality to capture IO for testing

Sets up an ExUnit test case

This module allows a developer to define a test case template to be used throughout his tests. This is useful when there are a set of functions that should be shared between tests or a set of setup/teardown callbacks

ExUnit.DocTest implements functionality similar to Python's doctest

Conveniences for parsing and evaluating filters

This module simply defines the callbacks expected by an ExUnit.Formatter

Convenience functions to work with and pretty print exceptions and stacktraces

This module contains functions to manipulate files

Functions for working with floating point numbers

This module is a convenience for defining GenEvent callbacks in Elixir

This module is a convenience for defining GenFSM callbacks in Elixir

This module is a convenience for defining GenServer callbacks in Elixir

A key-value store

A set store

Welcome to IEx

Welcome to Interactive Elixir. You are currently seeing the documentation for the module IEx.Helpers which provides many helpers to make Elixir's shell more joyful to work with

Provides an interface for adjusting options of the running IEx session

Functions handling IO

Functionality to render ANSI escape sequences (http:\en.wikipedia.org/wiki/ANSIescapecode) — characters embedded in text used to control formatting, color, and other output options on video text terminals

A set of functions for creating and manipulating algebra documents, as described in ["Strictly Pretty" (2000) by Christian Lindig][0]

Functions for working with integers

Kernel provides the default macros and functions Elixir imports into your environment. These macros and functions can be skipped or cherry-picked via the import macro. For instance, if you want to tell Elixir not to import the if macro, you can do:

A module responsible for compiling files in parallel

A module responsible for requiring files in parallel

In this module we define Elixir special forms. Special forms cannot be overridden by the developer and are the basic building blocks of Elixir code

Provides macros and functions for working with typespecs

A keyword is a list of tuples where the first element of the tuple is an atom and the second element can be any value

Implements functions that only make sense for lists and cannot be part of the Enum protocol. In general, favor using the Enum API instead of List

A Dict implementation that works on lists of two-items tuples

Conveniences for working with macros

Mix is a build tool that provides tasks for creating, compiling, testing (and soon deploying) Elixir projects. Mix is inspired by the Leiningen build tool for Clojure and was written by one of its contributors

Module responsible for managing archives

Common functions to work with dependencies

Conveniences for working with paths and generating content

A module that provides conveniences for defining and working with projects

This module provides helper functions and defines the behaviour required by any SCM used by mix

Defines Mix.Shell contract

This is Mix's default shell. It simply prints messages to stdio and stderr

This is a Mix shell that uses the current process mailbox for communication instead of IO

A simple module that provides conveniences for creating, loading and manipulating tasks

Starts all registered apps. If no apps key exists, it starts the current application

Packages the current project (though not its dependencies) into a zip file according to the specification of the Erlang Archive Format

Clean generated application files

Executes the given command

A meta task that compiles source files. It simply runs the compilers registered in your project. At the end of compilation it ensures load paths are set

Writes an .app file

Compiles Elixir source files

Compile Erlang source files

Compile Leex source files

Compile Yecc source files

List all dependencies and their status. The output is given as follows:

Checks if all dependencies are valid and if not, abort. Prints the invalid dependencies' status before aborting

Remove the given dependencies' files

Compile dependencies

Get all out of date dependencies, i.e. dependencies that are not available or have an invalid lock

Loads all dependencies for the current build. This is invoked directly by loadpaths when the CLI boots

Unlock the given dependencies

Update the given dependencies

Executes the tasks separated by comma

Generates an escript for the project

If given a task name, prints the documentation for that task. If no task name is given, prints the short form documentation for all tasks

Load the application and its dependencies paths

List local tasks

Install an archive locally

Fetch a copy of rebar from the given path or url. It defaults to a rebar copy that ships with Elixir source if available or fetches it from https://github.com/elixir-lang/elixir/raw/3cf4c21ad1f4627585b80394c37ac9f4d39d3aa8/rebar. The local copy is stored in your MIX_HOME (defaults to ~/.mix)

Uninstall local tasks:

Creates a new Elixir project. It expects the path of the project as argument

Runs the given file or expression in the context of the application

Run the tests for a project

Utilities used throughout Mix and tasks

This module provides many functions to deal with modules during compilation time. It allows a developer to dynamically attach documentation, add, delete and register attributes and so forth

Functions related to VM nodes

This module contains functions to parse command line arguments

This module provides conveniences for manipulating or retrieving file system paths

Functions related to Erlang ports

Conveniences for working with processes and the process dictionary

Module responsible for consolidating protocols and helpers for extracting protocols and implementations from code paths for consolidation

Defines a Range

Functions for working with Records

Regular expressions for Elixir built on top of the re module in the Erlang Standard Library. More information can be found in the re documentation

This module specifies the Set API expected to be implemented by different representations

Module for creating and composing streams

A String in Elixir is a UTF-8 encoded binary

This module is a convenience to define Supervisor callbacks in Elixir. By using this module, you get the module behaviour automatically tagged as :supervisor and some helper functions are imported to make defining supervisors easier

The System module provides access to variables used or maintained by the VM and to functions that interact directly with the VM or the host system

Functions for working with tuples

Utilities for working with and creating URIs

Functions for parsing and matching versions against requirements

A record that keeps information about the test. It is received by formatters and also accessible in the metadata under the key :test

A record that keeps information about the test case. It is received by formatters and also accessible in the metadata under the key :case

A record responsible to hold file information. Its fields are:

A record that holds compile time environment information

This is a record that keeps information about your project dependencies. It contains:

The Access protocol is the underlying protocol invoked when the brackets syntax is used. For instance, foo[bar] is translated to access foo, bar which, by default, invokes the Access.access protocol

Enumerable protocol used by Enum and Stream modules

The Inspect protocol is responsible for converting any Elixir data structure into an algebra document. This document is then formatted, either in pretty printing format or a regular one

The List.Chars protocol is responsible for converting a structure to a list (only if applicable). The only function required to be implemented is to_char_list which does the conversion

The String.Chars protocol is responsible for converting a structure to a Binary (only if applicable). The only function required to be implemented is to_string which does the conversion