5

我试图创建一个适用于[Maybe a]. 但是， Maybe a 有 kind *，而 fmap 需要 kind * -> *。这导致了以下不幸的解决方案：

newtype Unfortunate a = Unfortunate ([Maybe a]) deriving Show

instance Functor Unfortunate
    where fmap f (Unfortunate a) = Unfortunate $ (fmap (fmap f)) a


-- |
-- >>> l = Unfortunate [Just 10, Just 1, Nothing, Just 15]
-- >>> fmap (*5) l
-- Unfortunate [Just 50,Just 5,Nothing,Just 75]

不幸的是必须创建一个newtype。我希望可以创建一个适用于 的实例，适用[Maybe a]于任何a. 即，可以称为 的东西fmap f [Just 10, Nothing]。

我似乎遗漏了一些语法。是否可以定义这样的实例？

4

3 回答 3

8

MaybeT完全（以及更多）你Unfortunate所做的：

λ> import Control.Monad.Trans.Maybe
λ> (*2) <$> MaybeT [Just 1, Just 2, Nothing]
MaybeT [Just 2,Just 4,Nothing]
λ> pure 1 :: MaybeT [] Int
MaybeT [Just 1]

您还可以使用 DeriveFunctor 标志并以机械方式派生“不幸的函子”：

λ> :set -XDeriveFunctor 
λ>  newtype Unfortunate a = Unfortunate ([Maybe a]) deriving (Functor, Show)
λ> (*2) <$> Unfortunate [Just 1, Just 2, Nothing]
Unfortunate [Just 2,Just 4,Nothing]
λ>

如果你想走泛型路线，还有泛型函子。

编辑：

另一种选择是使用 GeneralizedNewtypeDeriving：

λ> :set -XGeneralizedNewtypeDeriving 
λ> (*2) <$> Unfortunate (MaybeT [Just 1, Just 2, Nothing])
Unfortunate (MaybeT [Just 2,Just 4,Nothing])

编辑2：

正如 Daniel Wagner 在评论中指出的那样，我们也可以使用：

λ> import Data.Functor.Compose
λ> (*2) <$> Compose [Just 1, Just 2, Nothing]
Compose [Just 2,Just 4,Nothing]
于 2021-06-25T02:29:18.337 回答
7

不幸的是新类型的创建。我希望可以创建一个适用于 [Maybe a] 的实例，适用于任何 a。

已经有这样的例子了。它不仅适用于任何 [Maybe a]，而且适用于任何 [a]。并且由于a可以与 统一Maybe a，因此您也可以使用它[Maybe a]。

现在，显然这实际上不是您的意思。当专门用于这种类型时，fmap有类型

(Maybe a -> Maybe b) -> [Maybe a] -> [Maybe b]

但你希望它取而代之的是一个类型的函数(a -> b)。我提出这一点是为了解释为什么不能避免使用单独的类型1。您想要的类型已经有一个实例，因此您不能只定义一个替换该行为的新实例。您需要一个不同的类型来附加该实例。

正如在另一个答案中所讨论的，已经定义了可以组合以获得所需设置的泛型类型。但是你不能只使用一个 bare [Maybe a]。

1您可以打开一些语言扩展来破坏类型系统以允许这样做，但这可能会产生令人惊讶的后果，我不会在这里讨论。

于 2021-06-25T04:39:00.293 回答
4

这是一个完美的用例DerivingVia（我注意到我没有足够仔细地阅读这个问题，你必须使用一种newtype或另一种方式：这个解决方案不是你所希望的，但它是惯用的）

{-# Language DerivingVia              #-}
{-# Language StandaloneKindSignatures #-}

import Control.Applicative (Alternative)
import Control.Monad (MonadPlus)
import Control.Monad.Fix (MonadFix)
import Control.Monad.Trans.Maybe
import Control.Monad.Zip (MonadZip)
import Data.Kind (Type)

type    Fortunate :: Type -> Type
newtype Fortunate a = Fortunate [Maybe a]
 deriving
  ( Functor, Foldable, Applicative, Alternative
  , Monad, MonadPlus, MonadFail, MonadFix, MonadZip
  )
 via MaybeT []

其中一些实例(Functor, Foldable, Applicative, Alternative)可以通过Compose Maybe [].

要列出可以派生的实例，请使用:instances命令

>> :instances MaybeT []
instance [safe] Alternative (MaybeT [])
  -- Defined in ‘Control.Monad.Trans.Maybe’
instance [safe] Applicative (MaybeT [])
  -- Defined in ‘Control.Monad.Trans.Maybe’
...
>> :instances Compose Maybe []
instance Alternative (Compose Maybe [])
  -- Defined in ‘Data.Functor.Compose’
instance Applicative (Compose Maybe [])
  -- Defined in ‘Data.Functor.Compose’
...

因为是一个应用程序，您可以通过逐点（惯用的，应用程序）提升Fortunate推导出：(Semigroup, Monoid, Num, Bounded)

import Data.Monoid (Ap(..))

..
 deriving (Semigroup, Monoid, Num, Bounded)
 via Ap Fortunate a

其中(<>) = liftA2 (<>), abs = liftA abs, mempty = pure mempty, minBound = pure minBound.

于 2021-06-25T18:37:58.123 回答