{-# LANGUAGE OverloadedStrings #-}

module R.M ( RM
           , runR
           , nextN
           , nextU
           ) where

import           Control.Monad.State.Strict (State, get, modify, runState)
import           Data.Functor               (($>))
import qualified Data.Text                  as T
import           Nm
import           U

type RM = State Int

nextU :: T.Text -> a -> RM (Nm a)
nextU :: forall a. Text -> a -> RM (Nm a)
nextU Text
n a
l = do {i <- StateT Int Identity Int
forall s (m :: * -> *). MonadState s m => m s
get; modify (+1) $> Nm n (U$i+1) l}

nextN :: a -> RM (Nm a)
nextN :: forall a. a -> RM (Nm a)
nextN = Text -> a -> RM (Nm a)
forall a. Text -> a -> RM (Nm a)
nextU Text
"x"

runR :: Int -> RM x -> (x, Int)
runR :: forall x. Int -> RM x -> (x, Int)
runR = (RM x -> Int -> (x, Int)) -> Int -> RM x -> (x, Int)
forall a b c. (a -> b -> c) -> b -> a -> c
flip RM x -> Int -> (x, Int)
forall s a. State s a -> s -> (a, s)
runState