diff --git a/deterministic-game-engine.cabal b/deterministic-game-engine.cabal
--- a/deterministic-game-engine.cabal
+++ b/deterministic-game-engine.cabal
@@ -1,5 +1,5 @@
 name:                deterministic-game-engine
-version:             0.3.1
+version:             0.4.0
 synopsis:            Simple deterministic game engine
 description:         Haskell library for creating simple deterministic games,
                      such as tic-tac-toe. The engine requires a minimal set of
@@ -42,6 +42,6 @@
   type:                exitcode-stdio-1.0
   build-depends:       base <5.0,
                        hspec >=2.1 && <2.2,
-                       deterministic-game-engine ==0.3.1
+                       deterministic-game-engine ==0.4.0
 
   default-language:    Haskell2010
diff --git a/src/Game/Deterministic/GameEngine.hs b/src/Game/Deterministic/GameEngine.hs
--- a/src/Game/Deterministic/GameEngine.hs
+++ b/src/Game/Deterministic/GameEngine.hs
@@ -1,7 +1,7 @@
 {- |
 
-Haskell library for creating simple deterministic games,
-such as tic-tac-toe. The engine requires a minimal set of
+Library for creating simple deterministic games, such
+as tic-tac-toe. The engine requires a minimal set of
 actions related to the game, and then will run the game
 until a terminal state is reached.
 
@@ -9,10 +9,10 @@
 
 > import Game.Deterministic.GameEngine
 >
-> game :: Monad m => GameEngine m Int Int
+> game :: Monad m => GameEngine m [Char] [(Int, Char)]
 > game = GameEngine gameActions initialState
 >
-> gameActions :: Monad m => GameActions m Int Int
+> gameActions :: Monad m => GameActions m [Char] [(Int, Char)]
 > gameActions = GameActions {
 >    getPlayer  = -- find the next player from a game state,
 >    getMove    = -- find a move from the game state,
@@ -21,26 +21,21 @@
 >    getScore   = -- get score from a terminal state
 >  }
 >
-> initialState :: GameState Int
-> initialState = GameState 0
+> initialState :: GameState [Char]
+> initialState = GameState ['x', 'x', 'x']
 >
 > -- run the game engine until a terminal state is reached
 > playSimple game
 
 -}
 
-{-# LANGUAGE RankNTypes #-}
 
-
 module Game.Deterministic.GameEngine (
-    Symbol,
+    GameActions(..),
     GameState(..),
-    Player(..),
     Move(..),
-    GameActions(..),
+    Player(..),
     GameEngine(..),
-    GameEngineSimple,
-    GameEngineIO,
     play,
     playSimple,
     playIO
@@ -48,6 +43,8 @@
 
 
 import           Control.Monad.Identity
+
+
 import           Game.Deterministic.GameEngine.GameActions
 import           Game.Deterministic.GameEngine.GameState
 import           Game.Deterministic.GameEngine.Move
@@ -55,49 +52,39 @@
 
 
 data GameEngine m a b = GameEngine {
-    actions :: GameActions m a b,
+    gameEngineActions :: GameActions m a b,
     -- ^ Defines how the game will be played
 
-    state   :: GameState a
+    gameEngineState   :: GameState a
     -- ^ The current state of the game
   }
 -- ^ Holds information about how the game is played, and the current state of the game.
 
 
-type GameEngineSimple a b = GameEngine Identity a b
-type GameEngineIO a b = GameEngine IO a b
-
-
 play :: Monad m => GameEngine m a b -> m Int
 -- ^ Run the provided game engine under a monadic context until a terminal state is reached.
-play engine = do
-  isTerm <- isTerminal gameActions gameState
+play (GameEngine actions state) = do
+  isTerm <- isTerminal actions state
 
   if isTerm then do
-    player <- getPlayer gameActions gameState
-    getScore gameActions gameState player
+    player <- getPlayer actions state
+    getScore actions state player
     else do
-      nextState <- getNextState engine
-      play $ GameEngine (actions engine) nextState
-  where
-    gameActions = actions engine
-    gameState = state engine
+      nextState <- getNextState actions state
+      play $ GameEngine actions nextState
 
 
-playSimple :: GameEngineSimple a b -> Int
+playSimple :: GameEngine Identity a b -> Int
 -- ^ Run the provided game engine without a context until a terminal state is reached.
 playSimple = runIdentity . play
 
 
-playIO :: GameEngineIO a b -> IO Int
+playIO :: GameEngine IO a b -> IO Int
 -- ^ Run the provided game engine within an IO context until a terminal state is reached.
 playIO = play
 
 
-getNextState :: Monad m => GameEngine m a b -> m (GameState a)
-getNextState engine = do
-  nextMove <- getMove gameActions gameState
-  getResult gameActions gameState nextMove
-  where
-    gameActions = actions engine
-    gameState = state engine
+getNextState :: Monad m => GameActions m a b -> GameState a -> m (GameState a)
+getNextState actions state = do
+  nextMove <- getMove actions state
+  getResult actions state nextMove
diff --git a/src/Game/Deterministic/GameEngine/Player.hs b/src/Game/Deterministic/GameEngine/Player.hs
--- a/src/Game/Deterministic/GameEngine/Player.hs
+++ b/src/Game/Deterministic/GameEngine/Player.hs
@@ -1,10 +1,6 @@
 module Game.Deterministic.GameEngine.Player (
-    Symbol,
     Player(..)
   ) where
 
 
-type Symbol = Char
-
-
-data Player = Player Symbol deriving (Eq, Show)
+data Player = Player String deriving (Eq, Show)