{-# OPTIONS_GHC -optc-DUSE_RINTERNALS #-}
{-# LINE 1 "src/Language/R/HExp.hsc" #-}
-- |
-- Copyright: (C) 2013 Amgen, Inc.
--
-- Provides a /shallow/ view of a 'SEXP' R value as an algebraic datatype. This
-- is useful to define functions over R values in Haskell with pattern matching.
-- For example:
--
-- @
-- toPair :: SEXP a -> (SomeSEXP, SomeSEXP)
-- toPair (hexp -> List _ (Just car) (Just cdr)) = (SomeSEXP car, SomeSEXP cdr)
-- toPair (hexp -> Lang car (Just cdr)) = (SomeSEXP car, SomeSEXP cdr)
-- toPair s = error $ "Cannot extract pair from object of type " ++ typeOf s
-- @
--
-- (See 'Foreign.R.SomeSEXP' for why we need to use it here.)
--
-- The view is said to be 'shallow' because it only unfolds the head of the
-- R value into an algebraic datatype. In this way, functions producing views
-- can be written non-recursively, hence inlined at all call sites and
-- simplified away. When produced by a view function in a pattern match,
-- allocation of the view can be compiled away and hence producing a view can be
-- done at no runtime cost. In fact, pattern matching on a view in this way is
-- more efficient than using the accessor functions defined in "Foreign.R",
-- because we avoid the overhead of calling one or more FFI functions entirely.
--
-- 'HExp' is the /view/ and 'hexp' is the /view function/ that projects 'SEXP's
-- into 'HExp' views.

{-# LANGUAGE CPP #-}
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE PolyKinds #-}

{-# LINE 37 "src/Language/R/HExp.hsc" #-}
{-# LANGUAGE RoleAnnotations #-}

{-# LINE 39 "src/Language/R/HExp.hsc" #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE ViewPatterns #-}

module Language.R.HExp
  ( HExp(..)
  , (===)
  , hexp
  , unhexp
  , vector
  ) where

import Control.Applicative
import Control.Memory.Region (V)
import Control.Monad.R.Class
import qualified Foreign.R      as R
import Foreign.R (SEXP, SomeSEXP(..), SEXPTYPE, withProtected)
import Foreign.R.Constraints
import Internal.Error
import qualified Language.R.Globals as H

import qualified Data.Vector.SEXP as Vector

import Control.Monad ((<=<), guard, void)
import Control.Monad.Primitive ( unsafeInlineIO )
import Data.Int (Int32)
import Data.Word (Word8)
import Data.Complex
import Data.Maybe (isJust)
import Data.Type.Equality (TestEquality(..), (:~:)(Refl))
import GHC.Ptr (Ptr(..))
import Foreign.Storable
import Foreign.C -- for hsc2hs
import Foreign (castPtr)
import Unsafe.Coerce (unsafeCoerce)
-- Fixes redundant import warning >= 7.10 without CPP
import Prelude







-- Use explicit UNPACK pragmas rather than -funbox-strict-fields in order to get
-- warnings if a field is not unpacked when we expect it to.

-- | A view of R's internal 'SEXP' structure as an algebraic datatype. Because
-- this is in fact a GADT, the use of named record fields is not possible here.
-- Named record fields give rise to functions for whom it is not possible to
-- assign a reasonable type (existentially quantified type variables would
-- escape).
--
-- Note further that Haddock does not currently support constructor comments
-- when using the GADT syntax.
type role HExp phantom nominal
data HExp :: * -> SEXPTYPE -> * where
  -- Primitive types. The field names match those of <RInternals.h>.
  Nil       :: HExp s 'R.Nil
  -- Fields: pname (is Nil for R_UnboundValue), value, internal.
  Symbol    :: (a :∈ ['R.Char, 'R.Nil])
            => SEXP s a
            -> SEXP s b
            -> SEXP s c
            -> HExp s 'R.Symbol
  -- Fields: carval, cdrval, tagval.
  List      :: (R.IsPairList b, c :∈ ['R.Symbol, 'R.Nil])
            => SEXP s a
            -> SEXP s b
            -> SEXP s c
            -> HExp s 'R.List
  -- Fields: frame, enclos, hashtab.
  Env       :: (R.IsPairList a, b :∈ ['R.Env, 'R.Nil], c :∈ ['R.Vector, 'R.Nil])
            => SEXP s a
            -> SEXP s b
            -> SEXP s c
            -> HExp s 'R.Env
  -- Fields: formals, body, env.
  Closure   :: (R.IsPairList a)
            => SEXP s a
            -> SEXP s b
            -> SEXP s 'R.Env
            -> HExp s 'R.Closure
  -- Fields: value, expr, env.
  -- Once an promise has been evaluated, the environment is set to NULL.
  Promise   :: (R.IsExpression b, c :∈ ['R.Env, 'R.Nil])
            => SEXP s a
            -> SEXP s b
            -> SEXP s c
            -> HExp s 'R.Promise
  -- Derived types. These types don't have their own 'struct' declaration in
  -- <Rinternals.h>.
  -- Fields: function, args.
  Lang      :: (R.IsExpression a, R.IsPairList b)
            => SEXP s a
            -> SEXP s b
            -> HExp s 'R.Lang
  -- Fields: offset.
  Special   :: {-# UNPACK #-} !Int32
            -> HExp s 'R.Special
  -- Fields: offset.
  Builtin   :: {-# UNPACK #-} !Int32
            -> HExp s 'R.Builtin
  Char      :: {-# UNPACK #-} !(Vector.Vector 'R.Char Word8)
            -> HExp s 'R.Char
  Logical   :: {-# UNPACK #-} !(Vector.Vector 'R.Logical R.Logical)
            -> HExp s 'R.Logical
  Int       :: {-# UNPACK #-} !(Vector.Vector 'R.Int Int32)
            -> HExp s 'R.Int
  Real      :: {-# UNPACK #-} !(Vector.Vector 'R.Real Double)
            -> HExp s 'R.Real
  Complex   :: {-# UNPACK #-} !(Vector.Vector 'R.Complex (Complex Double))
            -> HExp s 'R.Complex
  String    :: {-# UNPACK #-} !(Vector.Vector 'R.String (SEXP V 'R.Char))
            -> HExp s 'R.String
  -- Fields: pairlist of promises.
  DotDotDot :: (R.IsPairList a)
            => SEXP s a
            -> HExp s 'R.List
  -- Fields: truelength, content.
  Vector    :: {-# UNPACK #-} !Int32
            -> {-# UNPACK #-} !(Vector.Vector 'R.Vector (SomeSEXP V))
            -> HExp s 'R.Vector
  -- Fields: truelength, content.
  Expr      :: {-# UNPACK #-} !Int32
            -> {-# UNPACK #-} !(Vector.Vector 'R.Expr (SomeSEXP V))
            -> HExp s 'R.Expr
  Bytecode  :: HExp s 'R.Bytecode -- TODO
  -- Fields: pointer, protectionValue, tagval
  ExtPtr    :: Ptr ()
            -> SEXP s b
            -> SEXP s 'R.Symbol
            -> HExp s 'R.ExtPtr
  -- Fields: key, value, finalizer, next.
  WeakRef   :: ( a :∈ ['R.Env, 'R.ExtPtr, 'R.Nil]
               , c :∈ ['R.Closure, 'R.Builtin, 'R.Special, 'R.Nil]
               , d :∈ ['R.WeakRef, 'R.Nil] )
            => SEXP s a
            -> SEXP s b
            -> SEXP s c
            -> SEXP s d
            -> HExp s 'R.WeakRef
  Raw       :: {-# UNPACK #-} !(Vector.Vector 'R.Raw Word8)
            -> HExp s 'R.Raw
  -- Fields: tagval.
  S4        :: SEXP s a
            -> HExp s 'R.S4

-- 'Im a hack

instance Eq (HExp s a) where
  == :: HExp s a -> HExp s a -> Bool
(==) = HExp s a -> HExp s a -> Bool
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Bool
(===)

-- | Heterogeneous equality.
(===) :: TestEquality f => f a -> f b -> Bool
x :: f a
x === :: f a -> f b -> Bool
=== y :: f b
y = Maybe (a :~: b) -> Bool
forall a. Maybe a -> Bool
isJust (Maybe (a :~: b) -> Bool) -> Maybe (a :~: b) -> Bool
forall a b. (a -> b) -> a -> b
$ f a -> f b -> Maybe (a :~: b)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality f a
x f b
y

-- | Wrapper for partially applying a type synonym.
newtype E s a = E (SEXP s a)

instance TestEquality (E s) where
  testEquality :: E s a -> E s b -> Maybe (a :~: b)
testEquality (E x :: SEXP s a
x@(SEXP s a -> HExp s a
forall s (a :: SEXPTYPE). SEXP s a -> HExp s a
hexp -> HExp s a
t1)) (E y :: SEXP s b
y@(SEXP s b -> HExp s b
forall s (a :: SEXPTYPE). SEXP s a -> HExp s a
hexp -> HExp s b
t2)) =
      (Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (SEXP s a -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP s a
x SEXP0 -> SEXP0 -> Bool
forall a. Eq a => a -> a -> Bool
== SEXP s b -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP s b
y) Maybe () -> Maybe (a :~: b) -> Maybe (a :~: b)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (a :~: b) -> Maybe (a :~: b)
forall (m :: * -> *) a. Monad m => a -> m a
return ((Any :~: Any) -> a :~: b
forall a b. a -> b
unsafeCoerce Any :~: Any
forall k (a :: k). a :~: a
Refl)) Maybe (a :~: b) -> Maybe (a :~: b) -> Maybe (a :~: b)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
      HExp s a -> HExp s b -> Maybe (a :~: b)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality HExp s a
t1 HExp s b
t2

instance TestEquality (HExp s) where
  testEquality :: HExp s a -> HExp s b -> Maybe (a :~: b)
testEquality Nil Nil = (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality (Symbol pname1 :: SEXP s a
pname1 value1 :: SEXP s b
value1 internal1 :: SEXP s c
internal1) (Symbol pname2 :: SEXP s a
pname2 value2 :: SEXP s b
value2 internal2 :: SEXP s c
internal2) = do
      Maybe (a :~: a) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (a :~: a) -> Maybe ()) -> Maybe (a :~: a) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s a -> E s a -> Maybe (a :~: a)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
pname1) (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
pname2)
      Maybe (b :~: b) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (b :~: b) -> Maybe ()) -> Maybe (b :~: b) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s b -> E s b -> Maybe (b :~: b)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s b -> E s b
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s b
value1) (SEXP s b -> E s b
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s b
value2)
      Maybe (c :~: c) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (c :~: c) -> Maybe ()) -> Maybe (c :~: c) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s c -> E s c -> Maybe (c :~: c)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s c -> E s c
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s c
internal1) (SEXP s c -> E s c
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s c
internal2)
      (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality (List carval1 :: SEXP s a
carval1 cdrval1 :: SEXP s b
cdrval1 tagval1 :: SEXP s c
tagval1) (List carval2 :: SEXP s a
carval2 cdrval2 :: SEXP s b
cdrval2 tagval2 :: SEXP s c
tagval2) = do
      Maybe (a :~: a) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (a :~: a) -> Maybe ()) -> Maybe (a :~: a) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s a -> E s a -> Maybe (a :~: a)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
carval1) (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
carval2)
      Maybe (b :~: b) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (b :~: b) -> Maybe ()) -> Maybe (b :~: b) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s b -> E s b -> Maybe (b :~: b)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s b -> E s b
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s b
cdrval1) (SEXP s b -> E s b
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s b
cdrval2)
      Maybe (c :~: c) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (c :~: c) -> Maybe ()) -> Maybe (c :~: c) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s c -> E s c -> Maybe (c :~: c)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s c -> E s c
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s c
tagval1) (SEXP s c -> E s c
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s c
tagval2)
      (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality (Env frame1 :: SEXP s a
frame1 enclos1 :: SEXP s b
enclos1 hashtab1 :: SEXP s c
hashtab1) (Env frame2 :: SEXP s a
frame2 enclos2 :: SEXP s b
enclos2 hashtab2 :: SEXP s c
hashtab2) = do
      Maybe (a :~: a) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (a :~: a) -> Maybe ()) -> Maybe (a :~: a) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s a -> E s a -> Maybe (a :~: a)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
frame1) (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
frame2)
      Maybe (b :~: b) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (b :~: b) -> Maybe ()) -> Maybe (b :~: b) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s b -> E s b -> Maybe (b :~: b)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s b -> E s b
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s b
enclos1) (SEXP s b -> E s b
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s b
enclos2)
      Maybe (c :~: c) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (c :~: c) -> Maybe ()) -> Maybe (c :~: c) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s c -> E s c -> Maybe (c :~: c)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s c -> E s c
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s c
hashtab1) (SEXP s c -> E s c
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s c
hashtab2)
      (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality (Closure formals1 :: SEXP s a
formals1 body1 :: SEXP s b
body1 env1 :: SEXP s 'Env
env1) (Closure formals2 :: SEXP s a
formals2 body2 :: SEXP s b
body2 env2 :: SEXP s 'Env
env2) = do
      Maybe (a :~: a) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (a :~: a) -> Maybe ()) -> Maybe (a :~: a) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s a -> E s a -> Maybe (a :~: a)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
formals1) (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
formals2)
      Maybe (b :~: b) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (b :~: b) -> Maybe ()) -> Maybe (b :~: b) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s b -> E s b -> Maybe (b :~: b)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s b -> E s b
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s b
body1) (SEXP s b -> E s b
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s b
body2)
      Maybe ('Env :~: 'Env) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe ('Env :~: 'Env) -> Maybe ())
-> Maybe ('Env :~: 'Env) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s 'Env -> E s 'Env -> Maybe ('Env :~: 'Env)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s 'Env -> E s 'Env
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s 'Env
env1) (SEXP s 'Env -> E s 'Env
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s 'Env
env2)
      (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality (Promise value1 :: SEXP s a
value1 expr1 :: SEXP s b
expr1 env1 :: SEXP s c
env1) (Promise value2 :: SEXP s a
value2 expr2 :: SEXP s b
expr2 env2 :: SEXP s c
env2) = do
      Maybe (a :~: a) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (a :~: a) -> Maybe ()) -> Maybe (a :~: a) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s a -> E s a -> Maybe (a :~: a)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
value1) (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
value2)
      Maybe (b :~: b) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (b :~: b) -> Maybe ()) -> Maybe (b :~: b) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s b -> E s b -> Maybe (b :~: b)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s b -> E s b
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s b
expr1) (SEXP s b -> E s b
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s b
expr2)
      Maybe (c :~: c) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (c :~: c) -> Maybe ()) -> Maybe (c :~: c) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s c -> E s c -> Maybe (c :~: c)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s c -> E s c
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s c
env1) (SEXP s c -> E s c
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s c
env2)
      (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality (Lang carval1 :: SEXP s a
carval1 cdrval1 :: SEXP s b
cdrval1) (Lang carval2 :: SEXP s a
carval2 cdrval2 :: SEXP s b
cdrval2) = do
      Maybe (a :~: a) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (a :~: a) -> Maybe ()) -> Maybe (a :~: a) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s a -> E s a -> Maybe (a :~: a)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
carval1) (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
carval2)
      Maybe (b :~: b) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (b :~: b) -> Maybe ()) -> Maybe (b :~: b) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s b -> E s b -> Maybe (b :~: b)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s b -> E s b
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s b
cdrval1) (SEXP s b -> E s b
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s b
cdrval2)
      (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality (Special offset1 :: Int32
offset1) (Special offset2 :: Int32
offset2) = do
      Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Maybe ()) -> Bool -> Maybe ()
forall a b. (a -> b) -> a -> b
$ Int32
offset1 Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
== Int32
offset2
      (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality (Builtin offset1 :: Int32
offset1) (Builtin offset2 :: Int32
offset2) = do
      Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Maybe ()) -> Bool -> Maybe ()
forall a b. (a -> b) -> a -> b
$ Int32
offset1 Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
== Int32
offset2
      (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality (Char vec1 :: Vector 'Char Word8
vec1) (Char vec2 :: Vector 'Char Word8
vec2) = do
      Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Maybe ()) -> Bool -> Maybe ()
forall a b. (a -> b) -> a -> b
$ Vector 'Char Word8
vec1 Vector 'Char Word8 -> Vector 'Char Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Vector 'Char Word8
vec2
      (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality (Int vec1 :: Vector 'Int Int32
vec1) (Int vec2 :: Vector 'Int Int32
vec2) = do
      Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Maybe ()) -> Bool -> Maybe ()
forall a b. (a -> b) -> a -> b
$ Vector 'Int Int32
vec1 Vector 'Int Int32 -> Vector 'Int Int32 -> Bool
forall a. Eq a => a -> a -> Bool
== Vector 'Int Int32
vec2
      (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality (Real vec1 :: Vector 'Real Double
vec1) (Real vec2 :: Vector 'Real Double
vec2) = do
      Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Maybe ()) -> Bool -> Maybe ()
forall a b. (a -> b) -> a -> b
$ Vector 'Real Double
vec1 Vector 'Real Double -> Vector 'Real Double -> Bool
forall a. Eq a => a -> a -> Bool
== Vector 'Real Double
vec2
      (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality (String vec1 :: Vector 'String (SEXP V 'Char)
vec1) (String vec2 :: Vector 'String (SEXP V 'Char)
vec2) = do
      Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Maybe ()) -> Bool -> Maybe ()
forall a b. (a -> b) -> a -> b
$ Vector 'String (SEXP V 'Char)
vec1 Vector 'String (SEXP V 'Char)
-> Vector 'String (SEXP V 'Char) -> Bool
forall a. Eq a => a -> a -> Bool
== Vector 'String (SEXP V 'Char)
vec2
      (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality (Complex vec1 :: Vector 'Complex (Complex Double)
vec1) (Complex vec2 :: Vector 'Complex (Complex Double)
vec2) = do
      Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Maybe ()) -> Bool -> Maybe ()
forall a b. (a -> b) -> a -> b
$ Vector 'Complex (Complex Double)
vec1 Vector 'Complex (Complex Double)
-> Vector 'Complex (Complex Double) -> Bool
forall a. Eq a => a -> a -> Bool
== Vector 'Complex (Complex Double)
vec2
      (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality (DotDotDot pairlist1 :: SEXP s a
pairlist1) (DotDotDot pairlist2 :: SEXP s a
pairlist2) = do
      Maybe (a :~: a) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (a :~: a) -> Maybe ()) -> Maybe (a :~: a) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s a -> E s a -> Maybe (a :~: a)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
pairlist1) (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
pairlist2)
      (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality (Vector truelength1 :: Int32
truelength1 vec1 :: Vector 'Vector (SomeSEXP V)
vec1) (Vector truelength2 :: Int32
truelength2 vec2 :: Vector 'Vector (SomeSEXP V)
vec2) = do
      let eq :: SomeSEXP s -> SomeSEXP s -> Bool
eq (SomeSEXP s1 :: SEXP s a
s1) (SomeSEXP s2) = Maybe (a :~: a) -> Bool
forall a. Maybe a -> Bool
isJust (Maybe (a :~: a) -> Bool) -> Maybe (a :~: a) -> Bool
forall a b. (a -> b) -> a -> b
$ E s a -> E s a -> Maybe (a :~: a)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
s1) (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
s2)
      Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Maybe ()) -> Bool -> Maybe ()
forall a b. (a -> b) -> a -> b
$ Int32
truelength1 Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
== Int32
truelength2
      Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Maybe ()) -> Bool -> Maybe ()
forall a b. (a -> b) -> a -> b
$ [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and ([Bool] -> Bool) -> [Bool] -> Bool
forall a b. (a -> b) -> a -> b
$ (SomeSEXP V -> SomeSEXP V -> Bool)
-> [SomeSEXP V] -> [SomeSEXP V] -> [Bool]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith SomeSEXP V -> SomeSEXP V -> Bool
forall s. SomeSEXP s -> SomeSEXP s -> Bool
eq (Vector 'Vector (SomeSEXP V) -> [SomeSEXP V]
forall (ty :: SEXPTYPE) a. SVECTOR ty a => Vector ty a -> [a]
Vector.toList Vector 'Vector (SomeSEXP V)
vec1) (Vector 'Vector (SomeSEXP V) -> [SomeSEXP V]
forall (ty :: SEXPTYPE) a. SVECTOR ty a => Vector ty a -> [a]
Vector.toList Vector 'Vector (SomeSEXP V)
vec2)
      (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality (Expr truelength1 :: Int32
truelength1 vec1 :: Vector 'Expr (SomeSEXP V)
vec1) (Expr truelength2 :: Int32
truelength2 vec2 :: Vector 'Expr (SomeSEXP V)
vec2) = do
      let eq :: SomeSEXP s -> SomeSEXP s -> Bool
eq (SomeSEXP s1 :: SEXP s a
s1) (SomeSEXP s2) = Maybe (a :~: a) -> Bool
forall a. Maybe a -> Bool
isJust (Maybe (a :~: a) -> Bool) -> Maybe (a :~: a) -> Bool
forall a b. (a -> b) -> a -> b
$ E s a -> E s a -> Maybe (a :~: a)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
s1) (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
s2)
      Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Maybe ()) -> Bool -> Maybe ()
forall a b. (a -> b) -> a -> b
$ Int32
truelength1 Int32 -> Int32 -> Bool
forall a. Eq a => a -> a -> Bool
== Int32
truelength2
      Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Maybe ()) -> Bool -> Maybe ()
forall a b. (a -> b) -> a -> b
$ [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and ([Bool] -> Bool) -> [Bool] -> Bool
forall a b. (a -> b) -> a -> b
$ (SomeSEXP V -> SomeSEXP V -> Bool)
-> [SomeSEXP V] -> [SomeSEXP V] -> [Bool]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith SomeSEXP V -> SomeSEXP V -> Bool
forall s. SomeSEXP s -> SomeSEXP s -> Bool
eq (Vector 'Expr (SomeSEXP V) -> [SomeSEXP V]
forall (ty :: SEXPTYPE) a. SVECTOR ty a => Vector ty a -> [a]
Vector.toList Vector 'Expr (SomeSEXP V)
vec1) (Vector 'Expr (SomeSEXP V) -> [SomeSEXP V]
forall (ty :: SEXPTYPE) a. SVECTOR ty a => Vector ty a -> [a]
Vector.toList Vector 'Expr (SomeSEXP V)
vec2)
      (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality Bytecode Bytecode = (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality (ExtPtr pointer1 :: Ptr ()
pointer1 protectionValue1 :: SEXP s b
protectionValue1 tagval1 :: SEXP s 'Symbol
tagval1) (ExtPtr pointer2 :: Ptr ()
pointer2 protectionValue2 :: SEXP s b
protectionValue2 tagval2 :: SEXP s 'Symbol
tagval2) = do
      Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Maybe ()) -> Bool -> Maybe ()
forall a b. (a -> b) -> a -> b
$ Ptr () -> Ptr Any
forall a b. Ptr a -> Ptr b
castPtr Ptr ()
pointer1 Ptr Any -> Ptr Any -> Bool
forall a. Eq a => a -> a -> Bool
== Ptr () -> Ptr Any
forall a b. Ptr a -> Ptr b
castPtr Ptr ()
pointer2
      Maybe (b :~: b) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (b :~: b) -> Maybe ()) -> Maybe (b :~: b) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s b -> E s b -> Maybe (b :~: b)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s b -> E s b
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s b
protectionValue1) (SEXP s b -> E s b
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s b
protectionValue2)
      Maybe ('Symbol :~: 'Symbol) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe ('Symbol :~: 'Symbol) -> Maybe ())
-> Maybe ('Symbol :~: 'Symbol) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s 'Symbol -> E s 'Symbol -> Maybe ('Symbol :~: 'Symbol)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s 'Symbol -> E s 'Symbol
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s 'Symbol
tagval1) (SEXP s 'Symbol -> E s 'Symbol
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s 'Symbol
tagval2)
      (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality (WeakRef key1 :: SEXP s a
key1 value1 :: SEXP s b
value1 finalizer1 :: SEXP s c
finalizer1 next1 :: SEXP s d
next1) (WeakRef key2 :: SEXP s a
key2 value2 :: SEXP s b
value2 finalizer2 :: SEXP s c
finalizer2 next2 :: SEXP s d
next2) = do
      Maybe (a :~: a) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (a :~: a) -> Maybe ()) -> Maybe (a :~: a) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s a -> E s a -> Maybe (a :~: a)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
key1) (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
key2)
      Maybe (b :~: b) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (b :~: b) -> Maybe ()) -> Maybe (b :~: b) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s b -> E s b -> Maybe (b :~: b)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s b -> E s b
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s b
value1) (SEXP s b -> E s b
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s b
value2)
      Maybe (c :~: c) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (c :~: c) -> Maybe ()) -> Maybe (c :~: c) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s c -> E s c -> Maybe (c :~: c)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s c -> E s c
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s c
finalizer1) (SEXP s c -> E s c
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s c
finalizer2)
      Maybe (d :~: d) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (d :~: d) -> Maybe ()) -> Maybe (d :~: d) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s d -> E s d -> Maybe (d :~: d)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s d -> E s d
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s d
next1) (SEXP s d -> E s d
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s d
next2)
      (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality (Raw vec1 :: Vector 'Raw Word8
vec1) (Raw vec2 :: Vector 'Raw Word8
vec2) = do
      Bool -> Maybe ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> Maybe ()) -> Bool -> Maybe ()
forall a b. (a -> b) -> a -> b
$ Vector 'Raw Word8
vec1 Vector 'Raw Word8 -> Vector 'Raw Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Vector 'Raw Word8
vec2
      (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality (S4 tagval1 :: SEXP s a
tagval1) (S4 tagval2 :: SEXP s a
tagval2) = do
      Maybe (a :~: a) -> Maybe ()
forall (f :: * -> *) a. Functor f => f a -> f ()
void (Maybe (a :~: a) -> Maybe ()) -> Maybe (a :~: a) -> Maybe ()
forall a b. (a -> b) -> a -> b
$ E s a -> E s a -> Maybe (a :~: a)
forall k (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
tagval1) (SEXP s a -> E s a
forall s (a :: SEXPTYPE). SEXP s a -> E s a
E SEXP s a
tagval2)
      (a :~: a) -> Maybe (a :~: a)
forall (m :: * -> *) a. Monad m => a -> m a
return a :~: a
forall k (a :: k). a :~: a
Refl
  testEquality _ _ = Maybe (a :~: b)
forall a. Maybe a
Nothing

instance Storable (HExp s a) where
  sizeOf :: HExp s a -> Int
sizeOf _ = (56)
{-# LINE 291 "src/Language/R/HExp.hsc" #-}
  alignment _ = 8
{-# LINE 292 "src/Language/R/HExp.hsc" #-}
  poke = pokeHExp
  peek :: Ptr (HExp s a) -> IO (HExp s a)
peek = SEXP s a -> IO (HExp s a)
forall s (a :: SEXPTYPE). SEXP s a -> IO (HExp s a)
peekHExp (SEXP s a -> IO (HExp s a))
-> (Ptr (HExp s a) -> SEXP s a) -> Ptr (HExp s a) -> IO (HExp s a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr (HExp s a) -> SEXP s a
forall s (a :: SEXPTYPE). Ptr (HExp s a) -> SEXP s a
R.SEXP
  {-# INLINE peek #-}

{-# INLINE peekHExp #-}
peekHExp :: SEXP s a -> IO (HExp s a)
peekHExp :: SEXP s a -> IO (HExp s a)
peekHExp s :: SEXP s a
s = do
    let coerce :: IO (HExp s a) -> IO (HExp s b)
        coerce :: IO (HExp s a) -> IO (HExp s b)
coerce = IO (HExp s a) -> IO (HExp s b)
forall a b. a -> b
unsafeCoerce

        -- (:∈) constraints are impossible to respect in 'peekHExp', because
        -- R doesn't tell us statically the form of the SEXPREC referred to by
        -- a pointer. So in this function only, we pretend all constrained
        -- fields actually always contain fields of form ANYSXP. This has no
        -- operational significance - it's only a way to bypass what's
        -- impossible to prove.
        coerceAny :: SEXP s a -> SEXP s 'R.Any -- '
        coerceAny :: SEXP s a -> SEXP s 'Any
coerceAny = SEXP s a -> SEXP s 'Any
forall s (a :: SEXPTYPE) (b :: SEXPTYPE). SEXP s a -> SEXP s b
R.unsafeCoerce

        sptr :: SEXP0
sptr = SEXP s a -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP s a
s

    case SEXP s a -> SEXPTYPE
forall s (a :: SEXPTYPE). SEXP s a -> SEXPTYPE
R.typeOf SEXP s a
s of
      R.Nil       -> IO (HExp s 'Nil) -> IO (HExp s a)
forall s (a :: SEXPTYPE) (b :: SEXPTYPE).
IO (HExp s a) -> IO (HExp s b)
coerce (IO (HExp s 'Nil) -> IO (HExp s a))
-> IO (HExp s 'Nil) -> IO (HExp s a)
forall a b. (a -> b) -> a -> b
$ HExp s 'Nil -> IO (HExp s 'Nil)
forall (m :: * -> *) a. Monad m => a -> m a
return HExp s 'Nil
forall s. HExp s 'Nil
Nil
      R.Symbol    -> IO (HExp s 'Symbol) -> IO (HExp s a)
forall s (a :: SEXPTYPE) (b :: SEXPTYPE).
IO (HExp s a) -> IO (HExp s b)
coerce (IO (HExp s 'Symbol) -> IO (HExp s a))
-> IO (HExp s 'Symbol) -> IO (HExp s a)
forall a b. (a -> b) -> a -> b
$
        SEXP s 'Any -> SEXP s Any -> SEXP s Any -> HExp s 'Symbol
forall (a :: SEXPTYPE) s (b :: SEXPTYPE) (c :: SEXPTYPE).
(a :∈ '[ 'Char, 'Nil]) =>
SEXP s a -> SEXP s b -> SEXP s c -> HExp s 'Symbol
Symbol    (SEXP s 'Any -> SEXP s Any -> SEXP s Any -> HExp s 'Symbol)
-> IO (SEXP s 'Any)
-> IO (SEXP s Any -> SEXP s Any -> HExp s 'Symbol)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (SEXP s Any -> SEXP s 'Any
forall s (a :: SEXPTYPE). SEXP s a -> SEXP s 'Any
coerceAny (SEXP s Any -> SEXP s 'Any)
-> (SEXP0 -> SEXP s Any) -> SEXP0 -> SEXP s 'Any
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> SEXP0 -> SEXP s Any
forall s (a :: SEXPTYPE). SEXP0 -> SEXP s a
R.sexp (SEXP0 -> SEXP s 'Any) -> IO SEXP0 -> IO (SEXP s 'Any)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (\hsc_ptr :: SEXP0
hsc_ptr -> SEXP0 -> Int -> IO SEXP0
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff SEXP0
hsc_ptr 32) SEXP0
sptr)
{-# LINE 317 "src/Language/R/HExp.hsc" #-}
                  IO (SEXP s Any -> SEXP s Any -> HExp s 'Symbol)
-> IO (SEXP s Any) -> IO (SEXP s Any -> HExp s 'Symbol)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (SEXP0 -> SEXP s Any
forall s (a :: SEXPTYPE). SEXP0 -> SEXP s a
R.sexp (SEXP0 -> SEXP s Any) -> IO SEXP0 -> IO (SEXP s Any)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (\hsc_ptr :: SEXP0
hsc_ptr -> SEXP0 -> Int -> IO SEXP0
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff SEXP0
hsc_ptr 40) SEXP0
sptr)
{-# LINE 318 "src/Language/R/HExp.hsc" #-}
                  IO (SEXP s Any -> HExp s 'Symbol)
-> IO (SEXP s Any) -> IO (HExp s 'Symbol)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (SEXP0 -> SEXP s Any
forall s (a :: SEXPTYPE). SEXP0 -> SEXP s a
R.sexp (SEXP0 -> SEXP s Any) -> IO SEXP0 -> IO (SEXP s Any)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (\hsc_ptr :: SEXP0
hsc_ptr -> SEXP0 -> Int -> IO SEXP0
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff SEXP0
hsc_ptr 48) SEXP0
sptr)
{-# LINE 319 "src/Language/R/HExp.hsc" #-}
      R.List      -> coerce $
        List      <$> (R.sexp <$> (\hsc_ptr -> peekByteOff hsc_ptr 32) sptr)
{-# LINE 321 "src/Language/R/HExp.hsc" #-}
                  <*> (coerceAny <$> R.sexp <$> (\hsc_ptr -> peekByteOff hsc_ptr 40) sptr)
{-# LINE 322 "src/Language/R/HExp.hsc" #-}
                  <*> (coerceAny <$> R.sexp <$> (\hsc_ptr -> peekByteOff hsc_ptr 48) sptr)
{-# LINE 323 "src/Language/R/HExp.hsc" #-}
      R.Env       -> coerce $
        Env       <$> (coerceAny <$> R.sexp <$> (\hsc_ptr -> peekByteOff hsc_ptr 32) sptr)
{-# LINE 325 "src/Language/R/HExp.hsc" #-}
                  <*> (coerceAny <$> R.sexp <$> (\hsc_ptr -> peekByteOff hsc_ptr 40) sptr)
{-# LINE 326 "src/Language/R/HExp.hsc" #-}
                  <*> (coerceAny <$> R.sexp <$> (\hsc_ptr -> peekByteOff hsc_ptr 48) sptr)
{-# LINE 327 "src/Language/R/HExp.hsc" #-}
      R.Closure   -> coerce $
        Closure   <$> (coerceAny <$> R.sexp <$> (\hsc_ptr -> peekByteOff hsc_ptr 32) sptr)
{-# LINE 329 "src/Language/R/HExp.hsc" #-}
                  <*> (R.sexp <$> (\hsc_ptr -> peekByteOff hsc_ptr 40) sptr)
{-# LINE 330 "src/Language/R/HExp.hsc" #-}
                  <*> (R.sexp <$> (\hsc_ptr -> peekByteOff hsc_ptr 48) sptr)
{-# LINE 331 "src/Language/R/HExp.hsc" #-}
      R.Promise   -> coerce $
        Promise   <$> (coerceAny <$> R.sexp <$> (\hsc_ptr -> peekByteOff hsc_ptr 32) sptr)
{-# LINE 333 "src/Language/R/HExp.hsc" #-}
                  <*> (coerceAny <$> R.sexp <$> (\hsc_ptr -> peekByteOff hsc_ptr 40) sptr)
{-# LINE 334 "src/Language/R/HExp.hsc" #-}
                  <*> (coerceAny <$> R.sexp <$> (\hsc_ptr -> peekByteOff hsc_ptr 48) sptr)
{-# LINE 335 "src/Language/R/HExp.hsc" #-}
      R.Lang      -> coerce $
        Lang      <$> (coerceAny <$> R.sexp <$> (\hsc_ptr -> peekByteOff hsc_ptr 32) sptr)
{-# LINE 337 "src/Language/R/HExp.hsc" #-}
                  <*> (coerceAny <$> R.sexp <$> (\hsc_ptr -> peekByteOff hsc_ptr 40) sptr)
{-# LINE 338 "src/Language/R/HExp.hsc" #-}
      R.Special   -> coerce $
        Special   <$> (fromIntegral <$> ((\hsc_ptr -> peekByteOff hsc_ptr 32) sptr :: IO CInt))
{-# LINE 340 "src/Language/R/HExp.hsc" #-}
      R.Builtin   -> coerce $
        Builtin   <$> (fromIntegral <$> ((\hsc_ptr -> peekByteOff hsc_ptr 32) sptr :: IO CInt))
{-# LINE 342 "src/Language/R/HExp.hsc" #-}
      R.Char      -> unsafeCoerce $ Char    (Vector.unsafeFromSEXP (unsafeCoerce s))
      R.Logical   -> HExp Any 'Logical -> IO (HExp s a)
forall a b. a -> b
unsafeCoerce (HExp Any 'Logical -> IO (HExp s a))
-> HExp Any 'Logical -> IO (HExp s a)
forall a b. (a -> b) -> a -> b
$ Vector 'Logical Logical -> HExp Any 'Logical
forall s. Vector 'Logical Logical -> HExp s 'Logical
Logical (SEXP Any 'Logical -> Vector 'Logical Logical
forall (ty :: SEXPTYPE) a s.
SVECTOR ty a =>
SEXP s ty -> Vector ty a
Vector.unsafeFromSEXP (SEXP s a -> SEXP Any 'Logical
forall a b. a -> b
unsafeCoerce SEXP s a
s))
      R.Int       -> HExp Any 'Int -> IO (HExp s a)
forall a b. a -> b
unsafeCoerce (HExp Any 'Int -> IO (HExp s a)) -> HExp Any 'Int -> IO (HExp s a)
forall a b. (a -> b) -> a -> b
$ Vector 'Int Int32 -> HExp Any 'Int
forall s. Vector 'Int Int32 -> HExp s 'Int
Int     (SEXP Any 'Int -> Vector 'Int Int32
forall (ty :: SEXPTYPE) a s.
SVECTOR ty a =>
SEXP s ty -> Vector ty a
Vector.unsafeFromSEXP (SEXP s a -> SEXP Any 'Int
forall a b. a -> b
unsafeCoerce SEXP s a
s))
      R.Real      -> HExp Any 'Real -> IO (HExp s a)
forall a b. a -> b
unsafeCoerce (HExp Any 'Real -> IO (HExp s a))
-> HExp Any 'Real -> IO (HExp s a)
forall a b. (a -> b) -> a -> b
$ Vector 'Real Double -> HExp Any 'Real
forall s. Vector 'Real Double -> HExp s 'Real
Real    (SEXP Any 'Real -> Vector 'Real Double
forall (ty :: SEXPTYPE) a s.
SVECTOR ty a =>
SEXP s ty -> Vector ty a
Vector.unsafeFromSEXP (SEXP s a -> SEXP Any 'Real
forall a b. a -> b
unsafeCoerce SEXP s a
s))
      R.Complex   -> HExp Any 'Complex -> IO (HExp s a)
forall a b. a -> b
unsafeCoerce (HExp Any 'Complex -> IO (HExp s a))
-> HExp Any 'Complex -> IO (HExp s a)
forall a b. (a -> b) -> a -> b
$ Vector 'Complex (Complex Double) -> HExp Any 'Complex
forall s. Vector 'Complex (Complex Double) -> HExp s 'Complex
Complex (SEXP Any 'Complex -> Vector 'Complex (Complex Double)
forall (ty :: SEXPTYPE) a s.
SVECTOR ty a =>
SEXP s ty -> Vector ty a
Vector.unsafeFromSEXP (SEXP s a -> SEXP Any 'Complex
forall a b. a -> b
unsafeCoerce SEXP s a
s))
      R.String    -> HExp Any 'String -> IO (HExp s a)
forall a b. a -> b
unsafeCoerce (HExp Any 'String -> IO (HExp s a))
-> HExp Any 'String -> IO (HExp s a)
forall a b. (a -> b) -> a -> b
$ Vector 'String (SEXP V 'Char) -> HExp Any 'String
forall s. Vector 'String (SEXP V 'Char) -> HExp s 'String
String  (SEXP Any 'String -> Vector 'String (SEXP V 'Char)
forall (ty :: SEXPTYPE) a s.
SVECTOR ty a =>
SEXP s ty -> Vector ty a
Vector.unsafeFromSEXP (SEXP s a -> SEXP Any 'String
forall a b. a -> b
unsafeCoerce SEXP s a
s))
      R.DotDotDot -> String -> IO (HExp s a)
forall a. String -> a
unimplemented (String -> IO (HExp s a)) -> String -> IO (HExp s a)
forall a b. (a -> b) -> a -> b
$ "peekHExp: " String -> String -> String
forall a. [a] -> [a] -> [a]
++ SEXPTYPE -> String
forall a. Show a => a -> String
show (SEXP s a -> SEXPTYPE
forall s (a :: SEXPTYPE). SEXP s a -> SEXPTYPE
R.typeOf SEXP s a
s)
      R.Vector    -> IO (HExp s 'Vector) -> IO (HExp s a)
forall s (a :: SEXPTYPE) (b :: SEXPTYPE).
IO (HExp s a) -> IO (HExp s b)
coerce (IO (HExp s 'Vector) -> IO (HExp s a))
-> IO (HExp s 'Vector) -> IO (HExp s a)
forall a b. (a -> b) -> a -> b
$
        Int32 -> Vector 'Vector (SomeSEXP V) -> HExp s 'Vector
forall s. Int32 -> Vector 'Vector (SomeSEXP V) -> HExp s 'Vector
Vector    (Int32 -> Vector 'Vector (SomeSEXP V) -> HExp s 'Vector)
-> IO Int32 -> IO (Vector 'Vector (SomeSEXP V) -> HExp s 'Vector)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (CInt -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Int32) -> IO CInt -> IO Int32
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((\hsc_ptr :: SEXP0
hsc_ptr -> SEXP0 -> Int -> IO CInt
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff SEXP0
hsc_ptr 40) SEXP0
sptr :: IO CInt))
{-# LINE 351 "src/Language/R/HExp.hsc" #-}
                  IO (Vector 'Vector (SomeSEXP V) -> HExp s 'Vector)
-> IO (Vector 'Vector (SomeSEXP V)) -> IO (HExp s 'Vector)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Vector 'Vector (SomeSEXP V) -> IO (Vector 'Vector (SomeSEXP V))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SEXP Any 'Vector -> Vector 'Vector (SomeSEXP V)
forall (ty :: SEXPTYPE) a s.
SVECTOR ty a =>
SEXP s ty -> Vector ty a
Vector.unsafeFromSEXP (SEXP s a -> SEXP Any 'Vector
forall a b. a -> b
unsafeCoerce SEXP s a
s))
      R.Expr      -> IO (HExp s 'Expr) -> IO (HExp s a)
forall s (a :: SEXPTYPE) (b :: SEXPTYPE).
IO (HExp s a) -> IO (HExp s b)
coerce (IO (HExp s 'Expr) -> IO (HExp s a))
-> IO (HExp s 'Expr) -> IO (HExp s a)
forall a b. (a -> b) -> a -> b
$
        Int32 -> Vector 'Expr (SomeSEXP V) -> HExp s 'Expr
forall s. Int32 -> Vector 'Expr (SomeSEXP V) -> HExp s 'Expr
Expr      (Int32 -> Vector 'Expr (SomeSEXP V) -> HExp s 'Expr)
-> IO Int32 -> IO (Vector 'Expr (SomeSEXP V) -> HExp s 'Expr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (CInt -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (CInt -> Int32) -> IO CInt -> IO Int32
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((\hsc_ptr :: SEXP0
hsc_ptr -> SEXP0 -> Int -> IO CInt
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff SEXP0
hsc_ptr 40) SEXP0
sptr :: IO CInt))
{-# LINE 354 "src/Language/R/HExp.hsc" #-}
                  IO (Vector 'Expr (SomeSEXP V) -> HExp s 'Expr)
-> IO (Vector 'Expr (SomeSEXP V)) -> IO (HExp s 'Expr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Vector 'Expr (SomeSEXP V) -> IO (Vector 'Expr (SomeSEXP V))
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SEXP Any 'Expr -> Vector 'Expr (SomeSEXP V)
forall (ty :: SEXPTYPE) a s.
SVECTOR ty a =>
SEXP s ty -> Vector ty a
Vector.unsafeFromSEXP (SEXP s a -> SEXP Any 'Expr
forall a b. a -> b
unsafeCoerce SEXP s a
s))
      R.Bytecode  -> IO (HExp s 'Bytecode) -> IO (HExp s a)
forall s (a :: SEXPTYPE) (b :: SEXPTYPE).
IO (HExp s a) -> IO (HExp s b)
coerce (IO (HExp s 'Bytecode) -> IO (HExp s a))
-> IO (HExp s 'Bytecode) -> IO (HExp s a)
forall a b. (a -> b) -> a -> b
$ HExp s 'Bytecode -> IO (HExp s 'Bytecode)
forall (m :: * -> *) a. Monad m => a -> m a
return HExp s 'Bytecode
forall s. HExp s 'Bytecode
Bytecode
      R.ExtPtr    -> IO (HExp s 'ExtPtr) -> IO (HExp s a)
forall s (a :: SEXPTYPE) (b :: SEXPTYPE).
IO (HExp s a) -> IO (HExp s b)
coerce (IO (HExp s 'ExtPtr) -> IO (HExp s a))
-> IO (HExp s 'ExtPtr) -> IO (HExp s a)
forall a b. (a -> b) -> a -> b
$
        Ptr () -> SEXP s Any -> SEXP s 'Symbol -> HExp s 'ExtPtr
forall s (b :: SEXPTYPE).
Ptr () -> SEXP s b -> SEXP s 'Symbol -> HExp s 'ExtPtr
ExtPtr    (Ptr () -> SEXP s Any -> SEXP s 'Symbol -> HExp s 'ExtPtr)
-> IO (Ptr ())
-> IO (SEXP s Any -> SEXP s 'Symbol -> HExp s 'ExtPtr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Ptr Any -> Ptr ()
forall a b. Ptr a -> Ptr b
castPtr (Ptr Any -> Ptr ()) -> IO (Ptr Any) -> IO (Ptr ())
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (\hsc_ptr :: SEXP0
hsc_ptr -> SEXP0 -> Int -> IO (Ptr Any)
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff SEXP0
hsc_ptr 32) SEXP0
sptr)
{-# LINE 358 "src/Language/R/HExp.hsc" #-}
                  IO (SEXP s Any -> SEXP s 'Symbol -> HExp s 'ExtPtr)
-> IO (SEXP s Any) -> IO (SEXP s 'Symbol -> HExp s 'ExtPtr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (SEXP0 -> SEXP s Any
forall s (a :: SEXPTYPE). SEXP0 -> SEXP s a
R.sexp (SEXP0 -> SEXP s Any) -> IO SEXP0 -> IO (SEXP s Any)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (\hsc_ptr :: SEXP0
hsc_ptr -> SEXP0 -> Int -> IO SEXP0
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff SEXP0
hsc_ptr 40) SEXP0
sptr)
{-# LINE 359 "src/Language/R/HExp.hsc" #-}
                  IO (SEXP s 'Symbol -> HExp s 'ExtPtr)
-> IO (SEXP s 'Symbol) -> IO (HExp s 'ExtPtr)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (SEXP0 -> SEXP s 'Symbol
forall s (a :: SEXPTYPE). SEXP0 -> SEXP s a
R.sexp (SEXP0 -> SEXP s 'Symbol) -> IO SEXP0 -> IO (SEXP s 'Symbol)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (\hsc_ptr :: SEXP0
hsc_ptr -> SEXP0 -> Int -> IO SEXP0
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff SEXP0
hsc_ptr 48) SEXP0
sptr)
{-# LINE 360 "src/Language/R/HExp.hsc" #-}
      R.WeakRef   -> coerce $
        WeakRef   <$> (coerceAny <$> R.sexp <$>
                       peekElemOff (castPtr $ R.unsafeSEXPToVectorPtr s) 0)
                  <*> (R.sexp <$>
                       peekElemOff (castPtr $ R.unsafeSEXPToVectorPtr s) 1)
                  <*> (coerceAny <$> R.sexp <$>
                       peekElemOff (castPtr $ R.unsafeSEXPToVectorPtr s) 2)
                  <*> (coerceAny <$> R.sexp <$>
                       peekElemOff (castPtr $ R.unsafeSEXPToVectorPtr s) 3)
      R.Raw       -> HExp Any 'Raw -> IO (HExp s a)
forall a b. a -> b
unsafeCoerce (HExp Any 'Raw -> IO (HExp s a)) -> HExp Any 'Raw -> IO (HExp s a)
forall a b. (a -> b) -> a -> b
$ Vector 'Raw Word8 -> HExp Any 'Raw
forall s. Vector 'Raw Word8 -> HExp s 'Raw
Raw (SEXP Any 'Raw -> Vector 'Raw Word8
forall (ty :: SEXPTYPE) a s.
SVECTOR ty a =>
SEXP s ty -> Vector ty a
Vector.unsafeFromSEXP (SEXP s a -> SEXP Any 'Raw
forall a b. a -> b
unsafeCoerce SEXP s a
s))
      R.S4        -> IO (HExp s 'S4) -> IO (HExp s a)
forall s (a :: SEXPTYPE) (b :: SEXPTYPE).
IO (HExp s a) -> IO (HExp s b)
coerce (IO (HExp s 'S4) -> IO (HExp s a))
-> IO (HExp s 'S4) -> IO (HExp s a)
forall a b. (a -> b) -> a -> b
$
        SEXP s Any -> HExp s 'S4
forall s (a :: SEXPTYPE). SEXP s a -> HExp s 'S4
S4        (SEXP s Any -> HExp s 'S4) -> IO (SEXP s Any) -> IO (HExp s 'S4)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (SEXP0 -> SEXP s Any
forall s (a :: SEXPTYPE). SEXP0 -> SEXP s a
R.sexp (SEXP0 -> SEXP s Any) -> IO SEXP0 -> IO (SEXP s Any)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (\hsc_ptr :: SEXP0
hsc_ptr -> SEXP0 -> Int -> IO SEXP0
forall a b. Storable a => Ptr b -> Int -> IO a
peekByteOff SEXP0
hsc_ptr 48) SEXP0
sptr)
{-# LINE 372 "src/Language/R/HExp.hsc" #-}
      _           -> unimplemented $ "peekHExp: " ++ show (R.typeOf s)

pokeHExp :: Ptr (HExp s a) -> HExp s a -> IO ()
pokeHExp :: Ptr (HExp s a) -> HExp s a -> IO ()
pokeHExp s :: Ptr (HExp s a)
s h :: HExp s a
h = do
    case HExp s a
h of
         Nil -> () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
         Symbol pname :: SEXP s a
pname value :: SEXP s b
value internal :: SEXP s c
internal -> do
           (\hsc_ptr :: Ptr (HExp s a)
hsc_ptr -> Ptr (HExp s a) -> Int -> SEXP0 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr (HExp s a)
hsc_ptr 32) Ptr (HExp s a)
s (SEXP s a -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP s a
pname)
{-# LINE 380 "src/Language/R/HExp.hsc" #-}
           (\hsc_ptr :: Ptr (HExp s a)
hsc_ptr -> Ptr (HExp s a) -> Int -> SEXP0 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr (HExp s a)
hsc_ptr 40) Ptr (HExp s a)
s (SEXP s b -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP s b
value)
{-# LINE 381 "src/Language/R/HExp.hsc" #-}
           (\hsc_ptr :: Ptr (HExp s a)
hsc_ptr -> Ptr (HExp s a) -> Int -> SEXP0 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr (HExp s a)
hsc_ptr 48) Ptr (HExp s a)
s (SEXP s c -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP s c
internal)
{-# LINE 382 "src/Language/R/HExp.hsc" #-}
         List carval :: SEXP s a
carval cdrval :: SEXP s b
cdrval tagval :: SEXP s c
tagval -> do
           (\hsc_ptr :: Ptr (HExp s a)
hsc_ptr -> Ptr (HExp s a) -> Int -> SEXP0 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr (HExp s a)
hsc_ptr 32) Ptr (HExp s a)
s (SEXP s a -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP s a
carval)
{-# LINE 384 "src/Language/R/HExp.hsc" #-}
           (\hsc_ptr :: Ptr (HExp s a)
hsc_ptr -> Ptr (HExp s a) -> Int -> SEXP0 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr (HExp s a)
hsc_ptr 40) Ptr (HExp s a)
s (SEXP s b -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP s b
cdrval)
{-# LINE 385 "src/Language/R/HExp.hsc" #-}
           (\hsc_ptr :: Ptr (HExp s a)
hsc_ptr -> Ptr (HExp s a) -> Int -> SEXP0 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr (HExp s a)
hsc_ptr 48) Ptr (HExp s a)
s (SEXP s c -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP s c
tagval)
{-# LINE 386 "src/Language/R/HExp.hsc" #-}
         Env frame :: SEXP s a
frame enclos :: SEXP s b
enclos hashtab :: SEXP s c
hashtab -> do
           (\hsc_ptr :: Ptr (HExp s a)
hsc_ptr -> Ptr (HExp s a) -> Int -> SEXP0 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr (HExp s a)
hsc_ptr 32) Ptr (HExp s a)
s (SEXP s a -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP s a
frame)
{-# LINE 388 "src/Language/R/HExp.hsc" #-}
           (\hsc_ptr :: Ptr (HExp s a)
hsc_ptr -> Ptr (HExp s a) -> Int -> SEXP0 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr (HExp s a)
hsc_ptr 40) Ptr (HExp s a)
s (SEXP s b -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP s b
enclos)
{-# LINE 389 "src/Language/R/HExp.hsc" #-}
           (\hsc_ptr :: Ptr (HExp s a)
hsc_ptr -> Ptr (HExp s a) -> Int -> SEXP0 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr (HExp s a)
hsc_ptr 48) Ptr (HExp s a)
s (SEXP s c -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP s c
hashtab)
{-# LINE 390 "src/Language/R/HExp.hsc" #-}
         Closure formals :: SEXP s a
formals body :: SEXP s b
body env :: SEXP s 'Env
env -> do
           (\hsc_ptr :: Ptr (HExp s a)
hsc_ptr -> Ptr (HExp s a) -> Int -> SEXP0 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr (HExp s a)
hsc_ptr 32) Ptr (HExp s a)
s (SEXP s a -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP s a
formals)
{-# LINE 392 "src/Language/R/HExp.hsc" #-}
           (\hsc_ptr :: Ptr (HExp s a)
hsc_ptr -> Ptr (HExp s a) -> Int -> SEXP0 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr (HExp s a)
hsc_ptr 40) Ptr (HExp s a)
s (SEXP s b -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP s b
body)
{-# LINE 393 "src/Language/R/HExp.hsc" #-}
           (\hsc_ptr :: Ptr (HExp s a)
hsc_ptr -> Ptr (HExp s a) -> Int -> SEXP0 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr (HExp s a)
hsc_ptr 48) Ptr (HExp s a)
s (SEXP s 'Env -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP s 'Env
env)
{-# LINE 394 "src/Language/R/HExp.hsc" #-}
         Promise value :: SEXP s a
value expr :: SEXP s b
expr env :: SEXP s c
env -> do
           (\hsc_ptr :: Ptr (HExp s a)
hsc_ptr -> Ptr (HExp s a) -> Int -> SEXP0 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr (HExp s a)
hsc_ptr 32) Ptr (HExp s a)
s (SEXP s a -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP s a
value)
{-# LINE 396 "src/Language/R/HExp.hsc" #-}
           (\hsc_ptr :: Ptr (HExp s a)
hsc_ptr -> Ptr (HExp s a) -> Int -> SEXP0 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr (HExp s a)
hsc_ptr 40) Ptr (HExp s a)
s (SEXP s b -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP s b
expr)
{-# LINE 397 "src/Language/R/HExp.hsc" #-}
           (\hsc_ptr :: Ptr (HExp s a)
hsc_ptr -> Ptr (HExp s a) -> Int -> SEXP0 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr (HExp s a)
hsc_ptr 48) Ptr (HExp s a)
s (SEXP s c -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP s c
env)
{-# LINE 398 "src/Language/R/HExp.hsc" #-}
         Lang carval :: SEXP s a
carval cdrval :: SEXP s b
cdrval -> do
           (\hsc_ptr :: Ptr (HExp s a)
hsc_ptr -> Ptr (HExp s a) -> Int -> SEXP0 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr (HExp s a)
hsc_ptr 32) Ptr (HExp s a)
s (SEXP s a -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP s a
carval)
{-# LINE 400 "src/Language/R/HExp.hsc" #-}
           (\hsc_ptr :: Ptr (HExp s a)
hsc_ptr -> Ptr (HExp s a) -> Int -> SEXP0 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr (HExp s a)
hsc_ptr 40) Ptr (HExp s a)
s (SEXP s b -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP s b
cdrval)
{-# LINE 401 "src/Language/R/HExp.hsc" #-}
         Special offset :: Int32
offset -> do
           (\hsc_ptr :: Ptr (HExp s a)
hsc_ptr -> Ptr (HExp s a) -> Int -> CInt -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr (HExp s a)
hsc_ptr 32) Ptr (HExp s a)
s (Int32 -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
offset :: CInt)
{-# LINE 403 "src/Language/R/HExp.hsc" #-}
         Builtin offset :: Int32
offset -> do
           (\hsc_ptr :: Ptr (HExp s a)
hsc_ptr -> Ptr (HExp s a) -> Int -> CInt -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff Ptr (HExp s a)
hsc_ptr 32) Ptr (HExp s a)
s (Int32 -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int32
offset :: CInt)
{-# LINE 405 "src/Language/R/HExp.hsc" #-}
         Char _vc :: Vector 'Char Word8
_vc        -> String -> IO ()
forall a. String -> a
unimplemented "pokeHExp"
         Logical  _vt :: Vector 'Logical Logical
_vt    -> String -> IO ()
forall a. String -> a
unimplemented "pokeHExp"
         Int  _vt :: Vector 'Int Int32
_vt        -> String -> IO ()
forall a. String -> a
unimplemented "pokeHExp"
         Real _vt :: Vector 'Real Double
_vt        -> String -> IO ()
forall a. String -> a
unimplemented "pokeHExp"
         String _vt :: Vector 'String (SEXP V 'Char)
_vt      -> String -> IO ()
forall a. String -> a
unimplemented "pokeHExp"
         Complex _vt :: Vector 'Complex (Complex Double)
_vt     -> String -> IO ()
forall a. String -> a
unimplemented "pokeHExp"
         Vector _v :: Int32
_v _     -> String -> IO ()
forall a. String -> a
unimplemented "pokeHExp"
         Bytecode        -> String -> IO ()
forall a. String -> a
unimplemented "pokeHExp"
         ExtPtr _ _ _    -> String -> IO ()
forall a. String -> a
unimplemented "pokeHExp"
         WeakRef _ _ _ _ -> String -> IO ()
forall a. String -> a
unimplemented "pokeHExp"
         Raw     _       -> String -> IO ()
forall a. String -> a
unimplemented "pokeHExp"
         S4      _       -> String -> IO ()
forall a. String -> a
unimplemented "pokeHExp"
         DotDotDot _     -> String -> IO ()
forall a. String -> a
unimplemented "pokeHExp"
         Expr _ _        -> String -> IO ()
forall a. String -> a
unimplemented "pokeHExp"

-- | A view function projecting a view of 'SEXP' as an algebraic datatype, that
-- can be analyzed through pattern matching.
hexp :: SEXP s a -> HExp s a
hexp :: SEXP s a -> HExp s a
hexp = IO (HExp s a) -> HExp s a
forall a. IO a -> a
unsafeInlineIO (IO (HExp s a) -> HExp s a)
-> (SEXP s a -> IO (HExp s a)) -> SEXP s a -> HExp s a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ptr (HExp s a) -> IO (HExp s a)
forall a. Storable a => Ptr a -> IO a
peek (Ptr (HExp s a) -> IO (HExp s a))
-> (SEXP s a -> Ptr (HExp s a)) -> SEXP s a -> IO (HExp s a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SEXP s a -> Ptr (HExp s a)
forall s (a :: SEXPTYPE). SEXP s a -> Ptr (HExp s a)
R.unSEXP
{-# INLINE hexp #-}

-- | Inverse hexp view to the real structure, note that for scalar types
-- hexp will allocate new SEXP, and @unhexp . hexp@ is not an identity function.
-- however for vector types it will return original SEXP.
unhexp :: MonadR m => HExp (Region m) a -> m (SEXP (Region m) a)
unhexp :: HExp (Region m) a -> m (SEXP (Region m) a)
unhexp   Nil = SEXP (Region m) 'Nil -> m (SEXP (Region m) a)
forall (m :: * -> *) a. Monad m => a -> m a
return (SEXP (Region m) 'Nil -> m (SEXP (Region m) a))
-> SEXP (Region m) 'Nil -> m (SEXP (Region m) a)
forall a b. (a -> b) -> a -> b
$ SEXP G 'Nil -> SEXP (Region m) 'Nil
forall t s (a :: SEXPTYPE). (t <= s) => SEXP s a -> SEXP t a
R.release SEXP G 'Nil
H.nilValue
unhexp s :: HExp (Region m) a
s@(Symbol{}) = IO (SEXP (Region m) 'Symbol) -> m (SEXP (Region m) a)
forall (m :: * -> *) a. MonadR m => IO a -> m a
io (IO (SEXP (Region m) 'Symbol) -> m (SEXP (Region m) a))
-> IO (SEXP (Region m) 'Symbol) -> m (SEXP (Region m) a)
forall a b. (a -> b) -> a -> b
$
  IO (SEXP V 'Symbol)
-> (SEXP (Region m) 'Symbol -> IO (SEXP (Region m) 'Symbol))
-> IO (SEXP (Region m) 'Symbol)
forall (a :: SEXPTYPE) s b.
IO (SEXP V a) -> (SEXP s a -> IO b) -> IO b
withProtected (SSEXPTYPE 'Symbol -> IO (SEXP V 'Symbol)
forall (a :: SEXPTYPE). SSEXPTYPE a -> IO (SEXP V a)
R.allocSEXP SSEXPTYPE 'Symbol
R.SSymbol)
                (\x :: SEXP (Region m) 'Symbol
x -> Ptr (HExp (Region m) 'Symbol) -> HExp (Region m) 'Symbol -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (SEXP (Region m) 'Symbol -> Ptr (HExp (Region m) 'Symbol)
forall s (a :: SEXPTYPE). SEXP s a -> Ptr (HExp s a)
R.unSEXP SEXP (Region m) 'Symbol
x) HExp (Region m) a
HExp (Region m) 'Symbol
s IO ()
-> IO (SEXP (Region m) 'Symbol) -> IO (SEXP (Region m) 'Symbol)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> SEXP (Region m) 'Symbol -> IO (SEXP (Region m) 'Symbol)
forall (m :: * -> *) a. Monad m => a -> m a
return SEXP (Region m) 'Symbol
x)
unhexp (List carval :: SEXP (Region m) a
carval cdrval :: SEXP (Region m) b
cdrval tagval :: SEXP (Region m) c
tagval) = SEXP V 'List -> m (SEXP (Region m) 'List)
forall (m :: * -> *) s (a :: SEXPTYPE).
(MonadR m, s ~ V) =>
SEXP s a -> m (SEXP (Region m) a)
acquire (SEXP V 'List -> m (SEXP (Region m) 'List))
-> (IO (SEXP V 'List) -> m (SEXP V 'List))
-> IO (SEXP V 'List)
-> m (SEXP (Region m) 'List)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< IO (SEXP V 'List) -> m (SEXP V 'List)
forall (m :: * -> *) a. MonadR m => IO a -> m a
io (IO (SEXP V 'List) -> m (SEXP (Region m) a))
-> IO (SEXP V 'List) -> m (SEXP (Region m) a)
forall a b. (a -> b) -> a -> b
$ do
  SEXP G a
rc <- SEXP (Region m) a -> IO (SEXP G a)
forall s (a :: SEXPTYPE). SEXP s a -> IO (SEXP G a)
R.protect SEXP (Region m) a
carval
  SEXP G b
rd <- SEXP (Region m) b -> IO (SEXP G b)
forall s (a :: SEXPTYPE). SEXP s a -> IO (SEXP G a)
R.protect SEXP (Region m) b
cdrval
  SEXP G c
rt <- SEXP (Region m) c -> IO (SEXP G c)
forall s (a :: SEXPTYPE). SEXP s a -> IO (SEXP G a)
R.protect SEXP (Region m) c
tagval
  SEXP V 'List
z  <- SEXP G a -> SEXP G b -> IO (SEXP V 'List)
forall s (a :: SEXPTYPE) (b :: SEXPTYPE).
SEXP s a -> SEXP s b -> IO (SEXP V 'List)
R.cons SEXP G a
rc SEXP G b
rd
  (\hsc_ptr :: SEXP0
hsc_ptr -> SEXP0 -> Int -> SEXP0 -> IO ()
forall a b. Storable a => Ptr b -> Int -> a -> IO ()
pokeByteOff SEXP0
hsc_ptr 48) (SEXP V 'List -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP V 'List
z) (SEXP G c -> SEXP0
forall s (a :: SEXPTYPE). SEXP s a -> SEXP0
R.unsexp SEXP G c
rt)
{-# LINE 440 "src/Language/R/HExp.hsc" #-}
  R.unprotect 3
  SEXP V 'List -> IO (SEXP V 'List)
forall (m :: * -> *) a. Monad m => a -> m a
return SEXP V 'List
z
unhexp (Lang carval :: SEXP (Region m) a
carval cdrval :: SEXP (Region m) b
cdrval) = SEXP V 'Lang -> m (SEXP (Region m) 'Lang)
forall (m :: * -> *) s (a :: SEXPTYPE).
(MonadR m, s ~ V) =>
SEXP s a -> m (SEXP (Region m) a)
acquire (SEXP V 'Lang -> m (SEXP (Region m) 'Lang))
-> (IO (SEXP V 'Lang) -> m (SEXP V 'Lang))
-> IO (SEXP V 'Lang)
-> m (SEXP (Region m) 'Lang)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< IO (SEXP V 'Lang) -> m (SEXP V 'Lang)
forall (m :: * -> *) a. MonadR m => IO a -> m a
io (IO (SEXP V 'Lang) -> m (SEXP (Region m) a))
-> IO (SEXP V 'Lang) -> m (SEXP (Region m) a)
forall a b. (a -> b) -> a -> b
$ do
    SEXP G a
carval' <- SEXP (Region m) a -> IO (SEXP G a)
forall s (a :: SEXPTYPE). SEXP s a -> IO (SEXP G a)
R.protect SEXP (Region m) a
carval
    SEXP G b
cdrval' <- SEXP (Region m) b -> IO (SEXP G b)
forall s (a :: SEXPTYPE). SEXP s a -> IO (SEXP G a)
R.protect SEXP (Region m) b
cdrval
    SEXP V 'Lang
x <- SSEXPTYPE 'Lang -> IO (SEXP V 'Lang)
forall (a :: SEXPTYPE). SSEXPTYPE a -> IO (SEXP V a)
R.allocSEXP SSEXPTYPE 'Lang
R.SLang
    SEXP V 'Lang -> SEXP V a -> IO ()
forall s (a :: SEXPTYPE) (b :: SEXPTYPE).
SEXP s a -> SEXP s b -> IO ()
R.setCar SEXP V 'Lang
x (SEXP G a -> SEXP V a
forall t s (a :: SEXPTYPE). (t <= s) => SEXP s a -> SEXP t a
R.release SEXP G a
carval')
    SEXP V 'Lang -> SEXP V b -> IO ()
forall s (a :: SEXPTYPE) (b :: SEXPTYPE).
SEXP s a -> SEXP s b -> IO ()
R.setCdr SEXP V 'Lang
x (SEXP G b -> SEXP V b
forall t s (a :: SEXPTYPE). (t <= s) => SEXP s a -> SEXP t a
R.release SEXP G b
cdrval')
    Int -> IO ()
R.unprotect 2
    SEXP V 'Lang -> IO (SEXP V 'Lang)
forall (m :: * -> *) a. Monad m => a -> m a
return SEXP V 'Lang
x
unhexp s :: HExp (Region m) a
s@(Env{})     = IO (SEXP (Region m) 'Env) -> m (SEXP (Region m) a)
forall (m :: * -> *) a. MonadR m => IO a -> m a
io (IO (SEXP (Region m) 'Env) -> m (SEXP (Region m) a))
-> IO (SEXP (Region m) 'Env) -> m (SEXP (Region m) a)
forall a b. (a -> b) -> a -> b
$
    IO (SEXP V 'Env)
-> (SEXP (Region m) 'Env -> IO (SEXP (Region m) 'Env))
-> IO (SEXP (Region m) 'Env)
forall (a :: SEXPTYPE) s b.
IO (SEXP V a) -> (SEXP s a -> IO b) -> IO b
withProtected (SSEXPTYPE 'Env -> IO (SEXP V 'Env)
forall (a :: SEXPTYPE). SSEXPTYPE a -> IO (SEXP V a)
R.allocSEXP SSEXPTYPE 'Env
R.SEnv)
                  (\x :: SEXP (Region m) 'Env
x -> Ptr (HExp (Region m) 'Env) -> HExp (Region m) 'Env -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (SEXP (Region m) 'Env -> Ptr (HExp (Region m) 'Env)
forall s (a :: SEXPTYPE). SEXP s a -> Ptr (HExp s a)
R.unSEXP SEXP (Region m) 'Env
x) HExp (Region m) a
HExp (Region m) 'Env
s IO () -> IO (SEXP (Region m) 'Env) -> IO (SEXP (Region m) 'Env)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> SEXP (Region m) 'Env -> IO (SEXP (Region m) 'Env)
forall (m :: * -> *) a. Monad m => a -> m a
return SEXP (Region m) 'Env
x)
unhexp s :: HExp (Region m) a
s@(Closure{}) = IO (SEXP (Region m) 'Closure) -> m (SEXP (Region m) a)
forall (m :: * -> *) a. MonadR m => IO a -> m a
io (IO (SEXP (Region m) 'Closure) -> m (SEXP (Region m) a))
-> IO (SEXP (Region m) 'Closure) -> m (SEXP (Region m) a)
forall a b. (a -> b) -> a -> b
$
    IO (SEXP V 'Closure)
-> (SEXP (Region m) 'Closure -> IO (SEXP (Region m) 'Closure))
-> IO (SEXP (Region m) 'Closure)
forall (a :: SEXPTYPE) s b.
IO (SEXP V a) -> (SEXP s a -> IO b) -> IO b
withProtected (SSEXPTYPE 'Closure -> IO (SEXP V 'Closure)
forall (a :: SEXPTYPE). SSEXPTYPE a -> IO (SEXP V a)
R.allocSEXP SSEXPTYPE 'Closure
R.SClosure)
                  (\x :: SEXP (Region m) 'Closure
x -> Ptr (HExp (Region m) 'Closure) -> HExp (Region m) 'Closure -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (SEXP (Region m) 'Closure -> Ptr (HExp (Region m) 'Closure)
forall s (a :: SEXPTYPE). SEXP s a -> Ptr (HExp s a)
R.unSEXP SEXP (Region m) 'Closure
x) HExp (Region m) a
HExp (Region m) 'Closure
s IO ()
-> IO (SEXP (Region m) 'Closure) -> IO (SEXP (Region m) 'Closure)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> SEXP (Region m) 'Closure -> IO (SEXP (Region m) 'Closure)
forall (m :: * -> *) a. Monad m => a -> m a
return SEXP (Region m) 'Closure
x)
unhexp s :: HExp (Region m) a
s@(Special{}) = IO (SEXP (Region m) 'Special) -> m (SEXP (Region m) a)
forall (m :: * -> *) a. MonadR m => IO a -> m a
io (IO (SEXP (Region m) 'Special) -> m (SEXP (Region m) a))
-> IO (SEXP (Region m) 'Special) -> m (SEXP (Region m) a)
forall a b. (a -> b) -> a -> b
$
    IO (SEXP V 'Special)
-> (SEXP (Region m) 'Special -> IO (SEXP (Region m) 'Special))
-> IO (SEXP (Region m) 'Special)
forall (a :: SEXPTYPE) s b.
IO (SEXP V a) -> (SEXP s a -> IO b) -> IO b
withProtected (SSEXPTYPE 'Special -> IO (SEXP V 'Special)
forall (a :: SEXPTYPE). SSEXPTYPE a -> IO (SEXP V a)
R.allocSEXP SSEXPTYPE 'Special
R.SSpecial)
                  (\x :: SEXP (Region m) 'Special
x -> Ptr (HExp (Region m) 'Special) -> HExp (Region m) 'Special -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (SEXP (Region m) 'Special -> Ptr (HExp (Region m) 'Special)
forall s (a :: SEXPTYPE). SEXP s a -> Ptr (HExp s a)
R.unSEXP SEXP (Region m) 'Special
x) HExp (Region m) a
HExp (Region m) 'Special
s IO ()
-> IO (SEXP (Region m) 'Special) -> IO (SEXP (Region m) 'Special)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> SEXP (Region m) 'Special -> IO (SEXP (Region m) 'Special)
forall (m :: * -> *) a. Monad m => a -> m a
return SEXP (Region m) 'Special
x)
unhexp s :: HExp (Region m) a
s@(Builtin{}) = IO (SEXP (Region m) 'Builtin) -> m (SEXP (Region m) a)
forall (m :: * -> *) a. MonadR m => IO a -> m a
io (IO (SEXP (Region m) 'Builtin) -> m (SEXP (Region m) a))
-> IO (SEXP (Region m) 'Builtin) -> m (SEXP (Region m) a)
forall a b. (a -> b) -> a -> b
$
    IO (SEXP V 'Builtin)
-> (SEXP (Region m) 'Builtin -> IO (SEXP (Region m) 'Builtin))
-> IO (SEXP (Region m) 'Builtin)
forall (a :: SEXPTYPE) s b.
IO (SEXP V a) -> (SEXP s a -> IO b) -> IO b
withProtected (SSEXPTYPE 'Builtin -> IO (SEXP V 'Builtin)
forall (a :: SEXPTYPE). SSEXPTYPE a -> IO (SEXP V a)
R.allocSEXP SSEXPTYPE 'Builtin
R.SBuiltin)
                  (\x :: SEXP (Region m) 'Builtin
x -> Ptr (HExp (Region m) 'Builtin) -> HExp (Region m) 'Builtin -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (SEXP (Region m) 'Builtin -> Ptr (HExp (Region m) 'Builtin)
forall s (a :: SEXPTYPE). SEXP s a -> Ptr (HExp s a)
R.unSEXP SEXP (Region m) 'Builtin
x) HExp (Region m) a
HExp (Region m) 'Builtin
s IO ()
-> IO (SEXP (Region m) 'Builtin) -> IO (SEXP (Region m) 'Builtin)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> SEXP (Region m) 'Builtin -> IO (SEXP (Region m) 'Builtin)
forall (m :: * -> *) a. Monad m => a -> m a
return SEXP (Region m) 'Builtin
x)
unhexp s :: HExp (Region m) a
s@(Promise{}) = IO (SEXP (Region m) 'Promise) -> m (SEXP (Region m) a)
forall (m :: * -> *) a. MonadR m => IO a -> m a
io (IO (SEXP (Region m) 'Promise) -> m (SEXP (Region m) a))
-> IO (SEXP (Region m) 'Promise) -> m (SEXP (Region m) a)
forall a b. (a -> b) -> a -> b
$
    IO (SEXP V 'Promise)
-> (SEXP (Region m) 'Promise -> IO (SEXP (Region m) 'Promise))
-> IO (SEXP (Region m) 'Promise)
forall (a :: SEXPTYPE) s b.
IO (SEXP V a) -> (SEXP s a -> IO b) -> IO b
withProtected (SSEXPTYPE 'Promise -> IO (SEXP V 'Promise)
forall (a :: SEXPTYPE). SSEXPTYPE a -> IO (SEXP V a)
R.allocSEXP SSEXPTYPE 'Promise
R.SPromise)
                  (\x :: SEXP (Region m) 'Promise
x -> Ptr (HExp (Region m) 'Promise) -> HExp (Region m) 'Promise -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (SEXP (Region m) 'Promise -> Ptr (HExp (Region m) 'Promise)
forall s (a :: SEXPTYPE). SEXP s a -> Ptr (HExp s a)
R.unSEXP SEXP (Region m) 'Promise
x) HExp (Region m) a
HExp (Region m) 'Promise
s IO ()
-> IO (SEXP (Region m) 'Promise) -> IO (SEXP (Region m) 'Promise)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> SEXP (Region m) 'Promise -> IO (SEXP (Region m) 'Promise)
forall (m :: * -> *) a. Monad m => a -> m a
return SEXP (Region m) 'Promise
x)
unhexp  (Bytecode{}) = String -> m (SEXP (Region m) 'Bytecode)
forall a. String -> a
unimplemented "unhexp"
unhexp (Real vt :: Vector 'Real Double
vt)     = SEXP (Region m) 'Real -> m (SEXP (Region m) a)
forall (m :: * -> *) a. Monad m => a -> m a
return (SEXP (Region m) 'Real -> m (SEXP (Region m) a))
-> SEXP (Region m) 'Real -> m (SEXP (Region m) a)
forall a b. (a -> b) -> a -> b
$ Vector 'Real Double -> SEXP (Region m) 'Real
forall (ty :: SEXPTYPE) a s.
SVECTOR ty a =>
Vector ty a -> SEXP s ty
Vector.unsafeToSEXP Vector 'Real Double
vt
unhexp (Logical vt :: Vector 'Logical Logical
vt)  = SEXP (Region m) 'Logical -> m (SEXP (Region m) a)
forall (m :: * -> *) a. Monad m => a -> m a
return (SEXP (Region m) 'Logical -> m (SEXP (Region m) a))
-> SEXP (Region m) 'Logical -> m (SEXP (Region m) a)
forall a b. (a -> b) -> a -> b
$ Vector 'Logical Logical -> SEXP (Region m) 'Logical
forall (ty :: SEXPTYPE) a s.
SVECTOR ty a =>
Vector ty a -> SEXP s ty
Vector.unsafeToSEXP Vector 'Logical Logical
vt
unhexp (Int vt :: Vector 'Int Int32
vt)      = SEXP (Region m) 'Int -> m (SEXP (Region m) a)
forall (m :: * -> *) a. Monad m => a -> m a
return (SEXP (Region m) 'Int -> m (SEXP (Region m) a))
-> SEXP (Region m) 'Int -> m (SEXP (Region m) a)
forall a b. (a -> b) -> a -> b
$ Vector 'Int Int32 -> SEXP (Region m) 'Int
forall (ty :: SEXPTYPE) a s.
SVECTOR ty a =>
Vector ty a -> SEXP s ty
Vector.unsafeToSEXP Vector 'Int Int32
vt
unhexp (Complex vt :: Vector 'Complex (Complex Double)
vt)  = SEXP (Region m) 'Complex -> m (SEXP (Region m) a)
forall (m :: * -> *) a. Monad m => a -> m a
return (SEXP (Region m) 'Complex -> m (SEXP (Region m) a))
-> SEXP (Region m) 'Complex -> m (SEXP (Region m) a)
forall a b. (a -> b) -> a -> b
$ Vector 'Complex (Complex Double) -> SEXP (Region m) 'Complex
forall (ty :: SEXPTYPE) a s.
SVECTOR ty a =>
Vector ty a -> SEXP s ty
Vector.unsafeToSEXP Vector 'Complex (Complex Double)
vt
unhexp (Vector _ vt :: Vector 'Vector (SomeSEXP V)
vt) = SEXP (Region m) 'Vector -> m (SEXP (Region m) a)
forall (m :: * -> *) a. Monad m => a -> m a
return (SEXP (Region m) 'Vector -> m (SEXP (Region m) a))
-> SEXP (Region m) 'Vector -> m (SEXP (Region m) a)
forall a b. (a -> b) -> a -> b
$ Vector 'Vector (SomeSEXP V) -> SEXP (Region m) 'Vector
forall (ty :: SEXPTYPE) a s.
SVECTOR ty a =>
Vector ty a -> SEXP s ty
Vector.unsafeToSEXP Vector 'Vector (SomeSEXP V)
vt
unhexp (Char vt :: Vector 'Char Word8
vt)     = SEXP (Region m) 'Char -> m (SEXP (Region m) a)
forall (m :: * -> *) a. Monad m => a -> m a
return (SEXP (Region m) 'Char -> m (SEXP (Region m) a))
-> SEXP (Region m) 'Char -> m (SEXP (Region m) a)
forall a b. (a -> b) -> a -> b
$ Vector 'Char Word8 -> SEXP (Region m) 'Char
forall (ty :: SEXPTYPE) a s.
SVECTOR ty a =>
Vector ty a -> SEXP s ty
Vector.unsafeToSEXP Vector 'Char Word8
vt
unhexp (String vt :: Vector 'String (SEXP V 'Char)
vt)   = SEXP (Region m) 'String -> m (SEXP (Region m) a)
forall (m :: * -> *) a. Monad m => a -> m a
return (SEXP (Region m) 'String -> m (SEXP (Region m) a))
-> SEXP (Region m) 'String -> m (SEXP (Region m) a)
forall a b. (a -> b) -> a -> b
$ Vector 'String (SEXP V 'Char) -> SEXP (Region m) 'String
forall (ty :: SEXPTYPE) a s.
SVECTOR ty a =>
Vector ty a -> SEXP s ty
Vector.unsafeToSEXP Vector 'String (SEXP V 'Char)
vt
unhexp (Raw vt :: Vector 'Raw Word8
vt)      = SEXP (Region m) 'Raw -> m (SEXP (Region m) a)
forall (m :: * -> *) a. Monad m => a -> m a
return (SEXP (Region m) 'Raw -> m (SEXP (Region m) a))
-> SEXP (Region m) 'Raw -> m (SEXP (Region m) a)
forall a b. (a -> b) -> a -> b
$ Vector 'Raw Word8 -> SEXP (Region m) 'Raw
forall (ty :: SEXPTYPE) a s.
SVECTOR ty a =>
Vector ty a -> SEXP s ty
Vector.unsafeToSEXP Vector 'Raw Word8
vt
unhexp S4{}          = String -> m (SEXP (Region m) 'S4)
forall a. String -> a
unimplemented "unhexp"
unhexp (Expr _ vt :: Vector 'Expr (SomeSEXP V)
vt)   = SEXP (Region m) 'Expr -> m (SEXP (Region m) a)
forall (m :: * -> *) a. Monad m => a -> m a
return (SEXP (Region m) 'Expr -> m (SEXP (Region m) a))
-> SEXP (Region m) 'Expr -> m (SEXP (Region m) a)
forall a b. (a -> b) -> a -> b
$ Vector 'Expr (SomeSEXP V) -> SEXP (Region m) 'Expr
forall (ty :: SEXPTYPE) a s.
SVECTOR ty a =>
Vector ty a -> SEXP s ty
Vector.unsafeToSEXP Vector 'Expr (SomeSEXP V)
vt
unhexp WeakRef{}     = String -> m (SEXP (Region m) 'WeakRef)
forall a. HasCallStack => String -> a
error "unhexp does not support WeakRef, use Foreign.R.mkWeakRef instead."
unhexp DotDotDot{}   = String -> m (SEXP (Region m) 'List)
forall a. String -> a
unimplemented "unhexp"
unhexp ExtPtr{}      = String -> m (SEXP (Region m) 'ExtPtr)
forall a. String -> a
unimplemented "unhexp"

-- | Project the vector out of 'SEXP's.
vector :: R.IsVector a => SEXP s a -> Vector.Vector a (Vector.ElemRep V a)
vector :: SEXP s a -> Vector a (ElemRep V a)
vector (SEXP s a -> HExp s a
forall s (a :: SEXPTYPE). SEXP s a -> HExp s a
hexp -> Char vec :: Vector 'Char Word8
vec)     = Vector a (ElemRep V a)
Vector 'Char Word8
vec
vector (SEXP s a -> HExp s a
forall s (a :: SEXPTYPE). SEXP s a -> HExp s a
hexp -> Logical vec :: Vector 'Logical Logical
vec)  = Vector a (ElemRep V a)
Vector 'Logical Logical
vec
vector (SEXP s a -> HExp s a
forall s (a :: SEXPTYPE). SEXP s a -> HExp s a
hexp -> Int vec :: Vector 'Int Int32
vec)      = Vector a (ElemRep V a)
Vector 'Int Int32
vec
vector (SEXP s a -> HExp s a
forall s (a :: SEXPTYPE). SEXP s a -> HExp s a
hexp -> Real vec :: Vector 'Real Double
vec)     = Vector a (ElemRep V a)
Vector 'Real Double
vec
vector (SEXP s a -> HExp s a
forall s (a :: SEXPTYPE). SEXP s a -> HExp s a
hexp -> Complex vec :: Vector 'Complex (Complex Double)
vec)  = Vector a (ElemRep V a)
Vector 'Complex (Complex Double)
vec
vector (SEXP s a -> HExp s a
forall s (a :: SEXPTYPE). SEXP s a -> HExp s a
hexp -> String vec :: Vector 'String (SEXP V 'Char)
vec)   = Vector a (ElemRep V a)
Vector 'String (SEXP V 'Char)
vec
vector (SEXP s a -> HExp s a
forall s (a :: SEXPTYPE). SEXP s a -> HExp s a
hexp -> Vector _ vec :: Vector 'Vector (SomeSEXP V)
vec) = Vector a (ElemRep V a)
Vector 'Vector (SomeSEXP V)
vec
vector (SEXP s a -> HExp s a
forall s (a :: SEXPTYPE). SEXP s a -> HExp s a
hexp -> Expr _ vec :: Vector 'Expr (SomeSEXP V)
vec)   = Vector a (ElemRep V a)
Vector 'Expr (SomeSEXP V)
vec
vector s :: SEXP s a
s = String -> String -> Vector a (ElemRep V a)
forall a. String -> String -> a
violation "vector" (String -> Vector a (ElemRep V a))
-> String -> Vector a (ElemRep V a)
forall a b. (a -> b) -> a -> b
$ SEXPTYPE -> String
forall a. Show a => a -> String
show (SEXP s a -> SEXPTYPE
forall s (a :: SEXPTYPE). SEXP s a -> SEXPTYPE
R.typeOf SEXP s a
s) String -> String -> String
forall a. [a] -> [a] -> [a]
++ " unexpected vector type."