Forum: Projeler trileri RSS
trchar ve trstring?
Sayfa:  1  2  sonraki 
acehreli (Moderatör) #1
Kullanıcı başlığı: Ali Çehreli
Üye Haz 2009 tarihinden beri · 4428 mesaj
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Konu adı: trchar ve trstring?
Başlıktaki gibi yapılar tanımlamak nasıl olur? Kendi gereken işleçlerini yükleyerek char ve string gibi kullanılabilirler.

D'nin alias this olanağı, bir türün otomatik olarak başka bir tür yerine geçmesini sağlıyor. Ondan da yararlanarak, örneğin trchar'ı otomatik olarak dchar yerine de kullanabiliriz (acaba char mı olmalı? :)):

Aklıma ilk gelen:

struct trchar
{
    dchar c_;
 
    this(dchar c)
    {
        c_ = c;
    }
 
    alias c_ this;
}
 
void dcharBekleyenİşlev(dchar c)
{
    dout.writefln(c);
}
 
// ...
 
    auto ğ = trchar('ğ');
    dcharBekleyenİşlev(ğ);

Örneğin < işlecini Türk alfabesine göre yükleyebiliriz. Hatta toUniLower işlevini de bu tür için yüklersek, kullanıcılar toUniLower_tr'yi özel olarak çağırmak zorunda kalmazlar, ve hatta yanlışlık da yapamazlar.

Buna bakmak isteyen var mı?

Ali
canalpay (Moderatör) #2
Kullanıcı başlığı: Can Alpay Çiftçi
Üye Tem 2009 tarihinden beri · 1133 mesaj · Konum: İzmir
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Evet güzel gibi duruyor. Çünkü biz sadece phobos'un Türkçeye uygun olmayan yanlarını çevirdik. Ama bu biçimde kolaylıkla tango( Lütfen tangonun net modülüne bakın. İçimden bir ses orada bir siteden dosya indirmek için gerekli işlevlerin yazıldığını söylüyor :-D ) gibi kütüphaneleri de kullanabiliriz(Değil mi ?).

Ama bunu nasıl yapacağımızı tam anlamadım. (Yapıları da daha tam olarak anlamadım.)

Bunun temelinde okul arası çok göz gezdirememiş olmam. Şuan okul yarıyıl tatiline girdi gibi bir şey olduğu için dershaneye bilmediğim yerlere bakmaya çalışıyorum.


Ama bu kodlar ile ne yaptığımızı anlamadım. Burada 'a' karakterini ortaya koyarsak 'a' karakteri aslında string. Ama biz bunu dchar gibi davranmasını sağlıyoruz. Ama aslında 'a' karakteri dchar çevirmemiş olduk. Sadece işlev dchar sanacak.
 
Eğer bunu ğ ile deneseydik dchar olmasına karşın 2 bayt mı olmalıydı ?


En iyisi bu kodları deneyip neyin ne olduğunu anlamaya çalışayım.
canalpay (Moderatör) #3
Kullanıcı başlığı: Can Alpay Çiftçi
Üye Tem 2009 tarihinden beri · 1133 mesaj · Konum: İzmir
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Derleyemedim.

Verilen hata:

isimsiz.d(23): Error: variable isimsiz.ğ conflicts with variable isimsiz.ğ at isimsiz.d(22)


Çakışan değişkenler:
    auto ğ = trchar('ğ');
    dcharBekleyenİşlev(ğ);
acehreli (Moderatör) #4
Kullanıcı başlığı: Ali Çehreli
Üye Haz 2009 tarihinden beri · 4428 mesaj
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Yanıtlanan mesaj #2
canalpay:
kolaylıkla tango( Lütfen tangonun net modülüne bakın.

Duyduklarıma bakılırsa Tango çok güzel bir kütüphane; ama ben bir süre odağımı kaybetmek istemiyorum. :)

İçimden bir ses orada bir siteden dosya indirmek için gerekli işlevlerin yazıldığını söylüyor :-D ) gibi kütüphaneleri de kullanabiliriz(Değil mi ?).

Eğer bu türler otomatik olarak dchar ve dstring'e dönüşürlerse, herhangi bir kütüphane ile kullanabiliriz.

(Yapıları da daha tam olarak anlamadım.)

class'lardan çok farklı değiller: ikisi de başka türleri bir araya getirerek yepyeni tür tanımlar.

En önemli fark: yapılar değer türüdür, sınıflar referans türüdür.

C ve C++'da her şey değer türü olduğu için sınıfların referanslığına alışmam gerekiyor. :) (İstisna olarak, C ve C++'da diziler bu ikisinin arasında bir şeydir.)

Bunun temelinde okul arası çok göz gezdirememiş olmam.

Gereksiz tekrar olacak ama okul önemli... :)

Ama bu kodlar ile ne yaptığımızı anlamadım. Burada 'a' karakterini ortaya koyarsak 'a' karakteri aslında string.

'char' demek istedin tabii. ("a" olsa string olurdu.)

Ama biz bunu dchar gibi davranmasını sağlıyoruz. Ama aslında 'a' karakteri dchar çevirmemiş olduk. Sadece işlev dchar sanacak.

Elimizde bir trchar olacak. Onun türü hiç değişmeyecek. Karşılaştırmasını filan kendi kuralların göre yapacak.

Kendisi farklı bir tür olarak kullanılmak istendiğinde, c_ üyesini kullanacak. alias c_ this, "benim yerime c_" kullanılabilir gibi bir anlama geliyor.

En iyisi bu kodları deneyip neyin ne olduğunu anlamaya çalışayım.

Denemek iyi... :)

Bu arada, işlev yükleme konusu çok işe yarayacak. trchar'ları Türkçe kuralına göre karşılaştırmak şu kadar kolay olmalı (derlemedim):

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

O işlev sayesinde artık trchar'ları da küçültebiliyoruz. İşini, uni.d'de tanımladığımız ve dchar kullanan toUniLower_tr'ye havale ediyor.

Böylece kütüphaneye trchar diye bir tür eklemiş olacağız.

Onun içine opCmp'un da mutlaka eklenmesi gerek. O da tr.string içindeki sıra numaralarından yararlanır.

Ali
acehreli (Moderatör) #5
Kullanıcı başlığı: Ali Çehreli
Üye Haz 2009 tarihinden beri · 4428 mesaj
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Yanıtlanan mesaj #3
Ben dmd 2.039 ile şunu derleyebiliyorum ve çalışıyor:

import std.cstream;
 
struct trchar
{
    dchar c_;
 
    this(dchar c)
    {
        c_ = c;
    }
 
    alias c_ this;
}
 
void dcharBekleyenİşlev(dchar c)
{
    dout.writefln("işlev içinde: ", c);
}
 
void main()
{
    auto ğ = trchar('ğ');
    dcharBekleyenİşlev(ğ);
}

Ali
canalpay (Moderatör) #6
Kullanıcı başlığı: Can Alpay Çiftçi
Üye Tem 2009 tarihinden beri · 1133 mesaj · Konum: İzmir
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Benim anladığım bir tür belirliyoruz. O türe istediğimiz özellikleri yüklüyoruz. Ve en sonunda o türün dchar gibi başka bir türün yerine geçmesini istiyoruz.(Yani aslında dchar türünü en baştan tasarlıyoruz, çok iyi bir olanak.)

Benim fikirlerim:
1. char[] yerine string olmalı bence. (Çünkü phobos öntanımlı olarak string kabul ediyor.)
2. Sadece dizgilerde çalışmamalı. Karakterlerde de çalışmalı. Bu da tabiki immutable char olmalı.
3. Bence her ne kadar immutable char ile bu yapıyı çağırsakta istersek dchar gibi türlerle de çağırabilmeliyiz. Ondan sonra çağırdığımız türü string yada immutable char'a çeviririz. Daha sonra yapı kaldığı yerden devam eder.
4. Ee bu birden fazla tür ile çalışacak(en basitinden hem string hem de immutable char) bu yüzden adı trstring gibi belirli bir ad olmamalı.
Ben trtür,  trimmutable ,trdeğişmez gibi adlar olabilir.(Şimdi hatırladım. Tango char'a Mut-8 dchar'a Mut-32 diyordu. Bizde trimmut-8 adını verebliriz.)
acehreli (Moderatör) #7
Kullanıcı başlığı: Ali Çehreli
Üye Haz 2009 tarihinden beri · 4428 mesaj
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Bu arada, Türkçe harflerin char'a sığmadıklarını da hatırlamak gerek. En küçük wchar olmalı...

canalpay:
Benim anladığım bir tür belirliyoruz. O türe istediğimiz özellikleri yüklüyoruz. Ve en sonunda o türün dchar gibi başka bir türün yerine geçmesini istiyoruz.

Evet. Otomatik olarak başka türlerin yerine geçmesi hem iyi, hem de kötü. Kavramsal olarak sonuçta bir karakter olduğu için, otomatik dönüşüm mantıklı ve kolay olur.

Öte yandan, başka her otomatik dönüşümde olduğu gibi, bazen farkedilmeden ve istenmeden dönüşmesinin yolunu da açar.

Bunu biraz daha düşünmek gerek. Belki to!string gibi bir işlev düşünebiliriz. Serbest işlev de olabilir, üye de...

1. char[] yerine string olmalı bence. (Çünkü phobos öntanımlı olarak string kabul ediyor.)

Kabul ama dizginin değiştirilebilir olmasını da isteyeceğiz. string, immutable char[] olduğu için değiştirilemiyor.

2. Sadece dizgilerde çalışmamalı. Karakterlerde de çalışmalı. Bu da tabiki immutable char olmalı.

Zaten karakteri temsil eden bir tür, ve onun dizi halini temsil eden bir tür gerekiyor... diye düşünmüştüm... Ama şimdi düşününce, aslında karakteri tanımlamak yeterli.

Dizgi, temel dizgilerde de olduğu gibi, onun dizi hali olur: trchar[] veya, belirteciyle birlikte: immutable trchar[] vs.

3. Bence her ne kadar immutable char ile bu yapıyı çağırsakta istersek dchar gibi türlerle de çağırabilmeliyiz. Ondan sonra çağırdığımız türü string yada immutable char'a çeviririz. Daha sonra yapı kaldığı yerden devam eder.

Güzel.

4. Ee bu birden fazla tür ile çalışacak(en basitinden hem string hem de immutable char) bu yüzden adı trstring gibi belirli bir ad olmamalı.
Ben trtür,  trimmutable ,trdeğişmez gibi adlar olabilir.(Şimdi hatırladım. Tango char'a Mut-8 dchar'a Mut-32 diyordu. Bizde trimmut-8 adını verebliriz.)

Veya, bir yapı şablonu olur ve biz tr!char, tr!dchar, tr!(immutable char) gibi çağırabiliriz. (Biliyorum, çok çirkin, ama onlara alias ile güzel isimler verebiliriz. :) )

Şöyle bir şey denedim:

import std.cstream;
 
struct tr(T)
{
    T c_;
 
    this(T c)
    {
        c_ = c;
    }
 
    TT to(TT)()
    {
        return cast(TT)c_;
    }
 
    alias T this;
}
 
void dcharBekleyenİşlev(dchar c)
{
    dout.writefln("işlev içinde: ", c);
}
 
void immutable_wchar_bekleyen_işlev(immutable wchar c)
{
    dout.writefln("immutable alan işlevde: ", c);
}
 
void main()
{
    // wchar
    auto ğ = tr!wchar('ğ');
    dcharBekleyenİşlev(ğ.to!dchar);
    immutable_wchar_bekleyen_işlev(ğ.to!(immutable wchar));
    dout.writefln("wchar: %s dchar: %s", ğ.to!wchar, ğ.to!dchar);
 
    // dchar
    auto ş = tr!dchar('ş');
    dcharBekleyenİşlev(ş.to!dchar);
    immutable_wchar_bekleyen_işlev(ş.to!(immutable wchar));
    dout.writefln("wchar: %s dchar: %s", ş.to!wchar, ş.to!dchar);
 
    // Böyle bir şey de gerçekleştirmek gerek
//     tr!wchar[] merhaba = "merhaba";
}

Ali
canalpay (Moderatör) #8
Kullanıcı başlığı: Can Alpay Çiftçi
Üye Tem 2009 tarihinden beri · 1133 mesaj · Konum: İzmir
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Bu arada, Türkçe harflerin char'a sığmadıklarını da hatırlamak gerek. En küçük wchar olmalı...
Ama kütüphane için tekrar string'e dönüştürmek gerekecek değil mi ? Yani yinede sığmayacak. Sadece sonuca daha erken varmış olacağız :-) Ayrıca char'ı tekrar wchar yaptığımızda bu sefer sığmayan şey sığmış olacak.

Diğer dediklerinize de yanıtlayacaktım ama kısaca :
   
auto ş = tr!dchar('ş');
Eğer böyle yapabiliyorsak böyle yapalım ama yapamıyorsak tabiki immutable char olmalı. Neden mi ? Çünkü immutable charı daha çok kullanıyoruz.(phobostan dolayı).

    tr!wchar[] merhaba = "merhaba";

Ben ayrıca trwchar[] diye tanımlayalım dememin nedeni whar[] şeklinde tanımlayamamdı. Sizce wchar[] şeklinde tanımlayabilir miyiz?

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

Anlamadığım yerler var. 2 T ne işe yarıyor.(tahmin !wchar da işe yarıyor.)

Şuan yapmak istediklerimiz(Bence):

1.tr!(istediğimizTür)('s');
2.tr!(istediğimiztüründizgisi[])("deneme");

Birincisini verdiğiniz kodlar hallediyor.Ama bana asıl sorun ikinci kodlar gibi geldi. Çünkü siz bu kodları vermeden öncede denemiştim ama pratik bir yolunu bulamadım.
acehreli (Moderatör) #9
Kullanıcı başlığı: Ali Çehreli
Üye Haz 2009 tarihinden beri · 4428 mesaj
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
canalpay:
Bu arada, Türkçe harflerin char'a sığmadıklarını da hatırlamak gerek. En küçük wchar olmalı...
Ama kütüphane için tekrar string'e dönüştürmek gerekecek değil mi ?

Kesinlikle.

Yani yinede sığmayacak.

Bir Türkçe harfi tek bir char'a yerleştirmek olanaksız; çünkü char, Unicode karakteri değil; onu oluşturan kodları içerebiliyor. (ASCII için bunlar bire bir.)

Ama D, wchar'ı bile bir char[]'a yerleştirmeye izin veriyor:

import std.cstream;
 
void main()
{
    wchar w = 'ğ';
    char[] dizgi;
    dizgi ~= w;
 
    dout.writefln("uzunluk: ", dizgi.length);   // 2 yazar
}

Eğer Türkçe harf gibi davranan bir yapı olacaksa, o da kendisini bu şekilde kullandırabilmeli.

D'nin iç olanak olarak sunduğu karakter ve dizi davranışlarını bir gözden geçirmek gerek.

Sadece sonuca daha erken varmış olacağız :-) Ayrıca char'ı tekrar wchar yaptığımızda bu sefer sığmayan şey sığmış olacak.

Anlıyorum.

Diğer dediklerinize de yanıtlayacaktım ama kısaca :
   
auto ş = tr!dchar('ş');
Eğer böyle yapabiliyorsak böyle yapalım ama yapamıyorsak tabiki immutable char olmalı. Neden mi ? Çünkü immutable charı daha çok kullanıyoruz.(phobostan dolayı).

Öte yandan, immutable her türe uygulanabilen bir depolama türü. Biz yalnızca türü tanımlayınca onu zaten immutable yapabileceğiz. Yani immutable'lığı özellikle türün parçası haline getirmenin gerektiğini düşünmüyorum.

Ama olabilir de aslında. Örneğin iki char'dan oluşan Türkçe harf sabitleri olursa, onların karakterleriyle teker teker oynamak yasal olmamalıdır.

    tr!wchar[] merhaba = "merhaba";

Ben ayrıca trwchar[] diye tanımlayalım dememin nedeni whar[] şeklinde tanımlayamamdı.

Başka şablonlardan doğru tür olarak çağırabilmek için, bizimkinin de şablon olmasında yarar var:

void foo(KarakterTürü)()
{
    tr!KarakterTürü k;
}

Yani, şablon olursa, foo'ya gönderilen karakter türü ne olursa olsun, doğru Türkçe harf seçilir.

alias ile nasıl olsa kullanışlı adlar da verilebiliyor:

alias tr!wchar trwchar;

Sizce wchar[] şeklinde tanımlayabilir miyiz?

Bizim türün dizisinde wchar[]'a otomatik dönüşüm olmadığını biliyorum.

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

Anlamadığım yerler var. 2 T ne işe yarıyor.(tahmin !wchar da işe yarıyor.)

Yapıyı tanımlarken kullanılan T ile karışmasın diye başka bir isim olarak seçtim. Yapı wchar ile kullanılmış bile olsa, to!dchar denebiliyor. Yani T yapının değişken türü, TT de to işlevinin...

Şuan yapmak istediklerimiz(Bence):

1.tr!(istediğimizTür)('s');
2.tr!(istediğimiztüründizgisi[])("deneme");

Birincisini verdiğiniz kodlar hallediyor.Ama bana asıl sorun ikinci kodlar gibi geldi. Çünkü siz bu kodları vermeden öncede denemiştim ama pratik bir yolunu bulamadım.

Bence ikincisini D diline bırakabilmeliyiz. Yani trwchar[] yazılabilmeli; ama "deneme" gibi bir dizgiyle ilklenemiyor.

Ali
acehreli (Moderatör) #10
Kullanıcı başlığı: Ali Çehreli
Üye Haz 2009 tarihinden beri · 4428 mesaj
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Bununla ilgili iki yapı yazdım.

İsimlerinin şimdilik im ve dizgi koydum. im, tek bir Türkçe karakteri temsil ediyor. (Harf diyemiyorum, çünkü bütün karakterler de kullanılabiliyor.) dizgi de im'leri bir araya getiren bir dizgi.

Bununla oynarken derleme zamanında karar vermeye yarayan static if'i de kullanma fırsatı buldum. Yerinde mi kullanıyorum, yoksa abartıyor muyum emin değilim. :)

Bu türler aklıma gelen bütün işlemleri sağlıyor. Unuttuğum şeyler var mı?

Aşağıdaki kod, trileri'nin son haliyle çalışıyor. Denemek için onu yenilemek gerek. Bu yapıları daha sonra o projeye ekleyebiliriz.

trileri'deki _tr işlevlerinin _tr olmayanlarını da bu sınıflar için yükledim. Böylece "Türkçe harf" türleri olmuş oluyorlar. O yüklediğim işlevlerde hızı düşünmedim. Şimdilik işlevselliğe önem verdim.

Şöyle bir şey:

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");
}

Ali
canalpay (Moderatör) #11
Kullanıcı başlığı: Can Alpay Çiftçi
Üye Tem 2009 tarihinden beri · 1133 mesaj · Konum: İzmir
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Elinize sağlık.

Ama hala "Ali Çehreli & Walter Bright" dizgisinde ne yapılacağı belirsiz değil mi ?

Ben bunun için yine "\" imini koymayı teklif ediyorum. (Bu hem trileri, hemde bu proje için geçerli.)

Örnek : "Ali Çehreli & Walter Br\ight"
toupper  (yada toupper_tr) işlevini çağırdığımızda sonucuda şöyle bir şey olur:

"ALİ ÇEHRELİ & WALTER BRIGHT"
Sizce ?
acehreli (Moderatör) #12
Kullanıcı başlığı: Ali Çehreli
Üye Haz 2009 tarihinden beri · 4428 mesaj
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Öncelikle, ben bu char, karakter, harf, vs. konusunda bir yazı yazmayı düşünmeye başladım. Hiçbir şey göründüğü gibi değil. :)

Örneğin; aslında bildiğimiz halde; char, wchar, ve dchar "harf" değiller. Harf olabilmek için, bir alfabeye bağlı olmak gerekir. D'nin karakter türleri, kendilerinin de söyledikleri gibi, yalnızca UTF kodlamaları...

Onları harf olarak kullanmak aslında zaten çalışmıyor.

canalpay:
Ama hala "Ali Çehreli & Walter Bright" dizgisinde ne yapılacağı belirsiz değil mi ?

Evet belirsiz. Çünkü 'i' ve 'i' harflerini karşılaştırmak bile belirsiz. Size sorsam: "'i' ve 'i' aynı harf midir?" o harflerin hangi alfabede olduklarını bilmeden cevap veremeyebilirsiniz.

Nedir harflerin aynılığı? Şekil benzerliği mi? Ses mi? Örneğin yukarıdaki 'i' ve 'i' farklı alfabedelerse aynı kabul edilirler mi?

Bunun cevabı yalnızca program tarafından bilinebilir. Bazen aynıdırlar, bazen değil.

O yüzden, im ileride hangi alfabeye ait olduğu bilgisini de taşıyacak. Örenğin im_tr ve im_az (Azeri). Farklı türden olacakları için onların karşılaştırılmaları yasal olmayacak.

Ancak kullanıcı kendi seçtiği karşılaştırma ile karşılaştırabilecek.

Ben bunun için yine "\" imini koymayı teklif ediyorum. (Bu hem trileri, hemde bu proje için geçerli.) Örnek : "Ali Çehreli & Walter Br\ight"

Yukarıda söylediklerimle paraler gidiyorsun. \i, senin dilinde ASCII (veya İngilizce) harf demek oluyor. Kesinlikle katılıyorum. Harfin kendisi alfabesini bilmeli.

(Ama \i olmaz; çünkü onlar özel karakter sabitleridir ya...)

toupper  (yada toupper_tr) işlevini çağırdığımızda sonucuda şöyle bir şey olur:

"ALİ ÇEHRELİ & WALTER BRIGHT"
Sizce ?

Kabul ama onu yukarıda gösterdiğim dizgi'leri bir araya getiren bir metin yapısında düşünebiliriz belki de. Bir dizgi im_tr'lerden oluşur, diğer dizgi im_en'lerden. O zaman herkes kendi bildiği gibi büyütülür. (DÜZELTME: metin, dizgileri bir araya getirir.)

Bu konuda daha ileri fikir yürütmeden önce IBM'in Unicode kütüphanesi olan ICU'ya bakmakta yarar var:

  http://www-01.ibm.com/software/globalization/icu/index.jsp

Tekerleği yeniden keşfetmeye gerek yok. :) (Ama bizim fikirler daha iyi olabilir. :-p)

Ali
canalpay (Moderatör) #13
Kullanıcı başlığı: Can Alpay Çiftçi
Üye Tem 2009 tarihinden beri · 1133 mesaj · Konum: İzmir
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Ben kendim için bir toparlayayım:
1. Kimin alfabesini kullanacağımız belli olmuyor. Bu yüzden neyi neye göre değiştireceğimiz belli olmuyor. Bazen I->i dönüşümü doğru iken bazen yanlış olabiliyor.
Bizde bu yüzden im_tr gibi programa hangi alfabeyi kullanmalarını belirtmelerini istiyoruz. Böylece evrensel bir doğruluk oluyor. (En iyisi biz kendimize yeni bir alfabe yapalım. Dİğer bu sorunu çekecek yabancıları boş verelim :-D )

2. Ama bazen bir değil 2 alfabe aynı anda kullanılmak zorunda kalınıyor. Bu işi de şu şekilde hâllediyoruz:

im_tr[] deneme="Ali Çehreli & -*-en-*- Walter Bright*-* "

Ve böylece programımıza şunu diyoruz:

Eğer elle hangi elle alfabe kullanılacağı belirtilmedi ise tr alfabesini kullan. Yok eğer -*-en -*- Yazı *-* ile belirtildi ise sen ön tanımlı alfabeyi unut ve belirtilen alfabenin (-*-belirtilen alfabe burası -*-) belirtilen dizgilerle kullan(belirtilen dizgi  *-*)       diyoruz. Böylece her bir olasılığı düşünmüş oluyoruz. Böylece şu şekilde bir şey yapabiliyoruz:

im_tr[] deneme = "Ali Çehreli & -*-en-*- Walter Bright*-* Yine Türkçe alfabesine devam. -*-az-*-Birde Azerice*-*....."

Gibi pratik bir iş yapabiliyoruz.


Tek bir harf için -*- kuralını uygulamak zor gelecektir bunu da şu şekilde hallederiz:

im_tr[] deneme = "Ali Çehreli & Walter Br[en]ight"

gibi.
acehreli (Moderatör) #14
Kullanıcı başlığı: Ali Çehreli
Üye Haz 2009 tarihinden beri · 4428 mesaj
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
canalpay:
im_tr[] deneme="Ali Çehreli & -*-en-*- Walter Bright*-* "

Alışılmış bir şey değil ama olabilir. Çıkış işlemlerinden önce veya dizgiyi başka kütüphane işlevlerine gönderirken o belirteçleri filtrelemek gerekecektir.

Benim metin dediğim, yine aynı mantığa sahipti ama veri hakkındaki bilgiyi verinin türünde tutuyordu:

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

metin kendi içinde iki değişik dil bilgisi tuttuğunu bilebilir.

Bu ikisinin dışında çözümler de bulunabilir. IBM'in ICU kütüphanesi çok bilinir. Onların nasıl düşündüklerini de merak ediyorum.

Başka çoğu tasarım, karakterin kendisine alfabe bilgisi vermiyor. Genelde üst düzey işlevlere bir yerel gönderiliyor ve "bu sıralamayı Türkçe'ye" göre yap deniyor. Yani onlarda verinin kendisi salt veri olarak duruyor. Bu sefer de program verinin ne olduğunu bilmek zorunda.

Bilmiyorum; belki de dünyada karakter sorunu yoktur zaten. Bir sürü program çalışıyor işte. :p

Ali
acehreli (Moderatör) #15
Kullanıcı başlığı: Ali Çehreli
Üye Haz 2009 tarihinden beri · 4428 mesaj
Grup üyelikleri: Genel Moderatörler, Üyeler
Profili göster · Bu konuya bağlantı
Yanıtlanan mesaj #12
acehreli on 2010-01-19, 23:52:
Harf olabilmek için, bir alfabeye bağlı olmak gerekir. D'nin karakter türleri, kendilerinin de söyledikleri gibi, yalnızca UTF kodlamaları...

Aynı fikirleri Andrei Alexandrescu'nun std.string'de yapacağı yeniliklerden bahsettiği bir konuda belirttim:

  http://www.digitalmars.com/webnews/newsgroups.…?art_grou…

Kendisi de aynı fikirde olduğunu söyledi:

  http://www.digitalmars.com/webnews/newsgroups.…?art_grou…

toupper ve tolower'a isteğe bağlı olan bir parametre vermeyi ve dönüşümleri kullanıcının belirleyebilmesini düşündüğünü söylüyor.

Henüz ayrıntılar belli değil...

Ali
Doğrulama Kodu: VeriCode Lütfen resimde gördüğünüz doğrulama kodunu girin:
İfadeler: :-) ;-) :-D :-p :blush: :cool: :rolleyes: :huh: :-/ <_< :-( :'( :#: :scared: 8-( :nuts: :-O
Özel Karakterler:
Sayfa:  1  2  sonraki 
Forum: Projeler trileri RSS
Bağlı değilsiniz. · Şifremi unuttum · ÜYELİK
This board is powered by the Unclassified NewsBoard software, 20100516-dev, © 2003-10 by Yves Goergen
Şu an: 2017-07-22, 09:35:57 (UTC -07:00)