View Source API Reference funx v0.1.0

A protocol for combining values in a generic, extensible way.

Internal access to :funx application configuration.

The Funx.Eq protocol defines an equality function, eq?/2, for comparing two values, and its complement, not_eq?/2, for checking inequality.

Utility functions for working with the Funx.Eq protocol. These functions assume that types passed in either support Elixir's equality operator or implement the Funx.Eq protocol.

Represents a system-level failure in an effectful computation.

Represents a validation error in the Funx library.

The Funx.Filterable protocol defines functions for conditionally retaining or discarding values within a context. It generalizes the concepts of filter, filter_map, and guard across different data structures like Maybe, List, and others.

The Funx.Foldable protocol defines two core folding operations: fold_l/3 (fold left) and fold_r/3 (fold right).

The Funx.List module provides utility functions for working with lists while respecting Eq and Ord instances. This allows for set-like operations, uniqueness constraints, and sorted collections that align with functional programming principles.

Provides macros for automatically implementing Funx.Eq and Funx.Ord protocols for a given struct based on a specified field.

Provides mathematical operations using Monoids.

The Funx.Monad protocol defines the core monadic operations: ap/2, bind/2, and map/2.

The Funx.Monad.Effect module defines the Effect monad, which represents asynchronous computations that may succeed (Right) or fail (Left). Execution is deferred until explicitly run, making Effect useful for structuring lazy, asynchronous workflows.

Represents the execution context attached to an effect.

Represents the Left variant of the Effect monad, used to model a failure or error in an asynchronous context.

Represents the Right variant of the Effect monad, used to model a successful computation in an asynchronous context.

The Funx.Monad.Either module provides an implementation of the Either monad, a functional abstraction used to model computations that may fail.

Represents the Left variant of the Either monad, used to model an error or failure.

Represents the Right variant of the Either monad, used to model a success or valid result.

The Funx.Monad.Identity module represents the identity monad, where values are simply wrapped in a structure and operations are applied directly to those values.

The Funx.Monad.Maybe module provides an implementation of the Maybe monad, a functional abstraction used to represent optional values in Elixir.

Represents the Just variant of the Maybe monad, used to model the presence of a value.

Represents the Nothing variant of the Maybe monad, used to model the absence of a value.

The Funx.Monad.Reader module represents the Reader monad, which allows computations to access shared, read-only environment values.

A protocol defining the Monoid algebraic structure, which consists of an identity element and an associative binary operation for combining values.

A Monoid implementation for equality checks for All.

A Monoid implementation for equality checks for Any.

A Monoid implementation for concatenating lists.

A Monoid implementation for maximum values.

A Monoid implementation for minimum values.

A monoid implementation for ordering logic (Ord). Provides default comparison functions and supports combining multiple Ord comparators into a single composite comparator.

A Monoid implementation for combining predicates using logical AND.

A Monoid implementation for combining predicates using logical OR.

A Monoid implementation for products.

A Monoid implementation for sums.

Utility functions for working with Monoids.

The Funx.Ord protocol defines a set of comparison functions: lt?/2, le?/2, gt?/2, and ge?/2.

Utility functions for working with the Funx.Ord protocol. These functions assume that types passed in either support Elixir's comparison operators or implement the Funx.Ord protocol.

Provides utility functions for working with predicates—functions that return true or false.

A collection of higher-order functions for functional programming in Elixir.