{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE UndecidableInstances #-} -- Wrinkle in Note [Trees That Grow]
                                      -- in module Language.Haskell.Syntax.Extension
{-# LANGUAGE ViewPatterns #-}

{-
(c) The University of Glasgow 2006
(c) The GRASP/@type@AQUA Project, Glasgow University, 1992-1998
-}

-- See Note [Language.Haskell.Syntax.* Hierarchy] for why not GHC.Hs.*

-- |
-- Abstract syntax of foreign function interface declarations.
module Language.Haskell.Syntax.Decls.Foreign (
  -- * Foreign function interface declarations
  -- ** Data-type
  ForeignDecl(..),
  -- ** Record synonym
  LForeignDecl,

  -- * Foreign export types
  -- ** Data-type
  ForeignExport(..),
  -- ** Specification
  CExportSpec(..),

  -- * Foreign import types
  -- ** Data-type
  ForeignImport(..),
  -- ** Specification
  CImportSpec(..),
  -- ** Sub-types
  CCallTarget(..),
  ForeignKind(..),
  Safety(..),

  -- * Foreign binding type
  CType(..),

  -- * General sub-types
  CLabelString,
  CCallConv(..),
  Header(..),

  -- * Extension points
  -- ** ForeignDecl
  XForeignExport,
  XForeignImport,
  XXForeignDecl,
  -- ** ForeignExport
  XCExport,
  XXForeignExport,
  -- ** ForeignImport
  XCImport,
  XXForeignImport,
  -- ** CCallTarget
  XStaticTarget,
  XDynamicTarget,
  XXCCallTarget,
  -- ** CType
  XCType,
  XXCType,
  -- ** Header
  XHeader,
  XXHeader,
  ) where

import Language.Haskell.Syntax.Extension
import Language.Haskell.Syntax.Type

import GHC.Data.FastString (FastString)

import Control.DeepSeq
import Data.Data        hiding (TyCon, Fixity, Infix)
import Data.Maybe
import Data.Eq
import Prelude (Enum, Show)

{-
************************************************************************
*                                                                      *
\subsection{Foreign function interface declaration}
*                                                                      *
************************************************************************
-}

-- foreign declarations are distinguished as to whether they define or use a
-- Haskell name
--
--  * the Boolean value indicates whether the pre-standard deprecated syntax
--   has been used

-- | Located Foreign Declaration
type LForeignDecl pass = XRec pass (ForeignDecl pass)

-- | Foreign Declaration
data ForeignDecl pass
  = ForeignImport
      { forall pass. ForeignDecl pass -> XForeignImport pass
fd_i_ext  :: XForeignImport pass   -- Post typechecker, rep_ty ~ sig_ty
      , forall pass. ForeignDecl pass -> LIdP pass
fd_name   :: LIdP pass             -- defines this name
      , forall pass. ForeignDecl pass -> LHsSigType pass
fd_sig_ty :: LHsSigType pass       -- sig_ty
      , forall pass. ForeignDecl pass -> ForeignImport pass
fd_fi     :: ForeignImport pass }

  | ForeignExport
      { forall pass. ForeignDecl pass -> XForeignExport pass
fd_e_ext  :: XForeignExport pass   -- Post typechecker, rep_ty ~ sig_ty
      , fd_name   :: LIdP pass             -- uses this name
      , fd_sig_ty :: LHsSigType pass       -- sig_ty
      , forall pass. ForeignDecl pass -> ForeignExport pass
fd_fe     :: ForeignExport pass }
  | XForeignDecl !(XXForeignDecl pass)

{-
    In both ForeignImport and ForeignExport:
        sig_ty is the type given in the Haskell code
        rep_ty is the representation for this type, i.e. with newtypes
               coerced away and type functions evaluated.
    Thus if the declaration is valid, then rep_ty will only use types
    such as Int and IO that we know how to make foreign calls with.
-}


-- |
-- Specification Of an imported external entity in dependence on the calling
-- convention
data ForeignImport pass
  = -- |
    -- Import of a C entity
    --
    --  * the two strings specifying a header file or library
    --   may be empty, which indicates the absence of a
    --   header or object specification (both are not used
    --   in the case of `CWrapper' and when `CFunction'
    --   has a dynamic target)
    --
    --  * the calling convention is irrelevant for code
    --   generation in the case of `CLabel', but is needed
    --   for pretty printing
    --
    --  * `Safety' is irrelevant for `CLabel' and `CWrapper'
    --
    CImport
      (XCImport pass)
      (XRec pass CCallConv) -- ccall
      (XRec pass Safety)    -- interruptible, safe or unsafe
      (Maybe (Header pass))        -- name of C header
      (CImportSpec pass)    -- details of the C entity
  | XForeignImport !(XXForeignImport pass)

-- |
-- Details of an external C entity
data CImportSpec pass
  = CLabel    CLabelString       -- import address of a C label
  | CFunction (CCallTarget pass) -- static or dynamic function
  | CWrapper                     -- wrapper to expose closures
                                 -- (former f.e.d.)

-- |
-- Specification of an externally exported entity in dependence on the calling
-- convention
data ForeignExport pass
  = CExport (XCExport pass) (XRec pass CExportSpec)
    -- ^ contains the calling convention
  | XForeignExport !(XXForeignExport pass)

{-
Stuff to do with calling convention:

ccall:          Caller allocates parameters, *and* deallocates them.

See: http://www.programmersheaven.com/2/Calling-conventions
-}

-- any changes here should be replicated in the Callconv type in template haskell
data CCallConv
  = CCallConv
  | CApiConv
  | StdCallConv
  | PrimCallConv
  | JavaScriptCallConv
  deriving (Int -> CCallConv
CCallConv -> Int
CCallConv -> [CCallConv]
CCallConv -> CCallConv
CCallConv -> CCallConv -> [CCallConv]
CCallConv -> CCallConv -> CCallConv -> [CCallConv]
(CCallConv -> CCallConv)
-> (CCallConv -> CCallConv)
-> (Int -> CCallConv)
-> (CCallConv -> Int)
-> (CCallConv -> [CCallConv])
-> (CCallConv -> CCallConv -> [CCallConv])
-> (CCallConv -> CCallConv -> [CCallConv])
-> (CCallConv -> CCallConv -> CCallConv -> [CCallConv])
-> Enum CCallConv
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: CCallConv -> CCallConv
succ :: CCallConv -> CCallConv
$cpred :: CCallConv -> CCallConv
pred :: CCallConv -> CCallConv
$ctoEnum :: Int -> CCallConv
toEnum :: Int -> CCallConv
$cfromEnum :: CCallConv -> Int
fromEnum :: CCallConv -> Int
$cenumFrom :: CCallConv -> [CCallConv]
enumFrom :: CCallConv -> [CCallConv]
$cenumFromThen :: CCallConv -> CCallConv -> [CCallConv]
enumFromThen :: CCallConv -> CCallConv -> [CCallConv]
$cenumFromTo :: CCallConv -> CCallConv -> [CCallConv]
enumFromTo :: CCallConv -> CCallConv -> [CCallConv]
$cenumFromThenTo :: CCallConv -> CCallConv -> CCallConv -> [CCallConv]
enumFromThenTo :: CCallConv -> CCallConv -> CCallConv -> [CCallConv]
Enum, CCallConv -> CCallConv -> Bool
(CCallConv -> CCallConv -> Bool)
-> (CCallConv -> CCallConv -> Bool) -> Eq CCallConv
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CCallConv -> CCallConv -> Bool
== :: CCallConv -> CCallConv -> Bool
$c/= :: CCallConv -> CCallConv -> Bool
/= :: CCallConv -> CCallConv -> Bool
Eq, Typeable CCallConv
Typeable CCallConv =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CCallConv -> c CCallConv)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CCallConv)
-> (CCallConv -> Constr)
-> (CCallConv -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CCallConv))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CCallConv))
-> ((forall b. Data b => b -> b) -> CCallConv -> CCallConv)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CCallConv -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CCallConv -> r)
-> (forall u. (forall d. Data d => d -> u) -> CCallConv -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CCallConv -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CCallConv -> m CCallConv)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CCallConv -> m CCallConv)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CCallConv -> m CCallConv)
-> Data CCallConv
CCallConv -> Constr
CCallConv -> DataType
(forall b. Data b => b -> b) -> CCallConv -> CCallConv
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CCallConv -> u
forall u. (forall d. Data d => d -> u) -> CCallConv -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CCallConv -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CCallConv -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CCallConv -> m CCallConv
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CCallConv -> m CCallConv
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CCallConv
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CCallConv -> c CCallConv
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CCallConv)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CCallConv)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CCallConv -> c CCallConv
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CCallConv -> c CCallConv
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CCallConv
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CCallConv
$ctoConstr :: CCallConv -> Constr
toConstr :: CCallConv -> Constr
$cdataTypeOf :: CCallConv -> DataType
dataTypeOf :: CCallConv -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CCallConv)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CCallConv)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CCallConv)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CCallConv)
$cgmapT :: (forall b. Data b => b -> b) -> CCallConv -> CCallConv
gmapT :: (forall b. Data b => b -> b) -> CCallConv -> CCallConv
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CCallConv -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CCallConv -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CCallConv -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CCallConv -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CCallConv -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CCallConv -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CCallConv -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CCallConv -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CCallConv -> m CCallConv
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CCallConv -> m CCallConv
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CCallConv -> m CCallConv
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CCallConv -> m CCallConv
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CCallConv -> m CCallConv
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CCallConv -> m CCallConv
Data, Int -> CCallConv -> ShowS
[CCallConv] -> ShowS
CCallConv -> String
(Int -> CCallConv -> ShowS)
-> (CCallConv -> String)
-> ([CCallConv] -> ShowS)
-> Show CCallConv
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CCallConv -> ShowS
showsPrec :: Int -> CCallConv -> ShowS
$cshow :: CCallConv -> String
show :: CCallConv -> String
$cshowList :: [CCallConv] -> ShowS
showList :: [CCallConv] -> ShowS
Show)

instance NFData CCallConv where
  rnf :: CCallConv -> ()
rnf = \case
    CCallConv
CCallConv -> ()
    CCallConv
StdCallConv -> ()
    CCallConv
PrimCallConv -> ()
    CCallConv
CApiConv -> ()
    CCallConv
JavaScriptCallConv -> ()

data ForeignKind
  = ForeignValue    -- ^ Binds to a value, a zero-arity function.
  | ForeignFunction -- ^ Binds to a function with arity /of at least one/.
  deriving stock (Int -> ForeignKind
ForeignKind -> Int
ForeignKind -> [ForeignKind]
ForeignKind -> ForeignKind
ForeignKind -> ForeignKind -> [ForeignKind]
ForeignKind -> ForeignKind -> ForeignKind -> [ForeignKind]
(ForeignKind -> ForeignKind)
-> (ForeignKind -> ForeignKind)
-> (Int -> ForeignKind)
-> (ForeignKind -> Int)
-> (ForeignKind -> [ForeignKind])
-> (ForeignKind -> ForeignKind -> [ForeignKind])
-> (ForeignKind -> ForeignKind -> [ForeignKind])
-> (ForeignKind -> ForeignKind -> ForeignKind -> [ForeignKind])
-> Enum ForeignKind
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ForeignKind -> ForeignKind
succ :: ForeignKind -> ForeignKind
$cpred :: ForeignKind -> ForeignKind
pred :: ForeignKind -> ForeignKind
$ctoEnum :: Int -> ForeignKind
toEnum :: Int -> ForeignKind
$cfromEnum :: ForeignKind -> Int
fromEnum :: ForeignKind -> Int
$cenumFrom :: ForeignKind -> [ForeignKind]
enumFrom :: ForeignKind -> [ForeignKind]
$cenumFromThen :: ForeignKind -> ForeignKind -> [ForeignKind]
enumFromThen :: ForeignKind -> ForeignKind -> [ForeignKind]
$cenumFromTo :: ForeignKind -> ForeignKind -> [ForeignKind]
enumFromTo :: ForeignKind -> ForeignKind -> [ForeignKind]
$cenumFromThenTo :: ForeignKind -> ForeignKind -> ForeignKind -> [ForeignKind]
enumFromThenTo :: ForeignKind -> ForeignKind -> ForeignKind -> [ForeignKind]
Enum, ForeignKind -> ForeignKind -> Bool
(ForeignKind -> ForeignKind -> Bool)
-> (ForeignKind -> ForeignKind -> Bool) -> Eq ForeignKind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ForeignKind -> ForeignKind -> Bool
== :: ForeignKind -> ForeignKind -> Bool
$c/= :: ForeignKind -> ForeignKind -> Bool
/= :: ForeignKind -> ForeignKind -> Bool
Eq, Typeable ForeignKind
Typeable ForeignKind =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ForeignKind -> c ForeignKind)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ForeignKind)
-> (ForeignKind -> Constr)
-> (ForeignKind -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ForeignKind))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ForeignKind))
-> ((forall b. Data b => b -> b) -> ForeignKind -> ForeignKind)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ForeignKind -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ForeignKind -> r)
-> (forall u. (forall d. Data d => d -> u) -> ForeignKind -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ForeignKind -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ForeignKind -> m ForeignKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ForeignKind -> m ForeignKind)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ForeignKind -> m ForeignKind)
-> Data ForeignKind
ForeignKind -> Constr
ForeignKind -> DataType
(forall b. Data b => b -> b) -> ForeignKind -> ForeignKind
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ForeignKind -> u
forall u. (forall d. Data d => d -> u) -> ForeignKind -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignKind -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignKind -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ForeignKind -> m ForeignKind
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForeignKind -> m ForeignKind
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForeignKind
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForeignKind -> c ForeignKind
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForeignKind)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ForeignKind)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForeignKind -> c ForeignKind
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ForeignKind -> c ForeignKind
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForeignKind
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ForeignKind
$ctoConstr :: ForeignKind -> Constr
toConstr :: ForeignKind -> Constr
$cdataTypeOf :: ForeignKind -> DataType
dataTypeOf :: ForeignKind -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForeignKind)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ForeignKind)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ForeignKind)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ForeignKind)
$cgmapT :: (forall b. Data b => b -> b) -> ForeignKind -> ForeignKind
gmapT :: (forall b. Data b => b -> b) -> ForeignKind -> ForeignKind
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignKind -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignKind -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignKind -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ForeignKind -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ForeignKind -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ForeignKind -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ForeignKind -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ForeignKind -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ForeignKind -> m ForeignKind
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ForeignKind -> m ForeignKind
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForeignKind -> m ForeignKind
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForeignKind -> m ForeignKind
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForeignKind -> m ForeignKind
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ForeignKind -> m ForeignKind
Data, Int -> ForeignKind -> ShowS
[ForeignKind] -> ShowS
ForeignKind -> String
(Int -> ForeignKind -> ShowS)
-> (ForeignKind -> String)
-> ([ForeignKind] -> ShowS)
-> Show ForeignKind
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ForeignKind -> ShowS
showsPrec :: Int -> ForeignKind -> ShowS
$cshow :: ForeignKind -> String
show :: ForeignKind -> String
$cshowList :: [ForeignKind] -> ShowS
showList :: [ForeignKind] -> ShowS
Show)

instance NFData ForeignKind where
  rnf :: ForeignKind -> ()
rnf = \case
    ForeignKind
ForeignValue    -> ()
    ForeignKind
ForeignFunction -> ()

-- | How to call a particular function in C-land.
data CCallTarget pass
  -- An "unboxed" ccall# to named function in a particular package.
  = StaticTarget
        (XStaticTarget pass)
        CLabelString -- C-land name of label.
        ForeignKind  -- only allowed in CAPI imports

  -- | The first argument of the import is the name of a function pointer (an Addr#).
  -- Used when importing a label as "foreign import ccall "dynamic" ..."
  | DynamicTarget (XDynamicTarget pass)
  | XCCallTarget !(XXCCallTarget pass)

data CExportSpec
  -- | foreign export ccall foo :: ty
  = CExportStatic
        CLabelString -- C Name of exported function
        CCallConv
  deriving Typeable CExportSpec
Typeable CExportSpec =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CExportSpec -> c CExportSpec)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CExportSpec)
-> (CExportSpec -> Constr)
-> (CExportSpec -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CExportSpec))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CExportSpec))
-> ((forall b. Data b => b -> b) -> CExportSpec -> CExportSpec)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CExportSpec -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CExportSpec -> r)
-> (forall u. (forall d. Data d => d -> u) -> CExportSpec -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CExportSpec -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CExportSpec -> m CExportSpec)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CExportSpec -> m CExportSpec)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CExportSpec -> m CExportSpec)
-> Data CExportSpec
CExportSpec -> Constr
CExportSpec -> DataType
(forall b. Data b => b -> b) -> CExportSpec -> CExportSpec
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> CExportSpec -> u
forall u. (forall d. Data d => d -> u) -> CExportSpec -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CExportSpec -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CExportSpec -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CExportSpec -> m CExportSpec
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CExportSpec -> m CExportSpec
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CExportSpec
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CExportSpec -> c CExportSpec
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CExportSpec)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CExportSpec)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CExportSpec -> c CExportSpec
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CExportSpec -> c CExportSpec
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CExportSpec
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CExportSpec
$ctoConstr :: CExportSpec -> Constr
toConstr :: CExportSpec -> Constr
$cdataTypeOf :: CExportSpec -> DataType
dataTypeOf :: CExportSpec -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CExportSpec)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CExportSpec)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CExportSpec)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CExportSpec)
$cgmapT :: (forall b. Data b => b -> b) -> CExportSpec -> CExportSpec
gmapT :: (forall b. Data b => b -> b) -> CExportSpec -> CExportSpec
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CExportSpec -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CExportSpec -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CExportSpec -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CExportSpec -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CExportSpec -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> CExportSpec -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CExportSpec -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CExportSpec -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CExportSpec -> m CExportSpec
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CExportSpec -> m CExportSpec
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CExportSpec -> m CExportSpec
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CExportSpec -> m CExportSpec
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CExportSpec -> m CExportSpec
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CExportSpec -> m CExportSpec
Data

type CLabelString = FastString  -- A C label, completely unencoded

-- | A C type, used in CAPI FFI calls
data CType pass
  = CType
      (XCType pass)
      (Maybe (Header pass)) -- header to include for this type
      FastString
  | XCType !(XXCType pass)

-- The filename for a C header file
-- See Note [Pragma source text] in "GHC.Types.SourceText"
data Header pass
  = Header
      (XHeader pass)
      FastString
  | XHeader !(XXHeader pass)

data Safety
  = PlaySafe          -- ^ Might invoke Haskell GC, or do a call back, or
                      --   switch threads, etc.  So make sure things are
                      --   tidy before the call. Additionally, in the threaded
                      --   RTS we arrange for the external call to be executed
                      --   by a separate OS thread, i.e., _concurrently_ to the
                      --   execution of other Haskell threads.

  | PlayInterruptible -- ^ Like PlaySafe, but additionally
                      --   the worker thread running this foreign call may
                      --   be unceremoniously killed, so it must be scheduled
                      --   on an unbound thread.

  | PlayRisky         -- ^ None of the above can happen; the call will return
                      --   without interacting with the runtime system at all.
                      --   Specifically:
                      --
                      --     * No GC
                      --     * No call backs
                      --     * No blocking
                      --     * No precise exceptions
                      --
  deriving ( Safety -> Safety -> Bool
(Safety -> Safety -> Bool)
-> (Safety -> Safety -> Bool) -> Eq Safety
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Safety -> Safety -> Bool
== :: Safety -> Safety -> Bool
$c/= :: Safety -> Safety -> Bool
/= :: Safety -> Safety -> Bool
Eq, Int -> Safety -> ShowS
[Safety] -> ShowS
Safety -> String
(Int -> Safety -> ShowS)
-> (Safety -> String) -> ([Safety] -> ShowS) -> Show Safety
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Safety -> ShowS
showsPrec :: Int -> Safety -> ShowS
$cshow :: Safety -> String
show :: Safety -> String
$cshowList :: [Safety] -> ShowS
showList :: [Safety] -> ShowS
Show, Typeable Safety
Typeable Safety =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Safety -> c Safety)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Safety)
-> (Safety -> Constr)
-> (Safety -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Safety))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Safety))
-> ((forall b. Data b => b -> b) -> Safety -> Safety)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Safety -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Safety -> r)
-> (forall u. (forall d. Data d => d -> u) -> Safety -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Safety -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Safety -> m Safety)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Safety -> m Safety)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Safety -> m Safety)
-> Data Safety
Safety -> Constr
Safety -> DataType
(forall b. Data b => b -> b) -> Safety -> Safety
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Safety -> u
forall u. (forall d. Data d => d -> u) -> Safety -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Safety -> m Safety
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Safety -> m Safety
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Safety
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Safety -> c Safety
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Safety)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Safety)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Safety -> c Safety
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Safety -> c Safety
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Safety
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Safety
$ctoConstr :: Safety -> Constr
toConstr :: Safety -> Constr
$cdataTypeOf :: Safety -> DataType
dataTypeOf :: Safety -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Safety)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Safety)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Safety)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Safety)
$cgmapT :: (forall b. Data b => b -> b) -> Safety -> Safety
gmapT :: (forall b. Data b => b -> b) -> Safety -> Safety
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Safety -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Safety -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Safety -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Safety -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Safety -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Safety -> m Safety
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Safety -> m Safety
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Safety -> m Safety
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Safety -> m Safety
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Safety -> m Safety
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Safety -> m Safety
Data, Int -> Safety
Safety -> Int
Safety -> [Safety]
Safety -> Safety
Safety -> Safety -> [Safety]
Safety -> Safety -> Safety -> [Safety]
(Safety -> Safety)
-> (Safety -> Safety)
-> (Int -> Safety)
-> (Safety -> Int)
-> (Safety -> [Safety])
-> (Safety -> Safety -> [Safety])
-> (Safety -> Safety -> [Safety])
-> (Safety -> Safety -> Safety -> [Safety])
-> Enum Safety
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Safety -> Safety
succ :: Safety -> Safety
$cpred :: Safety -> Safety
pred :: Safety -> Safety
$ctoEnum :: Int -> Safety
toEnum :: Int -> Safety
$cfromEnum :: Safety -> Int
fromEnum :: Safety -> Int
$cenumFrom :: Safety -> [Safety]
enumFrom :: Safety -> [Safety]
$cenumFromThen :: Safety -> Safety -> [Safety]
enumFromThen :: Safety -> Safety -> [Safety]
$cenumFromTo :: Safety -> Safety -> [Safety]
enumFromTo :: Safety -> Safety -> [Safety]
$cenumFromThenTo :: Safety -> Safety -> Safety -> [Safety]
enumFromThenTo :: Safety -> Safety -> Safety -> [Safety]
Enum )
        -- Show used just for Show Lex.Token, I think

instance NFData Safety where
  rnf :: Safety -> ()
rnf Safety
PlaySafe = ()
  rnf Safety
PlayInterruptible = ()
  rnf Safety
PlayRisky = ()