import tr.uni;
 
trchar toUniLower_tr(in trchar karakter)
{
    return trchar(toUniLower_tr(karakter.c_));
}

auto ş = tr!dchar('ş');

    tr!wchar[] merhaba = "merhaba";

    TT to(TT)()
    {
        return cast(TT)c_;
    }

import tr.uni;
import tr.string;
import std.conv;
 
struct im
{
    dchar karakter = karakter.init;
 
    this(T)(in T karakter)
    {
        this.karakter = karakter;
    }
 
    string toString()
    {
        return text(karakter);
    }
 
    const bool opEquals(T)(in T karakter)
    {
        return this.karakter == karakter;
    }
 
    const int opCmp(T)(in T sağdaki)
    {
        static if (is(T == im)) {
            double fark = sıraNumarası_tr(karakter) -
                          sıraNumarası_tr(sağdaki.karakter);
        } else {
            double fark = sıraNumarası_tr(karakter) -
                          sıraNumarası_tr(sağdaki);
        }
 
        return ((fark < 0)
                ? -1
                : (fark > 0) ? 1 : 0);
    }
 
    const dchar opCast()
    {
        return karakter;
    }
}
 
dchar toUniUpper(in im karakter)
{
    return toUniUpper_tr(cast(dchar)(karakter));
}
 
dchar toUniLower(in im karakter)
{
    return toUniLower_tr(cast(dchar)(karakter));
}
 
unittest
{
    {
        im k;
        assert(k.karakter == k.karakter.init);
    }
    {
        auto k = im('a');
        assert(k.karakter == 'a');
    }
    {
        char c = 'b';
        auto k = im(c);
        assert(k.karakter == 'b');
    }
    {
        auto k = im('ğ');
        assert(k.karakter == 'ğ');
    }
    {
        wchar c = 'ğ';
        auto k = im(c);
        assert(k.karakter == 'ğ');
    }
    {
        auto k = im('\U0001ffff');
        assert(k.karakter == '\U0001ffff');
    }
    {
        dchar c = '\U0001ffff';
        auto k = im(c);
        assert(k.karakter == '\U0001ffff');
    }
    assert(im('ı').toString == "ı");
    assert(im('c') == 'c');
    assert(im('ş') == 'ş');
    assert(im('\U0001ffff') == '\U0001ffff');
    assert(im('ç') < im('d'));
    assert(im('i') >= im('ı'));
    assert(im('ğ') < 'h');
    assert(im('t') >= 'ş');
    assert(cast(dchar)im('a') == 'a');
    assert(cast(dchar)im('Ğ') == 'Ğ');
    assert(cast(dchar)im('\U0001ffff') == '\U0001ffff');
 
    int[im] tablo;
    tablo[im('ğ')] = 42;
    tablo[im('z')] = 7;
    assert(tablo[im('ğ')] == 42);
 
    assert(toUniUpper(im('ı')) == 'I');
    assert(toUniLower(im('İ')) == 'i');
}
 
struct dizgi
{
    im[] karakterler = karakterler.init;
 
    this(T)(const T[] karakterler)
    {
        this.karakterler = this.karakterler.init;
 
        static if (is(T == im)) {
            this.karakterler ~= karakterler;
        } else {
            this ~= dtext(karakterler);
        }
    }
 
    dizgi opAssign(T)(in T sağdaki)
    {
        karakterler = karakterler.init;
        return opCatAssign(sağdaki);
    }
 
    size_t length()
    {
        return karakterler.length;
    }
 
    dizgi opCatAssign(T)(in T ek)
    {
        static if (is(T == const dizgi)) {
            karakterler ~= ek.karakterler;
 
        } else static if (is(T == im) ||
                          is(T == im[])) {
            karakterler ~= ek;
 
        } else static if (is(T == char) ||
                          is(T == wchar) ||
                          is(T == dchar)) {
            karakterler ~= im(ek);
 
        } else {
            foreach (dchar karakter; ek) {
                karakterler ~= im(karakter);
            }
        }
 
        return this;
    }
 
    dizgi opCat(T)(const T ek)
    {
        dizgi sonuç = this;
 
        static if (is(T == im[])) {
            // Bu bloğu ayırarak yazmaya gerek olmamalı; ama yapmazsak
            // opCatAssign içinde bir derleme hatası alıyoruz. (Neden? :))
            sonuç.karakterler ~= ek;
 
        } else {
            sonuç ~= ek;
        }
 
        return sonuç;
    }
 
    dizgi opCat_r(im[] ek)
    {
        dizgi sonuç = ek;
        sonuç ~= karakterler;
        return sonuç;
    }
 
    dizgi opCat_r(const wchar[] ek)
    {
        dizgi sonuç = ek;
        sonuç ~= karakterler;
        return sonuç;
    }
 
    const bool opEquals(const ref dizgi sağdaki)
    {
        return karakterler == sağdaki.karakterler;
    }
 
    const bool opEquals(const dchar[] sağdaki)
    {
        if (karakterler.length != sağdaki.length) {
            return false;
        }
 
        foreach (i; 0 .. karakterler.length) {
            if (karakterler[i] != sağdaki[i]) {
                return false;
            }
        }
 
        return true;
    }
 
    const string toString()
    {
        dstring sonuç;
 
        foreach (kar; karakterler) {
            sonuç ~= cast(dchar)kar;
        }
 
        return text(sonuç);
    }
}
 
dstring toupper(in dizgi d)
{
    return toupper_tr(dtext(d.toString()));
}
 
dstring tolower(in dizgi d)
{
    return tolower_tr(dtext(d.toString()));
}
 
dstring capitalize(in dizgi d)
{
    return capitalize_tr(dtext(d.toString()));
}
 
dstring capwords(in dizgi d)
{
    return capwords_tr(dtext(d.toString()));
}
 
void toupperInPlace(ref dizgi d)
{
    dchar[] kopya = dtext(d.toString()).dup;
    toupperInPlace_tr(kopya);
    d = kopya;
}
 
void tolowerInPlace(ref dizgi d)
{
    dchar[] kopya = dtext(d.toString()).dup;
    tolowerInPlace_tr(kopya);
    d = kopya;
}
 
unittest
{
    // Sonra kullanmak için bir im dizisi
    im[] imler;
    imler ~= im('a');
    imler ~= im('ğ');
 
    // Boş dizgi
    dizgi d;
    assert(d.length() == 0);
 
    // char ile başlamak ve her tür eklemek
    dizgi dc = "abcğ\U0001ffff";
    dc ~= 'z';
    dc ~= 'Ö';
    dc ~= '\U0001ffff';
    dc ~= "xyzağı\U0001ffff";
    dc ~= imler;
    assert(dc.length() == 17);
 
    // wchar ile başlamak ve her tür eklemek
    dizgi dw = "abcğ\U0001ffff"w;
    dw ~= 'z';
    dw ~= 'ş';
    dw ~= "ıüŞjx"w;
    dw ~= imler;
    assert(dw.length() == 14);
 
    // dchar ile başlamak ve her tür eklemek
    dizgi dd = "abcğ\U0001ffff"d;
    dd ~= 'z';
    dd ~= 'Ö';
    dd ~= '\U0001ffff';
    dd ~= "aouğabcü"d;
    dd ~= imler;
    assert(dd.length() == 18);
 
    // im dizisi ile başlamak
    auto di = dizgi(imler);
    assert(di.length() == 2);
 
    // Birleştirmek
    dizgi ekli = dc ~ dw;
    assert(ekli.length == dc.length + dw.length);
 
    ekli = ekli ~ imler;
    ekli = imler ~ ekli;
    assert(ekli == ekli);
    assert(ekli != "abc");
    assert(ekli == "ağabcğ\U0001ffffzÖ\U0001ffffxyzağı\U0001ffff"
           "ağabcğ\U0001ffffzşıüŞjxağağ");
 
    dizgi ekli2 = "abc";
    ekli2 = "xyz" ~ ekli2;
    assert(ekli2 == "xyzabc");
    ekli2 = "ğğğ"w ~ ekli2;
    assert(ekli2 == "ğğğxyzabc");
 
    dizgi abc = "abcğ";
    assert("abcğ" == abc);
    assert(abc != "abcğz");
    assert(abc != "abc");
    assert(abc != "abcğz");
    assert(abc != "abc");
    assert("abcğz" != abc);
 
    dizgi küçükBüyük = "ğüiĞÜI şç";
    assert(toupper(küçükBüyük) == "ĞÜİĞÜI ŞÇ");
    assert(tolower(küçükBüyük) == "ğüiğüı şç");
    assert(capitalize(küçükBüyük) == "Ğüiğüı şç");
    assert(capwords(küçükBüyük) == "Ğüiğüı Şç");
 
    toupperInPlace(küçükBüyük);
    assert(küçükBüyük == "ĞÜİĞÜI ŞÇ");
 
    tolowerInPlace(küçükBüyük);
    assert(küçükBüyük == "ğüiğüı şç");
 
    // Atama
    dizgi atanan = "abc";
    atanan = "xyz";
    assert(atanan == "xyz");
    atanan = "pqr"w;
    assert(atanan == "pqr");
    atanan = "ştu"d;
    assert(atanan == "ştu");
}

dizgi_tr a = "ali";
dizgi_en b = "jim";
metin satır;
satır ~= a;
satır ~= b;