如何在Haskell列表中获取元素？

Question

I want to make a function that looks up a String in a list of type [(String, Int)] and returns the Int paired with the String .

Like this:

λ> assignmentVariable "x" [("x", 3), ("y", 4), ("z", 1)]
3

Here's what I've tried:

assignmentVariable :: String -> [(String, Int)] -> Int
assignmentVariable [] = error "list is empty"
assignmentVariable n (x:xs) = if x == n
                              then xs
                              else assignmentVariable

How could I write this?

Answer 1

Let's take the posted code:

assignmentVariable::String -> [(String, Integer)] -> Integer
assignmentVariable [] = error "list is empty"
assignmentVariable n (x:xs) = if x == n then xs else ...

The first equation has only one argument, while the second has two. Let's fix that.

assignmentVariable::String -> [(String, Integer)] -> Integer
assignmentVariable _ []     = error "list is empty"
assignmentVariable n (x:xs) = if x == n then xs else ...

Since we do x == n , these variables must be of the same type. However, n::String and x::(String,Integer) . We need to split x into its components before comparing.

assignmentVariable::String -> [(String, Integer)] -> Integer
assignmentVariable _ []         = error "list is empty"
assignmentVariable n ((m,x):xs) = if m == n then xs else ...

The result xs is a list, not an Integer as the type signature suggests. You just want x there.

assignmentVariable::String -> [(String, Integer)] -> Integer
assignmentVariable _ []         = error "list is empty"
assignmentVariable n ((m,x):xs) = if m == n then x else ...

Finally, the recursive call. When m/=n , we want to try the other pairs in the list xs , so:

assignmentVariable::String -> [(String, Integer)] -> Integer
assignmentVariable _ []         = error "list is empty"
assignmentVariable n ((m,x):xs) = if m == n 
                                  then x
                                  else assignmentVariable n xs

Answer 2

You want to pattern-match on the pair.

assignmentVariable expected ((key, value) : rest)

If the variable name matches the expected name, the first element of the pair…

  = if key == expected

You return the associated value, the second element of the pair.

    then value

Otherwise, you try to find the value in the rest of the list.

    else assignmentVariable expected rest

You can implement it without pattern-matching, of course:

assignmentVariable expected list
  = if expected == fst (head list)
    then snd (head list)
    else assignmentVariable expected (tail list)

However, this is not the usual style in Haskell code.

This function also exists in the Prelude, by the name of lookup .

Answer 3

You're halfway there, actually!

First, it would be better to make a more general type signature, and a better name:

myLookup :: (Eq a) => a -> [(a, b)] -> b

You've done well to have sorted out the edge case of [] , but you've not quite finished:

myLookup _       []     = error "myLookup: empty list."
myLookup n  ((x, b):xs) = if x == n
                          then b
                          else myLookup n xs

Your problem was what you put after the else : you weren't recursively calling the function, you were returning the function, which doesn't make any sense - you need to call it again with different arguments to recur.

---

If you want to improve, try making a similar function of type Eq a => a -> [(a, b)] -> Maybe b for a challenge.

Answer 4

Just for posterity, I would like to propose an alternative implementation:

assignmentVariables :: Eq a => a -> [(a, b)] -> [b]
assignmentVariables n xs = [v | (n', v) <- xs, n == n']

You can run it in ghci:

> assignmentVariables "x" [("x", 3), ("y", 4), ("z", 1)]
[3]

"Ah!", I hear you say, "But it returns [3] and not 3 !". But don't give up on it yet; there are several advantages of the behavior of this function over the behavior you proposed.

The type of assignmentVariables is more honest than the type of assignmentVariable . It doesn't promise to return a value when it doesn't find the given key in its lookup table. This means that, unlike your version, this version will not cause runtime crashes. Moreover, it has a clean way to report the unlikely situation where there are conflicts in the lookup table: it will return all values associated with the given key, even if there are many.

The consumer of the call then gets to decide how to handle the exceptional cases: one can write

case assignmentVariables key lookupTable of
    []      -> -- do something appropriate to complain about missing keys
    [value] -> -- do something with the value
    values  -> -- do conflict resolution; for example, use the first value or complain or something

or may simply treat the output of assignmentVariables as a nondeterministic value. The key here is that you are not locked into one behavior (which, of all the choices, crashing ? really?).