Новый тип, производный IsSequence

Question

У меня новый тип X, который в основном список Ints. Я использую ClassyPrelude вместо стандартной Prelude и хочу получить класс IsSequence. Это делает необходимым также выводить множество других классов.

Расширение языка GeneralizedNewtypeDeriving должно позволять это (здесь используется вместе с расширением DerivingStrategies). Я хочу:

newtype X = X [Int] deriving newtype (MonoFunctor, MonoFoldable, MonoTraversable, Monoid, GrowingAppend, SemiSequence, MonoPointed, IsSequence)

полный файл:

{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE FlexibleContexts #-}

module Test where

import ClassyPrelude

newtype X = X [Int] deriving newtype (MonoFunctor, MonoFoldable, MonoTraversable, Monoid, GrowingAppend, SemiSequence, MonoPointed, IsSequence)

type instance Element X = Int

(все другие языковые расширения кажутся важными)

Тем не менее, это производит много сообщений об ошибках для MonoTraversable а также IsSequence:

/path/to/file/Test.hs:13:48: error:
    • Couldn't match representation of type ‘m [Int]’
                               with that of ‘m X’
        arising from the coercion of the method ‘omapM’
          from type ‘forall (m :: * -> *).
                     Applicative m =>
                     (Element [Int] -> m (Element [Int])) -> [Int] -> m [Int]’
            to type ‘forall (m :: * -> *).
                     Applicative m =>
                     (Element X -> m (Element X)) -> X -> m X’
      NB: We cannot know what roles the parameters to ‘m’ have;
        we must assume that the role is nominal
    • When deriving the instance for (MonoTraversable X)
   |
13 |   deriving newtype (MonoFunctor, MonoFoldable, MonoTraversable, Monoid, GrowingAppend, SemiSequence, MonoPointed, IsSequence)
   |                                                ^^^^^^^^^^^^^^^

/path/to/file/Test.hs:13:48: error:
    • Couldn't match representation of type ‘f [Int]’
                               with that of ‘f X’
        arising from the coercion of the method ‘otraverse’
          from type ‘forall (f :: * -> *).
                     Applicative f =>
                     (Element [Int] -> f (Element [Int])) -> [Int] -> f [Int]’
            to type ‘forall (f :: * -> *).
                     Applicative f =>
                     (Element X -> f (Element X)) -> X -> f X’
      NB: We cannot know what roles the parameters to ‘f’ have;
        we must assume that the role is nominal
    • When deriving the instance for (MonoTraversable X)
   |
13 |   deriving newtype (MonoFunctor, MonoFoldable, MonoTraversable, Monoid, GrowingAppend, SemiSequence, MonoPointed, IsSequence)
   |                                                ^^^^^^^^^^^^^^^

/path/to/file/Test.hs:13:115: error:
    • Couldn't match type ‘[Int]’ with ‘X’
        arising from the coercion of the method ‘initMay’
          from type ‘IsSequence [Int] => [Int] -> Maybe [Int]’
            to type ‘IsSequence X => X -> Maybe X’
    • When deriving the instance for (IsSequence X)
   |
13 |   deriving newtype (MonoFunctor, MonoFoldable, MonoTraversable, Monoid, GrowingAppend, SemiSequence, MonoPointed, IsSequence)
   |                                                                                                                   ^^^^^^^^^^

/path/to/file/Test.hs:13:115: error:
    • Couldn't match representation of type ‘m [Int]’
                               with that of ‘m X’
        arising from the coercion of the method ‘replicateM’
          from type ‘forall (m :: * -> *).
                     Monad m =>
                     Index [Int] -> m (Element [Int]) -> m [Int]’
            to type ‘forall (m :: * -> *).
                     Monad m =>
                     Index X -> m (Element X) -> m X’
      NB: We cannot know what roles the parameters to ‘m’ have;
        we must assume that the role is nominal
    • When deriving the instance for (IsSequence X)
   |
13 |   deriving newtype (MonoFunctor, MonoFoldable, MonoTraversable, Monoid, GrowingAppend, SemiSequence, MonoPointed, IsSequence)
   |                                                                                                                   ^^^^^^^^^^

/path/to/file/Test.hs:13:115: error:
    • Couldn't match representation of type ‘m [Int]’
                               with that of ‘m X’
        arising from the coercion of the method ‘filterM’
          from type ‘forall (m :: * -> *).
                     Monad m =>
                     (Element [Int] -> m Bool) -> [Int] -> m [Int]’
            to type ‘forall (m :: * -> *).
                     Monad m =>
                     (Element X -> m Bool) -> X -> m X’
      NB: We cannot know what roles the parameters to ‘m’ have;
        we must assume that the role is nominal
    • When deriving the instance for (IsSequence X)
   |
13 |   deriving newtype (MonoFunctor, MonoFoldable, MonoTraversable, Monoid, GrowingAppend, SemiSequence, MonoPointed, IsSequence)
   |                                              

что я не могу прочитать (может быть, это связано с подписями по умолчанию?, понятия не имею...). Если исключить 2 класса из производного предложения, код скомпилируется.

Вопрос: как вывести IsSequence в этом случае?

По нескольким причинам псевдоним типа невозможен для моего варианта использования, но я хочу использовать функции, предоставляемые этими классами. Если получение невозможно, необходимо реализовать методы класса самостоятельно.