Question

我对这个棘手问题表示歉意。我真心是想,但我是一只新鲜事,它显示了这一点。

I m 试图实施一种类似于一般的环形材料,并将其应用于Paul Hudak在《》书中描述的音乐数据结构。 The Haskell School of 音乐. 自然,半群体/大类动物群被遗漏,但我有以下相关法规:

newtype Duo     a b     = Duo     {duo1     :: a} -- A ring-like structure

data Song a =
       Primitive a
     | Song a :+: Song a             -- Composing Music Sequentially
     | Song a :=: Song a deriving Eq -- Composing Music Concurrently (in parallel)

instance Functor Song where
     fmap f (x :+: y)     = fmap f x :+: fmap f y
     fmap f (x :=: y)     = fmap f x :=: fmap f y
     fmap f (Primitive x) = Primitive $ f x

newtype Concurrent a = Concurrent {fromConcurrent :: Song a} deriving (Show)
newtype Sequential a = Sequential {fromSequential :: Song a} deriving (Show)

type Music a = Duo (Maybe (Concurrent a)) (Maybe (Sequential a))

I m attempting to write an instance of Functor for Music, as Duo doesn t have a Functor I thought this wouldn t be a problem.

I wrote the following implementation:

instance Functor Music where
     fmap :: (a -> b) -> Music a -> Music b
     fmap f = Duo . fmap (fmap f . fromConcurrent) . duo1

But I get the following error: • The type synonym ‘Music’ should have 1 argument, but has been given none • In the instance declaration for ‘Functor Music’ | 167 | instance Functor Music where | ^^^^^^^^^^^^^

Perhaps the problem is just that I m essentially writing a Functor for only a Subset of Duo, maybe this can only work if I make music a newtype instead of just a type synonym. I m really hoping to avoid that on account of the already egregious number of wrappers going on in this code, I d really hate to add another. Maybe you all can think of a way to implement a functor for Duo that makes sense, and makes this all work?

One thing I really don t understand is why it let s me make an instance for show:

instance (Show a) => Show (Music a) where
     show (Duo Nothing)               = "Silence"
     show (Duo (Just (Concurrent x))) = show x

Answer 1

Unfortunately, this kind of type-level abstraction is not allowed in Haskell. But I think you might have made some sort of conceptual error in your data type design somewhere. Expanding the types, since Duo has only one field, we would have:

Music a ~= Duo (Maybe (Concurrent a)) (Maybe (Sequential a))
        ~= Maybe (Concurrent a)
        ~= Maybe (Song a)

这真是你想要的吗?

在不大可能的情况下,我认为我非常希望切断中间商。

data Music a = Silence | Sound (Song a)
instance Functor Music where
    fmap f Silence = Silence
    fmap f (Sound notes) = Sound (fmap f notes)

If this is the intended behavior but you must keep the middlemen, newtype is the way forward.

In the likely event that this was not how you intended Music to behave, we can probably give you more/better advice, but we d need to know more about what you intend Duo to mean.

Regarding your edit/comment about Show: in your Show instance, you include a type argument to Music. The problem with the Functor instance is exactly the fact that you do not include the argument. In the Show instance, because the argument is available, the compiler can simply expand the type alias, so the line

instance Show a => Show (Music a)

is identical in every way the compiler cares about to the line

instance Show a => Show (Duo (Maybe (Concurrent a)) (Maybe (Sequential a)))

In your Functor instance, though, the compiler cannot expand the type alias, because you have not supplied the type argument. You could imagine adding type-level lambdas to Haskell, so that you could have instance Functor Music mean something like

instance Functor (a -> Duo (Maybe (Concurrent a)) (Maybe (Sequential a)))

but that has some serious problems. The naive way of adding it leads you to need to do higher-order unification during type-checking, which is undecidable.

友情链接