{-# OPTIONS_GHC -cpp -XMagicHash #-}
{- For Hugs, use the option -F"cpp -P -traditional" -}

module LinearScan.State where


import Debug.Trace (trace, traceShow, traceShowId)
import qualified Prelude
import qualified Data.IntMap
import qualified Data.IntSet
import qualified Data.List
import qualified Data.Ord
import qualified Data.Functor.Identity
import qualified Hask.Utils

import qualified LinearScan.Applicative as Applicative
import qualified LinearScan.Functor as Functor
import qualified LinearScan.Monad as Monad



#ifdef __GLASGOW_HASKELL__
import qualified GHC.Base as GHC.Base
import qualified GHC.Prim as GHC.Prim
#else
-- HUGS
import qualified LinearScan.IOExts as IOExts
#endif


#ifdef __GLASGOW_HASKELL__
--unsafeCoerce :: a -> b
unsafeCoerce = GHC.Base.unsafeCoerce#
#else
-- HUGS
--unsafeCoerce :: a -> b
unsafeCoerce = IOExts.unsafeCoerce
#endif


#ifdef __GLASGOW_HASKELL__
type Any = GHC.Prim.Any
#else
-- HUGS
type Any = ()
#endif

__ :: any
__ = Prelude.error "Logical or arity value used"

type State s a = s -> (,) a s

get :: State a1 a1
get i =
  (,) i i

gets :: (a1 -> a2) -> State a1 a2
gets f s =
  (,) (f s) s

modify :: (a1 -> a1) -> State a1 ()
modify f i =
  (,) () (f i)

coq_State_Functor :: Functor.Functor (State a1 Any)
coq_State_Functor _ _ f x st =
  let {filtered_var = x st} in
  case filtered_var of {
   (,) a st' -> (,) (f a) st'}

coq_State_Applicative :: Applicative.Applicative (State a1 Any)
coq_State_Applicative =
  Applicative.Build_Applicative coq_State_Functor (\_ x st -> (,) x st)
    (\_ _ f x st ->
    let {filtered_var = f st} in
    case filtered_var of {
     (,) f' st' ->
      unsafeCoerce (\f'0 st'0 _ ->
        let {filtered_var0 = x st'0} in
        case filtered_var0 of {
         (,) x' st'' -> (,) (f'0 x') st''}) f' st' __})

coq_State_Monad :: Monad.Monad (State a1 Any)
coq_State_Monad =
  Monad.Build_Monad coq_State_Applicative (\_ x st ->
    let {filtered_var = x st} in
    case filtered_var of {
     (,) y st' ->
      unsafeCoerce (\y0 st'0 _ ->
        let {filtered_var0 = y0 st'0} in
        case filtered_var0 of {
         (,) a st'' -> (,) a st''}) y st' __})