Modeling a sliding puzzle

Main.elm

import Html exposing (..) 
import Dict exposing (Dict)

type alias Board =
    { tiles : Dict (Int, Int) Int
    , empty : (Int, Int)
    }


newBoard =
  let
      addCell y x =
          Dict.insert (x,y) (1 + x + 4*y)
          
      addRow y board =
          List.foldl (addCell y) board [0..3]
  in
      { tiles = List.foldl addRow Dict.empty [0..3]
      , empty = (3,3)
      }


unsafeExtract : Maybe a -> a
unsafeExtract m =
    case m of
        Just x ->
            x
        _ ->
            Debug.crash "unsafe maybe extract"


swapLeft : Board -> Board
swapLeft board =
    let
        leftOf (x,y) =
            (max 0 (x-1),y)
            
        newEmpty =
            leftOf board.empty
            
        tile =
            Dict.get newEmpty board.tiles
                |> unsafeExtract
                
        newTiles =
            Dict.insert board.empty tile board.tiles
    in
        { tiles = newTiles
        , empty = newEmpty
        }


main = 
  let
      renderCell board y x =
          if board.empty == (x,y) then
              Html.text "[---]"
          else
              Dict.get (x,y) board.tiles
                  |> unsafeExtract
                  |> toString
                  |> \t -> Html.text ("[ " ++ t ++ " ]")
                  
      renderRow board y =
          List.map (renderCell board y) [0..3]
              |> div []
              
      renderBoard board =
          List.map (renderRow board) [0..3]
              |> div []
  in
      div []
          [ renderBoard newBoard
          , hr [] []
          , renderBoard (swapLeft newBoard)
          , hr [] []
          , renderBoard (swapLeft <| swapLeft newBoard)
          , hr [] []
          , renderBoard (swapLeft <| swapLeft <| swapLeft newBoard)
          , hr [] []
          , renderBoard (swapLeft <| swapLeft <| swapLeft <| swapLeft newBoard)
          ]