了解和使用Haskell积分类型类的基本概念

Question

I'm taking a course which focuses on Haskell & Prolog and there's an upcoming test for which i'm studying.

We're given a signature:

myList
  :: (Integral a)
  => [a]

And we have to create a variable myList which will return an infinite list which is different from standard positive integer list by changing the position of every third element by moving it two positions to the right, starting from the first one.

So for example, the beginning would look like: 2,3,1,5,6,4,8,9,7.. on a standard list which contains positive elements.

I tried to solve this with a code like this:

myList (x:y:z:xs)
  = y:z:x:(myList(xs))
myList [] = []
myList [x] = [x]

It gives the result needed but it's not following the signature. Could someone explain how to solve it so it would fit the signature and why it does.

Thanks.

Answer 1

The function (the implementation of which you got perfectly right, as a matter of fact)

myList (x:y:z:xs) = y:z:x:(myList xs)
myList []         = []
myList [x]        = [x]

is generic enough not to depend on the type of the elements in the list to be Integral a => a . So if you let Haskell infer its type, it will infer [a] -> [a] . If you constraint the type to Integral a => [a] -> [a] , it will still work, but be less generic, which will limit uses to just integral types.

---

Here's a demonstration of the principle:

Prelude> :{
Prelude| let myList (x:y:z:xs) = y:z:x:(myList(xs))
Prelude|     myList [] = []
Prelude|     myList [x] = [x]
Prelude| :}
Prelude> :t myList
myList :: [a] -> [a]

Prelude> take 15 $ myList ['a'..]
"bcaefdhigkljnom"
Prelude> take 15 $ myList [1..]
[2,3,1,5,6,4,8,9,7,11,12,10,14,15,13]

but

Prelude> :{
Prelude| let myList :: Integral a => [a] -> [a]
Prelude|     myList (x:y:z:xs) = y:z:x:(myList(xs))
Prelude|     myList [] = []
Prelude|     myList [x] = [x]
Prelude| :}
Prelude> :t myList
myList :: Integral a => [a] -> [a]

Prelude> take 15 $ myList [1..]
[2,3,1,5,6,4,8,9,7,11,12,10,14,15,13]

Prelude> take 15 $ myList ['a'..]    
<interactive>:34:11:
    No instance for (Integral Char) arising from a use of ‘myList’
    In the second argument of ‘($)’, namely ‘myList ['a' .. ]’
    In the expression: take 15 $ myList ['a' .. ]
    In an equation for ‘it’: it = take 15 $ myList ['a' .. ]

---

So the point is , both definitions are equivalent and capable of doing the same thing just as well as the other, but the constrained type signature is (and I'd say unjustifiably) less useful than the one with the general type signature.

If the assignment demands a function of type Integral a => [a] -> [a] , all you really need to do is simply annotate the function you already have with exactly that type signature. There is, however, no (reasonable/rational) way to somehow guide Haskell to infer that type from the function definition, as that would necessitate somehow indirectly indicating that the list must contain values of a type that support the operations in Integral ... yada yada.

As a final note : you got the implementation/algorithm perfectly right, but fell short on type signatures and the notion of generality.

---

EDIT: if what you actually need is not a function but a list (your question is a bit ambiguous in this respect), all you need to do is rename the below definition of myList to eg myList' or go (which I think is quite a typical name for nested recursive helpers) or something (which can but doesn't have to be an hidden within the list myList ) and then pass [1..] to it, assigning the result to myList :

myList :: Integral a => [a]
myList = go [1..]
  where go (x:y:z:xs) = y:z:x:(go xs)
        go []         = []
        go [x]        = [x]

of course looked this way, Integral a => [a] is indeed quite general a signature for the list (but not the most general, which would be (Enum a, Num a) => [a] as I was led to realize by dfeuer's comment), because the type a cannot be determined by the type of the input passed to the function, because you're always passing [1..] .

Answer 2

If we want to give an answer with the right signature without supplying any signatures by hand, we have to look at the Integral class and look which methods it implements. Applying any such method is likely to force the right signature.

Prelude> :i Integral
class (Real a, Enum a) => Integral a where
  quot :: a -> a -> a
  rem :: a -> a -> a
  div :: a -> a -> a
  mod :: a -> a -> a
  quotRem :: a -> a -> (a, a)
  divMod :: a -> a -> (a, a)
  toInteger :: a -> Integer

Since our sequence has something to do with remainders of division by 3, div and mod look promising.

After some fiddling with arithmetic, we arrive at something like

Prelude> let myList = map (\x -> x - x `mod` 3 + (x+2) `mod` 3 + 1) [0..]
Prelude> :t myList
myList :: Integral b => [b]