Safe Haskell	None
Language	Haskell2010

H.Prelude

Contents

Language.R functions
Globals

Description

DEPRECATED: use Language.R instead.

Synopsis

module Language.R.Instance
type Region (m :: Type -> Type) = PrimState m
class (Applicative m, MonadIO m, MonadCatch m, MonadMask m, PrimMonad m) => MonadR (m :: Type -> Type) where
- data ExecContext (m :: Type -> Type)
- io :: IO a -> m a
- acquire :: forall s (a :: SEXPTYPE). s ~ V => SEXP s a -> m (SEXP (Region m) a)
- getExecContext :: m (ExecContext m)
- unsafeRunWithExecContext :: m a -> ExecContext m -> IO a
acquireSome :: MonadR m => SomeSEXP V -> m (SomeSEXP (Region m))
data family ExecContext (m :: Type -> Type)
module Foreign.R.Error
data R s a
string :: String -> IO (SEXP V 'Char)
typeOf :: forall s (a :: SEXPTYPE). SEXP s a -> SEXPTYPE
type IsList (a :: SEXPTYPE) = (SingI a, a :∈ '['Char, 'Logical, 'Int, 'Real, 'Complex, 'String, 'Vector, 'Expr, 'WeakRef, 'Raw, 'List])
asTypeOf :: forall s (a :: SEXPTYPE). SomeSEXP s -> SEXP s a -> SEXP s a
unsafeCoerce :: forall s (a :: SEXPTYPE) (b :: SEXPTYPE). SEXP s a -> SEXP s b
data SSEXPTYPE (a :: SEXPTYPE) where
- SNil :: SSEXPTYPE 'Nil
- SSymbol :: SSEXPTYPE 'Symbol
- SList :: SSEXPTYPE 'List
- SClosure :: SSEXPTYPE 'Closure
- SEnv :: SSEXPTYPE 'Env
- SPromise :: SSEXPTYPE 'Promise
- SLang :: SSEXPTYPE 'Lang
- SSpecial :: SSEXPTYPE 'Special
- SBuiltin :: SSEXPTYPE 'Builtin
- SChar :: SSEXPTYPE 'Char
- SLogical :: SSEXPTYPE 'Logical
- SInt :: SSEXPTYPE 'Int
- SReal :: SSEXPTYPE 'Real
- SComplex :: SSEXPTYPE 'Complex
- SString :: SSEXPTYPE 'String
- SDotDotDot :: SSEXPTYPE 'DotDotDot
- SAny :: SSEXPTYPE 'Any
- SVector :: SSEXPTYPE 'Vector
- SExpr :: SSEXPTYPE 'Expr
- SBytecode :: SSEXPTYPE 'Bytecode
- SExtPtr :: SSEXPTYPE 'ExtPtr
- SWeakRef :: SSEXPTYPE 'WeakRef
- SRaw :: SSEXPTYPE 'Raw
- SS4 :: SSEXPTYPE 'S4
- SNew :: SSEXPTYPE 'New
- SFree :: SSEXPTYPE 'Free
- SFun :: SSEXPTYPE 'Fun
cast :: forall (a :: SEXPTYPE) s. SSEXPTYPE a -> SomeSEXP s -> SEXP s a
finalize :: IO ()
type family Sing :: k -> Type
data SEXP s (a :: SEXPTYPE)
class SingI ty => Literal a (ty :: SEXPTYPE) | a -> ty where
- mkSEXPIO :: a -> IO (SEXP V ty)
- fromSEXP :: SEXP s ty -> a
data SomeSEXP s = SomeSEXP !(SEXP s a)
unSomeSEXP :: SomeSEXP s -> (forall (a :: SEXPTYPE). SEXP s a -> r) -> r
install :: MonadR m => String -> m (SEXP V 'Symbol)
eval :: forall m s (a :: SEXPTYPE). MonadR m => SEXP s a -> m (SomeSEXP (Region m))
isRInteractive :: Ptr CInt
nilValue :: SEXP G 'Nil
unboundValue :: SEXP G 'Symbol
missingArg :: SEXP G 'Symbol
baseEnv :: SEXP G 'Env
emptyEnv :: SEXP G 'Env
globalEnv :: SEXP G 'Env
data Logical
- = FALSE
- | TRUE
- | NA
type PairList = 'List
type IsVector (a :: SEXPTYPE) = (SingI a, a :∈ '['Char, 'Logical, 'Int, 'Real, 'Complex, 'String, 'Vector, 'Expr, 'WeakRef, 'Raw])
type IsGenericVector (a :: SEXPTYPE) = (SingI a, a :∈ '['Vector, 'Expr, 'WeakRef])
type IsPairList (a :: SEXPTYPE) = (SingI a, a :∈ '['List, 'Nil])
type IsExpression (a :: SEXPTYPE) = (SingI a, a :∈ '['Lang, 'Expr, 'Symbol])
withEmbeddedR :: Config -> IO a -> IO a
eval_ :: forall m s (a :: SEXPTYPE). MonadR m => SEXP s a -> m ()
evalEnv :: forall m s (a :: SEXPTYPE). MonadR m => SEXP s a -> SEXP s 'Env -> m (SomeSEXP (Region m))
cancel :: IO ()
throwR :: MonadR m => SEXP s 'Env -> m a
throwRMessage :: MonadR m => String -> m a
parseFile :: FilePath -> (SEXP s 'Expr -> IO a) -> IO a
parseText :: String -> Bool -> IO (SEXP V 'Expr)
strings :: String -> IO (SEXP V 'String)
automatic :: forall m s (a :: SEXPTYPE). MonadR m => SEXP s a -> m (SEXP G a)
automaticSome :: MonadR m => SomeSEXP s -> m (SomeSEXP G)
signalHandlersPtr :: Ptr CInt
inputHandlers :: Ptr InputHandler
pokeRVariables :: RVariables -> IO ()
runRegion :: NFData a => (forall s. R s a) -> IO a
unsafeRunRegion :: NFData a => R s a -> IO a
data Config = Config {
- configProgName :: Last String
- configArgs :: [String]
- configSignalHandlers :: Last Bool
}
defaultConfig :: Config
initialize :: Config -> IO ()
toPairList :: MonadR m => [(String, SomeSEXP (Region m))] -> m (SomeSEXP (Region m))
fromPairList :: SomeSEXP s -> [(String, SomeSEXP s)]
fromSomeSEXP :: forall s a (form :: SEXPTYPE). Literal a form => SomeSEXP s -> a
mkSEXP :: forall a (b :: SEXPTYPE) m. (Literal a b, MonadR m) => a -> m (SEXP (Region m) b)
dynSEXP :: forall a s (ty :: SEXPTYPE). Literal a ty => SomeSEXP s -> a
mkSEXPVector :: forall s (a :: SEXPTYPE). (Storable (ElemRep s a), IsVector a) => SSEXPTYPE a -> [IO (ElemRep s a)] -> SEXP s a
mkSEXPVectorIO :: forall s (a :: SEXPTYPE). (Storable (ElemRep s a), IsVector a) => SSEXPTYPE a -> [IO (ElemRep s a)] -> IO (SEXP s a)
mkProtectedSEXPVector :: forall (b :: SEXPTYPE) s (a :: SEXPTYPE). IsVector b => SSEXPTYPE b -> [SEXP s a] -> SEXP s b
mkProtectedSEXPVectorIO :: forall (b :: SEXPTYPE) s (a :: SEXPTYPE). IsVector b => SSEXPTYPE b -> [SEXP s a] -> IO (SEXP s b)
funToSEXP :: HFunWrap a b => (b -> IO (FunPtr b)) -> a -> IO (SEXP s 'ExtPtr)
refresh :: MonadR m => m ()
module Language.R.HExp
module Language.R.Literal
module Language.R.QQ
module Language.R.Globals

Documentation

module Language.R.Instance

type Region (m :: Type -> Type) = PrimState m Source #

class (Applicative m, MonadIO m, MonadCatch m, MonadMask m, PrimMonad m) => MonadR (m :: Type -> Type) where Source #

The class of R interaction monads. For safety, in compiled code we normally use the R monad. For convenience, in a GHCi session, we normally use the IO monad directly (by means of a MonadR instance for IO, imported only in GHCi).

Minimal complete definition

getExecContext, unsafeRunWithExecContext

Associated Types

data ExecContext (m :: Type -> Type) Source #

A reification of an R execution context, i.e. a "session".

Methods

io :: IO a -> m a Source #

Lift an IO action.

acquire :: forall s (a :: SEXPTYPE). s ~ V => SEXP s a -> m (SEXP (Region m) a) Source #

Acquire ownership in the current region of the given object. This means that the liveness of the object is guaranteed so long as the current region remains active (the R garbage collector will not attempt to free it).

default acquire :: forall s (a :: SEXPTYPE). (MonadIO m, Region m ~ G) => SEXP s a -> m (SEXP (Region m) a) Source #

getExecContext :: m (ExecContext m) Source #

Get the current execution context.

unsafeRunWithExecContext :: m a -> ExecContext m -> IO a Source #

Provides no static guarantees that resources do not extrude the scope of their region. Acquired resources are not freed automatically upon exit. For internal use only.

Instances

Instances details

MonadR IO Source #

Instance details

Defined in H.Prelude.Interactive

Associated Types

data ExecContext IO
Instance details Defined in H.Prelude.Interactive data ExecContext IO = ExecContext

Methods

io :: IO a -> IO a Source #

acquire :: forall s (a :: SEXPTYPE). s ~ V => SEXP s a -> IO (SEXP (Region IO) a) Source #

getExecContext :: IO (ExecContext IO) Source #

unsafeRunWithExecContext :: IO a -> ExecContext IO -> IO a Source #

MonadR (R s) Source #

Instance details

Defined in Language.R.Instance

Associated Types

newtype ExecContext (R s)
Instance details Defined in Language.R.Instance newtype ExecContext (R s) = ExecContext (IORef Int)

Methods

io :: IO a -> R s a Source #

acquire :: forall s0 (a :: SEXPTYPE). s0 ~ V => SEXP s0 a -> R s (SEXP (Region (R s)) a) Source #

getExecContext :: R s (ExecContext (R s)) Source #

unsafeRunWithExecContext :: R s a -> ExecContext (R s) -> IO a Source #

acquireSome :: MonadR m => SomeSEXP V -> m (SomeSEXP (Region m)) Source #

acquire for SomeSEXP.

data family ExecContext (m :: Type -> Type) Source #

A reification of an R execution context, i.e. a "session".

Instances

Instances details

data ExecContext IO Source #
Instance details Defined in H.Prelude.Interactive data ExecContext IO = ExecContext
newtype ExecContext (R s) Source #
Instance details Defined in Language.R.Instance newtype ExecContext (R s) = ExecContext (IORef Int)

module Foreign.R.Error

Language.R functions

data R s a Source #

The R monad, for sequencing actions interacting with a single instance of the R interpreter, much as the IO monad sequences actions interacting with the real world. The R monad embeds the IO monad, so all IO actions can be lifted to R actions.

Instances

Instances details

MonadIO (R s) Source #

Instance details

Defined in Language.R.Instance

Methods

liftIO :: IO a -> R s a #

MonadCatch (R s) Source #

Instance details

Defined in Language.R.Instance

Methods

catch :: (HasCallStack, Exception e) => R s a -> (e -> R s a) -> R s a #

MonadMask (R s) Source #

Instance details

Defined in Language.R.Instance

Methods

mask :: HasCallStack => ((forall a. R s a -> R s a) -> R s b) -> R s b #

uninterruptibleMask :: HasCallStack => ((forall a. R s a -> R s a) -> R s b) -> R s b #

generalBracket :: HasCallStack => R s a -> (a -> ExitCase b -> R s c) -> (a -> R s b) -> R s (b, c) #

MonadThrow (R s) Source #

Instance details

Defined in Language.R.Instance

Methods

throwM :: (HasCallStack, Exception e) => e -> R s a #

Applicative (R s) Source #

Instance details

Defined in Language.R.Instance

Methods

pure :: a -> R s a #

(<*>) :: R s (a -> b) -> R s a -> R s b #

liftA2 :: (a -> b -> c) -> R s a -> R s b -> R s c #

(*>) :: R s a -> R s b -> R s b #

(<*) :: R s a -> R s b -> R s a #

Functor (R s) Source #

Instance details

Defined in Language.R.Instance

Methods

fmap :: (a -> b) -> R s a -> R s b #

(<$) :: a -> R s b -> R s a #

Monad (R s) Source #

Instance details

Defined in Language.R.Instance

Methods

(>>=) :: R s a -> (a -> R s b) -> R s b #

(>>) :: R s a -> R s b -> R s b #

return :: a -> R s a #

MonadFail (R s) Source #

Instance details

Defined in Language.R.Instance

Methods

fail :: String -> R s a #

MonadR (R s) Source #

Instance details

Defined in Language.R.Instance

Associated Types

newtype ExecContext (R s)
Instance details Defined in Language.R.Instance newtype ExecContext (R s) = ExecContext (IORef Int)

Methods

io :: IO a -> R s a Source #

acquire :: forall s0 (a :: SEXPTYPE). s0 ~ V => SEXP s0 a -> R s (SEXP (Region (R s)) a) Source #

getExecContext :: R s (ExecContext (R s)) Source #

unsafeRunWithExecContext :: R s a -> ExecContext (R s) -> IO a Source #

PrimMonad (R s) Source #

Instance details

Defined in Language.R.Instance

Associated Types

type PrimState (R s)
Instance details Defined in Language.R.Instance type PrimState (R s) = s

Methods

primitive :: (State# (PrimState (R s)) -> (# State# (PrimState (R s)), a #)) -> R s a #

(NFData a, Literal a b) => Literal (R s a) 'ExtPtr Source #

Instance details

Defined in Language.R.Literal

Methods

mkSEXPIO :: R s a -> IO (SEXP V 'ExtPtr) Source #

fromSEXP :: SEXP s0 'ExtPtr -> R s a Source #

(NFData b, Literal a a0, Literal b b0) => Literal (a -> R s b) 'ExtPtr Source #

Instance details

Defined in Language.R.Literal

Methods

mkSEXPIO :: (a -> R s b) -> IO (SEXP V 'ExtPtr) Source #

fromSEXP :: SEXP s0 'ExtPtr -> a -> R s b Source #

(NFData c, Literal a a0, Literal b b0, Literal c c0) => Literal (a -> b -> R s c) 'ExtPtr Source #

Instance details

Defined in Language.R.Literal

Methods

mkSEXPIO :: (a -> b -> R s c) -> IO (SEXP V 'ExtPtr) Source #

fromSEXP :: SEXP s0 'ExtPtr -> a -> b -> R s c Source #

(NFData a1, Literal a2 i1, Literal a3 i2, Literal a4 i3, Literal a1 i4) => Literal (a2 -> a3 -> a4 -> R s a1) 'ExtPtr Source #

Instance details

Defined in Language.R.Literal

Methods

mkSEXPIO :: (a2 -> a3 -> a4 -> R s a1) -> IO (SEXP V 'ExtPtr) Source #

fromSEXP :: SEXP s0 'ExtPtr -> a2 -> a3 -> a4 -> R s a1 Source #

(NFData a1, Literal a2 i1, Literal a3 i2, Literal a4 i3, Literal a5 i4, Literal a1 i5) => Literal (a2 -> a3 -> a4 -> a5 -> R s a1) 'ExtPtr Source #

Instance details

Defined in Language.R.Literal

Methods

mkSEXPIO :: (a2 -> a3 -> a4 -> a5 -> R s a1) -> IO (SEXP V 'ExtPtr) Source #

fromSEXP :: SEXP s0 'ExtPtr -> a2 -> a3 -> a4 -> a5 -> R s a1 Source #

(NFData a1, Literal a2 i1, Literal a3 i2, Literal a4 i3, Literal a5 i4, Literal a6 i5, Literal a1 i6) => Literal (a2 -> a3 -> a4 -> a5 -> a6 -> R s a1) 'ExtPtr Source #

Instance details

Defined in Language.R.Literal

Methods

mkSEXPIO :: (a2 -> a3 -> a4 -> a5 -> a6 -> R s a1) -> IO (SEXP V 'ExtPtr) Source #

fromSEXP :: SEXP s0 'ExtPtr -> a2 -> a3 -> a4 -> a5 -> a6 -> R s a1 Source #

(NFData a1, Literal a2 i1, Literal a3 i2, Literal a4 i3, Literal a5 i4, Literal a6 i5, Literal a7 i6, Literal a1 i7) => Literal (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> R s a1) 'ExtPtr Source #

Instance details

Defined in Language.R.Literal

Methods

mkSEXPIO :: (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> R s a1) -> IO (SEXP V 'ExtPtr) Source #

fromSEXP :: SEXP s0 'ExtPtr -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> R s a1 Source #

(NFData a1, Literal a2 i1, Literal a3 i2, Literal a4 i3, Literal a5 i4, Literal a6 i5, Literal a7 i6, Literal a8 i7, Literal a1 i8) => Literal (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> R s a1) 'ExtPtr Source #

Instance details

Defined in Language.R.Literal

Methods

mkSEXPIO :: (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> R s a1) -> IO (SEXP V 'ExtPtr) Source #

fromSEXP :: SEXP s0 'ExtPtr -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> R s a1 Source #

(NFData a1, Literal a2 i1, Literal a3 i2, Literal a4 i3, Literal a5 i4, Literal a6 i5, Literal a7 i6, Literal a8 i7, Literal a9 i8, Literal a1 i9) => Literal (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> R s a1) 'ExtPtr Source #

Instance details

Defined in Language.R.Literal

Methods

mkSEXPIO :: (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> R s a1) -> IO (SEXP V 'ExtPtr) Source #

fromSEXP :: SEXP s0 'ExtPtr -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> R s a1 Source #

(NFData a1, Literal a2 i1, Literal a3 i2, Literal a4 i3, Literal a5 i4, Literal a6 i5, Literal a7 i6, Literal a8 i7, Literal a9 i8, Literal a10 i9, Literal a1 i10) => Literal (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> R s a1) 'ExtPtr Source #

Instance details

Defined in Language.R.Literal

Methods

mkSEXPIO :: (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> R s a1) -> IO (SEXP V 'ExtPtr) Source #

fromSEXP :: SEXP s0 'ExtPtr -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> R s a1 Source #

(NFData a1, Literal a2 i1, Literal a3 i2, Literal a4 i3, Literal a5 i4, Literal a6 i5, Literal a7 i6, Literal a8 i7, Literal a9 i8, Literal a10 i9, Literal a11 i10, Literal a1 i11) => Literal (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> R s a1) 'ExtPtr Source #

Instance details

Defined in Language.R.Literal

Methods

mkSEXPIO :: (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> R s a1) -> IO (SEXP V 'ExtPtr) Source #

fromSEXP :: SEXP s0 'ExtPtr -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> R s a1 Source #

(NFData a1, Literal a2 i1, Literal a3 i2, Literal a4 i3, Literal a5 i4, Literal a6 i5, Literal a7 i6, Literal a8 i7, Literal a9 i8, Literal a10 i9, Literal a11 i10, Literal a12 i11, Literal a1 i12) => Literal (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> a12 -> R s a1) 'ExtPtr Source #

Instance details

Defined in Language.R.Literal

Methods

mkSEXPIO :: (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> a12 -> R s a1) -> IO (SEXP V 'ExtPtr) Source #

fromSEXP :: SEXP s0 'ExtPtr -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> a12 -> R s a1 Source #

(NFData a1, Literal a2 i1, Literal a3 i2, Literal a4 i3, Literal a5 i4, Literal a6 i5, Literal a7 i6, Literal a8 i7, Literal a9 i8, Literal a10 i9, Literal a11 i10, Literal a12 i11, Literal a13 i12, Literal a1 i13) => Literal (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> a12 -> a13 -> R s a1) 'ExtPtr Source #

Instance details

Defined in Language.R.Literal

Methods

mkSEXPIO :: (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> a12 -> a13 -> R s a1) -> IO (SEXP V 'ExtPtr) Source #

fromSEXP :: SEXP s0 'ExtPtr -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> a12 -> a13 -> R s a1 Source #

newtype ExecContext (R s) Source #

Instance details

Defined in Language.R.Instance

newtype ExecContext (R s) = ExecContext (IORef Int)

type PrimState (R s) Source #

Instance details

Defined in Language.R.Instance

type PrimState (R s) = s

string :: String -> IO (SEXP V 'Char) Source #

Deprecated: Use mkSEXP instead

Create an R character string from a Haskell string.

typeOf :: forall s (a :: SEXPTYPE). SEXP s a -> SEXPTYPE Source #

Return the "type" tag (aka the form tag) of the given SEXP. This function is pure because the type of an object does not normally change over the lifetime of the object.

type IsList (a :: SEXPTYPE) = (SingI a, a :∈ '['Char, 'Logical, 'Int, 'Real, 'Complex, 'String, 'Vector, 'Expr, 'WeakRef, 'Raw, 'List]) Source #

IsList a holds iff R's is.list() returns TRUE.

asTypeOf :: forall s (a :: SEXPTYPE). SomeSEXP s -> SEXP s a -> SEXP s a Source #

Cast form of first argument to that of the second argument.

unsafeCoerce :: forall s (a :: SEXPTYPE) (b :: SEXPTYPE). SEXP s a -> SEXP s b Source #

Unsafe coercion from one form to another. This is unsafe, in the sense that using this function improperly could cause code to crash in unpredictable ways. Contrary to cast, it has no runtime cost since it does not introduce any dynamic check at runtime.

data SSEXPTYPE (a :: SEXPTYPE) where Source #

Constructors

SNil :: SSEXPTYPE 'Nil
SSymbol :: SSEXPTYPE 'Symbol
SList :: SSEXPTYPE 'List
SClosure :: SSEXPTYPE 'Closure
SEnv :: SSEXPTYPE 'Env
SPromise :: SSEXPTYPE 'Promise
SLang :: SSEXPTYPE 'Lang
SSpecial :: SSEXPTYPE 'Special
SBuiltin :: SSEXPTYPE 'Builtin
SChar :: SSEXPTYPE 'Char
SLogical :: SSEXPTYPE 'Logical
SInt :: SSEXPTYPE 'Int
SReal :: SSEXPTYPE 'Real
SComplex :: SSEXPTYPE 'Complex
SString :: SSEXPTYPE 'String
SDotDotDot :: SSEXPTYPE 'DotDotDot
SAny :: SSEXPTYPE 'Any
SVector :: SSEXPTYPE 'Vector
SExpr :: SSEXPTYPE 'Expr
SBytecode :: SSEXPTYPE 'Bytecode
SExtPtr :: SSEXPTYPE 'ExtPtr
SWeakRef :: SSEXPTYPE 'WeakRef
SRaw :: SSEXPTYPE 'Raw
SS4 :: SSEXPTYPE 'S4
SNew :: SSEXPTYPE 'New
SFree :: SSEXPTYPE 'Free
SFun :: SSEXPTYPE 'Fun

cast :: forall (a :: SEXPTYPE) s. SSEXPTYPE a -> SomeSEXP s -> SEXP s a Source #

Cast the type of a SEXP into another type. This function is partial: at runtime, an error is raised if the source form tag does not match the target form tag.

finalize :: IO () Source #

Finalize an R instance.

type family Sing :: k -> Type #

The singleton kind-indexed type family.

Instances

Instances details

type Sing Source #
Instance details Defined in Foreign.R.Type type Sing = SSEXPTYPE
type Sing
Instance details Defined in Data.Singletons type Sing = SWrappedSing :: WrappedSing a -> Type
type Sing
Instance details Defined in Data.Singletons type Sing = SLambda :: (k1 ~> k2) -> Type
type Sing
Instance details Defined in Data.Singletons.Sigma type Sing = SSigma :: Sigma s t -> Type

data SEXP s (a :: SEXPTYPE) Source #

The basic type of all R expressions, classified by the form of the expression, and the memory region in which it has been allocated.

Instances

Instances details

ToJSON (SEXP s a) Source #
Instance details Defined in Language.R.Debug Methods toJSON :: SEXP s a -> Value # toEncoding :: SEXP s a -> Encoding # toJSONList :: [SEXP s a] -> Value # toEncodingList :: [SEXP s a] -> Encoding # omitField :: SEXP s a -> Bool #
NFData (SEXP s a) Source #
Instance details Defined in Foreign.R.Internal Methods rnf :: SEXP s a -> () #
Storable (SEXP s a) Source #
Instance details Defined in Foreign.R.Internal Methods sizeOf :: SEXP s a -> Int # alignment :: SEXP s a -> Int # peekElemOff :: Ptr (SEXP s a) -> Int -> IO (SEXP s a) # pokeElemOff :: Ptr (SEXP s a) -> Int -> SEXP s a -> IO () # peekByteOff :: Ptr b -> Int -> IO (SEXP s a) # pokeByteOff :: Ptr b -> Int -> SEXP s a -> IO () # peek :: Ptr (SEXP s a) -> IO (SEXP s a) # poke :: Ptr (SEXP s a) -> SEXP s a -> IO () #
Show (SEXP s a) Source #
Instance details Defined in Foreign.R.Internal Methods showsPrec :: Int -> SEXP s a -> ShowS # show :: SEXP s a -> String # showList :: [SEXP s a] -> ShowS #
Eq (SEXP s a) Source #
Instance details Defined in Foreign.R.Internal Methods (==) :: SEXP s a -> SEXP s a -> Bool # (/=) :: SEXP s a -> SEXP s a -> Bool #
Ord (SEXP s a) Source #
Instance details Defined in Foreign.R.Internal Methods compare :: SEXP s a -> SEXP s a -> Ordering # (<) :: SEXP s a -> SEXP s a -> Bool # (<=) :: SEXP s a -> SEXP s a -> Bool # (>) :: SEXP s a -> SEXP s a -> Bool # (>=) :: SEXP s a -> SEXP s a -> Bool # max :: SEXP s a -> SEXP s a -> SEXP s a # min :: SEXP s a -> SEXP s a -> SEXP s a #
PrintR (SEXP s a) Source #
Instance details Defined in H.Prelude.Interactive Methods printR :: MonadR m => SEXP s a -> m () Source #
SingI a => Literal (SEXP s a) a Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: SEXP s a -> IO (SEXP V a) Source # fromSEXP :: SEXP s0 a -> SEXP s a Source #

class SingI ty => Literal a (ty :: SEXPTYPE) | a -> ty where Source #

Values that can be converted to SEXP.

Minimal complete definition

Nothing

Methods

mkSEXPIO :: a -> IO (SEXP V ty) Source #

Internal function for converting a literal to a SEXP value. You probably want to be using mkSEXP instead.

default mkSEXPIO :: (IsVector ty, Literal [a] ty) => a -> IO (SEXP V ty) Source #

fromSEXP :: SEXP s ty -> a Source #

default fromSEXP :: (IsVector ty, Literal [a] ty) => SEXP s ty -> a Source #

Instances

Instances details

Literal Int32 'Int Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: Int32 -> IO (SEXP V 'Int) Source # fromSEXP :: SEXP s 'Int -> Int32 Source #
Literal Logical 'Logical Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: Logical -> IO (SEXP V 'Logical) Source # fromSEXP :: SEXP s 'Logical -> Logical Source #
Literal Text 'String Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: Text -> IO (SEXP V 'String) Source # fromSEXP :: SEXP s 'String -> Text Source #
Literal String 'String Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: String -> IO (SEXP V 'String) Source # fromSEXP :: SEXP s 'String -> String Source #
Literal Double 'Real Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: Double -> IO (SEXP V 'Real) Source # fromSEXP :: SEXP s 'Real -> Double Source #
Literal (Complex Double) 'Complex Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: Complex Double -> IO (SEXP V 'Complex) Source # fromSEXP :: SEXP s 'Complex -> Complex Double Source #
Literal (SomeSEXP s) 'Any Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: SomeSEXP s -> IO (SEXP V 'Any) Source # fromSEXP :: SEXP s0 'Any -> SomeSEXP s Source #
Literal [Complex Double] 'Complex Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: [Complex Double] -> IO (SEXP V 'Complex) Source # fromSEXP :: SEXP s 'Complex -> [Complex Double] Source #
Literal [Int32] 'Int Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: [Int32] -> IO (SEXP V 'Int) Source # fromSEXP :: SEXP s 'Int -> [Int32] Source #
Literal [Logical] 'Logical Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: [Logical] -> IO (SEXP V 'Logical) Source # fromSEXP :: SEXP s 'Logical -> [Logical] Source #
Literal [String] 'String Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: [String] -> IO (SEXP V 'String) Source # fromSEXP :: SEXP s 'String -> [String] Source #
Literal [Double] 'Real Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: [Double] -> IO (SEXP V 'Real) Source # fromSEXP :: SEXP s 'Real -> [Double] Source #
SVECTOR ty a => Literal (Vector ty a) ty Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: Vector ty a -> IO (SEXP V ty) Source # fromSEXP :: SEXP s ty -> Vector ty a Source #
SingI a => Literal (SEXP s a) a Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: SEXP s a -> IO (SEXP V a) Source # fromSEXP :: SEXP s0 a -> SEXP s a Source #
(NFData a, Literal a b) => Literal (R s a) 'ExtPtr Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: R s a -> IO (SEXP V 'ExtPtr) Source # fromSEXP :: SEXP s0 'ExtPtr -> R s a Source #
(NFData b, Literal a a0, Literal b b0) => Literal (a -> R s b) 'ExtPtr Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: (a -> R s b) -> IO (SEXP V 'ExtPtr) Source # fromSEXP :: SEXP s0 'ExtPtr -> a -> R s b Source #
(NFData c, Literal a a0, Literal b b0, Literal c c0) => Literal (a -> b -> R s c) 'ExtPtr Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: (a -> b -> R s c) -> IO (SEXP V 'ExtPtr) Source # fromSEXP :: SEXP s0 'ExtPtr -> a -> b -> R s c Source #
(NFData a1, Literal a2 i1, Literal a3 i2, Literal a4 i3, Literal a1 i4) => Literal (a2 -> a3 -> a4 -> R s a1) 'ExtPtr Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: (a2 -> a3 -> a4 -> R s a1) -> IO (SEXP V 'ExtPtr) Source # fromSEXP :: SEXP s0 'ExtPtr -> a2 -> a3 -> a4 -> R s a1 Source #
(NFData a1, Literal a2 i1, Literal a3 i2, Literal a4 i3, Literal a5 i4, Literal a1 i5) => Literal (a2 -> a3 -> a4 -> a5 -> R s a1) 'ExtPtr Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: (a2 -> a3 -> a4 -> a5 -> R s a1) -> IO (SEXP V 'ExtPtr) Source # fromSEXP :: SEXP s0 'ExtPtr -> a2 -> a3 -> a4 -> a5 -> R s a1 Source #
(NFData a1, Literal a2 i1, Literal a3 i2, Literal a4 i3, Literal a5 i4, Literal a6 i5, Literal a1 i6) => Literal (a2 -> a3 -> a4 -> a5 -> a6 -> R s a1) 'ExtPtr Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: (a2 -> a3 -> a4 -> a5 -> a6 -> R s a1) -> IO (SEXP V 'ExtPtr) Source # fromSEXP :: SEXP s0 'ExtPtr -> a2 -> a3 -> a4 -> a5 -> a6 -> R s a1 Source #
(NFData a1, Literal a2 i1, Literal a3 i2, Literal a4 i3, Literal a5 i4, Literal a6 i5, Literal a7 i6, Literal a1 i7) => Literal (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> R s a1) 'ExtPtr Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> R s a1) -> IO (SEXP V 'ExtPtr) Source # fromSEXP :: SEXP s0 'ExtPtr -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> R s a1 Source #
(NFData a1, Literal a2 i1, Literal a3 i2, Literal a4 i3, Literal a5 i4, Literal a6 i5, Literal a7 i6, Literal a8 i7, Literal a1 i8) => Literal (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> R s a1) 'ExtPtr Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> R s a1) -> IO (SEXP V 'ExtPtr) Source # fromSEXP :: SEXP s0 'ExtPtr -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> R s a1 Source #
(NFData a1, Literal a2 i1, Literal a3 i2, Literal a4 i3, Literal a5 i4, Literal a6 i5, Literal a7 i6, Literal a8 i7, Literal a9 i8, Literal a1 i9) => Literal (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> R s a1) 'ExtPtr Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> R s a1) -> IO (SEXP V 'ExtPtr) Source # fromSEXP :: SEXP s0 'ExtPtr -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> R s a1 Source #
(NFData a1, Literal a2 i1, Literal a3 i2, Literal a4 i3, Literal a5 i4, Literal a6 i5, Literal a7 i6, Literal a8 i7, Literal a9 i8, Literal a10 i9, Literal a1 i10) => Literal (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> R s a1) 'ExtPtr Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> R s a1) -> IO (SEXP V 'ExtPtr) Source # fromSEXP :: SEXP s0 'ExtPtr -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> R s a1 Source #
(NFData a1, Literal a2 i1, Literal a3 i2, Literal a4 i3, Literal a5 i4, Literal a6 i5, Literal a7 i6, Literal a8 i7, Literal a9 i8, Literal a10 i9, Literal a11 i10, Literal a1 i11) => Literal (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> R s a1) 'ExtPtr Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> R s a1) -> IO (SEXP V 'ExtPtr) Source # fromSEXP :: SEXP s0 'ExtPtr -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> R s a1 Source #
(NFData a1, Literal a2 i1, Literal a3 i2, Literal a4 i3, Literal a5 i4, Literal a6 i5, Literal a7 i6, Literal a8 i7, Literal a9 i8, Literal a10 i9, Literal a11 i10, Literal a12 i11, Literal a1 i12) => Literal (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> a12 -> R s a1) 'ExtPtr Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> a12 -> R s a1) -> IO (SEXP V 'ExtPtr) Source # fromSEXP :: SEXP s0 'ExtPtr -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> a12 -> R s a1 Source #
(NFData a1, Literal a2 i1, Literal a3 i2, Literal a4 i3, Literal a5 i4, Literal a6 i5, Literal a7 i6, Literal a8 i7, Literal a9 i8, Literal a10 i9, Literal a11 i10, Literal a12 i11, Literal a13 i12, Literal a1 i13) => Literal (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> a12 -> a13 -> R s a1) 'ExtPtr Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: (a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> a12 -> a13 -> R s a1) -> IO (SEXP V 'ExtPtr) Source # fromSEXP :: SEXP s0 'ExtPtr -> a2 -> a3 -> a4 -> a5 -> a6 -> a7 -> a8 -> a9 -> a10 -> a11 -> a12 -> a13 -> R s a1 Source #
VECTOR V ty a => Literal (MVector V ty a) ty Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: MVector V ty a -> IO (SEXP V ty) Source # fromSEXP :: SEXP s ty -> MVector V ty a Source #

data SomeSEXP s Source #

A SEXP of unknown form.

Constructors

SomeSEXP !(SEXP s a)

Instances

Instances details

ToJSON (SomeSEXP s) Source #
Instance details Defined in Language.R.Debug Methods toJSON :: SomeSEXP s -> Value # toEncoding :: SomeSEXP s -> Encoding # toJSONList :: [SomeSEXP s] -> Value # toEncodingList :: [SomeSEXP s] -> Encoding # omitField :: SomeSEXP s -> Bool #
NFData (SomeSEXP s) Source #
Instance details Defined in Foreign.R.Internal Methods rnf :: SomeSEXP s -> () #
Storable (SomeSEXP s) Source #
Instance details Defined in Foreign.R.Internal Methods sizeOf :: SomeSEXP s -> Int # alignment :: SomeSEXP s -> Int # peekElemOff :: Ptr (SomeSEXP s) -> Int -> IO (SomeSEXP s) # pokeElemOff :: Ptr (SomeSEXP s) -> Int -> SomeSEXP s -> IO () # peekByteOff :: Ptr b -> Int -> IO (SomeSEXP s) # pokeByteOff :: Ptr b -> Int -> SomeSEXP s -> IO () # peek :: Ptr (SomeSEXP s) -> IO (SomeSEXP s) # poke :: Ptr (SomeSEXP s) -> SomeSEXP s -> IO () #
Show (SomeSEXP s) Source #
Instance details Defined in Foreign.R.Internal Methods showsPrec :: Int -> SomeSEXP s -> ShowS # show :: SomeSEXP s -> String # showList :: [SomeSEXP s] -> ShowS #
PrintR (SomeSEXP s) Source #
Instance details Defined in H.Prelude.Interactive Methods printR :: MonadR m => SomeSEXP s -> m () Source #
Literal (SomeSEXP s) 'Any Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: SomeSEXP s -> IO (SEXP V 'Any) Source # fromSEXP :: SEXP s0 'Any -> SomeSEXP s Source #

unSomeSEXP :: SomeSEXP s -> (forall (a :: SEXPTYPE). SEXP s a -> r) -> r Source #

Deconstruct a SomeSEXP. Takes a continuation since otherwise the existentially quantified variable hidden inside SomeSEXP would escape.

install :: MonadR m => String -> m (SEXP V 'Symbol) Source #

Internalize a symbol name.

eval :: forall m s (a :: SEXPTYPE). MonadR m => SEXP s a -> m (SomeSEXP (Region m)) Source #

Evaluate a (sequence of) expression(s) in the global environment.

isRInteractive :: Ptr CInt Source #

nilValue :: SEXP G 'Nil Source #

R's NULL value.

unboundValue :: SEXP G 'Symbol Source #

Special value to which all symbols unbound in the current environment resolve to.

missingArg :: SEXP G 'Symbol Source #

Value substituted for all missing actual arguments of a function call.

baseEnv :: SEXP G 'Env Source #

The base environment.

emptyEnv :: SEXP G 'Env Source #

The empty environment.

globalEnv :: SEXP G 'Env Source #

The global environment.

data Logical Source #

R uses three-valued logic.

Constructors

FALSE
TRUE
NA

Instances

Instances details

Storable Logical Source #
Instance details Defined in Foreign.R.Context Methods sizeOf :: Logical -> Int # alignment :: Logical -> Int # peekElemOff :: Ptr Logical -> Int -> IO Logical # pokeElemOff :: Ptr Logical -> Int -> Logical -> IO () # peekByteOff :: Ptr b -> Int -> IO Logical # pokeByteOff :: Ptr b -> Int -> Logical -> IO () # peek :: Ptr Logical -> IO Logical # poke :: Ptr Logical -> Logical -> IO () #
Show Logical Source #
Instance details Defined in Foreign.R.Context Methods showsPrec :: Int -> Logical -> ShowS # show :: Logical -> String # showList :: [Logical] -> ShowS #
Eq Logical Source #
Instance details Defined in Foreign.R.Context Methods (==) :: Logical -> Logical -> Bool # (/=) :: Logical -> Logical -> Bool #
Ord Logical Source #
Instance details Defined in Foreign.R.Context Methods compare :: Logical -> Logical -> Ordering # (<) :: Logical -> Logical -> Bool # (<=) :: Logical -> Logical -> Bool # (>) :: Logical -> Logical -> Bool # (>=) :: Logical -> Logical -> Bool # max :: Logical -> Logical -> Logical # min :: Logical -> Logical -> Logical #
Literal Logical 'Logical Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: Logical -> IO (SEXP V 'Logical) Source # fromSEXP :: SEXP s 'Logical -> Logical Source #
Literal [Logical] 'Logical Source #
Instance details Defined in Language.R.Literal Methods mkSEXPIO :: [Logical] -> IO (SEXP V 'Logical) Source # fromSEXP :: SEXP s 'Logical -> [Logical] Source #

type PairList = 'List Source #

Used where the R documentation speaks of "pairlists", which are really just regular lists.

type IsVector (a :: SEXPTYPE) = (SingI a, a :∈ '['Char, 'Logical, 'Int, 'Real, 'Complex, 'String, 'Vector, 'Expr, 'WeakRef, 'Raw]) Source #

Constraint synonym grouping all vector forms into one class. IsVector a holds iff R's is.vector() returns TRUE.

type IsGenericVector (a :: SEXPTYPE) = (SingI a, a :∈ '['Vector, 'Expr, 'WeakRef]) Source #

Non-atomic vector forms. See src/main/memory.c:SET_VECTOR_ELT in the R source distribution.

type IsPairList (a :: SEXPTYPE) = (SingI a, a :∈ '['List, 'Nil]) Source #

IsPairList a holds iff R's is.pairlist() returns TRUE.

type IsExpression (a :: SEXPTYPE) = (SingI a, a :∈ '['Lang, 'Expr, 'Symbol]) Source #

Constraint synonym grouping all expression forms into one class. According to R internals, an expression is usually a Lang, but can sometimes also be an Expr or a Symbol.

withEmbeddedR :: Config -> IO a -> IO a Source #

Initialize a new instance of R, execute actions that interact with the R instance and then finalize the instance. This is typically called at the very beginning of the main function of the program.

main = withEmbeddedR $ do {...}

Note that R does not currently support reinitialization after finalization, so this function should be called only once during the lifetime of the program (see srcunixsystem.c:Rf_initialize() in the R source code).

eval_ :: forall m s (a :: SEXPTYPE). MonadR m => SEXP s a -> m () Source #

Silent version of eval function that discards it's result.

evalEnv :: forall m s (a :: SEXPTYPE). MonadR m => SEXP s a -> SEXP s 'Env -> m (SomeSEXP (Region m)) Source #

Evaluate a (sequence of) expression(s) in the given environment, returning the value of the last.

cancel :: IO () Source #

Cancel any ongoing R computation in the current process. After interruption an RError exception will be raised.

This call is safe to run in any thread. If there is no R computation running, the next computaion will be immediately cancelled. Note that R will only interrupt computations at so-called "safe points" (in particular, not in the middle of a C call).

throwR Source #

Arguments

:: MonadR m
=> SEXP s 'Env	Environment in which to find error.
-> m a

Throw an R error as an exception.

throwRMessage :: MonadR m => String -> m a Source #

Throw an R exception with specified message.

parseFile :: FilePath -> (SEXP s 'Expr -> IO a) -> IO a Source #

Deprecated: Use [r| parse(file="pathtofile") |] instead.

Parse file and perform some actions on parsed file.

This function uses continuation because this is an easy way to make operations GC-safe.

parseText Source #

Arguments

:: String	Text to parse
-> Bool	Whether to annotate the AST with source locations.
-> IO (SEXP V 'Expr)

Deprecated: Use [r| parse(text=...) |] instead.

strings :: String -> IO (SEXP V 'String) Source #

Deprecated: Use mkSEXP instead

Create an R string vector from a Haskell string.

automatic :: forall m s (a :: SEXPTYPE). MonadR m => SEXP s a -> m (SEXP G a) Source #

Declare memory management for this value to be automatic. That is, the memory associated with it may be freed as soon as the garbage collector notices that it is safe to do so.

Values with automatic memory management are tagged with the global region. The reason is that just like for other global values, deallocation of the value can never be observed. Indeed, it is a mere "optimization" to deallocate the value sooner - it would still be semantically correct to never deallocate it at all.

automaticSome :: MonadR m => SomeSEXP s -> m (SomeSEXP G) Source #

automatic for SomeSEXP.

signalHandlersPtr :: Ptr CInt Source #

inputHandlers :: Ptr InputHandler Source #

pokeRVariables :: RVariables -> IO () Source #

runRegion :: NFData a => (forall s. R s a) -> IO a Source #

Run an R action in the global R instance from the IO monad. This action provides no static guarantees that the R instance was indeed initialized and has not yet been finalized. Make sure to call it within the scope of withEmbeddedR.

runRegion m fully evaluates the result of action m, to ensure that no thunks hold onto resources in a way that would extrude the scope of the region. This means that the result must be first-order data (i.e. not a function).

throws Error. Generaly any R function may throw RError that is safe to be cached and computation can proceed. However RError will cancel entire R block. So in order to catch exception in more fine grained way one has to use function tryCatch inside R block.

unsafeRunRegion :: NFData a => R s a -> IO a Source #

data Config Source #

Configuration options for the R runtime. Configurations form monoids, so arguments can be accumulated left-to-right through monoidal composition.

Constructors

Config

Fields

configProgName :: Last String
Program name. If Nothing then the value of getProgName will be used.
configArgs :: [String]
Command-line arguments.
configSignalHandlers :: Last Bool
Set to True if you're happy to let R install its own signal handlers during initialization. By default R sets following signal handlers:
- SIGPIPE - ignore signal;
- SIGUSR1 - save workspace and terminate program;
- SIGUSR2 - terminate program without saving workspace;
- SIGINT - cancel execution of the current function.
- N.B.* When program is terminated, haskell runtime will not have any chances to run any exception handlers or finalizers.

Instances

Instances details

Default Config Source #
Instance details Defined in Language.R.Instance Methods def :: Config #
Monoid Config Source #
Instance details Defined in Language.R.Instance Methods mempty :: Config # mappend :: Config -> Config -> Config # mconcat :: [Config] -> Config #
Semigroup Config Source #
Instance details Defined in Language.R.Instance Methods (<>) :: Config -> Config -> Config # sconcat :: NonEmpty Config -> Config # stimes :: Integral b => b -> Config -> Config #

defaultConfig :: Config Source #

Default argument to pass to initialize.

initialize :: Config -> IO () Source #

Create a new embedded instance of the R interpreter. Only works from the main thread of the program. That is, from the same thread of execution that the program's main function is running on. In GHCi, use -fno-ghci-sandbox to achieve this.

toPairList :: MonadR m => [(String, SomeSEXP (Region m))] -> m (SomeSEXP (Region m)) Source #

Create a pairlist from an association list. Result is either a pairlist or nilValue if the input is the null list. These are two distinct forms. Hence why the type of this function is not more precise.

fromPairList :: SomeSEXP s -> [(String, SomeSEXP s)] Source #

Create an association list from a pairlist. R Pairlists are nil-terminated chains of nested cons cells, as in LISP.

fromSomeSEXP :: forall s a (form :: SEXPTYPE). Literal a form => SomeSEXP s -> a Source #

Like fromSEXP, but with no static type satefy. Performs a dynamic (i.e. at runtime) check instead.

mkSEXP :: forall a (b :: SEXPTYPE) m. (Literal a b, MonadR m) => a -> m (SEXP (Region m) b) Source #

Create a SEXP value and protect it in current region

dynSEXP :: forall a s (ty :: SEXPTYPE). Literal a ty => SomeSEXP s -> a Source #

Like fromSomeSEXP, but behaves like the as.* family of functions in R, by performing a best effort conversion to the target form (e.g. rounds reals to integers, etc) for atomic types.

mkSEXPVector :: forall s (a :: SEXPTYPE). (Storable (ElemRep s a), IsVector a) => SSEXPTYPE a -> [IO (ElemRep s a)] -> SEXP s a Source #

mkSEXPVectorIO :: forall s (a :: SEXPTYPE). (Storable (ElemRep s a), IsVector a) => SSEXPTYPE a -> [IO (ElemRep s a)] -> IO (SEXP s a) Source #

mkProtectedSEXPVector :: forall (b :: SEXPTYPE) s (a :: SEXPTYPE). IsVector b => SSEXPTYPE b -> [SEXP s a] -> SEXP s b Source #

mkProtectedSEXPVectorIO :: forall (b :: SEXPTYPE) s (a :: SEXPTYPE). IsVector b => SSEXPTYPE b -> [SEXP s a] -> IO (SEXP s b) Source #

funToSEXP :: HFunWrap a b => (b -> IO (FunPtr b)) -> a -> IO (SEXP s 'ExtPtr) Source #

refresh :: MonadR m => m () Source #

Manually trigger processing all pending events. Useful when at an interactive prompt and no event loop is running.

module Language.R.HExp

module Language.R.Literal

module Language.R.QQ

Globals

module Language.R.Globals