h&䚽      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                   !(C) 2013 Amgen, Inc. Safe-Inferredinline-rA partial order on regions. In fact regions form a lattice, with  being the supremum and  the infimum.inline-rConvenient shorthand.inline-rConvenient shorthand.inline-rVoid is not a region. It is a placeholder marking the absence of region. Useful to tag objects that belong to no region at all.inline-rThe global region is a special region whose scope extends all the way to the end of the program. As such, any object allocated within this region lives "forever". In this sense, it is the top-level region, whose scope includes all other regions.(C) 2013 Amgen, Inc. Safe-Inferred(Hinline-r Initialize R. Safe-Inferredinline-rContent encoding.  (C) 2013 Amgen, Inc. Safe-Inferred6(C) 2015 Tweag I/O Limited. Safe-Inferred%&inline-rR input handler chain. Each input handler points to the next. This view of input handlers is shallow, in the sense that the  instance only unmarshalls the first element in the chain at any one time. A shallow view allows  and  to be inlinable.inline-rThe input handler callback.inline-r"Undocumented and currently unused.inline-r7Whether this input handler is activated or deactivated.inline-r2The file descriptor ahssociated with this handler.inline-r5Callbacks can optionally be passed in arbitrary data.inline-r$The next input handler in the chain. inline-r#Input handlers used in event loops.!inline-r R_wait_usec global variable."inline-rR_PolledEvents global variable.#inline-r R_wait_usec global variable.$inline-rR_PolledEvents global variable.%inline-rCreate and register a new . The given file descriptor should be open in non-blocking read mode. Make sure to dispose of the callback using freeHaskellFunPtr after calling & where appropriate.&inline-r=Remove an input handler from an input handler chain. Returns + if the handler was successfully removed,  otherwise. !"#$%& $#"!%&(C) 2013 Amgen, Inc. Safe-Inferred6inline-r User error.inline-r6An internal invariant has been violated. That's a bug.inline-rA violation that should have been made impossible by the type system was not.inline-rFeature not yet implemented.inline-r Function nameinline-r Error messageinline-r Function nameinline-r Error messageinline-r Function name2018 (C) Tweag I/O Limited. Safe-Inferred "iHinline-rR uses three-valued logic. HIJKLMNOP POLMNHIJK(C) 2013 Amgen, Inc. Safe-Inferred)*/1>*inline-rR "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 *-, and so does the value of this expression, 2 , have type * . 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._inline-rConstraint synonym grouping all expression forms into one class. According to R internals, an expression is usually a 1 , but can sometimes also be an = or a ,.`inline-r IsPairList a holds iff R's  is.pairlist() returns TRUE.ainline-rIsList a holds iff R's  is.list() returns TRUE.binline-rNon-atomic vector forms. See  src/main/memory.c:SET_VECTOR_ELT in the R source distribution.cinline-r=Constraint synonym grouping all vector forms into one class.  IsVector a holds iff R's  is.vector() returns TRUE.dinline-rUsed where the R documentation speaks of "pairlists", which are really just regular lists.*46,E9;7+8/<2C-51.03:=>?@ABDHIJK_`abcdeowfghijklmnpqrstuvxyz{|}~*46,E9;7+8/<2C-51.03:=>?@ABDeowfghijklmnpqrstuvxyz{|}~HIJKdcba`_(C) 2013 Amgen, Inc. Safe-Inferred/01 uFinline-rNon unicode wrapper for the G type family.Ginline-rThe predicate a :D as states that a is a member type of the set as.FGGFG1 (C) 2013 Amgen, Inc.None (/1*!inline-r(Info header for the SEXP data structure.inline-rType of the SEXP.inline-r)Is this an object with a class attribute.inline-rControl copying information.inline-rGeneral purpose data.inline-rMark object as 'in use' in GC.inline-r Debug marker.inline-r Trace marker.inline-rAlignment (not in use).inline-rA  of unknown form.inline-rThe basic type of all R expressions, classified by the form of the expression, and the memory region in which it has been allocated.inline-r5Flag that shows if computation should be interrupted.inline-rSignal handler switchinline-rGlobal environment.inline-rThe empty environment.inline-rThe base environment.inline-rMissing argument marker. Constant throughout the lifetime of the R instance.inline-rUnbound marker. Constant throughout the lifetime of the R instance.inline-rGlobal nil value. Constant throughout the lifetime of the R instance.inline-r Add a type index to the pointer.inline-r'Remove the type index from the pointer.inline-rLike  but for .inline-rRelease object into another region. Releasing is safe so long as the target region is "smaller" than the source region, in the sense of .inline-rDeconstruct a . Takes a continuation since otherwise the existentially quantified variable hidden inside  would escape.inline-r6Return the "type" tag (aka the form tag) of the given . This function is pure because the type of an object does not normally change over the lifetime of the object.inline-rCast the type of a  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.inline-r;Cast form of first argument to that of the second argument.inline-rUnsafe 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 , it has no runtime cost since it does not introduce any dynamic check at runtime.inline-r"Extract the header from the given .inline-r Check if object is an S4 object.>This is a function call so it will be more precise than using .inline-r-Get the attribute list from the given object.inline-r"Get attribute with the given name.inline-rSet the attribute list.inline-rValueinline-rAttribute name99 (C) 2013 Amgen, Inc. Safe-Inferred(/01682inline-rread CAR object valueinline-r Set the CAR value and return it.inline-rread CDR objectinline-r Set the CDR value and return it.inline-rread object`s Taginline-rEnclosing environment.inline-rHash table associated with the environment, used for faster name lookups.inline-r+Closure formals (aka the actual arguments).inline-rThe code of the closure.inline-rThe environment of the closure.inline-rThe code of a promise.inline-r1The environment in which to evaluate the promise.inline-r8The value of the promise, if it has already been forced.inline-rLength of the vector.inline-rRead True Length vector field.inline-rRead character vector datainline-rRead real vector data.inline-rRead integer vector data.inline-rRead raw data.inline-rRead logical vector data.inline-rRead complex vector data.inline-rRead string vector data.inline-r'Extract the data pointer from a vector.inline-rRead a name from symbol.inline-rRead value from symbol.inline-r Read internal value from symbol.inline-rInitialize a new string vector.inline-r1Initialize a new character vector (aka a string).inline-r.Create Character value with specified encodinginline-rIntern a string name into the symbol table.If name is not found, it is added to the symbol table. The symbol corresponding to the string name is returned.inline-r Allocate a .inline-rAllocate a pairlist of s, chained together.inline-rAllocate Vector.inline-r5Allocate a so-called cons cell, in essence a pair of  pointers.inline-rAllocate a so-called cons cell of language objects, in essence a pair of  pointers.inline-r Protect a  from being garbage collected by R. It is in particular necessary to do so for objects that are not yet pointed by any other object, e.g. when constructing a tree bottom-up rather than top-down.To avoid unbalancing calls to  and /, do not use these functions directly but use  instead.inline-r unprotect n unprotects the last n objects that were protected.inline-r4Unprotect a specific object, referred to by pointer.inline-r$Invoke an R garbage collector sweep.inline-rPreserve an object accross GCs.inline-r'Allow GC to remove an preserved object.inline-r Evaluate any  to its value.inline-rTry to evaluate expression.inline-rTry to evaluate without printing error/warning messages to stdout.inline-r"Construct a nullary function call.inline-rConstruct unary function call.inline-r!Construct a binary function call.inline-rFind a function by name.inline-rFind a variable by name.inline-rPerform an action with resource while protecting it from the garbage collection. This function is a safer alternative to  ! and  ", guaranteeing that a protected resource gets unprotected irrespective of the control flow, much like #$. *DBA@?>=:30.15-C2 if n == 0 then Nothing else Just (n,n-1)) 10 = <10,9,8,7,6,5,4,3,2,1>inline-rO(n)! Construct a vector with at most n by repeatedly applying the generator function to the a seed. The generator function yields Just' the next element and the new seed or Nothing if there are no more elements. -unfoldrN 3 (\n -> Just (n,n-1)) 10 = <10,9,8>inline-rO(n) Construct a vector with n elements by repeatedly applying the generator function to the already constructed part of the vector. constructN 3 f = let a = f <> ; b = f ; c = f in f inline-rO(n) Construct a vector with n elements from right to left by repeatedly applying the generator function to the already constructed part of the vector. constructrN 3 f = let a = f <> ; b = f ; c = f in f inline-rO(n): Yield a vector of the given length containing the values x, x+15 etc. This operation is usually more efficient than . enumFromN 5 3 = <5,6,7>inline-rO(n): Yield a vector of the given length containing the values x, x+y, x+y+y5 etc. This operations is usually more efficient than . +enumFromStepN 1 0.1 5 = <1,1.1,1.2,1.3,1.4>inline-rO(n) Enumerate values from x to y.WARNING: This operation can be very inefficient. If at all possible, use  instead.inline-rO(n) Enumerate values from x to y with a specific step z.WARNING: This operation can be very inefficient. If at all possible, use  instead.inline-rO(n) Prepend an elementinline-rO(n) Append an elementinline-rO(m+n) Concatenate two vectorsinline-rO(n)$ Concatenate all vectors in the listinline-rO(n) Execute the monadic action the given number of times and store the results in a vector.inline-rO(n) Construct a vector of the given length by applying the monadic action to each indexinline-r;Execute the monadic action and freeze the resulting vector. create (do { v <- new 2; write v 0 'a'; write v 1 'b'; return v }) = <a,b> inline-rO(n) Yield the argument but force it not to retain any extra memory, possibly by copying it.This is especially useful when dealing with slices. For example: force (slice 0 2 )Here, the slice retains a reference to the huge vector. Forcing it creates a copy of just the elements that belong to the slice and allows the huge vector to be garbage collected.inline-rO(m+n) For each pair (i,a)8 from the list, replace the vector element at position i by a. ,<5,9,2,7> // [(2,1),(0,3),(2,8)] = <3,9,8,7>inline-r Same as () but without bounds checking.inline-rO(m+n) For each pair (i,b), from the list, replace the vector element a at position i by f a b. ?accum (+) <5,9,2> [(2,4),(1,6),(0,3),(1,7)] = <5+3, 9+6+7, 2+4>inline-rSame as  but without bounds checking.inline-rO(n) Reverse a vectorinline-rO(n) Map a function over a vectorinline-rO(n)? Apply a function to every element of a Vector ty and its indexinline-r Monadic fold with strict accumulator that discards the resultinline-rO(n) Monadic fold over non-empty vectors with strict accumulator that discards the resultinline-rO(n) Prescan prescanl f z =  .  f z  Example: $prescanl (+) 0 <1,2,3,4> = <0,1,3,6>inline-rO(n) Prescan with strict accumulatorinline-rO(n) Scan postscanl f z =  .  f z  Example: &postscanl (+) 0 <1,2,3,4> = <1,3,6,10>inline-rO(n) Scan with strict accumulatorinline-rO(n) Haskell-style scan scanl f z = where y1 = z yi = f y(i-1) x(i-1) Example: $scanl (+) 0 <1,2,3,4> = <0,1,3,6,10>inline-rO(n)+ Haskell-style scan with strict accumulatorinline-rO(n) Scan over a non-empty vector scanl f = where y1 = x1 yi = f y(i-1) xiinline-rO(n)7 Scan over a non-empty vector with a strict accumulatorinline-rO(n) Right-to-left prescan prescanr f z =  .  (flip f) z .  inline-rO(n). Right-to-left prescan with strict accumulatorinline-rO(n) Right-to-left scaninline-rO(n)+ Right-to-left scan with strict accumulatorinline-rO(n)! Right-to-left Haskell-style scaninline-rO(n)9 Right-to-left Haskell-style scan with strict accumulatorinline-rO(n)+ Right-to-left scan over a non-empty vectorinline-rO(n) Right-to-left scan over a non-empty vector with a strict accumulatorinline-rO(n) Convert a vector to a listinline-rO(n) Convert a list to a vectorinline-rO(n) Convert the first n elements of a list to a vector fromListN n xs =  ( n xs) inline-rO(1) Unsafe convert a mutable vector to an immutable one with copying. The mutable vector may not be used after this operation.inline-rO(1) Unsafely convert an immutable vector to a mutable one with copying. The immutable vector may not be used after this operation.inline-rO(n). Yield a mutable copy of the immutable vector.inline-rO(n)/ Yield an immutable copy of the mutable vector.inline-rO(n) Copy an immutable vector into a mutable one. The two vectors must have the same length. This is not checked.inline-rO(n) Copy an immutable vector into a mutable one. The two vectors must have the same length.inline-ri starting indexinline-rn lengthinline-ri starting indexinline-rn lengthinline-rinitial vector (of length m)inline-r%list of index/value pairs (of length n)inline-raccumulating function finline-rinitial vector (of length m)inline-r%list of index/value pairs (of length n)544(C) 2013 Amgen, Inc. Safe-Inferredinline-rDeclare 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.inline-r for .(C) 2013 Amgen, Inc. Safe-Inferred1inline-rStores R variables in a static location. This makes the variables' addresses accesible after reloading in GHCi.inline-rSpecial value to which all symbols unbound in the current environment resolve to.inline-rR's NULL value.inline-rValue substituted for all missing actual arguments of a function call.inline-rThe base environment.inline-rThe empty environment.inline-rThe global environment.  (C) 2015 Tweag I/O Limited. Safe-Inferred%&qinline-r+Iterate over each input handler in a chain.inline-r Variant of  that throws away the result.inline-rRegister all R input handlers with the given event manager. Set an alarm to process polled events if  R_wait_usec is non-zero. Returns keys useful for unregistering input handlers.inline-rProcess events in a loop. Uses a new GHC event manager under the hood. This function should be called from the main thread. It never returns.Currently unimplemented.inline-r#Process events in a loop. Uses R's select() mechanism under the hood. This function should be called from the main thread. It never returns.inline-rManually trigger processing all pending events. Useful when at an interactive prompt and no event loop is running.(C) 2013 Amgen, Inc. Safe-Inferred()*/01inline-r.Wrapper for partially applying a type synonym.inline-rA view of R's internal  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).See  https://cran.r-project.org/doc/manuals/r-release/R-ints.html#SEXPTYPEs.inline-rThe NULL value (NILSXP).inline-r A symbol (SYMSXP).inline-rA list (LISTSXP).inline-rAn environment (ENVSXP).inline-r A closure (CLOSXP).inline-r A promise (PROMSXP).inline-rLanguage objects (LANGSXP) are calls (including formulae and so on). Internally they are pairlists with first element a reference to the function to be called with remaining elements the actual arguments for the call (and with the tags if present giving the specified argument names). Although this is not enforced, many places in the R code assume that the pairlist is of length one or more, often without checking.inline-r$A special (built-in) function call ( SPECIALSXP). It carries an offset into the table of primitives but for our purposes is opaque.inline-rA  BUILTINSXP. This is similar to , except the arguments to a  are always evaluated.inline-rAn internal character string (CHARSXP).inline-rA logical vector (LGLSXP).inline-rAn integer vector (INTSXP).inline-rA numeric vector (REALSXP).inline-rA complex vector (CPLXSXP).inline-rA character vector (STRSXP).inline-rA special type of LISTSXP for the value bound to a ... symbolinline-rA list/generic vector (VECSXP).inline-rAn expression vector (EXPRSXP).inline-r%A @byte-code@ object generated by R (BCODESXP).inline-rAn external pointer ( EXTPTRSXP)inline-rA weak reference ( WEAKREFSXP).inline-rA raw vector (RAWSXP).inline-rAn S4 class which does not consist solely of a simple type such as an atomic vector or function (S4SXP).inline-rHeterogeneous equality.inline-r%A view function projecting a view of  as an algebraic datatype, that can be analyzed through pattern matching.inline-rProject the vector out of s. inline-r the name (is  for ())inline-r0the value. Many symbols have their value set to ().inline-r'internal: if the symbol's value is a  .Internal1 function, this is a pointer to the appropriate .inline-rCARinline-rCDR (usually a  or )inline-rTAG (a  or )inline-rthe frame: a tagged pairlist with tag the symbol and CAR the bound valueinline-rthe enclosing environmentinline-rthe hash tableinline-rformals (a pairlist)inline-rthe bodyinline-rthe environmentinline-r the valueinline-rthe expressioninline-rthe environment. Once the promise has been evaluated, the environment is set to NULL.inline-r;CAR: the function (perhaps via a symbol or language object)inline-r4CDR: the argument list with tags for named argumentsinline-ra pairlist of promisesinline-r true lengthinline-r true lengthinline-r the pointerinline-rthe protection value (an R object which if alive protects this object)inline-ra taginline-rthe keyinline-r the valueinline-r the finalizerinline-r*the next entry in the weak references listinline-rthe tag(C) 2013 Amgen, Inc. Safe-Inferred"()*/(C) 2013 Amgen, Inc. Safe-Inferred %&1pinline-rConfiguration options for the R runtime. Configurations form monoids, so arguments can be accumulated left-to-right through monoidal composition.inline-rProgram name. If  then the value of  will be used.inline-rCommand-line arguments.inline-rSet to  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;5SIGUSR2 - terminate program without saving workspace;3SIGINT - 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.inline-rThe  monad, for sequencing actions interacting with a single instance of the R interpreter, much as the ? monad sequences actions interacting with the real world. The  monad embeds the  monad, so all  actions can be lifted to  actions.inline-rA static address that survives GHCi reloadings which indicates whether R has been initialized.inline-rInitialize 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).inline-rRun 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 . 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  *$. 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.inline-rDefault argument to pass to .inline-rPopulate environment with R_HOME$ variable if it does not exist and R_LIBS% variable if it doesn't exist either.inline-r0Allocate and initialize a new array of elements.inline-rAn MVar to make an atomic step of checking whether R is initialized and initializing it if needed.inline-rCreate 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.inline-rFinalize an R instance.inline-rArray elementsinline-r Continuation  (C) 2013 Amgen, Inc. Safe-Inferred1inline-rGenerate wrappers from n to m.inline-rGenerate wrapper.Example for input 5: foreign import ccall "wrapper" wrap5 :: ( SEXP a -> SEXP b -> SEXP c -> SEXP d -> SEXP e -> IO (SEXP f) ) -> IO (FunPtr ( SEXP a -> SEXP b -> SEXP c -> SEXP d -> SEXP e -> IO (SEXP f) ) ) inline-r&Generate Literal Instance for wrapper.Example for input 6:  instance ( Literal a a0, Literal b b0, Literal c c0, Literal d d0, Literal e e0 , Literal f f0, Literal g g0 ) => Literal (a -> b -> c -> d -> e -> f -> IO g) R.ExtPtr where mkSEXP = funToSEXP wrap6 fromSEXP = error "Unimplemented." 2013 (C) Amgen, Inc Safe-Inferred  2013 (C) Amgen, Inc Safe-Inferred"()*/1<zinline-rA class for functions that can be converted to functions on SEXPs.inline-r Values that can be converted to .inline-r0Internal function for converting a literal to a ' value. You probably want to be using  instead.inline-r4Create a SEXP value and protect it in current regioninline-rLike , but with no static type satefy. Performs a dynamic (i.e. at runtime) check instead.inline-rLike , 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.inline-rCreate 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.inline-rCreate an association list from a pairlist. R Pairlists are nil-terminated chains of nested cons cells, as in LISP.   Safe-Inferred(1Įinline-rInternalize a symbol name.inline-r#Call a pure binary R function. See  for additional comments.inline-rCall a pure unary R function of the given name in the global environment.2013 (C) Amgen, Inc Safe-Inferred()*1> inline-r#Parse and then evaluate expression.inline-r3Parse file and perform some actions on parsed file.This function uses continuation because this is an easy way to make operations GC-safe.inline-rInternalize a symbol name.inline-r3Create an R character string from a Haskell string.inline-r0Create an R string vector from a Haskell string.inline-rEvaluate a (sequence of) expression(s) in the given environment, returning the value of the last.inline-rEvaluate a (sequence of) expression(s) in the global environment.inline-rSilent version of $ function that discards it's result.inline-r!Throw an R error as an exception.inline-rCancel 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).inline-r,Throw an R exception with specified message.inline-rRead last error message.inline-r Text to parseinline-r2Whether to annotate the AST with source locations.inline-r#Environment in which to find error.*DBA@?>=:30.15-C2 apply (apply [r| function(x_hs, y_hs) x_hs + y_hs |] x) y inline-rthe R code that may contain antiquotations, which are identifiers ending with inline-reither an error message from R, or a list of unique antiquoted identifiers  Safe-InferredHKIJ_`abcde~}|{zyxvutsrqpnmlkjihgfowHKIJ_`abcde~}|{zyxvutsrqpnmlkjihgfow(c) 2016, AlphaSheets, Inc ExperimentalPortable Safe-Inferred ()*1;Ginline-rException during matching.inline-rGeneric error.inline-r&SEXP's type differ from requested one.inline-r"Requested attribute does not exit.inline-rA composition of  destructors. A  is bound to the region where  is allocated, so extracted value will not leak out of the region scope.This matcher is a pure function, so if you need to allocate any object (for example for comparison or lookup) you should do it before running matcher.inline-rMatch a , returning a  MatchError if matching failed.Result is always fully evaluated, since otherwise it wouldn't be possible to guarantee that thunks in the return value will not escape the memory region.inline-rReturns current . Never fails.inline-rReturns current ; if it is of the requested type, fails otherwise, returns  TypeMissmatch in that case.inline-rRun a submatcher on another . All exceptions in the internal matcher are propagated to the parent one. This combinator allows to inspect nested structures without exiting the matcher, so it's possible to effectively combine it with alternative function.inline-rSucceeds if current SomeSEXP is  +.inline-rSucceeds if current SomeSEXP7 is S4 object. This check is more accurate then using  guardType S4 as it uses internal R's function to check if the object is S4.inline-r Succeeds if  is an S3 object of the given type. In general case it's better to use  because it will run same check, but also will return the class(es) of the current expression.-This test is not expressible in terms of the , because guardType does not see additional information about S3 types. And any raw object can be a class instance.inline-rContinue execution if SEXP have required type. This check tests basic types of the expression like if it's integer, or real or character vector and such. If you need to test object type use  or  directly.inline-r?@ABBCDEEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstucvwxyyz{|}~                                 )                                                                             ! "                            %%%%%%%%'''''''jj)NYZ[]\^_`abcdefghjklmnop- -&&&''''''g%inline-r-1.0.1-GhtklwKWOeKCjogr8k191KForeign.R.TypeControl.Memory.RegionForeign.R.EmbeddedForeign.R.EncodingForeign.R.ErrorForeign.R.EventLoopForeign.R.ConstraintsForeign.R.ContextForeign.R.Internal Foreign.RForeign.R.ParseData.Vector.SEXP.Base H.PreludeData.Vector.SEXP.MutableData.Vector.SEXP Language.R.GCLanguage.R.GlobalsLanguage.R.EventLanguage.R.HExpLanguage.R.DebugLanguage.R.InstanceLanguage.R.Internal"Language.R.Internal.FunWrappers.THLanguage.R.Internal.FunWrappersLanguage.R.Literal Language.R Language.R.QQLanguage.R.MatcherH.Prelude.InteractiveInternal.Error withProtectedRprotect unprotectControl.Exceptionbracket_Control.Monad.R.ClassControl.Monad.R.Internal!Data.Vector.SEXP.Mutable.InternalH unboundValueErrorNullLanguage.R.Hexphexp'singletons-3.0.1-KINB4kF9c1gBeQbILshhmHData.SingletonsSing<=VGVoid GlobalRegion initEmbeddedR endEmbeddedRCEType CE_NativeCE_UTF8 CE_Latin1CE_Bytes CE_SymbolCE_Any $fEnumCEType $fEqCEType $fShowCETypeRError$fExceptionRError $fShowRError InputHandlerinputHandlerCallbackinputHandlerActivityinputHandlerActiveinputHandlerFDinputHandlerUserDatainputHandlerNext runHandlers checkActivity inputHandlersgraphicsPollingPeriodgraphicsPolledEvents pollingPeriod polledEventsaddInputHandlerremoveInputHandler$fStorableInputHandler$fEqInputHandler$fShowInputHandlerSEXPTYPENilSymbolListClosureEnvPromiseLangSpecialBuiltinCharLogicalIntRealComplexString DotDotDotAnyVectorExprBytecodeExtPtrWeakRefRawS4NewFreeFunIn:∈FALSETRUENASEXP0unSEXP0SEXPRECrCtx $fShowSEXP0$fStorableLogical $fEqLogical $fOrdLogical $fShowLogical $fEqSEXP0 $fOrdSEXP0$fStorableSEXP0$fNFDataSEXPTYPE$fEnumSEXPTYPE $fEqSEXPTYPE $fOrdSEXPTYPE$fShowSEXPTYPE$fLiftBoxedRepSEXPTYPE IsExpression IsPairListIsListIsGenericVectorIsVectorPairList SSEXPTYPESNilSSymbolSListSClosureSEnvSPromiseSLangSSpecialSBuiltinSCharSLogicalSIntSRealSComplexSString SDotDotDotSAnySVectorSExpr SBytecodeSExtPtrSWeakRefSRawSS4SNewSFreeSFun$fSingISEXPTYPEFun$fSingISEXPTYPEFree$fSingISEXPTYPENew$fSingISEXPTYPES4$fSingISEXPTYPERaw$fSingISEXPTYPEWeakRef$fSingISEXPTYPEExtPtr$fSingISEXPTYPEBytecode$fSingISEXPTYPEExpr$fSingISEXPTYPEVector$fSingISEXPTYPEAny$fSingISEXPTYPEDotDotDot$fSingISEXPTYPEString$fSingISEXPTYPEComplex$fSingISEXPTYPEReal$fSingISEXPTYPEInt$fSingISEXPTYPELogical$fSingISEXPTYPEChar$fSingISEXPTYPEBuiltin$fSingISEXPTYPESpecial$fSingISEXPTYPELang$fSingISEXPTYPEPromise$fSingISEXPTYPEEnv$fSingISEXPTYPEClosure$fSingISEXPTYPEList$fSingISEXPTYPESymbol$fSingISEXPTYPENil$fSingKindSEXPTYPESEXPInfoinfoTypeinfoObj infoNamedinfoGpinfoMark infoDebug infoTrace infoSpareSomeSEXPSEXPunSEXPcisS4 cgetAttrib csetAttribcAttribcRSTEPcRTRACEcRDEBUGcMARKcLEVELScNAMEDcOBJECTinterruptsPendingsignalHandlers globalEnvemptyEnvbaseEnv missingArgnilValueisRInteractivecTYPEOFsexpunsexpsomesexprelease unsafeReleaseunsafeReleaseSome unSomeSEXPcIntConv cIntToEnumcUIntFromSingEnum cIntFromEnumtypeOf unsafeCastcastasTypeOf unsafeCoercepeekInfoisS4 getAttributes getAttribute setAttributes $fNFDataSEXP $fShowSEXP$fNFDataSomeSEXP$fStorableSomeSEXP$fShowSomeSEXP$fShowSEXPInfo$fEqSEXP $fOrdSEXP$fStorableSEXPcarsetCarcdrsetCdrtagsetTagenvFrame envEnclosing envHashtabclosureFormals closureBody closureEnv promiseCode promiseEnv promiseValuelength trueLengthcharrealintegerrawlogicalcomplexstring readVector indexVector writeVectorunsafeSEXPToVectorPtrsymbolPrintName symbolValuesymbolInternalmkStringmkCharmkCharCE mkCharLenCEinstall allocSEXP allocList allocVectorallocVectorProtectedconslcons printValue unprotectPtrgcpreserveObject releaseObjectevaltryEval tryEvalSilentlang1lang2lang3findFunfindVar mkWeakRef ParseStatus PARSE_NULLPARSE_OKPARSE_INCOMPLETE PARSE_ERROR PARSE_EOF parseVector$fEnumParseStatus$fEqParseStatus$fShowParseStatusSVECTORVECTOREElemRepRegionMonadR ExecContextioacquiregetExecContextunsafeRunWithExecContext acquireSomeMVector mvectorBase mvectorOffset mvectorLengthfromSEXPtoSEXPnullslicetakedropsplitAtinittail unsafeSlice unsafeTake unsafeDrop unsafeInit unsafeTailoverlapsnew unsafeNew replicate replicateMcloneclearreadwriteswap unsafeRead unsafeWrite unsafeSwapsetcopy unsafeCopymove unsafeMove vectorBase vectorOffset vectorLengthunsafeFromSEXP unsafeToSEXPtoString toByteStringunsafeWithByteString!!?headlast unsafeIndex unsafeHead unsafeLastindexMheadMlastM unsafeIndexM unsafeHeadM unsafeLastMempty singletongenerateiterateNunfoldrunfoldrN constructN constructrN enumFromN enumFromStepN enumFromToenumFromThenTosnoc++concat generateMcreateforce// unsafeUpdaccum unsafeAccumreversemapimap concatMapmapMmapM_forMforM_zipWithzipWith3zipWith4zipWith5zipWith6izipWith izipWith3 izipWith4 izipWith5 izipWith6zipWithM zipWithM_filterifilterfilterM takeWhile dropWhile partitionunstablePartitionspanbreakelemnotElemfind findIndex elemIndexfoldlfoldl1foldl'foldl1'foldrfoldr1foldr'foldr1'ifoldlifoldl'ifoldrifoldr'allanysumproductmaximum maximumByminimum minimumBymaxIndex maxIndexByminIndex minIndexByfoldMfold1MfoldM'fold1M'foldM_fold1M_foldM'_fold1M'_prescanl prescanl' postscanl postscanl'scanlscanl'scanl1scanl1'prescanr prescanr' postscanr postscanr'scanrscanr'scanr1scanr1'toListfromList fromListN unsafeFreeze unsafeThawthawfreeze$fIsListVector $fShowVector $fEqVector $fVectorWa automatic automaticSomepokeRVariablessignalHandlersPtrforIHforIH_registerREvents eventLoopPolleventLoopSelectrefreshHExp===vector$fEqHExp$fTestEqualitySEXPTYPEHExp$fTestEqualitySEXPTYPEEinspect$fToJSONSomeSEXP $fToJSONSEXP$fToJSONComplex$fToJSONSEXPInfo$fToJSONSEXPTYPEConfigconfigProgName configArgsconfigSignalHandlers withEmbeddedR runRegionunsafeRunRegion defaultConfig initializefinalize $fMonadRR $fPrimMonadR $fMonadFailR$fMonoidConfig$fSemigroupConfig$fDefaultConfig$fApplicativeR $fFunctorR$fMonadR $fMonadIOR $fMonadCatchR $fMonadMaskR $fMonadThrowR installIOr2r1 thWrappers thWrapperthWrapperLiteralsthWrapperLiteralwrap3wrap2wrap1wrap0wrap12wrap11wrap10wrap9wrap8wrap7wrap6wrap5wrap4LiteralmkSEXPIOmkSEXP fromSomeSEXPdynSEXP mkSEXPVectormkSEXPVectorIOmkProtectedSEXPVectormkProtectedSEXPVectorIO toPairList fromPairList funToSEXP$fLiteralFUNExtPtr$fLiteralFUNExtPtr0$fLiteralRExtPtr$fLiteralSomeSEXPAny$fLiteralSEXPa$fLiteralMVectorty$fLiteralVectorty$fLiteral[]String$fLiteralComplexComplex$fLiteralDoubleReal$fLiteralInt32Int$fLiteralLogicalLogical$fLiteralTextString$fLiteral[]String0$fLiteral[]Complex$fLiteral[]Real$fLiteral[]Int$fLiteral[]Logical$fHFunWrapFUNFUN $fHFunWrapRIO$fLiteralFUNExtPtr1$fLiteralFUNExtPtr2$fLiteralFUNExtPtr3$fLiteralFUNExtPtr4$fLiteralFUNExtPtr5$fLiteralFUNExtPtr6$fLiteralFUNExtPtr7$fLiteralFUNExtPtr8$fLiteralFUNExtPtr9$fLiteralFUNExtPtr10 parseFile parseTextstringsevalEnveval_throwRcancel throwRMessagerrsafe collectAntisMatcher runMatcher matchOnlywiths4s3 guardType someAttribute attribute attributeslookupAttribute getS3ClasscharListdimdimnamesnamesrownameschoicelistfactor$fNFDataMatcherError$fMonoidMatcherError$fSemigroupMatcherError$fAlternativeMatcher$fFunctorMatcher$fApplicativeMatcher$fMonadFailMatcher$fMonadMatcher$fShowMatcherError$fGenericMatcherErrorPrintRprintRp printQuote $fMonadRIO$fPrintRSomeSEXP $fPrintRSEXPbaseForeign.StorableStorablepeekpokeghc-prim GHC.TypesTrueFalsefailure violation impossible unimplementedIO AcquireIO withAcquireWunW unsafeToPtrproxyWwithW foreignSEXP ForeignSEXPGHC.Basebytestring-0.11.3.1Data.ByteString.Internal ByteString rVariables GHC.MaybeNothingSystem.Environment getProgNameisRInitializedPtr populateEnv newCArrayinitLockHFunWrap parseEvalgetErrorMessageqqLockchopexpQQ antiSuffix MatcherError TypeMissmatchNoSuchAttribute