Sonucu anlamaya çalışıyorum

(*) . ( ) 

Haskell. Kompozisyon operatör çok fonksiyonlar - matematiksel standart bileşimi olduğunu biliyorum

(f . g) = f (g x)

Ama:

(*) . ( ) :: (Num (a -> a), Num a) => a -> (a -> a) -> a -> a

Bu tür imza anlamakta güçlük çekiyorum. Gibi şeyler yapabilmek için beklerdim:

((*) . ( )) 1 2 :: Num a => a -> a
= (* (  1 2))

( * ) Ne anlama geliyor . ( )'In türü imza? Böyle bir şey (kendi imzası ile eşleşen Sadece) ile oynamaya çalıştım:

((*) . ( )) 1 (\x -> x   1) 1

Ama bunu derlemek için başarısız olur. Bu oluştururken mantıksal adım adım yürümeye çalışıyorum, ama tam olarak bu neden oluyor nasıl bir anlayış değilim (ve ne sonuç).

Nasıl hissettiğini anlıyorum. Fonksiyon kompozisyon başta da kavramak oldukça zor buldum. Bana bu konuda yardımcı grok ne tür bir imza vardı. Düşünün:

(*) :: Num x => x -> x -> x
( ) :: Num y => y -> y -> y
(.) :: (b -> c) -> (a -> b) -> a -> c

Şimdi yazdığında (*) . ( ) aslında aynı (.) (*) ( ) (yani (*) ilk tartışma (.) ( ) ikinci bileşen (.)):

(.) :: (b -> c) -> (a -> b) -> a -> c
       |______|    |______|
           |           |
          (*)         ( )

Dolayısıyla (*) (yani Num x => x -> x -> x) tipi imza b -> c ile birleştirir:

(*) :: Num x => x -> x -> x -- remember that `x ->  x -> x`
                |    |____| -- is implicitly `x -> (x -> x)`
                |       |
                b ->    c

(.) (*) ::          (a -> b) -> a ->    c
                          |             |
                          |          |‾‾‾‾|
           Num x =>       x          x -> x

(.) (*) :: Num x => (a -> x) -> a -> x -> x

Dolayısıyla ( ) (yani Num y => y -> y -> y) tipi imza Num x => a -> x ile birleştirir:

( ) :: Num y => y -> y -> y -- remember that `y ->  y -> y`
                |    |____| -- is implicitly `y -> (y -> y)`
                |       |
       Num x => a ->    x

(.) (*) ( ) ::  Num x                => a ->     x    ->    x
                                        |        |          |
                                        |     |‾‾‾‾|     |‾‾‾‾|
                              Num y  => y     y -> y     y -> y

(.) (*) ( ) :: (Num (y -> y), Num y) => y -> (y -> y) -> y -> y

Num (y -> y) Num y nereden geldiğini açıklar umarım. 34 ** yazın çok garip bir işlevi kalır.

Bu kadar garip kılan y y -> y Num örnekleri alacağını tahmin ettiklerini söyledi. y Num ama nasıl y -> y bir örnek olması anlaşılabilir? y -> y Num bir örnek yapmak mantıksız görünüyor. Bu doğru olamaz.

Ancak, işlev kompozisyon aslında ne baktığınızda mantıklı geliyor:

( f  .  g ) = \z ->  f  ( g  z)

((*) . ( )) = \z -> (*) (( ) z)

44 ** bir işlevi var. Dolayısıyla z açıkça ( ) uygulandığından Num bir örnek olmalıdır. Böylece \z -> (*) (( ) z) tipi ... birazdan öğreneceğiz (*) (( ) z), türü olduğu Num t => t -> ....

Bu nedenle (( ) z) daha fazla sayıda gerektirir çünkü 53 ** türüdür. Ancak, başka bir numaraya uygulanır, (*) daha önce uygulanır.

Dolayısıyla (*) (( ) z) t -> t Num bir örnek olması bekleniyor ediliyor Num, bir örnek olmasını bekliyor. ... (t -> t) -> t -> t ve kısıtlama ile değiştirilir, böylece Num (t -> t), 63* *yazın çıkan eklenir.

Gerçekten (*) ( ) birleştirmek istediğiniz şekilde (.:) kullanarak

(.:) :: (c -> d) -> (a -> b -> c) -> a -> b -> d
f .: g = \x y -> f (g x y)

Dolayısıyla (*) .: ( ) \x y -> (*) (( ) x y) aynıdır. Şimdi iki argüman ( ) (( ) x y) aslında sadece Num t => t Num t => t -> t sağlamak için verilmiştir.

Dolayısıyla ((*) .: ( )) 2 3 5 istediğine inanıyorum ki ** 77, olan (*) 5 5 (*) (( ) 2 3) 5.

f .: g ** 79 (.:) (.:) = (.) . (.) olarak tanımlanabilir olarak yazılmış olabilir. Bu konuda daha fazla buradan okuyabilirsiniz:

What does (f .) . g mean in Haskell?

Bu yardımcı olur umarım.