Haskell xor nicht für die Zuordnung arbeiten

Question

Ich habe ein Problem der Verwendung von xor Funktion in Data.Bits Modul wie ein Code unter

import Data.Bits 

andFunc :: [Int] -> [Int] -> [Int] 
andFunc xs ys = zipWith (\x y -> x .&. y) xs ys 

xorFunc :: [Int] -> [Int] -> [Int] 
xorFunc xs ys = zipWith (\x y -> x xor y) xs ys 

Wenn ich versuche, andFunc mit Argumenten von [1..10] anzuwenden und [2..11] (Argumente sind nur willkürlich Array)

es funktioniert. (Schreibt nicht hier, sondern orFunc (.|.) funktioniert auch)

aber einige Gründe, xorFunc nicht .... und sagt

<interactive>:74:1: error: 
    ? Non type-variable argument 
     in the constraint: Enum ((a -> a -> a) -> t -> c) 
     (Use FlexibleContexts to permit this) 
    ? When checking the inferred type 
     it :: forall a t c. 
       (Enum ((a -> a -> a) -> t -> c), Enum t, 
       Num ((a -> a -> a) -> t -> c), Num t, Bits a) => 
       [c] 

Wissen Sie, warum?

Laufende Umwelt: GHC 8.2.1 ohne Flags Windows-10 64-Bit-

Answer 1

Wenn Sie Funktionen in Infix-Notation verwenden Sie Graviszeichen Syntax verwenden.

xorFunc :: [Int] -> [Int] -> [Int] 
xorFunc xs ys = zipWith (\x y -> x `xor` y) xs ys 

aber dies kann

xorFunc :: [Int] -> [Int] -> [Int] 
xorFunc xs ys = zipWith xor xs ys 

und Anwenden eta reduzieren (zweimal) etwas einfacher, indem nicht das Schreiben dieser als Lambda-Ausdruck gelöst werden, also Parameter weggelassen, die in der letzten Position auftreten und kann vollständig vom Typ Checker abgeleitet werden.

Answer 2

Infix-Funktionen werden mit Interpunktion geschrieben und können mit Klammern versehen werden; z.B. x + y kann auch (+) x y geschrieben werden. In die andere Richtung werden Präfixfunktionen mit Buchstaben geschrieben und können mit Backticks infixiert werden; z.B. zip xs ys kann auch geschrieben werden.

Wenn Sie das auf Ihren Fall anwenden, bedeutet dies, dass Sie einen von xor x y oder x `xor` y anstelle von x xor y schreiben sollten.

Answer 3

xor ist ein normaler Funktionsname, kein Operator. Sie müssen es in Backquotes einschließen, um es als Infix-Operator zu verwenden.

xorFunc xs ys = zipWith (\x y -> x `xor` y) xs ys 

Das heißt, Ihre Lambda-Ausdrücke sind nicht notwendig; verwenden nur xor als Argument zip:

xorFunc xs ys = zipWith xor xs ys 

oder einfach

xorFunc = zipWith xor 

(Ebenso andFunc = zipWith (.&.), schließen Sie den Operator in Klammern es als Funktionswert zu verwenden.)