Haruskah fungsi yang mengambil fungsi sebagai parameter, juga mengambil parameter ke fungsi tersebut sebagai parameter?

Saya sering menemukan diri saya menulis fungsi yang terlihat seperti ini karena memungkinkan saya untuk dengan mudah mengejek akses data, dan masih memberikan tanda tangan yang menerima parameter untuk menentukan data apa yang akan diakses.

public static string GetFormattedRate(
        Func<string, RateType>> getRate,
        string rateKey)
{
    var rate = getRate(rateKey);
    var formattedRate = rate.DollarsPerMonth.ToString("C0");
    return formattedRate;
}

Atau

public static string GetFormattedRate(
        Func<RateType, string> formatRate,
        Func<string, RateType>> getRate,
        string rateKey)
{
    var rate = getRate(rateKey);
    var formattedRate = formatRate(rate);
    return formattedRate;
}

Maka saya menggunakannya sesuatu seperti ini:

using FormatterModule;

public static Main()
{
    var getRate = GetRateFunc(connectionStr);
    var formattedRate = GetFormattedRate(getRate, rateType);
    // or alternatively
    var formattedRate = GetFormattedRate(getRate, FormatterModule.FormatRate, rateKey);

    System.PrintLn(formattedRate);
}

Apakah ini praktik umum? Saya merasa harus melakukan sesuatu yang lebih seperti

public static string GetFormattedRate(
        Func<RateType> getRate())
{
    var rate = getRate();
    return rate.DollarsPerMonth.ToString("C0");
}

Tapi itu sepertinya tidak berfungsi dengan baik karena saya harus membuat fungsi baru untuk masuk ke metode untuk setiap jenis tingkat.

Terkadang saya merasa harus melakukan sesuatu

public static string GetFormattedRate(RateType rate)
{
   return rate.DollarsPerMonth.ToString("C0");
}

Tapi itu tampaknya mengambil pengambilan dan memformat penggunaan kembali. Setiap kali saya ingin mengambil dan memformat saya harus menulis dua baris, satu untuk mengambil dan satu untuk memformat.

Apa yang saya lewatkan tentang pemrograman fungsional? Apakah ini cara yang tepat untuk melakukannya, atau apakah ada pola yang lebih baik yang mudah dipelihara dan digunakan?

Jika Anda melakukan ini cukup lama, pada akhirnya Anda akan menemukan diri Anda menulis fungsi ini berulang-ulang:

public static Type3 CombineFunc1AndFunc2(
    Func<Type1, Type2> func1,
    Func<Type2, Type3>> func2,
    Type1 input)
{
    return func2(func1(input))
}

Selamat, Anda telah menemukan komposisi fungsi .

Fungsi wrapper seperti ini tidak banyak digunakan ketika mereka dikhususkan untuk satu jenis. Namun, jika Anda memperkenalkan beberapa variabel tipe dan menghilangkan parameter input, maka definisi GetFormattedRate Anda terlihat seperti ini:

public static Func<A, C> Compose(
    Func<B, C> outer, Func<A, B>> inner)
{
    return (input) => outer(inner(input))
}

var GetFormattedRate = Compose(FormatRate, GetRate);
var formattedRate = GetFormattedRate(rateKey);

Seperti apa adanya, apa yang Anda lakukan hanya memiliki sedikit tujuan. Itu tidak umum, jadi Anda perlu menduplikasi kode itu di semua tempat. Itu terlalu rumit kode Anda karena sekarang kode Anda harus mengumpulkan semua yang dibutuhkan dari seribu fungsi kecil sendiri. Hati Anda berada di tempat yang tepat: Anda hanya perlu membiasakan diri menggunakan fungsi - fungsi tingkat tinggi yang umum ini untuk menyatukan semuanya. Atau, gunakan lambda mode lama yang bagus untuk berubah Func<A, B>dan Amenjadi Func<B>.

Jangan ulangi dirimu sendiri.

Sama sekali tidak ada alasan untuk melewatkan fungsi, dan parameternya, hanya untuk kemudian memanggilnya dengan parameter tersebut. Bahkan, dalam kasus Anda, Anda tidak punya alasan untuk melewatkan fungsi sama sekali . Penelepon mungkin juga hanya memanggil fungsi itu sendiri dan meneruskan hasilnya.

Pikirkan - alih-alih menggunakan:

var formattedRate = GetFormattedRate(getRate, rateType);

mengapa tidak menggunakan saja:

var formattedRate = GetFormattedRate(getRate(rateType));

?

Selain mengurangi kode yang tidak perlu, juga mengurangi kopling - jika Anda ingin mengubah cara pengambilannya (katakanlah, jika getRatesekarang membutuhkan dua argumen) Anda tidak perlu mengubah GetFormattedRate.

Demikian juga, tidak ada alasan untuk menulis GetFormattedRate(formatRate, getRate, rateKey)daripada menulis formatRate(getRate(rateKey)).

Jangan terlalu rumit.

Jika Anda benar-benar harus melewatkan fungsi ke dalam fungsi karena ia melewati beberapa argumen tambahan atau memanggilnya dalam satu lingkaran maka Anda bisa meneruskan lambda:

public static string GetFormattedRate(
        Func<string> getRate)
{
    var rate = getRate();
    var formattedRate = rate.DollarsPerMonth.ToString("C0");
    return formattedRate;
}

var formattedRate = GetFormattedRate(()=>getRate(rateKey));

Lambda akan mengikat argumen yang tidak diketahui fungsi dan menyembunyikan bahwa mereka ada.

Bukankah ini yang kamu inginkan?

class RateFormatter
{
    public abstract RateType GetRate(string rateKey);

    public abstract string FormatRate(RateType rate);

    public string GetFormattedRate(string rateKey)
    {
        var rate = GetRate(rateKey);
        var formattedRate = FormatRate(rate);
        return formattedRate;
    }
}

Dan menyebutnya seperti ini:

static class Program
{
    public static void Main()
    {
        var rateFormatter = new StandardRateFormatter(connectionStr);
        var formattedRate = rateFormatter.GetFormattedRate(rateKey);

        System.PrintLn(formattedRate);
    }
}

Jika Anda menginginkan metode yang dapat berperilaku dalam berbagai cara berbeda dalam bahasa berorientasi objek seperti C #, cara yang biasa dilakukan adalah meminta metode memanggil metode abstrak. Jika Anda tidak memiliki alasan khusus untuk melakukannya dengan cara yang berbeda, Anda harus melakukannya dengan cara itu.

Apakah ini terlihat seperti solusi yang baik, atau apakah ada kelemahan yang Anda pikirkan?