Group

Groups consecutively equivalent elements into a single tuple of the element and the number of its repetitions.

Similarly to uniq, group produces a range that iterates over unique consecutive elements of the given range. Each element of this range is a tuple of the element and the number of times it is repeated in the original range. Equivalence of elements is assessed by using the predicate pred, which defaults to "a == b". The predicate is passed to std.functional.binaryFun, and can either accept a string, or any callable that can be executed via pred(element, element).

struct Group (

alias pred

) if (

isInputRange!R

) {

struct Rebindable(T) via import std.typecons : Rebindable, tuple, Tuple;;

template tuple(Names...) via import std.typecons : Rebindable, tuple, Tuple;;

template Tuple(Specs...) via import std.typecons : Rebindable, tuple, Tuple;;

this(R input);

void popFront();

static if(isInfinite!R)

enum bool empty;

static if(!(isInfinite!R))

bool empty [@property getter];

auto ref front [@property getter];

static if(isForwardRange!R)

typeof(this) save [@property getter];

}

Constructors

this this(R input)

Members

Functions

popFront void popFront()

Properties

empty bool empty [@property getter]
front auto ref front [@property getter]
save typeof(this) save [@property getter]

Variables

empty enum bool empty;

Parameters

pred: Binary predicate for determining equivalence of two elements.
R: The range type

Return Value

A range of elements of type Tuple!(ElementType!R, uint), representing each consecutively unique element and its respective number of occurrences in that run. This will be an input range if R is an input range, and a forward range in all other cases.

Examples

import std.algorithm.comparison : equal;
import std.typecons : tuple, Tuple;

int[] arr = [ 1, 2, 2, 2, 2, 3, 4, 4, 4, 5 ];
assert(equal(group(arr), [ tuple(1, 1u), tuple(2, 4u), tuple(3, 1u),
    tuple(4, 3u), tuple(5, 1u) ][]));

Using group, an associative array can be easily generated with the count of each unique element in the range.

import std.algorithm.sorting : sort;
import std.array : assocArray;

uint[string] result;
auto range = ["a", "b", "a", "c", "b", "c", "c", "d", "e"];
result = range.sort!((a, b) => a < b)
    .group
    .assocArray;

assert(result == ["a": 2U, "b": 2U, "c": 3U, "d": 1U, "e": 1U]);