std.uni

import std.uni;
void main()
{
    // スクリプト/ブロックまたはプロパティ名を使用してコードポイントセットを初期化する
    // これで、'set'には両方のスクリプトのコードポイントが含まれる。
    auto set = unicode("Cyrillic") | unicode("Armenian");
    // 同じことだが、よりシンプルで、コンパイル時にチェックされる
    auto ascii = unicode.ASCII;
    auto currency = unicode.Currency_Symbol;

    // 簡単なセット操作
    auto a = set & ascii;
    assert(a.empty); // asciiと交差しないので
    a = set | ascii;
    auto b = currency - a; // すべてのASCII、キリル文字、アルメニア文字を引く

    // コードポイントセットのいくつかの特性
    assert(b.length > 45); // Unicode 6.1では46項目、6.2ではさらに増える
    // 集合にコードポイントが存在するかどうかを調べるのはちょうどいいが、
    // O(logN)である
    assert(!b['$']);
    assert(!b['\u058F']); // アルメニア・ドラム記号
    assert(b['¥']);

    // 高速なルックアップテーブルを構築することで、O(1)の複雑性を保証する
    // 1レベルのTrieルックアップテーブルは、本質的には巨大なビットセットであり、262Kb程度である
    auto oneTrie = toTrie!1(b);
    // 2レベルはかなりコンパクトだが、通常は若干遅い
    auto twoTrie = toTrie!2(b);
    // 3レベルはさらに小さく、少し遅い
    auto threeTrie = toTrie!3(b);
    assert(oneTrie['£']);
    assert(twoTrie['£']);
    assert(threeTrie['£']);

    // 最も適切なtrieレベルでtrieを構築し、
    // ファンクターとしてバインドする
    auto cyrillicOrArmenian = toDelegate(set);
    auto balance = find!(cyrillicOrArmenian)("Hello ընկեր!");
    assert(balance == "ընկեր!");
    // bool delegate(dchar)と互換性がある
    bool delegate(dchar) bindIt = cyrillicOrArmenian;

    // 正規化
    string s = "Plain ascii (and not only), is always normalized!";
    assert(s is normalize(s));// 同じ文字列である

    string nonS = "A\u0308ffin"; // 合字
    auto nS = normalize(nonS); // NFCは、W3Cが承認した標準規格である
    assert(nS == "Äffin");
    assert(nS != nonS);
    string composed = "Äffin";

    assert(normalize!NFD(composed) == "A\u0308ffin");
    // NFKDは、あいまいな照合・検索に役立つ互換性分解
    assert(normalize!NFKD("2¹⁰") == "210");
}

auto elemsPerPage = (2 ^^ bits_per_page) / Value.sizeOfInBits;
pages[index[n >> bits_per_page]][n & (elemsPerPage - 1)];

enum dchar lineSep;

定数コードポイント(0x2028) - 行区切り。

enum dchar paraSep;

定数コード点(0x2029) - 段落区切り。

enum dchar nelSep;

定数符号点(0x0085) - 次の行。

template isCodepointSet(T)

Tがある種のコードポイントの集合であるかどうかをテストする。テンプレート制約を意図している。

enum auto isIntegralPair(T, V = uint);

T が暗黙的にV に変換される整数のペアであるかどうかをテストする。 以下のコードは、T のペアに対してコンパイルされなければならない:

(T x){ V a = x[0]; V b = x[1];}

以下はコンパイルしてはならない:

(T x){ V c = x[2];}

alias CodepointSet = InversionList!(GcPolicy).InversionList;

コードポイントのセットに対する推奨デフォルト型。 詳細は現在の実装を参照のこと: InversionList.

struct CodepointInterval;

の推奨型を参照のこと。 std.typecons.Tuple の推奨型は、符号点の[a, b) 間隔を表す。で使用されている InversionList. どのような区間型もパスすべきである。 isIntegralPairをパスしなければならない。

struct InversionList(SP = GcPolicy);

InversionListはコードポイントの集合である の配列として表現される。 の配列として表現されるコードポイントの集合である(上記 CodepointIntervalを参照)。 この名前は、左から右への読み方に由来する。 例えば、すべての値[10, 50)、[80, 90)の集合は次のようになる、 と特異値60の集合は次のようになる:

10, 50, 60, 61, 80, 90

読み方は次のようになる。 これをどう読むかというと、負から始まるということは、次の数より小さい数はすべてこの集合に含まれないということである(正はその逆)。 正はその逆)。そして、左から右に数字が渡されるたびに、正負を入れ替える。 左から右へ数字が渡されるたびに、正負が入れ替わる。

こうすると、マイナスは10まで、プラスは50までとなる、 次に負を60まで、正を61まで、といった具合だ。 このように、冗長性の高いデータをスペース効率よく保存することができる。 をスペース効率よく保存することができる。ユニコード文字 プロパティがうまく適合する。この手法自体は、RLEエンコーディングのバリエーションとして見ることができる。 RLEエンコーディングのバリエーションと見ることもできる。

セットは(int のように)値型である。 は決してエイリアスされない。

例:

auto a = CodepointSet('a', 'z'+1);
auto b = CodepointSet('A', 'Z'+1);
auto c = a;
a = a | b;
assert(a == CodepointSet('A', 'Z'+1, 'a', 'z'+1));
assert(a != c);

以下も参照のこと。 unicodeを参照のこと。 を参照のこと。

メモリ使用量は、セット内の各連続区間あたり8バイトである。 値セマンティクスは COWテクニック したがって、この型をsharedにキャストするのは安全ではない。

注釈: この型は共有型である。

のテンプレート・パラメーターや現在のコードポイントの正確な型に依存することは推奨されない。 std.uni で設定されているコードポイントの正確な型に依存することは推奨されない。 標準アロケータの設計が最終化されたときに、型やパラメータが変更される可能性がある。 アロケータの設計が最終化されたときに、型やパラメータが変更される可能性がある。 テンプレートと併用するか isCodepointSetを使うか、デフォルトの エイリアス CodepointSetを使うこともできる。

pure this(Set)(Set set)
if (isCodepointSet!Set);

任意の型の別のコードポイントセットから構築する。

pure this(Range)(Range intervals)
if (isForwardRange!Range && isIntegralPair!(ElementType!Range));

コードポイント区間の前方範囲から集合を構成する。

this()(uint[] intervals...);

符号点間隔のプレーン値から集合を構成する。

Examples:

import std.algorithm.comparison : equal;

auto set = CodepointSet('a', 'z'+1, 'а', 'я'+1);
foreach (v; 'a'..'z'+1)
    assert(set[v]);
// キリル文字小文字の間隔
foreach (v; 'а'..'я'+1)
    assert(set[v]);
//特定の順序は必要なく、間隔が交差することもある
auto set2 = CodepointSet('а', 'я'+1, 'a', 'd', 'b', 'z'+1);
//同じ結果になる
assert(set2.byInterval.equal(set.byInterval));
// テストコンストラクタ this(Range)(Range intervals)
auto chessPiecesWhite = CodepointInterval(9812, 9818);
auto chessPiecesBlack = CodepointInterval(9818, 9824);
auto set3 = CodepointSet([chessPiecesWhite, chessPiecesBlack]);
foreach (v; '♔'..'♟'+1)
    assert(set3[v]);

@property scope auto byInterval();

この中のすべてのコードポイント区間にまたがる範囲を取得する。 InversionList.

const bool opIndex(uint val);

この集合にコードポイント valの有無をテストする。

Examples:

auto gothic = unicode.Gothic;
// ゴシック文字 ahsa
assert(gothic['\U00010330']);
// ゴシックには当然、asciiは含まれていない
assert(!gothic['$']);

@property size_t length();

この集合のコード・ポイントの数

This opBinary(string op, U)(U rhs)
if (isCodepointSet!U || is(U : dchar));

集合は集合代数の自然な構文をサポートしている:

演算子	数学表記法	説明
&	a∩b	交点
|	a∪b	共用体
-	a ∖ b	減算
~	a ～ b	対称集合の差、すなわち(a∪b)は(a∩b)を表す。

Examples:

import std.algorithm.comparison : equal;
import std.range : iota;

auto lower = unicode.LowerCase;
auto upper = unicode.UpperCase;
auto ascii = unicode.ASCII;

assert((lower & upper).empty); // 交わらない
auto lowerASCII = lower & ascii;
assert(lowerASCII.byCodepoint.equal(iota('a', 'z'+1)));
// 小文字のASCIIをすべて捨てる
writeln((ascii - lower).length); // 128 - 26

auto onlyOneOf = lower ~ ascii;
assert(!onlyOneOf['Δ']); // ASCIIではなく、小文字でもない
assert(onlyOneOf['$']); // ASCIIで小文字ではない
assert(!onlyOneOf['a']); // ASCIIと小文字
assert(onlyOneOf['я']); // ASCIIではなく小文字

// ASCIIの大文字小文字をすべて捨てる
auto noLetters = ascii - (lower | upper);
writeln(noLetters.length); // 128 - 26 * 2

ref This opOpAssign(string op, U)(U rhs)
if (isCodepointSet!U || is(U : dchar));

上記の演算子オーバーロードの'op='バージョン。

const bool opBinaryRight(string op : "in", U)(U ch)
if (is(U : dchar));

コードポイント chがあるかどうかをテストする、 と同じである。 opIndex.

Examples:

assert('я' in unicode.Cyrillic);
assert(!('z' in unicode.Cyrillic));

auto opUnary(string op : "!")();

この集合の反転集合を得る。

See Also:

inverted

@property auto byCodepoint();

この集合の各コードポイントにまたがる範囲。

Examples:

import std.algorithm.comparison : equal;
import std.range : iota;

auto set = unicode.ASCII;
set.byCodepoint.equal(iota(0, 0x80));

void toString(Writer)(scope Writer sink, ref scope const FormatSpec!char fmt);

このInversionListのテキスト表現を得る。 をテキストで取得する。

フォーマットフラグは、例えば各値に個別に適用される:

%s と%d は、区間を [low ... high) 積分の範囲としてフォーマットする。

%x 区間を[low .. high)範囲の小文字16進数としてフォーマットする。

%X 区間を[low .. high)範囲の大文字16進文字でフォーマットする。

Examples:

import std.conv : to;
import std.format : format;
import std.uni : unicode;

// これはもともとキリル文字を使用していた。
// 残念ながら、これは変更が頻繁に行われる範囲であり、
// そのため更新の際に壊れてしまった。
// そのため、変更される可能性が低い「基本ラテン文字」
// の範囲が代わりに使用された。

writeln(unicode.InBasic_latin.to!string); // "[0..128)"

// 仕様'%s'と'%d'は、上記のto!string呼び出しと同等である。
writeln(format("%d", unicode.InBasic_latin)); // unicode.InBasic_latin.to!string

writeln(format("%#x", unicode.InBasic_latin)); // "[0..0x80)"
writeln(format("%#X", unicode.InBasic_latin)); // "[0..0X80)"

ref auto add()(uint a, uint b);

この集合に区間[a, b]を加える。

Examples:

CodepointSet someSet;
someSet.add('0', '5').add('A','Z'+1);
someSet.add('5', '9'+1);
assert(someSet['0']);
assert(someSet['5']);
assert(someSet['9']);
assert(someSet['Z']);

@property auto inverted();

この集合の反転集合を得る。

同じように演算子を使う場合は、'! opUnaryを参照のこと。

Examples:

auto set = unicode.ASCII;
// 逆元との結合は、Unicodeのすべてのコードポイントを取得する
writeln((set | set.inverted).length); // 0x110000
// 逆数との交わりなし
assert((set & set.inverted).empty);

string toSourceCode(string funcName = "");

の名前を持つ単項関数のDソースコードを文字列として生成する。 funcNamedchar の単項関数のソースコードを文字列で生成する。もし funcNameが空の場合 の場合、ラムダ関数として調整される。

生成された関数は、渡されたコードポイントがこの集合に属するかどうかをテストする。 がこのセットに属するかどうかをテストする。結果は文字列ミックスインで使われる。 想定される使用領域は、パーサー・ジェネレーターなどでのメタプログラミングによる積極的な最適化である。 による積極的な最適化である。

注釈 比較的小さいセットや規則的なセットには注意して使用すること。それは 多段テーブルを使うよりも遅くなる可能性がある。

例:

import std.stdio;

// [a, b$RPAREN間隔を直接セットする
auto set = CodepointSet(10, 12, 45, 65, 100, 200);
writeln(set);
writeln(set.toSourceCode("func"));

上記は次のように出力される:

bool func(dchar ch)  @safe pure nothrow @nogc
{
    if (ch < 45)
    {
        if (ch == 10 || ch == 11) return true;
        return false;
    }
    else if (ch < 65) return true;
    else
    {
        if (ch < 100) return false;
        if (ch < 200) return true;
        return false;
    }
}

const @property bool empty();

このセットにコード・ポイントが含まれていなければ真。

Examples:

CodepointSet emptySet;
writeln(emptySet.length); // 0
assert(emptySet.empty);

template codepointSetTrie(sizes...) if (sumOfIntegerTuple!sizes == 21)

カスタムのマルチレベル固定トライを作成するための略記法である。 CodepointSet sizes はレベルごとのビット数である、 最上位ビットが最初に使用される。

注釈: sizes の合計は21でなければならない。

See Also:

toTrieこれはさらに単純である。

例:」である。

{
    import std.stdio;
    auto set = unicode("Number");
    auto trie = codepointSetTrie!(8, 5, 8)(set);
    writeln("Input code points to test:");
    foreach (line; stdin.byLine)
    {
        int count=0;
        foreach (dchar ch; line)
            if (trie[ch])// 数字である
                count++;
        writefln("Contains %d number code points.", count);
    }
}

template CodepointSetTrie(sizes...) if (sumOfIntegerTuple!sizes == 21)

codepointSetTrie関数によって生成されたTrieの型。

template codepointTrie(T, sizes...) if (sumOfIntegerTuple!sizes == 21)

template CodepointTrie(T, sizes...) if (sumOfIntegerTuple!sizes == 21)

Unicodeデータの固定されたTrie を構築するための少し一般的なツールである。

特に、codepointSetTrie とは異なり、 のマッピングを作成することができる。 dchar から任意の型T へのマッピングを作成できる。

注釈 CodepointSetsを取るオーバーロードは、当然ながら をブールマッピングTries にのみ変換する。

CodepointTrieは、codepointTrie関数によって生成されるTrieの型である。

auto codepointTrie()(T[dchar] map, T defValue = T.init);

auto codepointTrie(R)(R range, T defValue = T.init)
if (isInputRange!R && is(typeof(ElementType!R.init[0]) : T) && is(typeof(ElementType!R.init[1]) : dchar));

struct MatcherConcept;

すべてのUTF Matcherに共通するプロパティの概要を示す概念的な型である。

注釈: 説明のためだけに、すべてのメソッド 呼び出しはすべてアサーションに失敗する。 具体的なマッチャーを取得するには utfMatcherを使って具象マッチャ を取得するために使用する。

bool match(Range)(ref Range inp)
if (isRandomAccessRange!Range && is(ElementType!Range : char));

bool skip(Range)(ref Range inp)
if (isRandomAccessRange!Range && is(ElementType!Range : char));

bool test(Range)(ref Range inp)
if (isRandomAccessRange!Range && is(ElementType!Range : char));

意味的に等価な2つの操作を実行する: の前にあるコードポイントをデコードする。 inpの前にあるコード・ポイントをデコードし このマッチャーのコードポイントの集合に属するかどうかをテストする。

に対する効果は inpは、呼び出される関数の種類に依存する:

マッチ。コードポイントが集合の中に見つかれば、範囲 inp は、コード単位でそのサイズだけ進められる、 そうでなければ、範囲は変更されない。

スキップする。テストの結果に関係なく のサイズだけ進められる。

テストする。テスト。 テストの結果に関係なく。

Examples:

string truth = "2² = 4";
auto m = utfMatcher!char(unicode.Number);
assert(m.match(truth)); // '2'は確かに数字だ
assert(truth == "² = 4"); // 一致する
assert(m.match(truth)); // soは上付き文字の'2'である
assert(!m.match(truth)); // スペースは数字ではない
assert(truth == " = 4"); // 一致しない場合は影響されない
assert(!m.skip(truth)); // 同じテスト ...
assert(truth == "= 4"); // が、それに関わらずコードポイントをスキップする
assert(!m.test(truth)); // '='は数字ではない
assert(truth == "= 4"); // テストは決して引数に影響を与えない

@property auto subMatcher(Lengths...)();

高度な機能 - 既知のエンコード長に基づくマッチャーのサブセットへの直接アクセスを提供する。 のサブセットへの直接アクセスを提供する。長さは コード単位で提供される。サブマッチャーは test /match 。

サブマッチャーは、以下のようなコードポイントにはマッチしないので、注意して使用すること。 サブマッチャーは、選択された長さの集合に属さない符号化長を持つコードポイントにはマッチしないので、注意して使用すること。 サブマッチャーは、選択された長さの集合に属さない符号化長を持つコードポイントにはマッチしないので、注意して使用すること。また、サブマッチャーオブジェクトは を参照するので、親マッチャーのliftetimeを越えて使用してはならない。 を超えて使用してはならない。

サブ・マッチャーを使用するもう1つの注意点は、スキップが使用できないことである。 が使用できないことである。

enum auto isUtfMatcher(M, C);

Char の範囲に対して、M がUTF Matcherであるかどうかをテストする。

auto utfMatcher(Char, Set)(Set set)
if (isCodepointSet!Set);

Matcher オブジェクトを構築する。 からコードポイントを分類する setのコードポイントを分類する matcher オブジェクトを構築する。 Char からコードポイントを分類する matcher オブジェクトを構築する。

APIの概要は MatcherConceptを参照のこと。

auto toTrie(size_t level, Set)(Set set)
if (isCodepointSet!Set);

の最適な構成を構築するための便利な関数である。 の最適な構成を構築する setを構築するための便利な関数である。

パラメータlevel は、使用するトライレベルの数を示す、 許容される値は以下の通りである:1、2、3または4である。レベルは異なるトレードオフを表す スピードとサイズのトレードオフを表す。

レベル1は最も高速で、最もメモリを消費する(ビット配列)。

レベル4は最も遅く、フットプリントが最も小さい。

例については「あらすじ」のセクションを参照のこと。

注釈 レベル4は非常に実用的である(より速く、より予測可能である)。 を直接ルックアップするのに比べて、非常に実用的である。 setに直接ルックアップするのに比べ、非常に実用的である。

auto toDelegate(Set)(Set set)
if (isCodepointSet!Set);

一般的に最適なスピードとサイズのトレードオフでTrie 。 を構築し、それを以下の型のデリゲートにラップする: bool delegate(dchar ch).

事実上、これは「テスター」ラムダを作成する。 std.algorithm.findのような単項述語を取るアルゴリズムに適している。

例については「概要」のセクションを参照のこと。

struct unicode;

ブロック、スクリプト、一般カテゴリの名前またはエイリアスによってUnicodeコードポイントセットを検索するための単一のエントリポイント。 ブロック、スクリプト、または一般的なカテゴリ。

プロパティ名検索のよく定義された標準ルールを使用する。 これには、名前のファジーマッチングが含まれる。 'White_Space'、'white-SpAce'、'whitespace' はすべて等しいとみなされる。 と'white_Space'はすべて等しいとみなされ、同じ空白文字の集合が得られる。

pure @property auto opDispatch(string name)();

コンパイル時の正しさをチェックしながら の検索を実行する。 このショートカット・バージョンは、3つの検索を組み合わせている: ブロック全体、スクリプト、共通のバイナリー・プロパティである。

スクリプトとブロックは重複しているので、曖昧さをなくすための通常のトリックが使われる。 ブロックを取得するには unicode.InBlockName スクリプトを検索するには unicode.ScriptName を使う。

See Also:

block, script および(この検索には含まれていない) hangulSyllableType.

auto opCall(C)(scope const C[] name)
if (is(C : dchar));

ブロック、スクリプト、バイナリー・プロパティにまたがって同じ検索を行う、 であるが、実行時に実行される。 このバージョンは name それ以外の場合は、コンパイル時に チェックされた opDispatchの方が良い選択である。

利用可能なセットについては、プロパティの表を参照のこと。 セットを参照のこと。

struct block;

すべてのUnicodeブロックに対してコードポイントの集合を絞り込む。

注釈: ここでは、スクリプトは検索されないので、ブロック名は曖昧ではない。 したがって、検索には単に unicode.block.BlockName記法を使用する。

利用可能なセットについてはプロパティの表を参照のこと。

See Also:

プロパティの表を参照のこと。

Examples:

// .blockを使用して明示的にする
writeln(unicode.block.Greek_and_Coptic); // unicode.InGreek_and_Coptic

struct script;

コードポイントのセットをすべてのユニコードスクリプトに絞り込んで検索する。

利用可能なセットについてはプロパティの表を参照のこと。 セットを参照のこと。

Examples:

auto arabicScript = unicode.script.arabic;
auto arabicBlock = unicode.block.arabic;
// スクリプトとブロックの間に交点がある
assert(arabicBlock['؁']);
assert(arabicScript['؁']);
// しかし、両者は異なるものである
assert(arabicBlock != arabicScript);
writeln(arabicBlock); // unicode.inArabic
writeln(arabicScript); // unicode.arabic

struct hangulSyllableType;

指定されたハングル音節型を持つコードポイントの集合を取得する。

他のバイナリでないプロパティも(サポートされれば)、同じ表記に従う unicode.propertyName.propertyValue 記法に従う。 チェックされたアクセスはunicode.propertyName(propertyValue) は実行時にチェックされる。

利用可能なセットについてはプロパティの表を参照のこと。 セットを参照のこと。

Examples:

// Lは、unicode.Lのショートカットのように文字ではなく音節型である
auto leadingVowel = unicode.hangulSyllableType("L");
// 先頭の母音が存在するか確認する
foreach (vowel; '\u1110'..'\u115F')
    assert(leadingVowel[vowel]);
writeln(leadingVowel); // unicode.hangulSyllableType.L

CodepointSet parseSet(Range)(ref Range range, bool casefold = false)
if (isInputRange!Range && is(ElementType!Range : dchar));

ユニコードのコードポイント集合を解析する。 rangeを解析する。 構文'[...]'を使う。範囲は、正規表現セットの定義をスキップする。 casefoldパラメータは、大文字小文字を区別するかどうかを決定する。 つまり、セット内の文字に小文字と大文字の両方を含める。

pure @safe size_t graphemeStride(C)(scope const C[] input, size_t index)
if (is(C : dchar));

で始まる書記素クラスタの長さを計算する。 index. 結果の長さと indexはともに はコード単位である。

Parameters:

C	に暗黙的に変換可能な "型"である。dchars
C[] input	書記素クラスタの配列
size_t index	への開始インデックス。 input[]

Returns:

書記素クラスターの長さ

Examples:

writeln(graphemeStride("  ", 1)); // 1
// A + combing ring above
string city = "A\u030Arhus";
size_t first = graphemeStride(city, 0);
assert(first == 3); //\u030Aは2つのUTF-8コードユニットを持つ
writeln(city[0 .. first]); // "A\u030A"
writeln(city[first .. $]); // "rhus"

Grapheme decodeGrapheme(Input)(ref Input inp)
if (isInputRange!Input && is(immutable(ElementType!Input) == immutable(dchar)));

dcharの入力範囲から1つの完全な書記素クラスタを読み出す。 dcharの入力範囲から1つの完全な書記素クラスターを読み取る。 inp.

例:" を参照のこと。 Graphemeを参照のこと。

注釈 この関数は次のように変更する。 inpしたがって inp はL値でなければならない。

auto byGrapheme(Range)(Range range)
if (isInputRange!Range && is(immutable(ElementType!Range) == immutable(dchar)));

文字列を Grapheme.

によって文字列を反復処理する。 文字列を操作するのに便利である。

See Also:

byCodePoint

Examples:

import std.algorithm.comparison : equal;
import std.range.primitives : walkLength;
import std.range : take, drop;
auto text = "noe\u0308l"; // noëlはe + 結合二重引用符を使用する
assert(text.walkLength == 5); // 5つのコードポイント

auto gText = text.byGrapheme;
assert(gText.walkLength == 4); // 4グラフェム

assert(gText.take(3).equal("noe\u0308".byGrapheme));
assert(gText.drop(3).equal("l".byGrapheme));

auto byCodePoint(Range)(Range range)
if (isInputRange!Range && is(immutable(ElementType!Range) == immutable(Grapheme)));

auto byCodePoint(Range)(Range range)
if (isInputRange!Range && is(immutable(ElementType!Range) == immutable(dchar)));

の範囲をコードポイントに変換する。 Graphemeをコードポイントの範囲に変換する。

に対する操作を行った後に、結果を文字列に変換するのに便利である。 結果を文字列に変換するのに便利である。

コードポイントの範囲を渡された場合、同等の能力を持つ範囲を返す。

Examples:

import std.array : array;
import std.conv : text;
import std.range : retro;

string s = "noe\u0308l"; // noël

// これを反転させ、結果を文字列に変換する
string reverse = s.byGrapheme
    .array
    .retro
    .byCodePoint
    .text;

assert(reverse == "le\u0308on"); // lëon

struct Grapheme;

文字を効果的に詰め込むために設計された構造 を効果的に詰め込むように設計された構造である。

Graphemeは値セマンティクスを持つ。 Grapheme は常に異なるオブジェクトを指す。実際のシナリオでは Grapheme はスタックに収まるので、非常に長いクラスタ以外ではメモリ割り当てのオーバーヘッドを避けることができる。 を回避できる。

See Also:

decodeGrapheme, graphemeStride

this(C)(scope const C[] chars...)
if (is(C : dchar));

this(Input)(Input seq)
if (!isDynamicArray!Input && isInputRange!Input && is(ElementType!Input : dchar));

Ctor

const pure nothrow @nogc @trusted dchar opIndex(size_t index);

このクラスタ内の指定されたインデックスにあるコードポイントを取得する。

pure nothrow @nogc @trusted void opIndexAssign(dchar ch, size_t index);

このクラスタ内の指定されたインデックスのchを書き込む。

警告 この機能を使用すると、書記素クラスタが無効になる可能性がある、 も参照のこと。 Grapheme.valid.

Examples:

auto g = Grapheme("A\u0302");
writeln(g[0]); // 'A'
assert(g.valid);
g[1] = '~'; // ASCIIのチルダは結合記号ではない
writeln(g[1]); // '~'
assert(!g.valid);

pure nothrow @nogc @safe SliceOverIndexed!Grapheme opSlice(size_t a, size_t b) return;

pure nothrow @nogc @safe SliceOverIndexed!Grapheme opSlice() return;

Graphemeの文字をランダムアクセスできる。

警告 このGraphemeがスコープから外れると無効になる、 このGraphemeがスコープを離れると無効になる。

const pure nothrow @nogc @property @safe size_t length();

Grapheme クラスタの長さをコードポイントで表す。

ref @trusted auto opOpAssign(string op)(dchar ch);

この書記素に文字chを追加する。

警告 この機能を使用すると、書記素クラスタが無効になる可能性がある、 valid も参照のこと。

See Also:

Grapheme.valid

Examples:

import std.algorithm.comparison : equal;
auto g = Grapheme("A");
assert(g.valid);
g ~= '\u0301';
assert(g[].equal("A\u0301"));
assert(g.valid);
g ~= "B";
// もはや有効な書記素クラスタではない
assert(!g.valid);
// しかし、まだ役に立つかもしれない
assert(g[].equal("A\u0301B"));

ref auto opOpAssign(string op, Input)(scope Input inp)
if (isInputRange!Input && is(ElementType!Input : dchar));

入力範囲のすべての文字をinpに追加する。

@property bool valid()();

このオブジェクトが有効な拡張書記素クラスタを含んでいれば真。 このモジュールの復号プリミティブは常に有効なGrapheme を返す。

graphemeの文字に付加したり、直接操作したりすると、有効でなくなることがある。 を追加したり直接操作したりすると、有効でなくなることがある。アプリケーションによっては ある種のアプリケーションは、graphemeを任意のコードポイントの"小さな文字列"として使い、この特性を完全に無視することを選ぶかもしれない を完全に無視する。

int sicmp(S1, S2)(scope S1 r1, scope S2 r2)
if (isInputRange!S1 && isSomeChar!(ElementEncodingType!S1) && isInputRange!S2 && isSomeChar!(ElementEncodingType!S2));

大文字小文字を区別しない r1と r2. この関数は、より単純な比較ルールを使用する。 である。 icmp.しかし、以下の警告に注意してほしい。

Parameters:

S1 r1	文字の入力範囲
S2 r2	文字の入力範囲

Returns:

int 。文字列が一致すれば0となる、 <0である。 r1が辞書的に r2, >よりも辞書的に "大きい"場合は r1が辞書的に r2

警告 この関数は1:1コードポイントマッピングしか扱わない。 のみを処理するため、ドイツ語やギリシャ語などの特定のアルファベットには不十分である。 のような特定のアルファベットには不十分である。

See Also:

icmp std.algorithm.comparison.cmp

Examples:

writeln(sicmp("Август", "авгусТ")); // 0
// ギリシャ語も、1:Mのマッピングがない限りは使える
writeln(sicmp("ΌΎ", "όύ")); // 0
// 次のようなものは、
// ギリシャ文字の小文字のiotaとtonos、dialytikaとして等価に一致しない
assert(sicmp("ΐ", "\u03B9\u0308\u0301") != 0);

// 一方、icmpではそのような問題はない
writeln(icmp("ΐ", "\u03B9\u0308\u0301")); // 0
writeln(icmp("ΌΎ", "όύ")); // 0

int icmp(S1, S2)(S1 r1, S2 r2)
if (isForwardRange!S1 && isSomeChar!(ElementEncodingType!S1) && isForwardRange!S2 && isSomeChar!(ElementEncodingType!S2));

の大文字小文字を区別しない比較を行う。 r1と r2. 完全な大文字小文字変換のルールに従う。 これには、ドイツ語のßを "ss"と等しくマッチさせることも含まれる。 とは異なり、他の1:Mコードポイントマッピングも含まれる。 sicmp. .と違って icmp衒学的に正しいことの代償は パフォーマンスが若干悪くなることだ。

Parameters:

S1 r1	前方文字の範囲
S2 r2	前方文字の範囲

Returns:

文字列が一致する場合は0となるint 、 str1 が辞書的にstr2 より「小さい」場合は <0 、 str1 、辞書的に "大きい"場合は">0"である。str2

See Also:

sicmp std.algorithm.comparison.cmp

Examples:

writeln(icmp("Rußland", "Russland")); // 0
writeln(icmp("ᾩ -> \u1F70\u03B9", "\u1F61\u03B9 -> ᾲ")); // 0

Examples:

とそのエイリアスを使うことで std.utf.byUTFとそのエイリアスを使用することで、自動デコードによるGCアロケーションと や例外のスローを回避できる。 icmp@safe @nogc nothrow pure.

import std.utf : byDchar;

writeln(icmp("Rußland".byDchar, "Russland".byDchar)); // 0
writeln(icmp("ᾩ -> \u1F70\u03B9".byDchar, "\u1F61\u03B9 -> ᾲ".byDchar)); // 0

pure nothrow @nogc @safe ubyte combiningClass(dchar ch);

の結合クラスを返す。 ch.

Examples:

// コードを短くする
alias CC = combiningClass;

// チルダを組み合わせる
writeln(CC('\u0303')); // 230
// 下のリングを組み合わせる
writeln(CC('\u0325')); // 220
// 単純な帰結として、
// "チルダ"は"下のリング"の後に置かれるべきである

enum UnicodeDecomposition: int;

Unicode 文字分解型。

Canonical

正準分解。結果は正準等価シーケンスである。

Compatibility

互換分解。結果は互換等価シーケンスである。

注釈 互換性分解は非可逆変換である、 ファジーマッチや内部処理にのみ適している。

pure nothrow @safe dchar compose(dchar first, dchar second);

2文字の正規合成を試みる。 合成されれば合成された文字を返し、そうでなければdchar.initを返す。

前提として firstが secondであることを仮定している、 通常、最初がスターターであることを意味する。

注釈 ハングル音節はこの関数の対象外である。 以下のcomposeJamo 。

Examples:

writeln(compose('A', '\u0308')); // '\u00C4'
writeln(compose('A', 'B')); // dchar.init
writeln(compose('C', '\u0301')); // '\u0106'
// スターターは最初の1つであるため、
// 以下はcomposeしないことに注意
writeln(compose('\u0308', 'A')); // dchar.init

@safe Grapheme decompose(UnicodeDecomposition decompType = Canonical)(dchar ch);

完全なCanonical (デフォルト)または互換性のある 文字の分解 ch. 分解できない場合は Grapheme を返す。 chを返す。

注釈:この関数はハングルの音節も分解する。 この関数はハングルの音節も分解する。 も分解する。

See Also:

decomposeHangul限定版 ハングルの音節だけを考慮し、他の分解は考慮しない。 他の分解は考慮しない。

Examples:

import std.algorithm.comparison : equal;

writeln(compose('A', '\u0308')); // '\u00C4'
writeln(compose('A', 'B')); // dchar.init
writeln(compose('C', '\u0301')); // '\u0106'
// スターターは最初の1つであるため、
// 以下はcomposeしないことに注意
writeln(compose('\u0308', 'A')); // dchar.init

assert(decompose('Ĉ')[].equal("C\u0302"));
assert(decompose('D')[].equal("D"));
assert(decompose('\uD4DC')[].equal("\u1111\u1171\u11B7"));
assert(decompose!Compatibility('¹')[].equal("1"));

pure nothrow @safe Grapheme decomposeHangul(dchar ch);

ハングルの音節を分解する。もし chが構成音節でない場合 でない場合、この関数は次のように返す。 Graphemeのみを含む chをそのまま返す。

Examples:

import std.algorithm.comparison : equal;
assert(decomposeHangul('\uD4DB')[].equal("\u1111\u1171\u11B6"));

pure nothrow @nogc @safe dchar composeJamo(dchar lead, dchar vowel, dchar trailing = (dchar).init);

先頭の子音(lead), a vowelと任意の trailing子音jamosで構成する。

成功すると、構成された LV または LVT ハングルの音節を返す。

もし leadと vowelのいずれかが有効なハングル音節でない場合 のいずれかが有効なハングル文字クラスでない場合、dchar.init.

Examples:

writeln(composeJamo('\u1111', '\u1171', '\u11B6')); // '\uD4DB'
// T母音を除いたり、末尾子音でない符号を飛ばしたりすると、
// LV音節が構成される
writeln(composeJamo('\u1111', '\u1171')); // '\uD4CC'
writeln(composeJamo('\u1111', '\u1171', ' ')); // '\uD4CC'
writeln(composeJamo('\u1111', 'A')); // dchar.init
writeln(composeJamo('A', '\u1171')); // dchar.init

enum NormalizationForm: int;

正規化フォームの列挙型、 のような関数のテンプレート化された関数パラメータとして渡される。 normalize.

NFC

NFD

NFKC

NFKD

正規化形式を示す値からの省略形エイリアス。

pure @safe inout(C)[] normalize(NormalizationForm norm = NFC, C)(return scope inout(C)[] input);

戻り値 input選択された形式に正規化された文字列。 デフォルトでは C 形式が使用される。

正規化形式の詳細については 正規化セクションを参照のこと。

注釈 問題の文字列がすでに正規化されている場合、その文字列は修正されずに返される、 は変更されずに返され、メモリ確保は行われない。

Examples:

// どんなエンコーディングでも機能する
wstring greet = "Hello world";
assert(normalize(greet) is greet); // まったく同じスライス

// 4つのフォームがすべて異なるキャラクターの例:
// アキュート記号とフック記号を持つギリシャのウプシロン(コードポイント 0x03D3)
writeln(normalize!NFC("ϓ")); // "\u03D3"
writeln(normalize!NFD("ϓ")); // "\u03D2\u0301"
writeln(normalize!NFKC("ϓ")); // "\u038E"
writeln(normalize!NFKD("ϓ")); // "\u03A5\u0301"

bool allowedIn(NormalizationForm norm)(dchar ch);

正規化で "dchar"が常に許可されているかどうかをテストする。 chが常に許可されているか (Quick_Check=YES) をテストする。 フォームnorm 。

Examples:

// 例: キリル文字は常に許可されている。soはASCIIである
assert(allowedIn!NFC('я'));
assert(allowedIn!NFD('я'));
assert(allowedIn!NFKC('я'));
assert(allowedIn!NFKD('я'));
assert(allowedIn!NFC('Z'));

pure nothrow @nogc @safe bool isWhite(dchar c);

がユニコードの空白文字であるかどうか。 cがUnicode空白文字であるかどうか。 (一般的なUnicodeのカテゴリ:C0(タブ、垂直タブ、フォームフィード、 キャリッジリターン、ラインフィード文字)、Zs、Zl、Zp、NEL(U+0085)の一部)

pure nothrow @nogc @safe bool isLower(dchar c);

がUnicode小文字であるかどうかを返す。 cが Unicode小文字であるかどうかを返す。

pure nothrow @nogc @safe bool isUpper(dchar c);

がUnicode大文字かどうかを返す。 cがUnicode大文字であるかどうかを返す。

auto asLowerCase(Range)(Range str)
if (isInputRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range);

auto asUpperCase(Range)(Range str)
if (isInputRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range);

入力範囲 または文字列を大文字または小文字に変換する。

メモリを割り当てない。 デコードできないUTF-8またはUTF-16形式の文字は、大文字として扱われる。 として扱う。 std.utf.replacementDchar.

Parameters:

Range str

文字列または文字の範囲

Returns:

入力範囲dchars

See Also:

toUpper, toLower

Examples:

import std.algorithm.comparison : equal;

assert("hEllo".asUpperCase.equal("HELLO"));

auto asCapitalized(Range)(Range str)
if (isInputRange!Range && isSomeChar!(ElementEncodingType!Range) && !isConvertibleToString!Range);

入力範囲 つまり、最初の つまり、最初の文字を大文字に、それ以降の文字を小文字に変換する。

メモリを割り当てない。 デコードできないUTF-8またはUTF-16形式の文字は、以下のように扱われる。 として扱われる。 std.utf.replacementDchar.

Parameters:

Range str

文字列または文字の範囲

Returns:

dcharの入力範囲

See Also:

toUpper, toLower asUpperCase, asLowerCase

Examples:

import std.algorithm.comparison : equal;

assert("hEllo".asCapitalized.equal("Hello"));

pure @trusted void toLowerInPlace(C)(ref C[] s)
if (is(C == char) || is(C == wchar) || is(C == dchar));

を小文字に変換する。 sを小文字に変換する。 数文字の文字列では、変換後に文字列長が長くなることがある、 そのような場合、関数は正確に一度だけ再割り当てを行う。 もし sに大文字がなければ sは変更されない。

pure @trusted void toUpperInPlace(C)(ref C[] s)
if (is(C == char) || is(C == wchar) || is(C == dchar));

大文字に変換する sを大文字に変換する。 数文字の文字列の場合、変換後に文字列の長さが長くなることがある、 そのような場合、関数は正確に一度だけ再割り当てを行う。 もし sに小文字がない場合 sは変更されない。

pure nothrow @nogc @safe dchar toLower(dchar c);

もし cがUnicodeの大文字であれば、それに相当する小文字の が返される。そうでなければ cが返される。

警告 ドイツ語やギリシャ語のような特定のアルファベットは、1:1のマッピングを持たない。 を持たない。代わりに完全な文字列を受け取るtoLowerのオーバーロードを使用する。

@trusted ElementEncodingType!S[] toLower(S)(return scope S s)
if (isSomeString!S);

ElementEncodingType!S[] toLower(S)(S s)
if (!isSomeString!S && (isRandomAccessRange!S && hasLength!S && hasSlicing!S && isSomeChar!(ElementType!S)));

と同じ新しい配列を作成する。 sただし 文字が(Unicodeの小文字マッピングによって)すべて小文字に変換されることを除いては、同じ新しい配列を作成する。 もし s文字がない場合は sであれば、それ自身が返される。 sが string-のような型が返される。

Parameters:

S s	ランダムアクセス範囲 文字の

Returns:

と同じ要素型を持つ配列。 s.

pure nothrow @nogc @safe dchar toUpper(dchar c);

もし cがUnicodeの小文字の場合、それに相当する大文字の が返される。そうでなければ cが返される。

警告 ドイツ語やギリシャ語のような特定のアルファベットは、1:1の大文字と小文字の対応を持たない。 を持たない。代わりに完全な文字列を受け取るtoUpperのオーバーロードを使用する。

toUpperは、次の引数として使用できる。 std.algorithm.iteration.map の引数として使うことができる。 アルゴリズムを生成する。 文字列は std.algorithm.mutation.copy を使って std.array.appender.

Examples:

import std.algorithm.iteration : map;
import std.algorithm.mutation : copy;
import std.array : appender;

auto abuf = appender!(char[])();
"hello".map!toUpper.copy(abuf);
writeln(abuf.data); // "HELLO"

@trusted ElementEncodingType!S[] toUpper(S)(return scope S s)
if (isSomeString!S);

ElementEncodingType!S[] toUpper(S)(S s)
if (!isSomeString!S && (isRandomAccessRange!S && hasLength!S && hasSlicing!S && isSomeChar!(ElementType!S)));

と同じ新しい配列を確保する。 sと同じである。 文字が(Unicode大文字マッピングによって)すべて大文字に変換されること以外は同じである。 もし s文字が影響を受けなかった場合は sが返される。 s がstring-like型であれば、それ自身が返される。

Parameters:

S s	ランダムアクセス範囲 文字の

Returns:

と同じ要素型を持つ新しい配列。 s.

pure nothrow @nogc @safe bool isAlpha(dchar c);

を返す。 cがUnicodeのアルファベット文字 (一般Unicodeカテゴリ: Alphabetic)であるかどうかを返す。

pure nothrow @nogc @safe bool isMark(dchar c);

が cがUnicodeマーク (一般的なUnicodeのカテゴリ:Mn、Me、Mc)であるかどうかを返す。

pure nothrow @nogc @safe bool isNumber(dchar c);

が cがUnicode数値文字 (Unicodeの一般カテゴリ:Nd, Nl, No)であるかどうかを返す。

pure nothrow @nogc @safe bool isAlphaNum(dchar c);

が cがUnicodeのアルファベット文字か数字かを返す。 (一般的なUnicodeのカテゴリ:アルファベット、Nd、Nl、No)。

Parameters:

dchar c

任意のUnicode文字

Returns:

true その文字がAlphabetic、Nd、Nl、またはNo Unicodeにある場合 カテゴリ

pure nothrow @nogc @safe bool isPunctuation(dchar c);

がUnicode句読点文字であるかどうかを返す。 cがUnicode句読点文字であるかどうかを返す (一般的なUnicodeカテゴリ:Pd、Ps、Pe、Pc、Po、Pi、Pf)であるかどうかを返す。

pure nothrow @nogc @safe bool isSymbol(dchar c);

が cがUnicode記号文字 (一般的なUnicodeカテゴリ: Sm, Sc, Sk, So)であるかどうかを返す。

pure nothrow @nogc @safe bool isSpace(dchar c);

が cがUnicodeスペース文字 (一般的なUnicodeカテゴリ:Zs)

注釈 これは'˶n'、'˶r'、'˶t'および他の非スペース文字を含まない。 一般的に使用されるより厳密でないセマンティクスについては isWhite.

pure nothrow @nogc @safe bool isGraphical(dchar c);

を参照のこと。 cが Unicode グラフィカル文字であるかどうかを返す (一般的な Unicode カテゴリ: L、M、N、P、S、Zs)。

pure nothrow @nogc @safe bool isControl(dchar c);

が cがUnicode制御文字 (一般的なUnicodeカテゴリ:Cc)であるかどうかを返す。

pure nothrow @nogc @safe bool isFormat(dchar c);

が cがUnicodeフォーマット文字 (Unicodeの一般カテゴリ:Cf)であるかどうかを返す。

pure nothrow @nogc @safe bool isPrivateUse(dchar c);

が cがUnicode私用コードポイント (一般的なUnicodeカテゴリ:Co)であるかどうかを返す。

pure nothrow @nogc @safe bool isSurrogate(dchar c);

が cがUnicodeサロゲートコードポイント (一般 Unicode カテゴリ:Cs)であるかどうかを返す。

pure nothrow @nogc @safe bool isSurrogateHi(dchar c);

を返す。 cがUnicode上位サロゲート(先頭サロゲート)であるかどうかを返す。

pure nothrow @nogc @safe bool isSurrogateLo(dchar c);

が cがUnicode低サロゲート(トレイルサロゲート)であるかどうかを返す。

pure nothrow @nogc @safe bool isNonCharacter(dchar c);

がUnicode非文字iであるかどうかを返す。 cがUnicode非文字であるかどうかを返す。 抽象文字が割り当てられていないコードポイントであるかどうかを返す。 (一般的なUnicodeカテゴリ:Cn)