如何使用haskell类型？

Question

Really simple question, i can't for the life of me google the info :(

I have the following types:

type NI = Int
type Age = Int
type Balance = Int
type Person = (NI, Age, Balance)

How do I create a function that returns true if a person's age is over 65? I've tried:

retired :: Person -> Bool
retired p = p >= 65

It doesn't work obviously, i realise that even when i tried it. I'm stumped on something so simple.

Answer 1

as Person is a tuple you should pattern-match it like this:

retired (_,age,_) = age >= 65

and it should work

Answer 2

type X = Y defines a type alias . In this example, X is defined to be the same as Y . Therefore, retired :: Person -> Bool is the same as retired :: (Int, Int, Int) -> Bool .

Then we can ask the question: how do we obtain a person's age? Well, Person is the same as (Int, Int, Int) , and we know the second element of the tuple is the person's age. Therefore, an equivalent question is: how do we obtain the second element of a 3-tuple?

This is done in Haskell by deconstructing the tuple, which is the opposite of constructing the tuple. An example of constructing a tuple is x = (1,2,3) . To deconstruct a tuple, we use a similar notation but flip the sides: (a,b,c) = x . This is the same as (a,b,c) = (1,2,3) , and the same as the three assignments a = 1; b = 2; c = 3 a = 1; b = 2; c = 3 a = 1; b = 2; c = 3 .

Haskell allows you to use this deconstruction notation for function arguments. Therefore, retired p = e could be written retired (ni, age, balance) = e , recalling that Person is a 3-tuple. Now it is straight-forward that e should be age >= 65 .

To elaborate further, retired (ni, age, balance) = e is equivalent to retired p = let (ni, age, balance) = p in e . This is useful to know because then function application is clearer. retired x is let (ni, age, balance) = x in [x/p]e where [x/p]e means "substitute x for p in e ".

---

Another approach is to define a data type using record notation.

data Person = Person { ni :: Int, age :: Int, balance :: Int }

This defines a new type called Person , and is not the same as the 3-tuple of type (Int, Int, Int) . Additionally, this defines three projection functions ni :: Person -> Int , age :: Person -> Int , and balance :: Person -> Int .

Now if we implement retired :: Person -> Bool we can do so as retired p = age p >= 65 , or in point-free form retired = (>= 65) . age retired = (>= 65) . age .

To reconnect with the first approach, can you also use deconstruction? Absolutely. A Person is constructed as x = Person mnp , and so similarly can be deconstructed as Person abc = x . Therefore, another definition for retired is retired (Person nab) = a >= 65 .