Elixir Documentation
Callbacks
Exceptions
Functions
Guides
- Anonymous functions
- Basic types
- Binaries, strings, and charlists
- Changelog for Elixir v1.18
- Client-server communication with GenServer
- Code-related anti-patterns
- Compatibility and deprecations
- Comprehensions
- Configuration and releases
- Debugging
- Dependencies and umbrella projects
- Design-related anti-patterns
- Distributed tasks and tags
- Doctests, patterns, and with
- Domain-Specific Languages (DSLs)
- Enum cheatsheet
- Enumerables and Streams
- Erlang libraries
- Gradual set-theoretic types
- IO and the file system
- Introduction
- Introduction to Mix
- Library guidelines
- Lists and tuples
- Macros
- Meta-programming anti-patterns
- Module attributes
- Modules and functions
- Naming conventions
- Operators reference
- Optional syntax sheet
- Pattern matching
- Patterns and guards
- Process-related anti-patterns
- Processes
- Protocols
- Quote and unquote
- Recursion
- Sigils
- Simple state management with agents
- Speeding up with ETS
- Structs
- Supervising dynamic children
- Supervision trees and applications
- Syntax reference
- Task and gen_tcp
- Typespecs reference
- Unicode syntax
- What are anti-patterns?
- Writing documentation
- alias, require, import, and use
- case, cond, and if
- try, catch, and rescue
Macros
Modules
Protocols
Sections
- (Linked) Lists
- 1. Enhancements
- 2. Bug fixes
- 3. Soft deprecations (no warnings emitted)
- 4. Hard deprecations
- @external_resource
- A brief introduction to xref
- A simple example
- A word on distributed agents
- API
- Aborting the suite
- Accessing and updating structs
- Accumulating
- Acknowledgements
- After
- Agents 101
- Aggregations
- Aliases
- Aliases
- Alternative return types
- Alternatives
- Ancestor and Caller Tracking
- Application configuration
- Application environment
- Arguments
- As a provider
- As annotations
- As compile-time constants
- As temporary storage
- Assembling multiple releases
- Atoms
- Autocomplete
- Automatic code formatting
- Backends and backwards compatibility
- Base 16 alphabet
- Base 32 (extended hex) alphabet
- Base 32 alphabet
- Base 64 (URL and filename safe) alphabet
- Base 64 alphabet
- Basic arithmetic
- Behaviours
- Between Elixir and Erlang/OTP
- Between non-major Elixir versions
- Binaries
- Bitstring generators
- Bitstrings
- Boolean obsession
- Booleans and nil
- Breakpoints
- Building our own test case
- Built-in protocols
- CLI configuration
- Calendar sigils
- Call syntax
- Captures
- Case, Callbacks and Assertions
- Casing
- Caveats
- Caveats
- Caveats
- Caveats
- Character classes
- Charlists
- Charlists
- Child specification
- Chunking
- Clauses and guards
- Client / Server APIs
- Client/server in agents
- Closures
- Code loading on the Erlang VM
- Code organization by process
- Code.fetch_docs/1
- Coloring
- Colors
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command line options
- Command-line options
- Command-line options
- Comments overuse
- Comparing dates
- Comparing naive date times
- Comparing times
- Comparison operators
- Compilation
- Compilation tracers
- Compile binary patterns
- Compile callbacks
- Compile options
- Compile-time dependencies
- Compile-time environment
- Compilers
- Complex else clauses in with
- Complex extractions in clauses
- Concatenating & flattening
- Configuration
- Configuration
- Configuration
- Configuration
- Configuration
- Configuration
- Configuration
- Configuration
- Configuration
- Configuration
- Configuration
- Configuration
- Configuration
- Configuration
- Configuration
- Configuration
- Configuring releases
- Configuring the shell
- Consolidation
- Consolidation
- Context
- Context
- Conversion
- Converting between timezones
- Coverage
- Creating Streams
- Custom and overridden operators
- Custom config provider
- Custom implementation
- Custom patterns and guards expressions
- Custom sigils
- Customization
- Data types
- Datetimes as snapshots
- Debugging with the :sys module
- Decoding
- Default arguments
- Default values and required keys
- Defining a specification
- Defining anonymous functions
- Defining structs
- Definition
- Dependencies
- Dependencies within an umbrella project
- Dependency handling
- Deployments
- Deprecations
- Deps task
- Deriving
- Directory structure
- Distributed tasks
- Doctests
- Doctests
- Documentation
- Documentation != Code comments
- Documentation metadata
- Don't drink the kool aid
- Duplicate keys and ordering
- Duplicates & uniques
- Dynamic atom creation
- DynamicSupervisor Example
- Dynamically supervised tasks
- ETS
- ETS as a cache
- Eager vs Lazy
- Echo server
- Else
- Encoding
- Encoding
- Encoding and coloring
- Engine
- Enumerables
- Environment variables
- Environment variables
- Environments
- Environments
- Erlang Term Storage
- Erlang projects
- Erlang/OTP handlers
- Errors
- Escape characters
- Escapes
- Escaping
- ExUnit improvements
- Example
- Example
- Example
- Example
- Example
- Example
- Example
- Example
- Example
- Examples
- Examples
- Examples
- Examples
- Examples
- Examples
- Examples
- Examples
- Examples
- Examples
- Examples
- Examples
- Examples
- Examples
- Examples
- Examples
- Examples
- Examples
- Exceptions
- Exceptions for control-flow
- Exit reasons and restarts
- Exiting the shell
- Exits
- Exploring
- Exporting coverage
- Expressions
- Expressions in IEx
- External dependencies
- Fallback to Any
- Fields
- File-system watchers
- Filtering
- Filters
- Filters
- Finding
- Formatted text output
- Formatting
- Formatting functions
- Formatting options
- Function arguments
- Function definition
- Functions which raise an error
- Further information
- GenServer callbacks
- General operators
- Generated functions
- Generators and filters
- Getting started
- Going further
- Grapheme clusters
- Grouping
- Guards
- Guards
- Guards
- Helpers
- Hiding internal modules and functions
- Hot Code Upgrades
- Hot code swapping
- How to supervise
- How to supervise
- IO data
- IO devices
- IO.inspect/2
- ISO 8601 compliance
- Identifying functions and documentation
- Implementation details
- Implementation notes
- Implementing Any
- Importing dependencies configuration
- Indexing
- Inlining
- Inspect representation
- Installation
- Integration with Mix
- Interactive mode
- Internal and external functions
- Internal dependencies
- Interpolation
- Interpolation and escaping in string sigils
- Intervals
- Introduction
- Invoking this module
- JSON support
- Joining & interspersing
- Kernel functions
- Known issues
- Language server listeners
- Large code generation
- Learn more
- Learning Erlang
- Levels
- Line coverage
- Links
- Listening to compilation
- Lists or tuples?
- Log Capture
- Long parameter list
- Loops through recursion
- Macro hygiene
- Mapping
- Maps and structs
- Markdown
- Message
- Message and function APIs
- Metadata
- Migrating from Supervisor's :simple_one_for_one
- Migrating from use Mix.Config
- Mirrors
- Mirrors
- Mix.Project
- Mix.Task
- Modifiers
- Module Attributes
- Module attributes
- Module attributes
- Module nesting
- Module-based supervisors
- Module-based supervisors
- Monitors or links?
- Multi alias/import/require/use
- Multiple config files
- Multiple implementations
- Name registration
- Name registration
- Name registration
- Name registration
- Namespace trespassing
- Naming processes
- Next steps
- Non-assertive map access
- Non-assertive pattern matching
- Non-assertive truthiness
- Observer
- Observer
- Opaque types
- Open mechanisms
- Operating system process partitioning
- Operator precedence and associativity
- Options
- Options
- Other agent actions
- Other options
- Other tools and community
- Our first distributed code
- Our first macro
- Our first project
- Our first supervisor
- Parameterized tests
- Pasting multiline expressions into IEx
- Pattern matching
- Patterns
- Phases
- Pitfalls
- Plugins
- Potential incompatibilities
- Precompilation
- Predicates
- Primitive obsession
- Private macros
- Processes
- Processes and raw files
- Profile output
- Profile output
- Profile output
- Profile output
- Project compilation
- Projects or applications?
- Protocols and Structs
- Protocols and structs
- Pry
- Publishing
- Quoting
- Race conditions?
- Random
- Receiving "regular" messages
- Recommendations
- Reduce and map algorithms
- Reflection
- Registrations
- Regular expressions
- Releases
- Remote shells
- Representation
- Requirements
- Reserved words
- Reversing
- Roadmap
- Routing layer
- Running commands
- Running scripts
- Running tests
- Running the release
- SSL certificates
- Scalability and partitioning
- Scalability and partitioning
- Scattered process interfaces
- Scripting mode
- Seeking within a file
- Self-synchronization
- Sending and receiving messages
- Sending unnecessary data
- Set operations
- Shared options
- Shared state in tests
- Shell history
- Shifting
- Shutting down
- Side-effects
- Simple Example
- Size or length?
- Slicing
- Sorting
- Spawning processes
- Special names
- Splitting
- Splitting (drop and take)
- Start and shutdown
- State
- Statically supervised tasks
- Storing information with attributes
- Streams
- String and binary operations
- Strings
- Strings, charlists, and word lists sigils
- Struct fields
- Structs are bare maps underneath
- Structs with 32 fields or more
- Structural comparison
- Structural comparison
- Summing up
- Summing up
- Summing up
- Summing up
- Supervision trees
- Supervisor and worker options
- Supervisor strategies and options
- Supported types
- Syntax
- Tags
- Tags
- Targets
- Task supervisor
- Task-specific options
- Tasks
- Tasks
- Tasks are processes
- Test filters and tags
- Test setup with ExUnit callbacks
- Testing a GenServer
- The --stale option
- The .iex.exs file
- The :into option
- The BREAK menu
- The Client API
- The Elixir AST
- The File module
- The IO module
- The Path module
- The User switch command
- The application callback
- The application callback module
- The application environment
- The application life cycle
- The application resource file
- The binary module
- The bucket supervisor
- The capture operator
- The capture operator
- The crypto module
- The digraph module
- The dynamic() type
- The environment
- The match operator
- The math module
- The need for monitoring
- The pin operator
- The pipe operator
- The queue module
- The rand module
- The standard library
- The string() type
- The test macro
- The trouble with (mutable) state
- The zip and zlib modules
- Throws
- Time
- Time zone database
- Timeouts
- Tmp Dir
- Tooling
- Trailing bang (foo!)
- Trailing question mark (foo?)
- Truthy and falsy values
- Tuples
- Type inference
- Type system improvements
- Types
- Types
- Types and their syntax
- UTF-8 and Encodings
- UTF-8 encoded and encodings
- Umbrella projects
- Umbrellas
- Underscore (_foo)
- Understanding Aliases
- Understanding applications
- Understanding test results
- Unicode Annex #31
- Unicode Technical Standard #39
- Unicode and Code Points
- Unicode and code points
- Unnecessary macros
- Unquoting
- Unrelated multi-clause function
- Unsupervised processes
- Updating nested data structures
- Use cases
- Using application configuration for libraries
- Using as a PubSub
- Using as a dispatcher
- Using epochs
- Using epochs
- Using in :via
- Variables scope
- Versions
- Walk-through
- When (not) to use a GenServer
- When not to use doctest
- When to format code
- Where patterns and guards can be used
- Why Collectable?
- Why releases?
- Why releases?
- Wiring it all up
- Working with files
- Wrapping up
- Write macros responsibly
- Zipping
- Zombie operating system processes
- Zombie operating system processes
- __mix_recompile__?/0
- alias
- all?(enum, fun)
- any?(enum, fun)
- async and await
- async/await
- at(enum, index, default \\ nil)
- call, cast or info?
- case
- child_spec/1 function
- chunk_by(enum, fun)
- chunk_every(enum, count)
- chunk_every(enum, count, step, leftover \\ [])
- compare
- concat(enums)
- concat(left, right)
- cond
- config/runtime.exs
- count(enum)
- count(enum, fun)
- dbg and breakpoints
- dbg/2
- dedup(enum)
- dedup_by(enum, fun)
- do-end blocks
- drop(enum, amount)
- drop_every(enum, nth)
- drop_while(enum, fun)
- each(enum, fun)
- empty?(enum)
- ensure_compiled/1 and ensure_compiled!/1
- fetch!(enum, index)
- fetch(enum, index)
- filter(enum, fun)
- find(enum, default \\ nil, fun)
- find_index(enum, fun)
- find_value(enum, default \\ nil, fun)
- flat_map(enum, fun)
- flat_map_reduce(enum, acc, fun)
- frequencies(enum)
- frequencies_by(enum, key_fun)
- get, fetch, fetch!
- group_by(enum, key_fun)
- group_by(enum, key_fun, value_fun)
- if
- import
- intersperse(enum, separator \\ "")
- into(enum, collectable)
- into(enum, collectable, transform)
- iodata and chardata
- is_ prefix (is_foo)
- join(enum, joiner \\ "")
- length and size
- map(enum, fun)
- map_every(enum, nth, fun)
- map_intersperse(enum, separator \\ "", mapper)
- map_join(enum, joiner \\ "", mapper)
- map_reduce(enum, acc, fun)
- max(enum)
- max_by(enum, mapper)
- member?(enum, value)
- min(enum)
- min_by(enum, mapper)
- mix deps.unlock + mix deps.get
- mix format --migrate
- mix xref graph
- mix xref trace FILE
- product(enum)
- product_by(enum, mapper)
- random(enum)
- reduce(enum, acc, fun)
- reduce_while(enum, acc, fun)
- reject(enum, fun)
- require
- reverse(enum)
- reverse(enum, tail)
- reverse_slice(enum, start_index, count)
- scan(enum, acc, fun)
- shuffle(enum)
- slice(enum, index_range)
- slice(enum, start_index, amount)
- slide(enum, range_or_single_index, insertion_index)
- sort(enum, sorter \\ :asc)
- sort_by(enum, mapper, sorter \\ :asc)
- split(enum, amount)
- split_while(enum, fun)
- split_with(enum, fun)
- sum(enum)
- sum_by(enum, mapper)
- take(enum, amount)
- take_every(enum, nth)
- take_random(enum, count)
- take_while(enum, fun)
- to_list(enum)
- uniq(enum)
- uniq_by(enum, fun)
- unzip(list)
- use
- use instead of import
- v1.17
- v1.18.0 (2024-12-19)
- v1.18.1 (2024-12-24)
- v1.18.2 (2025-01-22)
- v1.18.3 (2025-03-06)
- with
- with_index(enum)
- with_index(enum, fun)
- zip(enum1, enum2)
- zip_reduce(left, right, acc, fun)
- zip_with(enum1, enum2, fun)
Structs
Types