Elm decrement counter while iterating array - functional-programming

Question

I've recently decided to take a more in depth look at functional programming and I decided to start out with Elm.
I'm very inexperienced at this so I feel like I am actually fighting the concept and the language and that my thought process is all wrong so I was hoping someone could help me with my simple exercises.
I'm trying to create a Minesweeper game, and for starters, I was just trying to populate a grid with mines.
Here's my code so far
import Array exposing (Array)
type State = Hidden | Tagged | Revealed
type alias Cell = {isMine: Bool, nearbyMines: Int, state: State}
type alias Board = Array (Array Cell)
mines : Int
mines = 100
initCell : Cell
initCell =
{isMine = False, nearbyMines = 0, state = Hidden}
generate : Int -> Int -> Board
generate lines cols =
Array.initialize lines (\y ->
Array.initialize cols (\x -> initCell))
markAsMine : Int -> Int -> Cell -> Cell
markAsMine x y cell =
if mines > 0
then {cell | isMine = True}
else cell
fillMines : Int -> Board -> Board
fillMines amount board =
board
|> Array.indexedMap (\y row -> row |> Array.indexedMap (\x cell-> markAsMine x y cell))
Of course, all this will do is mark every cell as a mine, so how do decrement the counter every time I mark a cell as mine?
This should be something trivial, hence why I think I'm struggling with the different programming paradigm!
Thanks in advance for any help,
Cheers!

Answer 1

A more functional approach would try to avoid using state when possible. Instead of thinking about it in terms of traversing a set of cells and decrementing a stateful field telling you how many mines are yet to be placed, it would be more idiomatic to pass in a Set of (x, y) values that have already been determined to be mines.
import Set exposing (Set)
fillMines : Int -> Set ( Int, Int ) -> Board -> Board
fillMines amount mines board =
board
|> Array.indexedMap
(\y row ->
row |> Array.indexedMap (\x cell -> { cell | isMine = Set.member ( x, y ) mines })
)
You then shift the responsibility of determining which (x, y) cells are mines to elsewhere in the application, and since Minesweeper is a randomized game, you'll probably want to create a random set of cells assigned as mines. The type signature could look something like this:
import Random
minefieldGenerator : Int -> Int -> Int -> Random.Generator (Set (Int, Int))
minefieldGenerator lines cols numMines = ...
The implementation of minefieldGenerator is outside the scope of this question, but you can use this generator using Random.generate (which will let the Elm Architecture generate a random number when returned from inside an update function), or you can pass in a known seed value to execute step.