Comment puis-je créer un opérateur en Haskell?

Faire un ternaires de la logique de la table, et je voudrais faire ma propre fonction pour un opérateur que je vais appeler <=>.

Ainsi, par exemple, je veux faire cela, mais ce n'est pas le bon. quelle est la manière correcte de le faire?

data Ternary = T | F | M
deriving (Eq,  Show, Ord)

<=> :: Ternary -> Ternary -> Ternary
<=> T F = F
<=> T T = T
<=> T M = M
<=> F F = T
<=> F T = F
<=> F M = M
<=> M F = M
<=> M T = M
<=> M M = T
  • Tout comme une note de côté, M <=> M devrait être M plutôt que T. Mais cela dépend de votre "Peut-être" de la sémantique.
  • N'oubliez pas que vous pouvez définir arité et associativité des opérateurs en utilisant infixl, infixr...
InformationsquelleAutor user1189352 | 2012-02-20
  1. 43

    Juste ajouter des parenthèses autour de votre opérateur:

    (<=>) :: Ternary -> Ternary -> Ternary
(<=>) T F = F
(<=>) T T = T
(<=>) T M = M
(<=>) F F = T
(<=>) F T = F
(<=>) F M = M
(<=>) M F = M
(<=>) M T = M
(<=>) M M = T

    Ce qu'il transforme à partir de la forme infixe de forme préfixe. Alternativement, vous pouvez simplement utiliser infix dans la définition:

    (<=>) :: Ternary -> Ternary -> Ternary
T <=> F = F
T <=> T = T
T <=> M = M
F <=> F = T
F <=> T = F
F <=> M = M
M <=> F = M
M <=> T = M
M <=> M = T
    • Est-il un moyen de créer quelque chose comme la : opérateur cons? Le : opérateur cons a cette particularité, lorsqu'il estime tout sur le côté droit de la liste. J'ai essayé de recréer le : de l'opérateur, mais il nécessite toujours entre parenthèses, sur le côté droit.
    • peut-être il pourrait être intéressant de mentionner infix ainsi?
    • Vous pouvez faire la même chose vous-même la façon suivante: data List a = Nil | a :- List a et puis la partie cruciale: infixr 5 :-. N'a pas à être 5, mais qui est la priorité des listes, vient d'être infixr et PAS infixl ou infix. infixl 9 est la valeur par défaut
    InformationsquelleAutor Clark Gaebel
  2. 11

    Les noms de fonction avec les symboles ont une syntaxe différente que ceux sans:

    -- Works:
(<^>) :: Int -> Int -> Int
a <^> b = a + b

-- Doesn't work:
{ -
<^> :: Int -> Int -> Int
<^> a b = a + b
- }

-- Works:
letters :: Int -> Int -> Int
letters a b = a + b

-- Doesn't work:
{ -
(letters) :: Int -> Int -> Int
a letters b = a + b
- }

    Je vous promets, si - Haskell est bien la peine d'apprendre les règles complexes.

    • Pour être complet: a `letters` b fonctionne ...
    InformationsquelleAutor amindfv
  3. 1

    Vous pouvez simplifier (ligne-sage) de la définition comme suit:

    (<=>) :: Ternary -> Ternary -> Ternary
T <=> T = T
F <=> F = T
M <=> M = T
M <=> _ = M
_ <=> M = M
_ <=> _ = F
    • Qui n'a pas l'air plus simple pour moi.
    • C'est pourquoi j'ai un (line-wise) là. La clarté est discutable si. Je peux voir le code mieux parce que je suis forcé d'en déduire ce qu'il fait réellement, par opposition à la recherche d'un raw tableaux de définition. Mais c'est moi.
    • IMO c'est plus simple, je peux rapidement voir que si elles sont égales alors retourner vrai, s'ils ne le sont pas, mais on est un peut-être, ensuite, de retour peut-être, si elles ne sont pas égaux et n'impliquent pas de peut-être alors retourner faux. Seulement la partie que je trouve surprenant, c'est la M <=> M être T partie.
    InformationsquelleAutor Thomas Eding
  4. 0

    Puisque vous avez Eq et Ord, vous pouvez effectuer les opérations suivantes:

    data Ternary = T | F | M
deriving (Eq, Show, Ord)

(<=>) :: Ternary -> Ternary -> Ternary
x <=> y = if x == y then T else max x y

    Si vous ne vous arrive de le modifier de sorte que M <=> M == M, vous pouvez effectuer les opérations suivantes:

    data Ternary = M | T | F
deriving (Eq, Show, Ord, Enum)

(<=>) :: Ternary -> Ternary -> Ternary
x <=> y = fromEnum $ rem (toEnum x * toEnum y) 3
    InformationsquelleAutor Olathe