Fixing Errors (Haskell) Simple Snakes & Ladder Game

Question

today I am here to request any helping to sort out the 5~ unique errors I have left to compile this Snakes & Ladder Game. I am providing the errors I am getting below and also the code.

I am providing all the information I feel is necessary to provide me some pointers. Thank you in advance. Any help is much appreciated.

Main.hs:10:88:
   Ambiguous occurrence ‘concat’
   It could refer to either 'Data.List.concat'
   imported from ‘Data.List’ at Main.hs:3:1-16
                                (and originally defined in ‘GHC.List’)
                             or ‘Data.Foldable.concat’,
                                imported from ‘Data.Foldable’ at Main.hs:5:1-20

Main.hs:10:96:
    Ambiguous occurrence ‘replicate’
    It could refer to either 'Data.List.replicate'
    imported from ‘Data.List.replicate’ at Main.hs:3:1-16
                               (and originally defined in ‘GHC.List’)
                            or ‘Data.Sequence.replicate’,
                               imported from ‘Data.Sequence’ at Main.hs:4:1-20

Main.hs:10:96:
    Ambiguous occurrence ‘elem’
    It could refer to either 'Data.List.elem'
    imported from ‘Data.List’ at Main.hs:3:1-16
                               (and originally defined in ‘GHC.List’)
                            or ‘Data.Foldable.elem’,
                                imported from ‘Data.Sequence’ at Main.hs:5:1-20

Main.hs:17:48:
  Not in scope: pos’
  Perhaps you meant ‘pos’ (line 14) 

Main.hs:43:37: Not in scope: ‘nums’

Here is the code:

module Main where

import Data.List
import Data.Sequence
import Data.Foldable
import Control.Lens

data Game = G Int Int Int [Int] [Bool] [Bool] [Bool] [Int] [Property] Int
data Property = Int | E | A | D
displayRow game@(G rows cols nplayers pos e a d drolls props turn) n = unlines [ '+' : concat (replicate n "---+") , '|' : concat (replicate n "   |")]
display game@(G 0 cols nplayers pos e a d drolls props turn) = ""
display game@(G rows cols nplayers pos e a d drolls props turn) = (displayRow game cols) ++ display (G (rows - 1) cols nplayers pos e a d drolls props turn)
go game@(G rows cols nplayers pos e a d drolls props 0) _ = display game
go game@(G rows cols nplayers pos e a d drolls props turn) i
  | elem (rows*cols) pos = display game 
  | nplayers == i = go (G rows cols nplayers pos e a d drolls props (turn - 1)) 0 
  | otherwise = go (move (G rows cols nplayers pos' e a d (tail drolls) props turn) i roll) (i + 1) where
    roll = if d!!i then 2*(head drolls) else (head drolls)
move (G rows cols nplayers pos e a d drolls props turn) i j = case (elemIndex posij pos) of
  Just k -> (move (G rows cols nplayers pos' e' a' d' drolls props turn) k 1) 
  Nothing -> (G rows cols nplayers pos' e' a' d' drolls props turn) 
  where
    posij = if (pos!!i + j) > rows*cols then rows*cols else pos!!i + j 
    pos'
      | props!!posij > posij = if e!!i then pos & ix i .~ (2*(props!!posij) - posij) else pos & ix i .~ (props!!posij)
      | props!!posij < posij = if a!!i then pos & ix i .~ posij else pos & ix i .~ (props!!posij)
      | otherwise = pos & ix i .~ posij
    e'
      | props!!posij > posij = if e!!i then e & ix i .~ False else e
      | props!!posij == E = e & ix i .~ True
      | otherwise = e
    a'
      | props!!posij < posij = if a!!i then a & ix i .~ False else a
      | props!!posij == A = a & ix i .~ True
      | otherwise = a
    d' = if (props!!posij) == D then (d & ix i .~ True) else (d & ix i .~ False)
instance Show Game where
  show game@(G rows cols nplayers pos e a d drolls props turn) = go game 0 
build (l:ls) = build' (G 0 0 0 [] [] [] [] [] [] 0) (l:ls) where
  build' game (l:ls) = build' (update game l) ls
  build' game [] = game
  update (G rows cols nplayers pos e a d drolls props turn) s = case (words s) of
                    "board":l -> G (nums!!0) (nums!!1) nplayers pos e a d drolls [i | i <- [0..(nums!!0)*(nums!!1)]] turn
                    "players":l -> G rows cols (nums!!0) [0 | _ <- [1..(nums!!0)]] [False | _ <- [1..(nums!!0)]] [False | _ <- [1..(nums!!0)]] [False | _ <- [1..(nums!!0)]] drolls props turn
                    "dice":l -> G rows cols nplayers pos e a d (cycle nums) props turn
                    "ladder":l -> G rows cols nplayers pos e a d drolls (props & ix (nums!!0) .~ (nums!!1)) turn
                    "snake":l -> G rows cols nplayers pos e a d drolls (props & ix (nums!!0) .~ (nums!!1)) turn
                    "powerup":"escalator":l -> G rows cols nplayers pos e a d drolls (over (elements (flip elem nums)) (const E) props) turn
                    "powerup":"antivenom":l -> G rows cols nplayers pos e a d drolls (over (elements (flip elem nums)) (const A) props) turn
                    "powerup":"double":l -> G rows cols nplayers pos e a d drolls (over (elements (flip elem nums)) (const D) props) turn
                    "turns":l -> G rows cols nplayers pos e a d nums props (turn + (nums!!0)) where
                      nums = map read l :: [Int]
readFrom input = build (lines input)
main = do
  input <- getContents
  putStr $ show $ readFrom input

Answer 1

Here is your code formatted for sanity, and with type signatures added:

module Main where

import Data.Foldable
import Control.Lens

data Game = G Int Int Int [Int] [Bool] [Bool] [Bool] [Int] [Property] Int

data Property = Int | E | A | D

displayRow :: Game -> Int -> String
displayRow game@(G rows cols nplayers pos e a d drolls props turn) n = unlines [ '+' : concat (replicate n "---+") , '|' : concat (replicate n "   |")]

display :: Game -> String
display game@(G 0 cols nplayers pos e a d drolls props turn) = ""
display game@(G rows cols nplayers pos e a d drolls props turn) = (displayRow game cols) ++ display (G (rows - 1) cols nplayers pos e a d drolls props turn)

go :: Game -> Int -> String
go game@(G rows cols nplayers pos e a d drolls props 0) _ = display game
go game@(G rows cols nplayers pos e a d drolls props turn) i
  | elem (rows*cols) pos = display game
  | nplayers == i = go (G rows cols nplayers pos e a d drolls props (turn - 1)) 0
  | otherwise = go (move (G rows cols nplayers pos' e a d (tail drolls) props turn) i roll) (i + 1)
    where
      roll = if d!!i then 2*(head drolls) else (head drolls)

move :: Game -> Int -> Int -> Game
move (G rows cols nplayers pos e a d drolls props turn) i j = case (elemIndex posij pos) of
  Just k -> (move (G rows cols nplayers pos' e' a' d' drolls props turn) k 1)
  Nothing -> (G rows cols nplayers pos' e' a' d' drolls props turn)
  where
    posij = if (pos!!i + j) > rows*cols then rows*cols else pos!!i + j
    pos'
      | props!!posij > posij = if e!!i then pos & ix i .~ (2*(props!!posij) - posij) else pos & ix i .~ (props!!posij)
      | props!!posij < posij = if a!!i then pos & ix i .~ posij else pos & ix i .~ (props!!posij)
      | otherwise = pos & ix i .~ posij
    e'
      | props!!posij > posij = if e!!i then e & ix i .~ False else e
      | props!!posij == E = e & ix i .~ True
      | otherwise = e
    a'
      | props!!posij < posij = if a!!i then a & ix i .~ False else a
      | props!!posij == A = a & ix i .~ True
      | otherwise = a
    d' = if (props!!posij) == D then (d & ix i .~ True) else (d & ix i .~ False)

instance Show Game where
  show game@(G rows cols nplayers pos e a d drolls props turn) = go game 0

build :: [String] -> Game
build (l:ls) = build' (G 0 0 0 [] [] [] [] [] [] 0) (l:ls) 
  where
    build' game (l:ls) = build' (update game l) ls
    build' game [] = game

update :: Game -> String -> Game
update (G rows cols nplayers pos e a d drolls props turn) s = case (words s) of
    "board":l -> G (nums!!0) (nums!!1) nplayers pos e a d drolls [i | i <- [0..(nums!!0)*(nums!!1)]] turn
    "players":l -> G rows cols (nums!!0) [0 | _ <- [1..(nums!!0)]] [False | _ <- [1..(nums!!0)]] [False | _ <- [1..(nums!!0)]] [False | _ <- [1..(nums!!0)]] drolls props turn
    "dice":l -> G rows cols nplayers pos e a d (cycle nums) props turn
    "ladder":l -> G rows cols nplayers pos e a d drolls (props & ix (nums!!0) .~ (nums!!1)) turn
    "snake":l -> G rows cols nplayers pos e a d drolls (props & ix (nums!!0) .~ (nums!!1)) turn
    "powerup":"escalator":l -> G rows cols nplayers pos e a d drolls (over (elements (flip elem nums)) (const E) props) turn
    "powerup":"antivenom":l -> G rows cols nplayers pos e a d drolls (over (elements (flip elem nums)) (const A) props) turn
    "powerup":"double":l -> G rows cols nplayers pos e a d drolls (over (elements (flip elem nums)) (const D) props) turn
    "turns":l -> G rows cols nplayers pos e a d nums props (turn + (nums!!0))
    where
      nums = map read l :: [Int]

readFrom :: String -> Game
readFrom input = build (lines input)

main :: IO ()
main = do
  input <- getContents
  putStr $ show $ readFrom input

Your errors were caused by importing Data.List and Data.Sequence, which both provided functions with the same names as functions in the Prelude and each other, so they had a name conflict and ambiguous names.

Work from here and update with specific problems if you encounter any, and make sure to include what you have tried to do to solve the issues.