剝NEWTYPE構造

Question

更多的往往不是我寫的剝離一種新型的唯一的構造函數，如下面的函數返回不是Nothing第一個參數：

process (Pick xs) = (\(First x) -> x) . mconcat . map (First . process) $ xs 

我認爲lambda是不必要的冗長。我想寫這樣的事情：

process (Pick xs) = -First . mconcat . map (First . process) $ xs 

Haskell的元編程設施是否允許類似這樣的事情？任何其他解決方案都可以以更簡潔的方式解決此問題，也是值得歡迎的。

UPD。整個代碼已被要求：

data Node where 
    Join :: [Node] -> Node 
    Pick :: [Node] -> Node 
    Given :: Maybe String -> Node 
    Name :: String -> Node 

process :: Node -> Maybe String 
process (Join xs) = liftM os_path_join (mapM process xs) 
process (Pick xs) = getFirst . mconcat . map (First . process) $ xs 
process (Name x) = Just x 
process (Given x) = x 

Answer 1

澤塔的意見建議，coerce是一個很好的，一般的方式要做到這一點：

process (Pick xs) = coerce . mconcat . map (First . process) $ xs 

另一個約coerce好處是，你可以用它來強制類型構造的「內部」在沒有運行時的成本，這樣的：

example :: [Sum Int] -> [Int] 
example = coerce 

替代，map getFirst，會誘發了map遍歷一個運行時開銷。

此外，在每次製作newtype時間，GHC自動進行適當的Coercible實例，所以你永遠不必擔心與底層機器搞亂（你甚至不需要deriving吧）：

newtype Test = Test Char 

example2 :: Maybe Test -> Maybe Char 
example2 = coerce 

Answer 2

如果您使用Data.Monoid.First，那麼這裏就是getFirst。許多newtype包裝器使用記錄語法來提供一種簡單的功能來解開新類型。

Answer 3

元編程看起來過於複雜。我簡單地使用

unFirst (First x) = x -- define once, use many times 

process (Pick xs) = unFirst . mconcat . map (First . process) $ xs 

通常情況下，函數與新類型一起定義，例如，

newtype First a = First { unFirst :: a } 

Answer 4

在這種情況下，你可以實際使用的newtypes包更一般地解決這個問題：

process :: Node -> Maybe String 
process (Pick xs) = ala' First foldMap process xs 
process (Join xs) = liftM os_path_join (mapM process xs) 
process (Name x) = Just x 
process (Given x) = x 

你甚至可以有一個更寬泛的版本，需要一個Newtype n (Maybe String)像

process' 
    :: (Newtype n (Maybe String), Monoid n) 
    => (Maybe String -> n) -> Node -> Maybe String 
process' wrapper (Pick xs) = ala' wrapper foldMap (process' wrapper) xs 
process' wrapper (Join xs) = liftM os_path_join (mapM (process' wrapper) xs) 
process' wrapper (Name x) = Just x 
process' wrapper (Given x) = x 

Then

> let processFirst = process' First 
> let processLast = process' Last 
> let input = Pick [Given Nothing, Name "bar", Given (Just "foo"), Given Nothing] 
> processFirst input 
Just "bar" 
> ProcessLast input 
Just "foo" 

至於它是如何工作的解釋，ala'功能需要一個NEWTYPE包裝，以確定Newtype實例來使用，在這種情況下，我們想成爲foldMap功能：

foldMap :: (Monoid m, Foldable t) => (a -> m) -> t a -> m 

因爲foldMap f結束是一個普遍的mconcat . map f而不是僅僅是列表的Foldable類型，然後一個函數用作掛鉤到高階函數的「預處理器」被傳遞到ala'（foldMap），然後在這種情況下一些Foldable t => t Node來處理。如果您不想要預處理步驟，則只需使用ala，其中id用於其預處理器。使用此功能有時會因爲其複雜的類型而變得困難，但作爲文檔顯示foldMap中的示例通常是一個不錯的選擇。

這樣做的動力是，如果你想寫自己newtype包裝爲Maybe String：

newtype FirstAsCaps = FirstAsCaps { getFirstAsCaps :: Maybe String } 

firstAsCaps :: Maybe String -> FirstAsCaps 
firstAsCaps = FirstAsCaps . fmap (fmap toUpper) 

instance Monoid FirstAsCaps where 
    mempty = firstAsCaps Nothing 
    mappend (FirstAsCaps f) (FirstAsCaps g) 
     = FirstAsCaps $ ala First (uncurry . on (<>)) (f, g) 

instance Newtype FirstAsCaps (Maybe String) where 
    pack = firstAsCaps 
    unpack = getFirstAsCaps 

然後

> process' firstAsCaps input 
Just "BAR"