Question

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.

Answer 1

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.