手动推导`f1 x xs =（filter。（<））x xs`的类型

Question

我想手动得出以下类型：

f1 x xs = (filter . (<)) x xs

第一次看到x ，所以：

x :: t1

然后(<)具有这种类型：

(<) :: Ord a1 => a1 -> a1 -> Bool

如果以下类型可以统一，我们只能说(< x) ：

t1  ~  a1

然后

x :: a1

所以

(<x) :: Ord a1 => a1 -> Bool

过滤器具有此类型

filter :: (a2 -> Bool) -> [a2] -> [a2]

第一次看到xs，所以：

xs :: t2

如果可以统一以下类型，我们只能说(filter . (<)) x xs ：

a1 -> Bool ~ a2 -> Bool
t2  ~ [a2]

所以当正确的类型是Ord a => a -> [a] -> [a] f1 :: (a2 -> Bool) -> [a2] -> [a2] ，我得到f1 :: (a2 -> Bool) -> [a2] -> [a2]与filter相同的类型（询问GHCi）。

有什么帮助吗？

Answer 1

约束

a1 -> Bool ~ a2 -> Bool

可以分解为

a1 ~ a2

显然是真的

Bool ~ Bool

所以你有a1 ~ a2 。 您已经知道x为a1 ， xs为[a2]并且由于有了filter ，结果类型为[a2] 。 因此，您最终得到：

f1 :: Ord a2 => a2 -> [a2] -> [a2]

（不要忘记从(<)获得的类约束a1 。）

Answer 2

我们可以以自上而下的方式处理给定的表达式。 这样一来，您无需猜测发生了什么，推导纯粹是机械地进行的，并且出错的可能性极小：

f1    x   xs = (filter . (<)) x xs
f1    x   xs :: c                        (filter . (<)) x xs :: c
f1    x :: b -> c                        xs :: b
f1 :: a -> b -> c                        x  :: a 

(filter .  (<)) x      xs  :: c
filter    ((<)  x)  ::  b  -> c          c ~ [d] , b ~ [d]
filter :: (d->Bool) -> [d] -> [d]        (<) x :: d -> Bool

(<) :: (Ord a) => a -> a -> Bool
(<)               x :: d -> Bool         a ~ d , (Ord a)

f1  :: (Ord a) => a -> [a] -> [a]

解决此问题的另一种方法是注意到可以在f1的定义中执行eta减少 ：

f1    x   xs = (filter . (<)) x xs
f1           = (.) filter (<)

(.) :: (   b      ->     c     ) -> (           a ->   b      ) -> (a->c)
(.)             filter                           (<)            ::   t1
(.) :: ((d->Bool) -> ([d]->[d])) -> ((Ord a) => a -> (a->Bool)) ->   t1

        b ~ d -> Bool , c ~ [d] -> [d] , t1 ~ a -> c , (Ord a)
        b ~ a -> Bool
        -------------
            d ~ a

f1 :: t1 ~ (Ord a) => a -> c 
         ~ (Ord a) => a -> [d] -> [d]
         ~ (Ord a) => a -> [a] -> [a]

当然，我们使用类型正确的箭头关联性：a- a -> b -> c实际上是a -> (b -> c) 。

我们还对类型派生使用通用方案

f    x    y    z :: d
f    x    y :: c -> d      , z :: c
f    x :: b -> c -> d      , y :: b
f :: a -> b -> c -> d      , x :: a