Início / coding / Perguntas / 79020424
Accepted
kesarling
Asked: 2024-09-25 05:31:48 +0800 CST

Como sobrecarrego um determinado operador em Haskell para aceitar tipos diferentes em cada lado?

  • 772

ERM:

class Foo s where
    myCons :: Char -> s -> s
    myCons c xs = <my definition of however I wish to interpret this>

instance (Eq, Show) Foo where
    (:) x y = x `myCons` y

Erro:

Pattern bindings (except simple variables) not allowed in instance declaration:
      (:) x y = x `myCons` y

O que estou fazendo errado?

O que eu quero fazer:

fooFromList :: [Int] -> Foo
fooFromList [] = Foo []
fooFromList (x:xs) = let x' = (convertDigitToChar x) in x':(fooFromList xs)
list

2 respostas

  1. Você não pode sobrescrever funções existentes. Haskell usa polimorfismo ad-hoc para isso.

    O que você pode fazer no caso de uma lista é trabalhar com a OverloadedListsextensão  [ghc-doc] .

    Se você tiver um tipo de dado Foocom:

    data Foo a = MyEmpty | MyCons a (Foo a)

    Você pode usar:

    import GHC.IsList (IsList)

instance IsList (Foo a) where
  type Item (Foo a) = a
  toList = foldr MyCons MyEmpty
  fromList MyEmpty = []
  fromList (MyCons x xs) = x : fromList xs

    Se você compilar com -XOverloadedLists, poderá usar literais de lista em seu código que serão do tipo Foo a.

    Mas isso não sobrecarrega a (:)função: se você usar :, ela ainda usará o (:) :: a -> [a] -> [a]one.

    • 1
  2. Best Answer

    Recomendo simplesmente extrair o Fooaplicativo fora da recursão. (Na verdade... um novo tipo é realmente necessário, ou você apenas o criou como um palpite? O que faz Fooque [Char]não faz?)

    fooFromList :: [Int] -> Foo
fooFromList xs = Foo (map convertDigitToChar xs)

    Então, se eu estiver tentando fazer de Foo uma instância de Eq e Show, como eu faria isso?

    O compilador pode escrever essas instâncias para você, e é raro fazer algo diferente do que o derivador faz.

    data Foo = Foo [Char] deriving (Eq, Show)
    • 1

relate perguntas