Haskell模式匹配（初学者）

Question

I have to implement a small programm in Haskell that increments/decrements a result by what in the console line is. For example if we have -a in the console the results must be 0, if -b the result must be incremented with 6 and so on. I have to do this with pattern matching.

I haven't used Haskell until now and I find it pretty hard to understand. I have this to start with:

import System.Environment
main = getArgs >>= print . (foldr apply 0) . reverse
apply :: String -> Integer -> Integer

I don't understand what in the main is. What does it make and the reverse from end, what does it do? As I've read on the internet the getArgs function gives me the values from the console line. But how can I use them? Are there are equivalent functions like for/while in Haskell?

Also, if you have some examples or maybe could help me, I will be very thankful.

Thanks!

Answer 1

This is not beginner-friendly code. Several shortcuts are taken there to keep the code very compact (and in pointfree form). The code

main = getArgs >>= print . (foldr apply 0) . reverse

can be expanded as follows

main = do
  args <- getArgs
  let reversedArgs = reverse args
      result = foldr apply 0 reversedArgs
  print result

The result of this can be seen as follows. If the command line arguments are, say, args = ["A","B","C"] , then we get reversedArgs = ["C","B","A"] and finally

result = apply "C" (apply "B" (apply "A" 0))

since foldr applies the function apply in such way.

Honestly, I'm unsure about why the code uses reverse and foldr for your task. I would have considered foldl (or, to improve performance, foldl' ) instead.

Answer 2

I expect the exercise is not to touch the given code, but to expand on it to perform your function. It defines a complicated-looking main function and declares the type of a more straight forward apply , which is called but not defined.

import System.Environment   -- contains the function getArgs
-- main gets arguments, does something to them using apply, and prints
main = getArgs >>= print . (foldr apply 0) . reverse
-- apply must have this type, but what it does must be elsewhere
apply :: String -> Integer -> Integer

If we concentrate on apply , we see that it receives a string and an integer, and returns an integer. This is the function we have to write, and it can't decide control flow, so we can just get to it while hoping the argument handling works out.

If we do want to figure out what main is up to, we can make a few observations. The only integer in main is 0 , so the first call must get that as its second argument; later ones will be chained with whatever is returned, as that's how foldr operates. r stands for from the right, but the arguments are reverse d, so this still processes arguments from the left.

So I could go ahead and just write a few apply bindings to make the program compile:

apply "succ"   n = succ n
apply "double" n = n + n
apply "div3"   n = n `div` 3

This added a few usable operations. It doesn't handle all possible strings.

$ runhaskell pmb.hs succ succ double double succ div3
3
$ runhaskell pmb.hs hello?
pmb.hs: pmb.hs:(5,1)-(7,26): Non-exhaustive patterns in function apply

The exercise should be about how you handle the choice of operation based on the string argument. There are several options, including distinct patterns as above, pattern guards, case and if expressions.

It can be useful to examine the used functions to see how they might fit together. Here's a look at a few of the used functions in ghci :

Prelude> import System.Environment
Prelude System.Environment> :t getArgs
getArgs :: IO [String]
Prelude System.Environment> :t (>>=)
(>>=) :: Monad m => m a -> (a -> m b) -> m b
Prelude System.Environment> :t print
print :: Show a => a -> IO ()
Prelude System.Environment> :t (.)
(.) :: (b -> c) -> (a -> b) -> a -> c
Prelude System.Environment> :t foldr
foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
Prelude System.Environment> :t reverse
reverse :: [a] -> [a]

This shows that all the strings come out of getArgs , it and print operate in the IO monad, which must be the m in >>= , and . transfers results from the right function into arguments for the left function. The type signature alone doesn't tell us what order foldr handles things, though, or what reverse does (though it can't create new values, only reorder including repetition).

As a last exercise, I'll rewrite the main function in a form that doesn't switch directions as many times:

main = print . foldl (flip apply) 0 =<< getArgs

This reads from right to left in a data flow sense and handles arguments from left to right because foldl performs left-associative folding. flip is just there to match the argument order for apply .

Answer 3

As suggested in the comment, hoogle is a great tool. To find out what exactly you get from getArgs you can search for it on hoogle:

https://hackage.haskell.org/package/base-4.11.1.0/docs/System-Environment.html#v:getArgs As you can see, it's of type IO [String] . Since I don't know how familiar you are with the IO abstractions yet, we'll just say that the right part of >>= gets those as argument.

The arguments for a call like ./a.out -a -b --asdf Hi will then be a list of strings:

["-a", "-b", "--asdf", "Hi"] .

The fold + reverse in the main will then do some magic, and your apply function will be called with each string in the list and the previous return value ( 0 for the first invocation).

In Haskell, String is the same as [Char] with a bit of compiler sugar, so you can match on strings like you would on regular lists in your definition of apply .