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

module LinearScan.Applicative 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.Functor as Functor



#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"

data Applicative f =
   Build_Applicative (Functor.Functor f) (() -> Any -> f) (() -> () -> f -> f
                                                          -> f)

is_functor :: (Applicative a1) -> Functor.Functor a1
is_functor applicative =
  case applicative of {
   Build_Applicative is_functor0 pure0 ap0 -> is_functor0}

pure :: (Applicative a1) -> a2 -> a1
pure applicative x =
  case applicative of {
   Build_Applicative is_functor0 pure0 ap0 -> unsafeCoerce pure0 __ x}

ap :: (Applicative a1) -> a1 -> a1 -> a1
ap applicative x x0 =
  case applicative of {
   Build_Applicative is_functor0 pure0 ap0 -> ap0 __ __ x x0}

liftA2 :: (Applicative a1) -> (a2 -> a3 -> a4) -> a1 -> a1 -> a1
liftA2 h f x y =
  ap h (Functor.fmap (is_functor h) f x) y