Katlamadaki fonksiyonel argümanın adı nedir

Üst düzey işlevde katla / azalt işlevi işlevsel bağımsız değişkenin adı nedir?

Satırların basit analizler (bir sütunun minimum, maksimum, ortalamasını bulmak gibi) üretmek için katlandığı bir monadik tablo işleme kütüphanesi üzerinde çalışıyorum. Bu nedenle, foldfonksiyonun argümanı için sağlam bir isim arıyorum ve ML topluluğunda (veya Haskell veya Common Lisp) ikinci ve üçüncü adaylar olarak iyi bilinen herhangi bir isim ilginç olacaktır.

Fonksiyonların façıklamasında benzer bir isim yaygındır, ancak tanımlayıcı değildir foldve bir isim daha uygundur.

@ Jozefg'in belirttiği gibi, bunun tek bir cevabı var mı bilmiyorum. Ve tamamen spekülasyon dışında, olası bir açıklama:

- Ben türü nedeni, şüpheli (a -> b -> b)de Haskellfoldr örneğin, - ile gelip herhangi bir ad olandan daha anlamlıdır. Yana ave btipi parametreleri olabilir şey , fonksiyon sıra hemen hemen her şeyi yapabilirdi. Eğer gibi isimlerle kalacaksın Yani function, combiner, morphism, ve argument, ya özellikle anlamlı değildir ki. Kısa ve dikkat dağıtıcı olmayan bir ad da kullanabilir.

Başka bir örnek id :: a -> aişlevdir: argümanına ne demelisiniz? Yine, bence idtürü argüman adından daha açıklayıcı.

Bununla birlikte, sana katılıyorum - görünüşe göre, belki de matematikte ortak bir isim olmalı. Umarım biri bu konuda beni düzeltebilir.

Gerçek kodda adının bazı örnekleri:

In Haskell'ın kütüphaneler , çoğunlukla denir f(ve bazen operatoryorumlarda):

class Foldable t where
    -- | Map each element of the structure to a monoid,
    -- and combine the results.
    foldMap :: Monoid m => (a -> m) -> t a -> m
    foldMap f = foldr (mappend . f) mempty

    -- | Right-associative fold of a structure.
    --
    -- @'foldr' f z = 'Prelude.foldr' f z . 'toList'@
    foldr :: (a -> b -> b) -> b -> t a -> b
    foldr f z t = appEndo (foldMap (Endo . f) t) z

    -- | Right-associative fold of a structure, 
    -- but with strict application of the operator.
    foldr' :: (a -> b -> b) -> b -> t a -> b
    foldr' f z0 xs = foldl f' id xs z0
      where f' k x z = k $! f x z

    -- | Left-associative fold of a structure.
    --
    -- @'foldl' f z = 'Prelude.foldl' f z . 'toList'@
    foldl :: (a -> b -> a) -> a -> t b -> a
    foldl f z t = appEndo (getDual (foldMap (Dual . Endo . flip f) t)) z

    -- | Left-associative fold of a structure.
    -- but with strict application of the operator.
    --
    -- @'foldl' f z = 'List.foldl'' f z . 'toList'@
    foldl' :: (a -> b -> a) -> a -> t b -> a
    foldl' f z0 xs = foldr f' id xs z0
      where f' x k z = k $! f z x

    -- | A variant of 'foldr' that has no base case,
    -- and thus may only be applied to non-empty structures.
    --
    -- @'foldr1' f = 'Prelude.foldr1' f . 'toList'@
    foldr1 :: (a -> a -> a) -> t a -> a
    foldr1 f xs = fromMaybe (error "foldr1: empty structure")
                    (foldr mf Nothing xs)
      where
        mf x Nothing = Just x
        mf x (Just y) = Just (f x y)

    -- | A variant of 'foldl' that has no base case,
    -- and thus may only be applied to non-empty structures.
    --
    -- @'foldl1' f = 'Prelude.foldl1' f . 'toList'@
    foldl1 :: (a -> a -> a) -> t a -> a
    foldl1 f xs = fromMaybe (error "foldl1: empty structure")
                    (foldl mf Nothing xs)
      where
        mf Nothing y = Just y
        mf (Just x) y = Just (f x y)

-- instances for Prelude types

instance Foldable Maybe where
    foldr _ z Nothing = z
    foldr f z (Just x) = f x z

    foldl _ z Nothing = z
    foldl f z (Just x) = f z x

instance Ix i => Foldable (Array i) where
    foldr f z = Prelude.foldr f z . elems
    foldl f z = Prelude.foldl f z . elems
    foldr1 f = Prelude.foldr1 f . elems
    foldl1 f = Prelude.foldl1 f . elems

-- | Monadic fold over the elements of a structure,
-- associating to the right, i.e. from right to left.
foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
foldrM f z0 xs = foldl f' return xs z0
  where f' k x z = f x z >>= k

-- | Monadic fold over the elements of a structure,
-- associating to the left, i.e. from left to right.
foldlM :: (Foldable t, Monad m) => (a -> b -> m a) -> a -> t b -> m a
foldlM f z0 xs = foldr f' return xs z0
  where f' x k z = f z x >>= k

-- | Map each element of a structure to an action, evaluate
-- these actions from left to right, and ignore the results.
traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
traverse_ f = foldr ((*>) . f) (pure ())

-- | Map each element of a structure to a monadic action, evaluate
-- these actions from left to right, and ignore the results.
mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
mapM_ f = foldr ((>>) . f) (return ())

f Clojure'da da denir :

(def
    ^{:arglists '([f coll] [f val coll])
      :doc "f should be a function of 2 arguments. If val is not supplied,
  returns the result of applying f to the first 2 items in coll, then
  applying f to that result and the 3rd item, etc. If coll contains no
  items, f must accept no arguments as well, and reduce returns the
  result of calling f with no arguments.  If coll has only 1 item, it
  is returned and f is not called.  If val is supplied, returns the
  result of applying f to val and the first item in coll, then
  applying f to that result and the 2nd item, etc. If coll contains no
  items, returns val and f is not called."
      :added "1.0"}    
    reduce
     (fn r
       ([f coll]
             (let [s (seq coll)]
               (if s
                 (r f (first s) (next s))
                 (f))))
       ([f val coll]
          (let [s (seq coll)]
            (if s
              (if (chunked-seq? s)
                (recur f 
                       (.reduce (chunk-first s) f val)
                       (chunk-next s))
                (recur f (f val (first s)) (next s)))
              val)))))

fİşlev argümanı için kötü bir isim olduğu fikrine katılmıyorum fold. Biz adı tanımladığı biliyoruz bu yüzden programlamada açıklayıcı isimler istediğiniz nedenidir ve adı fsık bir işlev için matematik (ve fonksiyonel programlama dillerinde) kullanılır (gibidir gve h).

Hakkında neredeyse hiçbir şey bilmiyoruz f(tasarım gereği, eğer bu konuda daha spesifik olsaydık fold, pek çok şeyi kullanamazdık ) ve isim fbize bilmemiz gereken her şeyi söyler, bunun dışında iki argümanın bir işlevi vardır. Adı f, İngilizce zamiri 'it' gibidir - neredeyse her şey anlamına gelebilecek bir yer tutucudur. Biz bir cümleyle kullanana kadar 'bunun' ne folduğunu bilmiyoruz ve biz diyene kadar ne olduğunu bilmiyoruz fold.

Bir şeyleri adlandırırken, addan mümkün olduğunca fazla bilgi almak istiyoruz ve adın kısa olmasını tercih ediyoruz (önemli bilgilerden ödün vermeden alabilirsek). Burada, bize neredeyse bildiğimiz her şeyi anlatan çok kısa bir ismimiz var. Geliştirilebileceğini sanmıyorum.

Zorunlu programlamada, ibir döngü sayacı olarak kullanılır (olduğu gibi jve kdaha fazlasına ihtiyacımız varsa); Fonksiyonel programlamada, füst düzey fonksiyonlarda fonksiyon argümanı için kullanılır (olduğu gibi gve hdaha fazlasına ihtiyacımız varsa). F / g / h konvansiyonunun i / j / k konvansiyonu kadar iyi kurulduğundan emin olmak için fonksiyonel dillerle ilgili yeterli deneyimim yok, ancak değilse, bence olmalı (kesinlikle matematikte kurulmuş).

Ben zamiri dışında duydum Bunun en yaygın isim folurdu binary operationya binary function- Bundan daha spesifik olan sorunun tam anlamıyla yapabileceği olduğu şey ve insanlar tipi imza sopa neden en olduğunu a -> b -> a(veya a -> b -> bdoğru katlayın değilse) .

Ben belirli tip imza bir isim var neyse ki o tip imza tam olarak, sopa yapmak öneriyoruz Yani: binary function, tıpkı a -> abir olduğunu unary operationve a -> bbir olduğunu unary function, arayabileceğiniz a -> a -> abir binary operationve a -> b -> cbir binary function.

İstediğiniz işleve bazen "birleştirme işlevi" denir (bkz. Örn . Fold'daki HaskellWiki sayfası ), ancak buna standart terminoloji adını vermek için yeterli değildir.