% 在 Haskell 中做什么？

Question

I'm used to using % to mean "modulo" in other languages. In Haskell, we have to use mod xy or x `mod` y . So, what is this symbol used for in Haskell?

Answer 1

With a quick look on Hoogle , you can see that % is an infix function defined as

(%) :: Integral a => a -> a -> Ratio a

and as you can guess it is part of the Data.Ratio library, which mostly deals with ratios (ie: fractions). It is code is

x % y = reduce (x * signum y) (abs y)

thus given two integrals (x,y) , it returns an irreducible fraction x/y

Answer 2

In Haskell, we can define binary operators with various symbols (including % ) like ordinary functions, So you can define % as an arbitrary operator you want (in the module which you define it).

As the most typical case, % is provided as the constructor of the Ratio type by Data.Ratio module .

Try the code below on GHCi to make sure that % is provided by Data.Ratio :

ghci> 3 % 9

<interactive>:1:3: error:
    Variable not in scope: (%) :: Integer -> Integer -> t
ghci> import Data.Ratio
ghci> 3 % 9
1 % 3

And remember you can search such operators and functions in these search engines:

• https://www.haskell.org/hoogle/
• https://www.stackage.org/

Actually I've looked up how % is defined by Hoogle .

% is an infix function defined as

(%) :: Integral a => a -> a -> Ratio a

and from the type definition above, you can see that it is part of the Data.Ratio library, which mostly deals with ratios (ie: fractions). Its code is

x % y = reduce (x * signum y) (abs y)

thus given two integrals (x,y) , it returns an irreducible fraction x/y

Answer 3

Searching for (%) on Stackage Hoogle , it appears that Data.Ratio defines the % operator as constructing a Ratio value from a numerator and denominator. A GHCi example:

Prelude> :m + Data.Ratio
Prelude Data.Ratio> let x = 1 % 2
Prelude Data.Ratio> x
1 % 2
Prelude Data.Ratio> :t x
x :: Integral a => Ratio a

Answer 4

Data.Ratio uses % as a constructor, but unless that type was defined before the Integral type class, it doesn't explain why % was available for use by Data.Ratio . (Of course, qualified imports allow you to use the same operator name in multiple modules, so either way, % being used by Data.Ratio isn't really a reason.)

Note, however, that Integral defines both mod and rem functions . I suspect that % was intentionally left out of Integral , both to avoid 1) making a choice as to whether it should be an alias for mod or rem , as well as 2) making people remember which choice was made.

Also, languages use different definitions for % , so either (%) = mod or (%) = rem had the potential for confusing someone .

Answer 5

Found this in "Old School" Davies Introduction to Functional Programming Systems Using Haskell . (He constantly compares Haskell to Pascal.) It's a simulation of stack arithmetic

type Stack = [Float]

push :: Float -> Stack -> Stack
push x stack = x : stack

addStack :: Stack -> Stack
addStack (x:y:stack) = (y + x) : stack

subtStack :: Stack -> Stack
subtStack (x:y:stack) = (y - x) : stack

multStack :: Stack -> Stack
multStack  (x:y:stack) = (y * x) : stack

divStack :: Stack -> Stack
divStack  (x:y:stack) = (y / x) : stack

emptyStack :: Stack
emptyStack = []

popStack :: Stack -> (Float, Stack)
popStack (top:rest) = (top,rest)

Then

let f % g     = g . f
    actionsOn = push 12.2 %
                push 7.1 %
                push 6.7 %
                divStack %
                push 4.3 %
                subtStack %
                multStack %
                push 2.2 %
                addStack
in popStack (actionsOn emptyStack)

(-37.331642,[])

This is just a neater version of a crazy-looking nested function

popStack (addStack (push 2.2 (multStack (subtStack (push 4.3 (divStack (push 6.7 (push 7.1 (push 12.2 emptyStack)))))))))

which itself avoids creating and passing a new stack for each stack operation. In summary, what YAMAMOTO Yuji says right at the beginning is applicable here and not really any Ratio stuff AFAIK.