"Noktadan bağımsız" stil nedir (Fonksiyonel Programlamada)?

Son zamanlarda fark ettiğim bir cümle, "noktasız" stil kavramı ...

Birincisi, bu soru vardı ve bu da .

Sonra, burada "Tartışmaya değer başka bir konu da yazarların noktasız stilden hoşlanmamasıdır" dediğini keşfettim .

"Noktasız" stil nedir? Birisi kısa bir açıklama yapabilir mi? "Otomatik" körlemeyle bir ilgisi var mı?

Seviyem hakkında bir fikir edinmek için - kendime Şema öğretiyorum ve basit bir Şema tercümanı yazdım ... "Örtülü" körlemenin ne olduğunu anlıyorum, ancak Haskell veya ML bilmiyorum.

Tanımınızı öğrenmek için Wikipedia makalesine bakın :

Örtük programlama (noktasız programlama), bir fonksiyon tanımının değişkenler yerine birleştiriciler ve fonksiyon bileşimi [...] kullanarak argümanlarıyla ilgili bilgileri içermediği bir programlama paradigmasıdır.

Haskell örneği:

Geleneksel (bağımsız değişkenleri açıkça belirtirsiniz):

sum (x:xs) = x + (sum xs)
sum [] = 0

Noktasız ( sumherhangi bir açık argüman içermez - sadece +0 ile başlayan bir kat ):

 sum = foldr (+) 0

Veya daha basit: Bunun yerine g(x) = f(x)sadece yazabilirsiniz g = f.

Yani evet: Bu, körlemeyle (veya işlev kompozisyonu gibi işlemler) yakından ilgilidir.

Noktadan bağımsız stil, tanımlanmakta olan fonksiyonun argümanlarından açıkça bahsedilmediği, fonksiyonun fonksiyon bileşimi yoluyla tanımlandığı anlamına gelir.

İki işleviniz varsa, örneğin

square :: a -> a
square x = x*x

inc :: a -> a
inc x = x+1

ve bu iki işlevi hesaplayan bir işlevle birleştirmek istiyorsanız x*x+1, bunu şu şekilde "nokta dolu" olarak tanımlayabilirsiniz:

f :: a -> a
f x = inc (square x)

Noktadan bağımsız alternatif, argüman hakkında konuşmak değildir x:

f :: a -> a
f = inc . square

Bir JavaScript örneği:

//not pointfree cause we receive args
var initials = function(name) {
  return name.split(' ').map(compose(toUpperCase, head)).join('. ');
};

const compose = (...fns) => (...args) => fns.reduceRight((res, fn) => [fn.call(null, ...res)], args)[0];
const join = m => m.join();

//pointfree
var initials = compose(join('. '), map(compose(toUpperCase, head)), split(' '));

initials("hunter stockton thompson");
// 'H. S. T'

Referans

Point free style, kodun, var olmalarına ve kullanılmalarına rağmen, argümanlarından açıkça bahsetmediği anlamına gelir.

Bu, işlevlerin çalışma biçimi nedeniyle Haskell'de çalışır.

Örneğin:

myTake = take

bir bağımsız değişken alan bir işlev döndürür, bu nedenle siz de istemediğiniz sürece bağımsız değişkeni açıkça yazmanız için bir neden yoktur.

TypeScript'te başka herhangi bir kitaplık olmayan bir örnek:

interface Transaction {
  amount: number;
}

class Test {
  public getPositiveNumbers(transactions: Transaction[]) {
    return transactions.filter(this.isPositive);

    //return transactions.filter((transaction: {amount: number} => transaction.amount > 0));
  }

  public getBigNumbers(transactions: Transaction[]) {
    // point-free
    return transactions.filter(this.moreThan(10));

    // not point-free
    // return transactions.filter((transaction: any) => transaction.amount > 10);
  }

  private isPositive(transaction: Transaction) {
    return transactions.amount > 0;
  }

  private moreThan(amount: number) {
    return (transaction: Transaction) => {
      return transactions.amount > amount;
    }
  }
}

Noktasız stilin daha "akıcı" ve okunması daha kolay olduğunu görebilirsiniz.