Haskell Control.Arrow：試圖寫一個filterA函數

Question

我正在嘗試編寫filterA :: (ArrowChoice arr) => arr a Bool -> arr [a] [a]函數，該函數從列表中刪除每個元素，其中f :: arr a Bool返回False。這是我迄今爲止

listcase [] = Left() 
listcase (x:xs) = Right (x, xs) 

filterA f = arr listcase >>> 
      arr (const []) ||| (first (f &&& arr id) >>> 
      arr (\((b,x),xs) -> if b then 
       x : (filterA f xs) 
       else filterA f xs 
      )) 

現在這一點也適用(->) a箭測試它的時候，像這樣：

λ> filterA (== 8) [8,9] 
[8] 

但是，它沒有工作，爲Kleisli箭似

λ> runKleisli (Kleisli $ filterA (== 8)) (return [8,9] :: [IO Int]) 

<interactive>:160:47: 
    Couldn't match expected type `IO Int' with actual type `[t0]' 
    In the first argument of `return', namely `[8, 9]' 
    In the second argument of `runKleisli', namely 
     `(return [8, 9] :: [IO Int])' 
    In the expression: 
     runKleisli (Kleisli $ filterA (== 8)) (return [8, 9] :: [IO Int]) 

當添加類型簽名filterA :: (Arrow arr) => arr a Bool -> arr [a] [a]或filterA :: (ArrowChoice arr) => arr a Bool -> arr [a] [a]時，它會拋出此錯誤：

arrows.hs:11:22: 
    Could not deduce (arr ~ (->)) 
    from the context (Arrow arr) 
     bound by the type signature for 
       filterA :: Arrow arr => arr a Bool -> arr [a] [a] 
     at arrows.hs:7:12-51 
     `arr' is a rigid type variable bound by 
      the type signature for 
       filterA :: Arrow arr => arr a Bool -> arr [a] [a] 
      at arrows.hs:7:12 
    Expected type: [a] -> [a] 
     Actual type: arr [a] [a] 
    The function `filterA' is applied to two arguments, 
    but its type `arr a Bool -> arr [a] [a]' has only one 
    In the second argument of `(:)', namely `(filterA f xs)' 
    In the expression: x : (filterA f xs) 

我不明白爲什麼。我錯過了什麼？

編輯： @ jaket的評論工作（我猜這有點愚蠢）但類型簽名仍然不匹配。 我也更新了代碼更加緊湊（仍然得到同樣的錯誤雖然）

filterA f = arr listcase >>> 
      arr (const []) ||| (arr toEither >>> 
      (filterA f) ||| (second (filterA f) >>> arr uncurry (:))) 
    where toEither (x, xs) = if f x then Right (x, xs) else Left xs 

GHC推斷類型爲filterA :: (a -> Bool) -> [a] -> [a]，順便說一句。

Answer 1

你的問題是你'試圖在y的函數定義中進行遞歸OU與arr裹在裏面，你叫filterA f，就像它在這一行是一個函數：

   x : (filterA f xs) 

，只有當箭頭類型爲(->)，這是什麼類型的錯誤之一是告訴你的作品。

相反，你需要做遞歸在箭頭的水平，如：

listcase :: [t] -> Either() (t, [t]) 
listcase [] = Left() 
listcase (x:xs) = Right (x, xs) 

filterA :: (ArrowChoice arr) => arr a Bool -> arr [a] [a] 
filterA f = listcase ^>> 
      arr (const []) ||| ((f &&& arr id) *** filterA f >>^ 
           (\((b, x), xs) -> if b then x:xs else xs)) 

（它編譯）

你runKleisli例子是有點糊塗了，你的意思是說：

runKleisli (filterA $ Kleisli $ return . (== 8)) [8,9] 

或

runKleisli (filterA $ arr (== 8)) [8,9] :: IO [Int] 

這是直截了當地看待類型。

Answer 2

正如我在評論中提到：

runKleisli (Kleisli $ filterA (== 8)) [8, 9] 

接下來需要提起f :: a -> b成箭頭arr a b

(first (arr f &&& arr id) 
     ^^^ 

在功能

：

filterA :: ArrowChoice arr => (a -> Bool) -> arr [a] [a] 
filterA f = arr listcase >>> 
      arr (const []) ||| (first (f &&& arr id) >>> 
      arr (\((b,x),xs) -> if b then 
       x : (filterA f xs) 
       else filterA f xs 
      )) 

Answer 3

只是爲了補充其他答案：使用Arrow syntax（也見GHC手冊，第Arrow notation）你可以寫函數稍微更可讀：

{-# LANGUAGE Arrows #-} 

import Control.Arrow 

filterA :: (ArrowChoice arr) => arr a Bool -> arr [a] [a] 
filterA f = farr 
    where 
    farr = proc xs -> 
      case xs of 
       []  -> returnA -< [] 
       (x:xs') -> do 
        b <- f -< x 
        ys' <- farr -< xs' 
        returnA -< if b then x : ys' else ys' 

內部轉換箭頭符號的結果很可能是稍微簡潔一些，但希望編譯器能夠爲您優化。