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.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

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

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Ö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.

Alıntı (canalpay):

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.

Alıntı:

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...)

Alıntı:

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

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (canalpay):

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

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (acehreli:1263977548):

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

http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D&article_id=105439

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

http://www.digitalmars.com/webnews/newsgroups.php?art_group=digitalmars.D&article_id=105441

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

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Ben şuan ayrıntıları merak ediyorum. "bir lisan bir insan" sözünü büyültmek sorun değil. Ama "Ali & Jim" örneğini nasıl çözeceklerini merak ile bekliyorum.

Bu arada diğer dillerin davranışlarını inceledim:
**
Python2:**
D ile aynı**
Python3:**
D ile aynı**
Php(Bence çok kötü bir durumda):**
"BiR küçÜcÜK ASLANcık varmış";
// PHP 5.3.0beta2-dev (cli) ile tr_TR.UTF-8 yerelindeki çıktısı:
// BiR KüçÜCÜK ASLANCıK VARMış
Denedim. ı i aynı bırakılmasını anlayabilirim hatta en iyisi o şu anlık ama ç gibi Türkçe karakterlerin aynı olması tam bir fiyasko. Sanırım php6 ile unicode desteği gelecek. O zaman düzelir.
Csharp(Linux mono ile):
Küçük iken: Ali & Jim
ALİ &JİM

JİM yerine JIM yapmasını da csharp'çılar sağlıyordur herhalde. Bakmak gerekiyor.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]