Thread overview
MoreInfo(types...) Adam'dan, çok güzel!
Aug 30
Cos00kun
August 30

Merhaba,

Bugün biraz okuma yapıyorum (bu arada 100. yıl, 30 Ağustos Zafer bayramımızı tebrik ederim)..

Adam D.Ruppe'nin D Cookbook kitabının "Extending the runtime type information" başlığında (sayfa 219) güzel bir uygulama dikkatimi çekti. Her ne kadar ileri seviye olsa da Çoşkun'nun auto ve türler üzerine araştırmasına katkı sağlayabilir. Çünkü türleri sadece kullanmak yetmiyor, kendi türleriniz üzerinde de, olabildiğince ve ustaca tarzanlık yapmak gerekebilir:

İşte (kendi sadeleştirmem ile) ustaca tarzanlık:

MoreInfo birBak(T)(T t) {
  if (auto ptr = typeid(t) in moreTypeInfo)
    return *ptr;

  return null;
}

MoreInfo birBak(T)() {
  if (auto ptr = typeid(T) in moreTypeInfo)
    return *ptr;

  return null;
}

interface MoreInfo {
  bool birSayı_Mı();
  string ptrVer_strAl(in void*);
}

class MoreInfoImpl(T) : MoreInfo {
  import trait = std.traits;

  bool birSayı_Mı() {
    return trait.isIntegral!T;
  }

  string ptrVer_strAl(in void* ptr) {
    import std.conv;

    auto t = cast(T*) ptr;
    return to!string(*t);
  }
}

Aslında bu kodları yarı yarıya düşürdüm içinde işleri kolaylaştırıcı mixin template EnableMoreInfo(types...) vardı. Ancak kodu tam okuyabilmek için ona ihtiyaç duymadan kendi AA'mı liste halinde ekleyebilmek istedim. Yani şöyle:

MoreInfo[TypeInfo] moreTypeInfo;

static this() {
   moreTypeInfo[typeid(int)] = new MoreInfoImpl!int();
   moreTypeInfo[typeid(Foo)] = new MoreInfoImpl!Foo();
}

// şimdi kendi türümüzü oluşturup deneyelim:

class Foo
{
  override string toString() { return "Bu bir Foo Class"; }
}

import std.conv, std.traits;
void main()
{
  int a = 34;
  Foo foo = new Foo;
  import std.stdio;

  /** örnek-1 **/
  isIntegral!(typeof(a)).writeln(": doğrudan, yansıma yok");
  birBak(a).birSayı_Mı.writeln(); // true

  isIntegral!Foo.writeln(": doğrudan, yansıma yok");
  birBak!(Foo).birSayı_Mı.writeln(); // false

  /** örnek-2 **/
  a.to!string.writeln;
  auto str1 = birBak(a).ptrVer_strAl(&a);
  typeof(str1).stringof.writeln(": ", str1);

  foo.to!string.writeln;
  auto str2 = birBak(foo).ptrVer_strAl(&foo);
  typeof(str2).stringof.writeln(": ", str2);
}

Çıktısı ise lüzumsuz ama siz de deneyin belki daha lüzumlu örnekler ile doldurabilirsiniz:

>

true: doğrudan, yansıma yok
true
false: doğrudan, yansıma yok
false
34
string: 34
Bu bir Foo Class
string: Bu bir Foo Class

Gerçekten güzel ve etkilici değil mi? Tabi bu etkileyicilik D'den geliyor o başka :)

Başarılar...

August 30

On Tuesday, 30 August 2022 at 06:34:23 UTC, Salih Dincer wrote:

>

Adam D.Ruppe'nin D Cookbook kitabının "Extending the runtime type information" başlığında (sayfa 219)

Kodun orijinali 74 satırdır:

/// stores the information
immutable MoreInfo[TypeInfo] moreTypeInfo;
/// Gets extended info from a value
public immutable(MoreInfo) extTypeInfo(T)(T t)
{
    if (auto ptr = typeid(t) in moreTypeInfo)
        return *ptr;
    return null;
}
/// Gets extended info from a type
public immutable(MoreInfo) extTypeInfo(T)()
{
    if (auto ptr = typeid(T) in moreTypeInfo)
        return *ptr;

    return null;
}
/// The interface we provide to more info
public interface MoreInfo
{
immutable:
    /// is it an integral type?
    bool isIntegral();
    /// given a pointer to this type, return it as a string
    /// Be sure the pointer is actually the correct type!
    string getAsString(in void*);
}
/// The implementation of the interface for any type
private class MoreInfoImpl(T) : MoreInfo
{
immutable:
    // std.traits offers reflection helpers
    import trait = std.traits;

    bool isIntegral()
    {
        return trait.isIntegral!T;
    }

    string getAsString(in void* ptr)
    {
        import std.conv;

        auto t = cast(T*) ptr;
        return to!string(*t);
    }
}
/// This creates all the instances we want to enable
public mixin template EnableMoreInfo(types...)
{
    /// A static constructor is run at thread startup
    shared static this()
    {
        foreach (type; types)
            moreTypeInfo[typeid(type)] = new immutable MoreInfoImpl!type();
    }
}
/* User code */
class A
{
} // a random custom class
// enable more info for built-in ints and our class

mixin EnableMoreInfo!(int, A);
void main()
{
    import std.stdio;

    // test
    writeln(extTypeInfo(1).isIntegral()); // true
    writeln(extTypeInfo!(A).isIntegral()); // false
    int a = 34;
    writeln(extTypeInfo(a).getAsString(&a)); // prints 34
}

Referans olması amacıyla durmasında fayda var sanırım?

Sevgiler, saygular...

August 30

On Tuesday, 30 August 2022 at 11:37:06 UTC, Salih Dincer wrote:

>

Referans olması amacıyla durmasında fayda var sanırım?

elbette :) ama bu sefer kodları yemeklere bulamadığına şaşırmadım dersem yalan olur :)))
Teşekkürler.. İnceleyeceğim uzun uzun özellikle yarın öğlen vaktinde..

Evet 30 Ağustos zafer bayramımız kutlu olsun hepimizin ve bu hatırlatma içinde +1 teşekkür