std.algorithm

This package implements generic algorithms oriented towards the processing of sequences. Sequences processed by these functions define range-based interfaces. See also Reference on ranges and tutorial on ranges.

Algorithms are categorized into the following submodules:

Many functions in this package are parameterized with a predicate. The predicate may be any suitable callable type (a function, a delegate, a functor, or a lambda), or a compile-time string. The string may consist of any legal D expression that uses the symbol a (for unary functions) or the symbols a and b (for binary functions). These names will NOT interfere with other homonym symbols in user code because they are evaluated in a different context. The default for all binary comparison predicates is "a == b" for unordered operations and "a < b" for ordered operations.

Modules

comparison
module std.algorithm.comparison

This module contains generic comparison algorithms.

internal
module std.algorithm.internal

Helper functions for std.algorithm package.

iteration
module std.algorithm.iteration

This module contains generic iteration algorithms.

mutation
module std.algorithm.mutation

This module contains generic mutation algorithms.

searching
module std.algorithm.searching

This module contains generic searching algorithms.

setops
module std.algorithm.setops

This module contains generic algorithms that implement set operations.

sorting
module std.algorithm.sorting

This module contains generic sorting algorithms.

Examples

int[] a = ...;
static bool greater(int a, int b)
{
    return a > b;
}
sort!greater(a);           // predicate as alias
sort!((a, b) => a > b)(a); // predicate as a lambda.
sort!"a > b"(a);           // predicate as string
                           // (no ambiguity with array name)
sort(a);                   // no predicate, "a < b" is implicit

Meta

Suggestion Box / Bug Report