Foreign.R.Type

Definition of SEXPTYPE, which classifies the possible forms of an R expression (a SEXP). It is normally not necessary to import this module directly, since it is reexported by Foreign.R.

This is done in a separate module because we want to use hsc2hs rather than c2hs for discharging the boilerplate around SEXPTYPE. This is because SEXPTYPE is nearly but not quite a true enumeration and c2hs has trouble dealing with that.

This module also defines a singleton version of SEXPTYPE, called SSEXPTYPE. This is actually a family of types, one for each possible SEXPTYPE. Singleton types are a way of emulating dependent types in a language that does not have true dependent type. They are useful in functions whose result type depends on the value of one of its arguments. See e.g. allocVector.

Documentation

data SEXPTYPE

R "type". Note that what R calls a "type" is not what is usually meant by the term: there is really only a single type, called SEXP, and an R "type" in fact refers to the class or form of the expression.

To better illustrate the distinction, note that any sane type system normally has the subject reduction property: that the type of an expression is invariant under reduction. For example, (x -> x) 1 has type SEXPTYPE, and so does the value of this expression, 2, have type SEXPTYPE. Yet the form of the expression is an application of a function to a literal, while the form of its reduct is an integer literal.

We introduce convenient Haskell-like names for forms because this datatype is used to index SEXP and other types through the DataKinds extension.

Constructors

Nil

Symbol

List

Closure

Env

Promise

Lang

Special

Builtin

Char

Logical

Int

Real

Complex

String

DotDotDot

Any

Vector

Expr

Bytecode

ExtPtr

WeakRef

Raw

S4

New

Free

Fun

Instances

ToJSON SEXPTYPE

Defined in Language.R.Debug

Methods

toJSON :: SEXPTYPE -> Value

toEncoding :: SEXPTYPE -> Encoding

toJSONList :: [SEXPTYPE] -> Value

toEncodingList :: [SEXPTYPE] -> Encoding

Enum SEXPTYPE

Defined in Foreign.R.Type

Methods

succ :: SEXPTYPE -> SEXPTYPE

pred :: SEXPTYPE -> SEXPTYPE

toEnum :: Int -> SEXPTYPE

fromEnum :: SEXPTYPE -> Int

enumFrom :: SEXPTYPE -> [SEXPTYPE]

enumFromThen :: SEXPTYPE -> SEXPTYPE -> [SEXPTYPE]

enumFromTo :: SEXPTYPE -> SEXPTYPE -> [SEXPTYPE]

enumFromThenTo :: SEXPTYPE -> SEXPTYPE -> SEXPTYPE -> [SEXPTYPE]

Show SEXPTYPE

Defined in Foreign.R.Type

Methods

showsPrec :: Int -> SEXPTYPE -> ShowS

show :: SEXPTYPE -> String

showList :: [SEXPTYPE] -> ShowS

NFData SEXPTYPE

Defined in Foreign.R.Type

Methods

rnf :: SEXPTYPE -> ()

Eq SEXPTYPE

Defined in Foreign.R.Type

Methods

(==) :: SEXPTYPE -> SEXPTYPE -> Bool

(/=) :: SEXPTYPE -> SEXPTYPE -> Bool

Ord SEXPTYPE

Defined in Foreign.R.Type

Methods

compare :: SEXPTYPE -> SEXPTYPE -> Ordering

(<) :: SEXPTYPE -> SEXPTYPE -> Bool

(<=) :: SEXPTYPE -> SEXPTYPE -> Bool

(>) :: SEXPTYPE -> SEXPTYPE -> Bool

(>=) :: SEXPTYPE -> SEXPTYPE -> Bool

max :: SEXPTYPE -> SEXPTYPE -> SEXPTYPE

min :: SEXPTYPE -> SEXPTYPE -> SEXPTYPE

SingKind SEXPTYPE

Defined in Foreign.R.Type

Associated Types

type Demote SEXPTYPE = (r :: Type)

Methods

fromSing :: forall (a :: SEXPTYPE). Sing a -> Demote SEXPTYPE

toSing :: Demote SEXPTYPE -> SomeSing SEXPTYPE

SingI 'Any

Defined in Foreign.R.Type

Methods

sing :: Sing 'Any

SingI 'Builtin

Defined in Foreign.R.Type

Methods

sing :: Sing 'Builtin

SingI 'Bytecode

Defined in Foreign.R.Type

Methods

sing :: Sing 'Bytecode

SingI 'Char

Defined in Foreign.R.Type

Methods

sing :: Sing 'Char

SingI 'Closure

Defined in Foreign.R.Type

Methods

sing :: Sing 'Closure

SingI 'Complex

Defined in Foreign.R.Type

Methods

sing :: Sing 'Complex

SingI 'DotDotDot

Defined in Foreign.R.Type

Methods

sing :: Sing 'DotDotDot

SingI 'Env

Defined in Foreign.R.Type

Methods

sing :: Sing 'Env

SingI 'Expr

Defined in Foreign.R.Type

Methods

sing :: Sing 'Expr

SingI 'ExtPtr

Defined in Foreign.R.Type

Methods

sing :: Sing 'ExtPtr

SingI 'Free

Defined in Foreign.R.Type

Methods

sing :: Sing 'Free

SingI 'Fun

Defined in Foreign.R.Type

Methods

sing :: Sing 'Fun

SingI 'Int

Defined in Foreign.R.Type

Methods

sing :: Sing 'Int

SingI 'Lang

Defined in Foreign.R.Type

Methods

sing :: Sing 'Lang

SingI 'List

Defined in Foreign.R.Type

Methods

sing :: Sing 'List

SingI 'Logical

Defined in Foreign.R.Type

Methods

sing :: Sing 'Logical

SingI 'New

Defined in Foreign.R.Type

Methods

sing :: Sing 'New

SingI 'Nil

Defined in Foreign.R.Type

Methods

sing :: Sing 'Nil

SingI 'Promise

Defined in Foreign.R.Type

Methods

sing :: Sing 'Promise

SingI 'Raw

Defined in Foreign.R.Type

Methods

sing :: Sing 'Raw

SingI 'Real

Defined in Foreign.R.Type

Methods

sing :: Sing 'Real

SingI 'S4

Defined in Foreign.R.Type

Methods

sing :: Sing 'S4

SingI 'Special

Defined in Foreign.R.Type

Methods

sing :: Sing 'Special

SingI 'String

Defined in Foreign.R.Type

Methods

sing :: Sing 'String

SingI 'Symbol

Defined in Foreign.R.Type

Methods

sing :: Sing 'Symbol

SingI 'Vector

Defined in Foreign.R.Type

Methods

sing :: Sing 'Vector

SingI 'WeakRef

Defined in Foreign.R.Type

Methods

sing :: Sing 'WeakRef

TestEquality (HExp s :: SEXPTYPE -> Type)

Defined in Language.R.HExp

Methods

testEquality :: forall (a :: k) (b :: k). HExp s a -> HExp s b -> Maybe (a :~: b)

Lift SEXPTYPE

Defined in Foreign.R.Type

Methods

lift :: Quote m => SEXPTYPE -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => SEXPTYPE -> Code m SEXPTYPE

type Demote SEXPTYPE

Defined in Foreign.R.Type

type Demote SEXPTYPE = SEXPTYPE

type Sing

Defined in Foreign.R.Type

type Sing = SSEXPTYPE

data SSEXPTYPE :: SEXPTYPE -> Type where

Constructors

SNil :: SSEXPTYPE ('Nil :: SEXPTYPE)

SSymbol :: SSEXPTYPE ('Symbol :: SEXPTYPE)

SList :: SSEXPTYPE ('List :: SEXPTYPE)

SClosure :: SSEXPTYPE ('Closure :: SEXPTYPE)

SEnv :: SSEXPTYPE ('Env :: SEXPTYPE)

SPromise :: SSEXPTYPE ('Promise :: SEXPTYPE)

SLang :: SSEXPTYPE ('Lang :: SEXPTYPE)

SSpecial :: SSEXPTYPE ('Special :: SEXPTYPE)

SBuiltin :: SSEXPTYPE ('Builtin :: SEXPTYPE)

SChar :: SSEXPTYPE ('Char :: SEXPTYPE)

SLogical :: SSEXPTYPE ('Logical :: SEXPTYPE)

SInt :: SSEXPTYPE ('Int :: SEXPTYPE)

SReal :: SSEXPTYPE ('Real :: SEXPTYPE)

SComplex :: SSEXPTYPE ('Complex :: SEXPTYPE)

SString :: SSEXPTYPE ('String :: SEXPTYPE)

SDotDotDot :: SSEXPTYPE ('DotDotDot :: SEXPTYPE)

SAny :: SSEXPTYPE ('Any :: SEXPTYPE)

SVector :: SSEXPTYPE ('Vector :: SEXPTYPE)

SExpr :: SSEXPTYPE ('Expr :: SEXPTYPE)

SBytecode :: SSEXPTYPE ('Bytecode :: SEXPTYPE)

SExtPtr :: SSEXPTYPE ('ExtPtr :: SEXPTYPE)

SWeakRef :: SSEXPTYPE ('WeakRef :: SEXPTYPE)

SRaw :: SSEXPTYPE ('Raw :: SEXPTYPE)

SS4 :: SSEXPTYPE ('S4 :: SEXPTYPE)

SNew :: SSEXPTYPE ('New :: SEXPTYPE)

SFree :: SSEXPTYPE ('Free :: SEXPTYPE)

SFun :: SSEXPTYPE ('Fun :: SEXPTYPE)

type family Sing :: k -> Type

The singleton kind-indexed type family.

Instances

type Sing

Defined in Foreign.R.Type

type Sing = SSEXPTYPE

type Sing

Defined in Data.Singletons

type Sing = SWrappedSing :: WrappedSing a -> Type

type Sing

Defined in Data.Singletons

type Sing = SLambda :: (k1 ~> k2) -> Type

data Logical

R uses three-valued logic.

Constructors

FALSE

TRUE

NA

Instances

Storable Logical

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

Defined in Foreign.R.Context

Methods

showsPrec :: Int -> Logical -> ShowS

show :: Logical -> String

showList :: [Logical] -> ShowS

Eq Logical

Defined in Foreign.R.Context

Methods

(==) :: Logical -> Logical -> Bool

(/=) :: Logical -> Logical -> Bool

Ord Logical

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

Defined in Language.R.Literal

Methods

mkSEXPIO :: Logical -> IO (SEXP V 'Logical0)

fromSEXP :: SEXP s 'Logical0 -> Logical

Literal [Logical] 'Logical

Defined in Language.R.Literal

Methods

mkSEXPIO :: [Logical] -> IO (SEXP V 'Logical0)

fromSEXP :: SEXP s 'Logical0 -> [Logical]

type PairList = List

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 ': '[])))))))))))

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])

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

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

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

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

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

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

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.