Início / coding / Perguntas / 79431578
Accepted
alias
Asked: 2025-02-12 07:48:08 +0800 CST

Resolvendo variável de tipo ambíguo

  • 772

Eu tenho um tipo de termo que, em essência, é:

data Term a = Term a Bool
            deriving Show

O Boolé um tipo de ajudante, e é necessário apenas ocasionalmente. Gostaria que o usuário pudesse ignorá-lo se não for necessário. Ou seja, o seguinte deve funcionar:

main :: IO ()
main = print v
 where v = "a"
         =: Term "b" True
         =: []

onde:

class Join a b where
   (=:) :: a -> [b] -> [b]
   infixr 1 =:

instance Join a (Term a) where
   x =: y = Term x False : y

instance Join (Term a) (Term a) where
   x =: y = x : y

Infelizmente, o GHC reclama:

a.hs:15:8-12: error: [GHC-39999]
    • Ambiguous type variable ‘b0’ arising from a use of ‘print’
      prevents the constraint ‘(Show b0)’ from being solved.
      Relevant bindings include v :: [b0] (bound at a.hs:17:8)

Mas se eu escrever mainassim:

main :: IO ()
main = print v
 where v :: [Term String]
       v = "a"
         =: Term "b" True
         =: []

Então está tudo bem. (Observe que a única diferença é que dei vuma assinatura de tipo.)

Estou curioso para saber se existe algum truque moderno do GHC (famílias de tipos, famílias de tipos injetivos, famílias de tipos fechados, GADTs, etc., ou algum sinalizador mágico) que tornaria a assinatura de tipo desnecessária e permitiria que o GHC deduzisse o tipo sozinho, sem qualquer ajuda.

Aqui está o programa na íntegra:

data Term a = Term a Bool
            deriving Show

class Join a b where
   (=:) :: a -> [b] -> [b]
   infixr 1 =:

instance Join a (Term a) where
   x =: y = Term x False : y

instance Join (Term a) (Term a) where
   x =: y = x : y

main :: IO ()
main = print v
 where v :: [Term String]  -- Want to avoid this signature and let GHC deduce it.
       v = "a"
         =: Term "b" True
         =: []

E a questão é se há algum recurso ou truque do GHC que eu possa aplicar para que a assinatura de tipo em vnão seja necessária. Também estou feliz em mudar a Joinclasse ou adicionar novos parâmetros/dependências etc., desde que a definição local de vpossa ser escrita como está sem a assinatura de tipo.

Eu também apreciaria uma explicação de por que isso não seria possível, se houver uma boa razão legítima para que o que estou pedindo seja irracional. Parece-me que há informações de tipo suficientes para que o GHC deduza o tipo em si, mas suspeito que algum tipo de suposição de "mundo aberto" esteja acontecendo e nenhum dos truques de "família de tipos fechados" funcionará; se esse for realmente o caso. Para ser claro, estou perfeitamente feliz que a Joinclasse nunca seja instanciada em nenhum outro tipo.

haskell

2 respostas

  1. De longe, a coisa mais simples a fazer é simplesmente usar (:)em vez de (=:)quando você inclui o Boolcampo. Então você nem precisa de nenhuma classe, você apenas escreve:

    (=:) :: a -> [Term a] -> [Term a]
a =: ts = Term a False : ts

main = print v where
  v = "a"
    =: Term "b" True
     : []

    Você pode precisar de uma declaração de fixidez para =:.

    Reconheço que esta não é uma resposta completa, pois agora há dois nomes de funções diferentes, então pode não ser generalizável para a versão não minimizada do seu problema, mas considere isso de qualquer maneira...

    • 3
  2. Best Answer

    Aqui está uma abordagem. Você pode usar uma família de tipos fechados que seleciona o tipo correto do lado direito com base no tipo do lado esquerdo:

    type family Terms a where
  Terms (Term a) = [Term a]
  Terms a = [Term a]

    e definir o =:operador como uma função polimórfica simples usando esta família:

    infixr 1 =:
(=:) :: a -> Terms a -> Terms a
(=:) = undefined

    Agora, sua maincompilação ocorre porque o lado esquerdo de cada =:chamada força um tipo inequívoco do lado direito:

    main :: IO ()
main = print v
 where v = "a"
         =: Term "b" True
         =: []

    Claro, (=:) = undefinedé uma implementação decididamente subótima. Para implementar =:corretamente, você precisará usar uma restrição para despachar para a definição correta:

    (=:) :: (Join a (Terms a)) => a -> Terms a -> Terms a
(=:) = join

    Com definições de classe e instância apropriadas:

    class Join a b where
  join :: a -> b -> b

instance Join a [Term a] where
  join x y = Term x False : y

instance Join (Term a) [Term a] where
  join x y = x : y

    o programa completo parece funcionar como pretendido:

    {-# LANGUAGE GHC2021 #-}
{-# LANGUAGE TypeFamilies #-}

data Term a = Term a Bool
  deriving (Show)

type family Terms a where
  Terms (Term a) = [Term a]
  Terms a = [Term a]

class Join a b where
  join :: a -> b -> b

instance Join a [Term a] where
  join x y = Term x False : y

instance Join (Term a) [Term a] where
  join x y = x : y

infixr 1 =:
(=:) :: (Join a (Terms a)) => a -> Terms a -> Terms a
(=:) = join

main :: IO ()
main = print v
  where v =  "a"
          =: Term "b" True
          =: []
    • 1

relate perguntas