D'ye gönül vermişlere selam olsun...

D'de, aşırı yüklenmiş işlevlerden oluşan bir statik yapıyı son derece akıllıca kullanan ve yapı dışında partial(), partialN(), partialLeft() veya partialRight() gibi HOF'ların kullanıldığı bir örnek vardır, burada:

https://dlang.org/library/std/functional/partial.html

IMO, there is an example in the D programming language that extremely cleverly uses a static struct consisting of overloaded functions, with HOFs such as partial(), partialN(), partialLeft(), or partialRight() utilized outside it, here...

Buckle up and diversify the examples if available:

Kemerlerinizi bağlayın ve varsa örnekleri çeşitlendirin:

alias strings = string[];

struct Filter
{
  import std.algorithm;
  import std.regex : matchFirst, regex;

  static:

//  #1: Get element by index
  auto get(strings list, size_t i)
    => list[i];

//  #2: Get elements by multiple indices
  auto get(T)(strings list, T[] indices)
    => indices.map!(i => list[i]);

//  #3: Get able to find
  bool get(S...)(strings list, S words)
  {
    alias pred = e => e.canFind(words);
    return list.canFind!pred;
  }

//  #4: Get all elements containing a specific substring
  auto get(strings list, string str)
  {
    alias pred = s => s.canFind(str);
    return list.filter!pred;
  }

//  #5: Get elements matching regex patterns
  auto get(strings list, strings patterns)
  {
    auto r = regex(patterns);
    alias pred = e => e.matchFirst(r);
    return list.filter!pred;
  }
}

import std.meta, std.typecons, std.stdio;
import std.functional : partial;
void main()
{
    strings patterns, list = [
        "zero", "one", "two", "six", "ten",
        "Twenty", "Thirty"
    ];
    alias filter = partial!(Filter.get, list);

//  Test cases
    filter(2).writeln;        // "two"
    filter([1, 2]).writeln;   // ["one", "two"]

    alias seq = AliasSeq!("ne", "en");
    filter(seq).writeln;      // true

    assert(filter("ne", "twen", "thir"));
    assert(!filter("ru", "ur", "ar"));

    filter("o").writeln;      // ["zero", "one", "two"]

    patterns ~= "t.*o";
    filter(patterns).writeln; // ["two"]

    patterns ~= "T.*ty";
    filter(patterns).writeln; // ["two", "Twenty", "Thirty"]
}

Örneklere baktığımızda, işlevlerin katlanabileceğini görebilirsiniz. Resmi belgelere göre sıradan bir şey gibi görünse de ben bir deste örneği geçtim. Öyle ki yukarda, adeta bir İsviçre çakısı görüyorum. 😁

İstesek string üyesi bulunan bir sarma (string wrapper) yapabilirdik de! Ancak bir HOF (high-order function) ile böyle bir statik yapı çıkar mıydı emin değilim; hatta FOL (function overloading) anlamsızlaşırdı...

(Devamı gelcek)

SDB@79

On Tuesday, 10 December 2024 at 17:44:27 UTC, Salih Dincer wrote:

Şimdi, devam etmeden önce partial'i import eden satırın başına // işaretini koyun veya std.functional : prtl = partial şeklinde ismini değiştirin. Böylece ondan kurtulmuş olacaz, peki neden :)

Now, before proceeding, add // at the beginning of the line that imports partial or rename it as std.functional : prtl = partial. This way, we’ll get rid of it. But why? :)

//import std.functional : partial; /*
alias bindArgument = partialN;

alias partial(alias func, Args...) = partialN!(func, 0, Args);
template partialN(alias func, size_t N, Args...)
{
  auto partialN(A...)(A a)
  if(N <= a.length)
  {
    return func(a[0..N], Args[0], a[N..$]);
  }
}//*/

Bu kodu sanki ilk ben implement etmişim gibi (tabii ki değil çünkü bu forumda benden daha iyi coder arkadaşlarım var) Andrei'ye ile paylaştım. O da iyi göründüğünü ve Walter&Razvan'a göndermemi istedi. Belki bir gün kütüphanede yer alır ne dersiniz?

Andrei Alexandrescu, yazdı:

Neyse, mesele şu ki, elinizde bir dört çeker elektrikli araç var neden bunu farklı mod'larda kullanabileceğiniz halde sıradan önden çekişli bir dizel aracı onun yerine kullanasınız! Üstelik kod kırılımına yol açmıyor çünkü D öyle güzel tertiplenmiş ki sadece biraz sihirli dokunuş yetiyor :)

Bu kodu denemek için şurada değindiğim test kodunu ve hatta öncekileri de deneyin lütfen. Eğer bir sorun oluyorsa lütfen bildirin:

https://forum.dlang.org/post/hofufjhcqeefxnybxyax@forum.dlang.org

auto hello(T)(T a, T b, T c, T d, T e)
  => a~b~c~d~e;

enum msg { h = "h", e = "e", l = "l", o = "o" }

void main()
{
  with(msg)
  {
    assert(bindArgument!(hello, 0, h)(e,l,l,o) == "hello");
    assert(bindArgument!(hello, 1, e)(h,l,l,o) == "hello");
    assert(bindArgument!(hello, 2, l)(h,e,l,o) == "hello");
    assert(bindArgument!(hello, 3, l)(h,e,l,o) == "hello");
    assert(bindArgument!(hello, 4, o)(h,e,l,l) == "hello");

    alias Fun = bindArgument!(hello, 5, e);
    //Fun(h, l, l, o).writeln; //error
  }
}

SDB@79