Ambigu Événement

Je suis actuellement en train d'apprendre à écrire des classes de type. Je n'arrive pas à écrire l'Ord type de classe avec des erreurs de compilation d'ambigu événement.

module Practice where

class  (Eq a) => Ord a  where
    compare              :: a -> a -> Ordering
    (<), (<=), (>=), (>) :: a -> a -> Bool
    max, min             :: a -> a -> a

    -- Minimal complete definition:
    --      (<=) or compare
    -- Using compare can be more efficient for complex types.
    compare x y
         | x == y    =  EQ
         | x <= y    =  LT
         | otherwise =  GT

    x <= y           =  compare x y /= GT
    x <  y           =  compare x y == LT
    x >= y           =  compare x y /= LT
    x >  y           =  compare x y == GT

    -- note that (min x y, max x y) = (x,y) or (y,x)
    max x y 
         | x <= y    =  y
         | otherwise =  x
    min x y
         | x <= y    =  x
         | otherwise =  y

Erreurs sont

Practice.hs:26:14:
    Ambiguous occurrence `<='
    It could refer to either `Practice.<=', defined at Practice.hs:5:10
                          or `Prelude.<=',
                             imported from `Prelude' at Practice.hs:1:8-15
...

et ainsi de suite. Je pense que c'est en contradiction avec le " Prélude version définis.

OriginalL'auteur user1850254 | 2013-05-07

  1. 20

    Le problème est que les noms de vos fonctions sont en conflit avec les standards de l'Prélude.

    Pour résoudre ce problème, vous pouvez ajouter explicitement la déclaration d'importation qui cache les noms en conflit:

    module Practice where

import Prelude hiding (Ord, compare, (<), (<=), (>=), (>), max, min)

...
    Merci.Qui a résolu mon problème

    OriginalL'auteur hammar

  2. 12

    hammar est droit, c'est à cause de conflits avec la norme Prélude noms. Mais il y a une autre solutions en plus de hiding noms de Prélude.

    Vous pouvez importer Prélude qualifiés:

    module Practice where

import qualified Prelude as P

...

    Ensuite, vous pouvez accéder à la fois à vous et à la version standard de la fonction: max exécutera votre version, et P.max exécutera standard Prélude.

    Il y a aussi de cacher complètement la norme Prélude fonctions: GHC extension du NoImplicitPrelude (http://www.haskell.org/haskellwiki/No_import_of_Prelude). Il peut être activé par écrit 

    { -# LANGUAGE NoImplicitPrelude #- }

    dans le tout début de votre fichier

    OriginalL'auteur Andrey Komarov