3

I'm trying to store randomly generated dice values in some data structure, but don't know how exactly to do it in Haskell. I have so far, only been able to generate random ints, but I want to be able to compare them to the corresponding color values and store the colors instead (can't really conceive what the function would look like). Here is the code I have --

module Main where

import System.IO
import System.Random
import Data.List

diceColor = [("Black",1),("Green",2),("Purple",3),("Red",4),("White",5),("Yellow",6)]
diceRoll = []

rand :: Int -> [Int] -> IO ()
rand n rlst = do
       num <- randomRIO (1::Int, 6)
       if n == 0
        then printList rlst       -- here is where I need to do something to store the values
        else rand (n-1) (num:rlst)

printList x = putStrLn (show (sort x))

--matchColor x = doSomething()

main :: IO ()
main = do
    --hSetBuffering stdin LineBuffering
    putStrLn "roll, keep, score?"
    cmd <- getLine
    doYahtzee cmd
    --rand (read cmd) []

doYahtzee :: String -> IO ()
doYahtzee cmd = do
if cmd == "roll" 
    then do rand 5 []
        else putStrLn "Whatever"

After this, I want to be able to give the user the ability to keep identical dices (as in accumulate points for it) and give them a choice to re-roll the left over dices - I'm thinking this can done by traversing the data structure (with the dice values) and counting the repeating dices as points and storing them in yet another data structure. If the user chooses to re-roll he must be able to call random again and replace values in the original data structure.

I'm coming from an OOP background and Haskell is new territory for me. Help is much appreciated.

Improve this question
1
  • Which tutorials are you using to learn Haskell? Commented Mar 6, 2012 at 19:46

3 Answers 3

Reset to default
7

So, several questions, lets take them one by one :

First : How to generate something else than integers with the functions from System.Random (which is a slow generator, but for your application, performance isn't vital). There is several approaches, with your list, you would have to write a function intToColor :

intToColor :: Int -> String
intToColor n = head . filter (\p -> snd p == n) $ [("Black",1),("Green",2),("Purple",3),("Red",4),("White",5),("Yellow",6)]

Not really nice. Though you could do better if you wrote the pair in the (key, value) order instead since there's a little bit of support for "association list" in Data.List with the lookup function :

intToColor n = fromJust . lookup n $ [(1,"Black"),(2,"Green"),(3,"Purple"),(4,"Red"),(5,"White"),(6,"Yellow")]

Or of course you could just forget this business of Int key from 1 to 6 in a list since lists are already indexed by Int :

intToColor n = ["Black","Green","Purple","Red","White","Yellow"] !! n

(note that this function is a bit different since intToColor 0 is "Black" now rather than intToColor 1, but this is not really important given your objective, if it really shock you, you can write "!! (n-1)" instead)

But since your colors are not really Strings and more like symbols, you should probably create a Color type :

data Color = Black | Green | Purple | Red | White | Yellow deriving (Eq, Ord, Show, Read, Enum)

So now Black is a value of type Color, you can use it anywhere in your program (and GHC will protest if you write Blak) and thanks to the magic of automatic derivation, you can compare Color values, or show them, or use toEnum to convert an Int into a Color !

So now you can write :

randColorIO :: IO Color
randColorIO = do
   n <- randomRIO (0,5)
   return (toEnum n)

Second, you want to store dice values (colors) in a data structure and give the option to keep identical throws. So first you should stock the results of several throws, given the maximum number of simultaneous throws (5) and the complexity of your data, a simple list is plenty and given the number of functions to handle lists in Haskell, it is the good choice.

So you want to throws several dices :

nThrows :: Int -> IO [Color]
nThrows 0 = return []
nThrows n = do
   c <- randColorIO
   rest <- nThrows (n-1)
   return (c : rest)

That's a good first approach, that's what you do, more or less, except you use if instead of pattern matching and you have an explicit accumulator argument (were you going for a tail recursion ?), not really better except for strict accumulator (Int rather than lists).

Of course, Haskell promotes higher-order functions rather than direct recursion, so let's see the combinators, searching "Int -> IO a -> IO [a]" with Hoogle gives you :

replicateM :: Monad m => Int -> m a -> m [a]

Which does exactly what you want :

nThrows n = replicateM n randColorIO

(I'm not sure I would even write this as a function since I find the explicit expression clearer and almost as short)

Once you have the results of the throws, you should check which are identical, I propose you look at sort, group, map and length to achieve this objective (transforming your list of results in a list of list of identical results, not the most efficient of data structure but at this scale, the most appropriate choice). Then keeping the colors you got several time is just a matter of using filter.

Then you should write some more functions to handle interaction and scoring :

type Score = Int
yahtzee :: IO Score
yahtzeeStep :: Int -> [[Color]] -> IO [[Color]] -- recursive
scoring :: [[Color]] -> Score

So I recommend to keep and transmit a [[Color]] to keeps track of what was put aside. This should be enough for your needs.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

That was very thorough and patient of you. Thanks a lot. Should I be calling replicateM n randColorIO in doYahtzee? Because I tried nThrows n, it seems to work; I have no way of knowing because it doesn't print to screen and when I tried putStrLn (nThrows 5) it threw couldn't match [char] with type IO[color]. I was expecting it to return a list of enums (colors) but it seems to return chars.
No, no, (nThrows n) is of type IO [Color], [Char] is the type expected by putStrLn (String and [Char] are synonyms), you see that putStrLn can't display an IO action. You have to execute the action, get the result and convert it to a String (with show) to use putStrLn on it. That could look like : do { colors <- nThrows 5; print colors } where colors will be of type [Colors] and print is a standard function of type (Show a) => a -> IO (), print x = putStrLn (show x).
Basically, in a type error by GHC, you have two type : the "expected type" which is the type the context impose on the expression (here the type error was on the expression "nThrows 5" and the context "putStrLn _" wanted a String (==[Char]) in this spot) and the "actual type" which is the type of the expression, not taking context into account (here "nThrows 5" is of type IO [Color]). The type error gives you both and it's important to understand which is which to resolve the mismatch.
3

You are basically asking two different questions here. The first question can be answered with a function like getColor n = fst . head $ filter (\x -> snd x == n) diceColor.

Your second question, however, is much more interesting. You can't replace elements. You need a function that can call itself recursively, and this function will be driving your game. It needs to accept as parameters the current score and the list of kept dice. On entry the score will be zero and the kept dice list will be empty. It will then roll as many dice as needed to fill the list (I'm not familiar with the rules of Yahtzee), output it to the user, and ask for choice. If the user chooses to end the game, the function returns the score. If he chooses to keep some dice, the function calls itself with the current score and the list of kept dice. So, to sum it up, playGame :: Score -> [Dice] -> IO Score.

Disclaimer: I am, too, very much a beginner in Haskell.

Improve this answer

3 Comments

Where exactly do I call getColor? I've called it in "then do" of doYahtzee as getColor(rand 5 []) but it says couldn't match expected type IO () with type [char]. As for the rules of Yahtzee Jr. the user first gets to roll 5 dice and then gets to decide with colors to keep. S/he goes for 5 turns with 3 rolls each (can change color of choice within 3 rolls). Can't repeat colors for turns and at the end of 5 turns, the game sums up the points for all colors.
The getColor function will work with the insides of your list, not your list itself - like in map getColor $ rand 5 [], which will turn your list of Ints to a list of Strings. And by the way, if the turns also matter, they will also need to be a parameter to your playGame function.
Note that your getColor is equivalent to lookup n (map swap diceColor).
1

at first thought:

rand :: Int -> IO [Int]
rand n = mapM id (take n (repeat (randomRIO (1::Int, 6))))

although the haskellers could remove the parens

Improve this answer

6 Comments

mapM id is sequence, but the whole thing can be written as replicateM n $ randomRIO (1, 6). The type annotation is unnecessary since it can be inferred from the type signature.
I thought so, well, I included the type annotation as a statement of intent.
GHCi throws "Couldn't match expected type '()' with actual type '[int]' when I call rand 5 in the "then do" statement. Also can I print to view the contents of mapM or replicateM as Hammar suggests?
this is because it should be called as l <- rand n when in a do statement after which you can use l as you would any list such as using return l. and note that this rand replaces your rand function.
Now it says the last statement in a 'do' construct must be an expression. So if I called show on rand, would this display the list?
|

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.