初学Haskell：使用反向功能进行最后一个功能

Question

I'm attempting to make a function that generates the last item in a list. I want to use reverse and !!. This is what I have so far:

myLast :: [a] -> [a] -> Int -> a
myLast xs = (reverse xs) !! 1

I know the problem lies somewhere within the type, but I'm having trouble identifying how to fix it.

Answer 1

A function's type signature has nothing to do with what you use in the function, it only describes how other people can use this function you're defining . So by writing

myLast :: [a] -> [a] -> Int -> a

you're saying, users need to supply two lists and and integer. Just to get the last element of one of the lists?? That doesn't make sense.

You surely mean

myLast :: [a] -> a

You should generally write that down before even thinking about how you're going to implement that function.

With that signature, you can write various implementations:

myLast :: [a] -> a
myLast xs = head $ reverse xs

myLast' :: [a] -> a
myLast' [l] = l
myLast' (_:xs) = myLast' xs

myLast'' :: [a] -> a
myLast'' = fix $ \f (x:xs) -> maybe x id . teaspoon $ f xs

or whatever weird implementation you choose, it has nothing to do with the signature.

On an unrelated note: though last is actually a standard function from the prelude, it's a kind of function avoided in modern Haskell: last [] gives an error, because the is no a value to be found in the empty list! Errors are bad. Hence the “ideal” way to write it is actually

myLast :: [a] -> Maybe a
myLast [] = Nothing
myLast [x] = x
myLast (_:xs) = myLast xs

Answer 2

I would recommend not using !! at all, but to use head .

myLast xs = head (reverse xs)

Head returns the first element of the list it is given as argument.
If you insist on using !! , in Haskell arrays are indeed zero-based, which means that !! 0 !! 0 gets the first element, !! 1 !! 1 the second, etc.

As for the type: myLast takes an array of some type and returns one item of that same type. That is denoted as follows:

 
 
 
 
  
  
  myLast :: [a] -> a
 
 
  

@leftaroundabout covered this way better in his answer.

Answer 3

Based on @leftaroundabout 's answer, here's an implementation that should do what you want:

safeHead :: [a] -> Maybe a
safeHead [] = Nothing
safeHead (x:_) = Just x

myLast :: [a] -> Maybe a
myLast [] = Nothing
myLast xs = safeHead $ reverse xs

The Maybe type is constructed as follows (from Hackage ):

data  Maybe a  =  Nothing | Just a
  deriving (Eq, Ord)

myLast [1, 2, 3, 4] , for example, will return Just 4 . If you want to use the value 4 you can use the function fromJust function from the Data.Maybe module ( fromJust (Just 4) returns 4 ). fromJust is defined like this:

-- | The 'fromJust' function extracts the element out of a 'Just' and
-- throws an error if its argument is 'Nothing'.
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> fromJust (Just 1)
-- 1
--
-- >>> 2 * (fromJust (Just 10))
-- 20
--
-- >>> 2 * (fromJust Nothing)
-- *** Exception: Maybe.fromJust: Nothing
--
fromJust          :: Maybe a -> a
fromJust Nothing  = error "Maybe.fromJust: Nothing" -- yuck
fromJust (Just x) = x