std.algorithm.comparison

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

template among(values...) if (isExpressionTuple!values)

探す valueの中で valuesで最初にマッチした値の で最初にマッチする値のインデックスを返す。 values0 を返す。 value の中にない場合は values.述語pred は 述語は値の比較に使われ、デフォルトでは等式を使う。

Parameters:

pred	値の比較に使われる述語。
Value value	検索する値。
Values values	値を比較する値。

Returns:

値が見つからなかった場合は0が返され、そうでない場合は、見つかった値のインデックスに1を足した値が返される。 に1を足した値が返される。

See Also:

findと canFindは、範囲内の値を見つけるためのものである。 である。

Examples:

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

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

// 42は24より大きい
writeln(42.among!((lhs, rhs) => lhs > rhs)(43, 24, 100)); // 2

Examples:

あるいは valuesをコンパイル時に渡すこともできる。 より効率的な検索が可能になるが、等号でのマッチングしかサポートしない:

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

auto castSwitch(choices...)(Object switchObject);

switchオブジェクトの型に基づいたハンドラのコレクションのいずれかを実行し、返す。 スイッチ・オブジェクトのタイプに基づいてハンドラのコレクションのいずれかを実行し、返す。

最初の選択肢は switchObjectの型にキャストできる最初の選択肢が呼び出される。 にキャストされて呼び出される。 switchObjectで呼び出される。 型にキャストされて呼び出され、返される値は castSwitch.

選択肢の戻り値の型がvoidの場合、選択肢は例外を投げなければならない。 ただし、すべての選択肢がvoidの場合を除く。その場合、castSwitch自身はvoidを返す。

Throws:

選択肢のどれにもマッチしない場合、SwitchError がスローされる。SwitchError は、すべての選択肢がvoidではなく、voidの選択肢が何も投げずに実行された場合にもスローされる。 の選択肢が何もスローされずに実行された場合にもスローされる。

Parameters:

choices	choices 、1つの引数を受け取る関数またはデリゲートで構成される必要がある。 ハンドラで構成される必要がある。また はゼロ引数を受け付ける。その選択肢は、 switchObject がNULLの場合に呼び出される。
Object switchObject	テストの対象となるオブジェクト。

Returns:

選択された選択肢の値。

注釈: 選択された選択肢の値。 castSwitchはオブジェクト型でのみ使用できる。

Examples:

import std.algorithm.iteration : map;
import std.format : format;

class A
{
    int a;
    this(int a) {this.a = a;}
    @property int i() { return a; }
}
interface I { }
class B : I { }

Object[] arr = [new A(1), new B(), null];

auto results = arr.map!(castSwitch!(
                            (A a) => "A with a value of %d".format(a.a),
                            (I i) => "derived from I",
                            ()    => "null reference",
                        ))();

// Aは直接処理される:
writeln(results[0]); // "A with a value of 1"(値が1のA)
// Bにはハンドラがない - Iのハンドラによって処理される:
writeln(results[1]); // "derived from I"(Iから派生した)
// nullはnullハンドラによって処理される:
writeln(results[2]); // "null reference"(null参照)

Examples:

ボイドハンドラーと併用する:

import std.exception : assertThrown;

class A { }
class B { }
// voidハンドラーは、次の例外をスローする場合に許可される:
assertThrown!Exception(
    new B().castSwitch!(
        (A a) => 1,
        (B d)    { throw new Exception("B is not allowed!"); }
    )()
);

// すべてのハンドラが voidの場合、voidハンドラも許可される:
new A().castSwitch!(
    (A a) { },
    (B b) { assert(false); },
)();

T1 clamp(T1, T2, T3)(T1 val, T2 lower, T3 upper);

クランプする valを指定された範囲にクランプする。結果は以下のものと同じ型である。 val.

Parameters:

T1 val	クランプする値。
T2 lower	クランプの下限。
T3 upper	クランプの上限。

Returns:

lowerもし valが lower, upperもし valより大きい場合 upperより大きい場合は valである。比較は を使う。 std.functional.lessThanを使用する)。 は、標準的な整数のカベリオンルールを使って戻り値に変換される。 std.functional.greaterThanを使用して)、たとえT1,T2 、 とT3 の符号付きが異なっていても)正しく変換される。

Examples:

writeln(clamp(2, 1, 3)); // 2
writeln(clamp(0, 1, 3)); // 1
writeln(clamp(4, 1, 3)); // 3

writeln(clamp(1, 1, 1)); // 1

writeln(clamp(5, -1, 2u)); // 2

auto x = clamp(42, uint.max, uint.max);
static assert(is(typeof(x) == int));
writeln(x); // -1

auto cmp(R1, R2)(R1 r1, R2 r2)
if (isInputRange!R1 && isInputRange!R2);

int cmp(alias pred, R1, R2)(R1 r1, R2 r2)
if (isInputRange!R1 && isInputRange!R2);

つの入力範囲に対して辞書式比較を行う。 を行う。 繰り返し r1と r2をロックステップで繰り返す、 cmpの各要素を比較する。 e1 の各要素を比較する。 r1の対応する要素e2 と比較する。 r2.もし の各要素を比較する、 cmpは負の値を返す。 もし r1が r2より少ない場合は正の値を返す。 r1 よりも要素が多い場合は正の値を返す。 r2よりも要素数が少ない場合は正の値、0 。 の場合は正の値となる。

範囲が文字列の場合 cmpは適切にUTFデコードを行い を適切に実行し、範囲を1コードポイントずつ比較する。

カスタム述語を指定することもでき、その場合は cmpを実行する。 predを使った辞書的三者比較を行う。それ以外の場合 opCmpを使用して要素が比較される。

Parameters:

pred	比較に使われる述語。述語 が指定されていない場合は、opCmp が暗示する順序が使われる。
R1 r1	最初の範囲。
R2 r2	2番目の範囲。

Returns:

0 範囲が等しい場合。負の値。 r1が r2または の異なる最初の要素が r1の対応する要素より小さい。 r2 pred の対応する要素より小さい。の接頭辞であれば正の値である。 r2の接頭辞であるか r1または最初の の最初の要素が r2の対応する要素より小さい。 r1 pred の対応する要素より小さい。

注釈: 文書の以前のバージョンでは、-1 が唯一の負の値であり、 が唯一の正の値であると誤って記載されていた。 は唯一の負の値であり、1 は唯一の正の値である。 それが正しいかどうかは、比較される型によって異なる。

Examples:

int result;

result = cmp("abc", "abc");
writeln(result); // 0
result = cmp("", "");
writeln(result); // 0
result = cmp("abc", "abcd");
assert(result < 0);
result = cmp("abcd", "abc");
assert(result > 0);
result = cmp("abc"d, "abd");
assert(result < 0);
result = cmp("bbc", "abc"w);
assert(result > 0);
result = cmp("aaa", "aaaa"d);
assert(result < 0);
result = cmp("aaaa", "aaa"d);
assert(result > 0);
result = cmp("aaa", "aaa"d);
writeln(result); // 0
result = cmp("aaa"d, "aaa"d);
writeln(result); // 0
result = cmp(cast(int[])[], cast(int[])[]);
writeln(result); // 0
result = cmp([1, 2, 3], [1, 2, 3]);
writeln(result); // 0
result = cmp([1, 3, 2], [1, 2, 3]);
assert(result > 0);
result = cmp([1, 2, 3], [1L, 2, 3, 4]);
assert(result < 0);
result = cmp([1L, 2, 3], [1, 2]);
assert(result > 0);

Examples:

個々の要素を語(ご)彙(い)の逆順で比較する述語の例

int result;

result = cmp!"a > b"("abc", "abc");
writeln(result); // 0
result = cmp!"a > b"("", "");
writeln(result); // 0
result = cmp!"a > b"("abc", "abcd");
assert(result < 0);
result = cmp!"a > b"("abcd", "abc");
assert(result > 0);
result = cmp!"a > b"("abc"d, "abd");
assert(result > 0);
result = cmp!"a > b"("bbc", "abc"w);
assert(result < 0);
result = cmp!"a > b"("aaa", "aaaa"d);
assert(result < 0);
result = cmp!"a > b"("aaaa", "aaa"d);
assert(result > 0);
result = cmp!"a > b"("aaa", "aaa"d);
writeln(result); // 0
result = cmp("aaa"d, "aaa"d);
writeln(result); // 0
result = cmp!"a > b"(cast(int[])[], cast(int[])[]);
writeln(result); // 0
result = cmp!"a > b"([1, 2, 3], [1, 2, 3]);
writeln(result); // 0
result = cmp!"a > b"([1, 3, 2], [1, 2, 3]);
assert(result < 0);
result = cmp!"a > b"([1, 2, 3], [1L, 2, 3, 4]);
assert(result < 0);
result = cmp!"a > b"([1L, 2, 3], [1, 2]);
assert(result > 0);

template equal(alias pred = "a == b")

によって定義されるように、2つ以上の範囲を等しいかどうか比較する。pred (デフォルトは== )によって定義される。

Examples:

import std.algorithm.comparison : equal;
import std.math.operations : isClose;

int[4] a = [ 1, 2, 4, 3 ];
assert(!equal(a[], a[1..$]));
assert(equal(a[], a[]));
assert(equal!((a, b) => a == b)(a[], a[]));

// 異なるタイプ
double[4] b = [ 1.0, 2, 4, 3];
assert(!equal(a[], b[1..$]));
assert(equal(a[], b[]));

// 前提:2つのベクトルがほぼ等しいことを保証する
double[4] c = [ 1.0000000005, 2, 4, 3];
assert(equal!isClose(b[], c[]));

Examples:

ヒント equalは、それ自体を他の関数の述語として使うことができる。 これは、範囲の要素型がそれ自身である場合に非常に便利である。 である場合に非常に便利である。特に equalはそれ自身の述語となり 範囲の範囲(範囲の...)の比較を可能にする。

import std.algorithm.comparison : equal;
import std.range : iota, chunks;
assert(equal!(equal!equal)(
    [[[0, 1], [2, 3]], [[4, 5], [6, 7]]],
    iota(0, 8).chunks(2).chunks(2)
));

bool equal(Ranges...)(Ranges rs)
if (rs.length > 1 && allSatisfy!(isInputRange, Ranges) && !allSatisfy!(isInfinite, Ranges) && is(typeof(binaryFun!pred(rs[0].front, rs[1].front))) && (rs.length == 2 || is(typeof(equal!pred(rs[1..$])) == bool)));

2つ以上の範囲が等しいかどうかを比較する。範囲は によってすべてが比較可能である限り、異なる要素型を持つことができる。 pred によって比較可能であればよい。 pred のΟ(min(rs[0].length, rs[1].length, ...)) 評価を行う。 equalがデフォルトの述語で呼び出された場合、実装は自由に 理論上のワーストケースである Ο(max(rs[0].length, rs[1].length, ...)) を実行する。

範囲の少なくとも1つは有限でなければならない。もし片方の範囲が無限であれば、結果は (静的に既知である)false である。

範囲が異なる種類のUTFコード単位(char 、wchar 、または dchar)を持つ場合、それらはUTFデコードを使用して比較される。 を使用して比較される。

Parameters:

Ranges rs

比較される範囲

Returns:

true すべての範囲がelementと等しい場合にのみ比較される 要素について，二項述語 に従う。pred

enum EditOp: char;

あるシーケンスを別のシーケンスに変換するのに必要な編集操作を符号化する。 エンコードする。シーケンスs (ソース)とt (ターゲット)が与えられたとき のシーケンスは EditOpのシーケンスは、 を に変換するために必要なステップをコード化する。 s tをエンコードする。たとえば、s = "cat" と"cars" の場合、s をt に変換する最小のシーケンスは次のようになる: 2文字をスキップし、't'を'r'に置き換え、's'を挿入する。編集操作 編集操作は、スペルチェッカーなどのアプリケーションで有用である。 (スペルミスのある単語に最も近い単語を検索する)、近似検索、差分形式のプログラムなどである。 検索、ファイル間の差分を計算するdiffスタイルのプログラム、パッチの効率的なエンコードなどである。 ファイル間の差分を計算するdiffスタイルのプログラム、パッチの効率的なエンコーディング、DNA配列解析、そして剽窃の検出などである。 盗作検出などである。

Examples:

with(EditOp)
{
    // [none, none, none, insert, insert, insert]
    writeln(levenshteinDistanceAndPath("foo", "foobar")[1]);
    // [substitute, none, substitute, none, none, remove]
    writeln(levenshteinDistanceAndPath("banana", "fazan")[1]);
}

none

現在の項目は同等であり、編集の必要はない。

substitute

ターゲットの現在の項目をソースの現在の項目で置き換える。

insert

ソースからターゲットに現在の項目を挿入する。

remove

ターゲットから現在の項目を削除する。

size_t levenshteinDistance(alias equals = (a, b) => a == b, Range1, Range2)(Range1 s, Range2 t)
if (isForwardRange!Range1 && isForwardRange!Range2);

size_t levenshteinDistance(alias equals = (a, b) => a == b, Range1, Range2)(auto ref Range1 s, auto ref Range2 t)
if (isConvertibleToString!Range1 || isConvertibleToString!Range2);

の間のレーベンシュタイン距離を返す。 と sと t.レーベンシュタイン距離は を変換するのに必要な編集操作の最小量を計算する。 s を t. Ο(s.length * t.length) 個のequals の評価を行い、Ο(min(s.length, t.length)) 個のストレージを占有する。

Parameters:

equals	2つの範囲の要素を比較するバイナリ述語。
Range1 s	元の範囲。
Range2 t	変換対象

Returns:

sをtに変換するための最小の編集回数。

GCメモリを割り当てない。

Examples:

import std.algorithm.iteration : filter;
import std.uni : toUpper;

writeln(levenshteinDistance("cat", "rat")); // 1
writeln(levenshteinDistance("parks", "spark")); // 2
writeln(levenshteinDistance("abcde", "abcde")); // 0
writeln(levenshteinDistance("abcde", "abCde")); // 1
writeln(levenshteinDistance("kitten", "sitting")); // 3
assert(levenshteinDistance!((a, b) => toUpper(a) == toUpper(b))
    ("parks", "SPARK") == 2);
writeln(levenshteinDistance("parks".filter!"true", "spark".filter!"true")); // 2
writeln(levenshteinDistance("ID", "I♥D")); // 1

Tuple!(size_t, EditOp[]) levenshteinDistanceAndPath(alias equals = (a, b) => a == b, Range1, Range2)(Range1 s, Range2 t)
if (isForwardRange!Range1 && isForwardRange!Range2);

Tuple!(size_t, EditOp[]) levenshteinDistanceAndPath(alias equals = (a, b) => a == b, Range1, Range2)(auto ref Range1 s, auto ref Range2 t)
if (isConvertibleToString!Range1 || isConvertibleToString!Range2);

との間のレーベンシュタイン距離と編集パスを返す。 sと t.

Parameters:

equals	2つの範囲の要素を比較するバイナリ述語。
Range1 s	元の範囲。
Range2 t	変換対象

Returns:

タプルで、最初の要素はsをtに変換するための最小限の編集量である。 2番目の要素は、この変換を行うための一連の編集である。

返されたEditOp[]配列のGCメモリを確保する。

Examples:

string a = "Saturday", b = "Sundays";
auto p = levenshteinDistanceAndPath(a, b);
writeln(p[0]); // 4
assert(equal(p[1], "nrrnsnnni"));

auto max(T...)(T args)
if (T.length >= 2 && !is(CommonType!T == void));

T max(T, U)(T a, U b)
if (is(T == U) && is(typeof(a < b)));

渡された引数を反復処理し、最大値を返す。

Parameters:

T args

最大値を選択する値。少なくとも2つの引数を渡さなければならない。 が渡され、それらは< と比較可能でなければならない。

Returns:

渡された値の最大値である。返される値の型は以下の通りである。 渡された引数のうち、最大の値を格納できる型である。 引数の少なくとも1つがNaNの場合、結果は不特定値となる。 対応方法については std.algorithm.searching.maxElementを参照のこと。 を参照のこと。

See Also:

std.algorithm.searching.maxElement

Examples:

int a = 5;
short b = 6;
double c = 2;
auto d = max(a, b);
assert(is(typeof(d) == int));
writeln(d); // 6
auto e = min(a, b, c);
assert(is(typeof(e) == double));
writeln(e); // 2

auto min(T...)(T args)
if (T.length >= 2 && !is(CommonType!T == void));

T min(T, U)(T a, U b)
if (is(T == U) && is(typeof(a < b)));

渡された引数を反復処理し、最小値を返す。

Parameters:

T args

最小値を選択する値。少なくとも2つの引数を渡さなければならない。 が渡され、それらは< と比較可能でなければならない。

Returns:

渡された値の最小値である。返される値の型は、渡された引数の中で最小の値を格納できる型である。 渡された引数のうち、最小値を格納できる型である。 引数のうち少なくとも1つがNaNの場合、結果は不特定値となる。 対応方法については std.algorithm.searching.minElementを参照のこと。 を参照のこと。

See Also:

std.algorithm.searching.minElement

Examples:

int a = 5;
short b = 6;
double c = 2;
auto d = min(a, b);
static assert(is(typeof(d) == int));
writeln(d); // 5
auto e = min(a, b, c);
static assert(is(typeof(e) == double));
writeln(e); // 2
ulong f = 0xffff_ffff_ffff;
const uint g = min(f, 0xffff_0000);
writeln(g); // 0xffff_0000
dchar h = 100;
uint i = 101;
static assert(is(typeof(min(h, i)) == dchar));
static assert(is(typeof(min(i, h)) == uint));
writeln(min(h, i)); // 100

Examples:

符号が混在する引数では、戻り値の型は最も小さい値を格納できる型となる。 である。

int a = -10;
uint f = 10;
static assert(is(typeof(min(a, f)) == int));
writeln(min(a, f)); // -10

Examples:

<との比較をサポートするユーザー定義型がサポートされている。

import std.datetime;
writeln(min(Date(2012, 12, 21), Date(1982, 1, 4))); // Date(1982, 1, 4)
writeln(min(Date(1982, 1, 4), Date(2012, 12, 21))); // Date(1982, 1, 4)
writeln(min(Date(1982, 1, 4), Date.min)); // Date.min
writeln(min(Date.min, Date(1982, 1, 4))); // Date.min
writeln(min(Date(1982, 1, 4), Date.max)); // Date(1982, 1, 4)
writeln(min(Date.max, Date(1982, 1, 4))); // Date(1982, 1, 4)
writeln(min(Date.min, Date.max)); // Date.min
writeln(min(Date.max, Date.min)); // Date.min

Tuple!Ranges mismatch(alias pred = (a, b) => a == b, Ranges...)(Ranges rs)
if (rs.length >= 2 && allSatisfy!(isInputRange, Ranges));

の要素をロックステップで順次比較する。 rsの要素をロックステップで順次比較する。 最初の不一致で停止する(pred によれば、デフォルトでは 等しい)。で始まる範囲を縮小したタプルを返す。 2つの不一致値で始まる縮小された範囲のタプルを返す。Ο(min(r[0].length, r[1].length, ...)) を実行する。 predの評価を行う。

Examples:

int[6] x = [ 1,   5, 2, 7,   4, 3 ];
double[6] y = [ 1.0, 5, 2, 7.3, 4, 8 ];
auto m = mismatch(x[], y[]);
writeln(m[0]); // x[3 .. $]
writeln(m[1]); // y[3 .. $]

auto m2 = mismatch(x[], y[], x[], y[]);
writeln(m2[0]); // x[3 .. $]
writeln(m2[1]); // y[3 .. $]
writeln(m2[2]); // x[3 .. $]
writeln(m2[3]); // y[3 .. $]

auto predSwitch(alias pred = "a == b", T, R...)(T switchExpression, lazy R choices);

switch式の値に基づいて、式のコレクションのいずれかを返す。 式を返す。

choicesは、test式とreturn式のペアで構成する必要がある。 式のペアで構成される必要がある。各テスト式は、以下のように比較される。 switchExpressionと比較される。 pred(switchExpressionが第1引数)と比較され、それが真であれば が返される。

test式とreturn式の両方が遅延評価される。

Parameters:

T switchExpression	述語の最初の引数。
R choices	テスト式とリターン式のペア。テスト 式は述語の第2引数となり、return式は とテスト式を引数として述語が真を返す場合に返される。 式は、switchExpression とテスト式を引数として、述語が真を返す場合に返される。 また デフォルトのreturn式も持つことができる。 式を含まない最後の式でなければならない。返り式はvoid型であってもよい。 常にスローする。

Returns:

述語をtrueにした最初のテスト式に関連する戻り値式、またはテスト式がない場合はデフォルトの戻り値式である。 述語を真にした最初のテスト式に関連づけられた戻り値式、 または、テスト式がマッチしなかった場合のデフォルトの戻り値式である。 を返す。

Throws:

デフォルトの戻り値式がなく、述語がどのテスト式でも真を返さない場合、 がスローされる。 SwitchError 述語がどのテスト式でも真を返さない場合 -SwitchError がスローされる。 もスローされる。

Examples:

string res = 2.predSwitch!"a < b"(
    1, "less than 1",
    5, "less than 5",
    10, "less than 10",
    "greater or equal to 10");

writeln(res); // "less than 5"(5未満)

//引数が遅延しているため、predSwitchを使用して
//再帰関数を作成できる:
int factorial(int n)
{
    return n.predSwitch!"a <= b"(
        -1, {throw new Exception("Can not calculate n! for n < 0");}(),
        0, 1, // 0! = 1
        n * factorial(n - 1) // n! = n * (n - 1)! for n >= 0
        );
}
writeln(factorial(3)); // 6

//常にスローする場合は、空の戻り値式が許可される:
import std.exception : assertThrown;
assertThrown!Exception(factorial(-9));

bool isSameLength(Ranges...)(Ranges rs)
if (allSatisfy!(isInputRange, Ranges));

2つ以上の範囲の要素数が同じかどうかをチェックする。この関数は以下のように最適化されている。 この関数は、常にどちらかの範囲のlength メンバを利用するように最適化されている。 のメンバを常に利用するように最適化されている。

すべての範囲にlength メンバがあるか、少なくとも1つが無限である、 _isSameLengthの複雑度はΟ(1) である。そうでなければ、複雑度は Ο(n) である。ここでn は、長さが未知の範囲の長さのうち最小のものである。 である。

無限の範囲は同じ長さとみなされる。無限範囲が有限範囲と同じ長さを持つことはない。 有限の範囲と同じ長さを持つことはない。

Parameters:

Ranges rs

2つ以上の入力レンジ

Returns:

true が同じ長さであれば、 。false

Examples:

assert(isSameLength([1, 2, 3], [4, 5, 6]));
assert(isSameLength([1, 2, 3], [4, 5, 6], [7, 8, 9]));
assert(isSameLength([0.3, 90.4, 23.7, 119.2], [42.6, 23.6, 95.5, 6.3]));
assert(isSameLength("abc", "xyz"));
assert(isSameLength("abc", "xyz", [1, 2, 3]));

int[] a;
int[] b;
assert(isSameLength(a, b));
assert(isSameLength(a, b, a, a, b, b, b));

assert(!isSameLength([1, 2, 3], [4, 5]));
assert(!isSameLength([1, 2, 3], [4, 5, 6], [7, 8]));
assert(!isSameLength([0.3, 90.4, 23.7], [42.6, 23.6, 95.5, 6.3]));
assert(!isSameLength("abcd", "xyz"));
assert(!isSameLength("abcd", "xyz", "123"));
assert(!isSameLength("abcd", "xyz", "1234"));

bool isPermutation(Flag!"allocateGC" allocateGC, Range1, Range2)(Range1 r1, Range2 r2)
if (allocateGC == Yes.allocateGC && isForwardRange!Range1 && isForwardRange!Range2 && !isInfinite!Range1 && !isInfinite!Range2);

bool isPermutation(alias pred = "a == b", Range1, Range2)(Range1 r1, Range2 r2)
if (is(typeof(binaryFun!pred)) && isForwardRange!Range1 && isForwardRange!Range2 && !isInfinite!Range1 && !isInfinite!Range2);

両方の範囲が互いに順列であるかどうかをチェックする。

この関数は、Yes.allocateGC フラグが渡された場合に割り当てることができる。これは これは、Yes.allocateGC オプションよりも複雑であるという利点がある。しかし このオプションは、各要素の 要素のtoHash メソッドで決定できる範囲にのみ有効である。カスタマイズされた等式が必要な場合はpred テンプレート化された関数 "を渡すことができ、関数は自動的に非配置アルゴリズムに切り替わる。 に自動的に切り替わる。この関数は自動的に非割り当てアルゴリズムに切り替わる。 std.functional.binaryFunを参照のこと。 predを参照されたい。

非割り当て前方範囲オプション:Ο(n^2) 非割当フォワード・レンジ・オプションとカスタムpred:Ο(n^2) 順方向範囲指定オプション:償却済みΟ(r1.length) +Ο(r2.length)

Parameters:

pred	等号の定義方法を変更するオプションのパラメータ
allocateGC	Yes.allocateGC/No.allocateGC
Range1 r1	有限の前方範囲
Range2 r2	有限の前方範囲

Returns:

true のすべての要素が r1に同じ回数だけ現れる。 r2. それ以外の場合は、false を返す。

Examples:

import std.typecons : Yes;

assert(isPermutation([1, 2, 3], [3, 2, 1]));
assert(isPermutation([1.1, 2.3, 3.5], [2.3, 3.5, 1.1]));
assert(isPermutation("abc", "bca"));

assert(!isPermutation([1, 2], [3, 4]));
assert(!isPermutation([1, 1, 2, 3], [1, 2, 2, 3]));
assert(!isPermutation([1, 1], [1, 1, 1]));

// 高速だが、GCが処理するメモリーを割り当てる
assert(isPermutation!(Yes.allocateGC)([1.1, 2.3, 3.5], [2.3, 3.5, 1.1]));
assert(!isPermutation!(Yes.allocateGC)([1, 2], [3, 4]));

CommonType!(T, Ts) either(alias pred = (a) => a, T, Ts...)(T first, lazy Ts alternatives)
if (alternatives.length >= 1 && !is(CommonType!(T, Ts) == void) && allSatisfy!(ifTestable, T, Ts));

if (unaryFun!pred(a)) テストに合格した最初の引数a を取得する。 もし テストに合格する引数がない場合は、最後の引数を返す。

Lispのor 演算子やPythonの のような動的言語における 演算子の動作に似ている。 (or ...) やPythonのa or b or ... のような動的言語における 演算子の動作に似ている。 を返す。

ロジックを単純化する。 マッチャーが試される。最初にマッチしたものがマッチ結果を返す、 通常、抽象構文木(AST)として返される。

Bugs:

現在、レイジーパラメーターは、DMDによってあまりにも制限的に推測されている。 と推論される。このため 現在 eitherをnothrow 。Bugzilla 12647の問題を参照のこと。

Returns:

テストに合格した最初の引数pred 。

Examples:

const a = 1;
const b = 2;
auto ab = either(a, b);
static assert(is(typeof(ab) == const(int)));
writeln(ab); // a

auto c = 2;
const d = 3;
auto cd = either!(a => a == 3)(c, d); // 述語を使用する
static assert(is(typeof(cd) == int));
writeln(cd); // d

auto e = 0;
const f = 2;
auto ef = either(e, f);
static assert(is(typeof(ef) == int));
writeln(ef); // f

Examples:

immutable p = 1;
immutable q = 2;
auto pq = either(p, q);
static assert(is(typeof(pq) == immutable(int)));
writeln(pq); // p

writeln(either(3, 4)); // 3
writeln(either(0, 4)); // 4
writeln(either(0, 0)); // 0
writeln(either("", "a")); // ""

Examples:

string r = null;
writeln(either(r, "a")); // "a"
writeln(either("a", "")); // "a"

immutable s = [1, 2];
writeln(either(s, s)); // s

writeln(either([0, 1], [1, 2])); // [0, 1]
writeln(either([0, 1], [1])); // [0, 1]
writeln(either("a", "b")); // "a"

static assert(!__traits(compiles, either(1, "a")));
static assert(!__traits(compiles, either(1.0, "a")));
static assert(!__traits(compiles, either('a', "a")));