among

Find value among values, returning the 1-based index of the first matching value in values, or 0 if value is not among values. The predicate pred is used to compare values, and uses equality by default.

  1. uint among(Value value, Values values)
    uint
    among
    (
    alias pred =
    (
    a
    ,
    b
    )
    => a == b
    Value
    Values...
    )
    (
    Value value
    ,
    Values values
    )
    if (
    Values.length != 0
    )
  2. template among(values...)

Parameters

pred

The predicate used to compare the values.

value Value

The value to search for.

values Values

The values to compare the value to.

Return Value

Type: uint

0 if value was not found among the values, otherwise the index of the found value plus one is returned.

Examples

assert(3.among(1, 42, 24, 3, 2));

if (auto pos = "bar".among("foo", "bar", "baz"))
    assert(pos == 2);
else
    assert(false);

// 42 is larger than 24
assert(42.among!((lhs, rhs) => lhs > rhs)(43, 24, 100) == 2);

Alternatively, values can be passed at compile-time, allowing for a more efficient search, but one that only supports matching on equality:

assert(3.among!(2, 3, 4));
assert("bar".among!("foo", "bar", "baz") == 2);

See Also

find and canFind for finding a value in a range.

Meta