(Bu yöntemin ismi şakayla karışık olarak "self-important" olarak kalıyor.)

Seçerek import[1] ve yerel import[2,3] olanaklarını çok çok kolaylaştıran ve hatta işlev parametresi kullanımında önceden import gerektirmeyen bir yöntem keşfedildi:

// Bu şablon Phobos'a ekleniyor:
template from(string moduleName) {
   mixin("import from = " ~ moduleName ~ ";");
}

// Yöntem, aşağıdaki kullanımı sağlıyor.
// (Derleyicide değişiklik gerekmiyor; deneyebilirsiniz.)
void foo(from!"std.datetime".SysTime zaman) {
   // ...
}

void main() {
   // İşin güzel ve kötü tarafı, from'un eklediği SysTime sembolü yalnızca
   // foo() içinde görülüyor. Çağıranların da hangi SysTime'dan
   // bahsettiklerini belirtmeleri şart (modül düzeyinde import da olabilirdi):
   import std.datetime : SysTime;
   foo(SysTime.init);
}

Konusu şuradaydı:

http://forum.dlang.org/thread/tzqzmqhankrkbrfsrmbo@forum.dlang.org

Blogu şurada:

https://dlang.org/blog/2017/02/13/a-new-import-idiom/

Reddit konusu:

https://www.reddit.com/r/programming/comments/5tt33y/a_new_import_idiom_for_d/

Ali

[1] http://ddili.org/ders/d/moduller.html#ix_moduller.import,%20se%C3%A7erek

[2] http://ddili.org/ders/d/moduller.html#ix_moduller.import,%20yerel

[3] http://ddili.org/ders/d/katmalar.html#ix_katmalar.import,%20yerel

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

Ben daha önce böyle bir gereksinim duymadığım için bana çok elzem gelmedi. İşin doğrusu bu özellik nasıl bir kullanım senaryosunda alternatiflerinden daha etkili ve verimli olur bunuda bilemiyorum. Böyle bir örnek aklına geliyor mu Ali?

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

Blog yazısının sonunda bir soru var: Aşağıdaki STD yapısı olayı daha da kolaylaştırıyormuş ama yazarın söylediğine göre bir sorunu varmış (ama düzeltilebiliyormuş). Sorununun ne olduğunu bilmiyorum ama aşağıdaki kod std.datetime hiçbir yerde açıkça eklenmeden derleniyor:

// Bunun da Phobos'a eklendiğini varsayalım:
static struct STD {
   template opDispatch(string moduleName) {
       mixin("import opDispatch = std." ~ moduleName ~ ";");
   }
}

void foo(STD.datetime.SysTime zaman) {
   import std.stdio : writeln;
   writeln(zaman);
}

void main() {
   foo(STD.datetime.SysTime(42));
}

Bayıldım... :)

Ali

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

Çok ilginç bir konuya benziyor. Ben şimdilik hızlıca bakabildim.

Günce yazısında derleme zamanının ilk duruma göre %30'a düştüğünü ve çalıştırılabilir boyutunun ilk duruma göre %41 düştüğünü söylemiş. Ama benim denediğimde olmadı. Bunu örnek üzerinde derleme seçenekleri ile gösterebilecek var mı acaba.

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

Yalnızca derleme zamanına etkisi olacağı düşünülüyor ama Erdem gibi başkaları da pek etkisini göremiyorlar.

Temelde, bu yöntem başka yollarla mümkün olmayan bir import tembelliği getiriyor.

Normalde modülün başına 'import std.datetime;' yazarız ve herşey yolunda gider. Ancak, o durumda derleyicinin o modülün tamamını okuması ve bir ölçüde derlemesi gerekir. Onun yerine seçerek import yeğlenir çünkü derleyici yalnızca eklenen isimleri okur ve derler:

import std.datetime : SysTime;

Onun sakıncası, SysTime'ın yalnızca tek işlev içinde kullanıldığı durumdur. O zaman da yerel import kullanırız:

void foo() {
   import std.datetime : SysTime;
   // ...
}

Onun yararı, foo() programda hiç çağrılmadığı zamanlarda öne çıkar: Derleyici std.datetime'ı hiç açmaz bile. (Aslında sanırım bu yalnızca foo'nun şablon olduğu durumda doğru. Yoksa, normal işlev olduğunda yine de o modülü açıp foo'nun içindeki kodları derlemesi gerekir.)

Seçerek import'un ve yerel import'un başka bir yararı, isim kirlenmesini aza indirmesidir: Yalnızca belirtilen isimler ve olabiliyorsa yalnızca belirli kapsamlara eklenirler.

Buraya kadar güzel. Bir de SysTime'ın foo'nun parametrelerinde geçtiğini düşünelim. Bu durumda SysTime'ın yerel import edilmesi olanaksızdır:

import std.datetime : SysTime;
void foo(SysTime zaman) {
   // ...
}

Yani, parametrenin derlenebilmesi için import'un foo'nun dışına alınması gerekir. İşte bu yeni yöntem, bunun önüne geçiyor: SysTime ismi çok yerel olarak ve seçilerek ekleniyor. Hem işlevin parametre listesini kapsıyor hem de içini. (Bir derleyici hatasına veya açığına dayandığını düşünmeden edemiyorum. :) )

Beni bu konuda hâlâ rahatsız eden bir şey var: Eğer SysTime işlevin arayüzünde geçiyorsa, o işlevi çağıran herkesin SysTime'ı bir şekilde eklemiş olması gerekir. N adet kullanıcı ayrı ayrı ekleyeceğine tek burada eklemek yetebilir ve böylece foo'yu kullanabilmek için başka modül eklemek gerekmemiş olur:

public import std.datetime : SysTime;
void foo(SysTime zaman) {
   // ...
}

Yani, zaten böyle olması daha kullanışlı olduğundan, from yöntemi ne kadar güzel olursa olsun, ben her durumda kullanışlı olduğunu düşünmüyorum.

Ali

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

Alıntı (acehreli):

O söylediğimde yanılıyorum çünkü foo'nun içinde bulunduğu modülü ekleyen herkes foo'yu çağırmak zorunda değil. Dolayısıyla, std.datetime'ın foo'dan önce public import edilmesi yanlış kabul edilmelidir çünkü SysTime ismini herkese ekleyerek bazı durumlarda gereksiz isim kirliliği oluşturmuş demektir.

Ali

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

Şimdi denedim Ali aynen söylediğin gibi modül içinde foo yerine başka bir işlevi çağırdığımda herhangi bir hata vermeden çalıştı ancak foo çağrılınca SysTime tanımını istedi. public import tekniğini bende çok kullanıyordum bundan sonra daha dikkatli olacağım.

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