我如何遍历一个 n 元素列表并对每个元素应用一个函数

Question

right player wins , the function returns 1, if the other side does its -1

evalTurn :: Symbol -> Symbol -> Outcome
evalTurn x y | x == y = 0
evalTurn 0 1 = 1
evalTurn 0 2 = -1
evalTurn 1 2 = 1
evalTurn 0 1 = -1
evalTurn 2 0 = 1
evalTurn 2 1 = -1
evalTurn 1 0 = -1

i need to evaluate the following with the truth table above.

evalBunch (x,y,z) = evalTurn x + evalTurn y + evalTurn z

evalMatch :: ([Symbol], [Symbol]) -> Outcome
evalMatch (x,y) = evalBunch (zip x y)

the test case presents 2 players with each turn's result , summed up

evalMatch ([1,1,1], [0,0,0]) == -3

Answer 1

First, consider using more domain-centered data types for your values, instead of just using ints with special meanings. eg it looks like here you're playing Rock Paper Scissors, so you'd have a better time with something like

data Symbol = Rock | Paper | Scissors deriving Eq
data Outcome = Win | Lose | Tie

evalTurn :: Symbol -> Symbol -> Outcome
evalTurn x y | x == y = Tie
evalTurn Rock Paper = Lose
-- ...

As is, you've accidentally repeated a case in your evalTurn : you have that evalTurn 0 1 = 1 , but also evalTurn 0 1 = -1 . This would be easier to spot if you used richer domain models. Or, if you want to stick with your integers, there is actually a shortcut using modular arithmetic:

evalTurn x y = case (y - x) `mod` 3 of
  0 -> 0
  1 -> 1
  2 -> -1

As to your actual question there are a number of problems before you can get to what you're trying to fix. evalTurn , evalBunch , and evalMatch all disagree on what the type of Symbol should be, and how many arguments evalTurn actually takes. Does it make sense to call evalTurn with one argument, as evalBunch does? Surely not.

My first suggestion would be to forget this evalBunch function completely, and write evalMatch in terms of evalTurn directly. It would probably be good practice for you to write it recursively by hand, rather than using fancy zips, curries, and function composition.

---

Another thing you could do, if you like the richer domain models I suggsted but don't want to write out all 9 cases (or 7 if you shortcut the x == y cases), is to instead define "does X beat Y" as a boolean primitive, and then build upon that to decide the more complicated question of who wins a match:

beats :: Symbol -> Symbol -> Bool
Rock `beats` Scissors = True
Scissors `beats` Paper = True
Paper `beats` Rock = True
_ `beats` _ = False

evalTurn :: Symbol -> Symbol -> Outcome
evalTurn x y | x `beats` y = Win
             | y `beats` x = Lose
             | otherwise = Tie

It's not really much shorter, perhaps even longer. But it avoided repetition, and now as a nice side benefit the program "knows" a little more about Symbols outside the context of evalTurn , which may prove useful somehow in another part of the program. For example, you could use this to draw a tutorial diagram of what beats what.

Answer 2

Keeping a little to the way in which the initial problem was presented, I suggest the following simplifications:

type Symbol = Int
type Outcome = Int

evalTurn :: (Symbol, Symbol) -> Outcome
evalTurn (x, y)
  | (x == y)           =  0
  | (x == 0 && y == 1) =  1
  | (x == 0 && y == 2) = -1
  | (x == 1 && y == 2) =  1
  | (x == 2 && y == 0) =  1
  | (x == 2 && y == 1) = -1
  | (x == 1 && y == 0) = -1

evalBunch :: (Foldable t, Functor t) => t (Symbol, Symbol) -> Outcome
evalBunch v = sum $ fmap evalTurn v

--Pointfree style is more elegant
--evalBunch = sum . fmap evalTurn

So, doesn't this function solve your use case?

Prelude> evalBunch [(1, 0), (1,0), (1,0)] 
Prelude> -3