!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrst u v w x y z { | } ~                                   ! " # $ % & ' ( )*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~(C) 2013 Amgen, Inc.Safe0 User error.6An internal invariant has been violated. That's a bug.NA violation that should have been made impossible by the type system was not.Feature not yet implemented.  Function name Error message Function name Error message Function name Safe!"^R input handler chain. Each input handler points to the next. This view of input handlers is shallow, in the sense that the c instance only unmarshalls the first element in the chain at any one time. A shallow view allows  and  to be inlinable.The input handler callback."Undocumented and currently unused.7Whether this input handler is activated or deactivated.2The file descriptor ahssociated with this handler.5Callbacks can optionally be passed in arbitrary data.$The next input handler in the chain. #Input handlers used in event loops.  R_wait_usec global variable. R_PolledEvents global variable. R_wait_usec global variable.R_PolledEvents global variable.Create and register a new s. 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.=Remove an input handler from an input handler chain. Returns + if the handler was successfully removed,  otherwise.     (C) 2013 Amgen, Inc.Safe0123412121234(C) 2013 Amgen, Inc.Safe5 Finalize R.6 Initialize R.56565656(C) 2013 Amgen, Inc.None*+,DQR7Class alias used for c2hs fun< hooks, since it currently does not like Unicode operators.8The predicate a :" as states that a is a member type of the set as.7878877881(C) 2013 Amgen, Inc.None%&*,ADQRTR "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.WTo better illustrate the distinction, note that any sane type system normally has the subject reduction propertyM: 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 formv 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.>wConstraint synonym grouping all expression forms into one class. According to R internals, an expression is usually a  , but can sometimes also be an ( or a .? IsPairList a holds iff R's  is.pairlist() returns TRUE.@IsList a holds iff R's  is.list() returns TRUE.ANon-atomic vector forms. See  src/main/memory.c:SET_VECTOR_ELT in the R source distribution.B=Constraint synonym grouping all vector forms into one class.  IsVector a holds iff R's  is.vector() returns TRUE.C[Used where the R documentation speaks of "pairlists", which are really just regular lists.DR uses three-valued logic.b !"#$%&'()*+,-./09:>?@ABCDEFGHIJN$!&"#-'. %()*+,/0>?@ABCDEFGH( !"#$%&'()*+,-./0HDEFGCBA@?>) !"#$%&'()*+,-./09:>?@ABCDEFGHIJ(C) 2013 Amgen, Inc.None,kGenerate wrappers from n to m.lGenerate 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) ) ) n&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." klmnklmnklnmklmn(C) 2013 Amgen, Inc.NoneDQRoBA partial order on regions. In fact regions form a lattice, with s being the supremum and r the infimum.pConvenient shorthand.qConvenient shorthand.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.sThe 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.opqrsopqrssrqpoopqrs None $*+,ADIOQRT+t(Info header for the SEXP data structure.vType of the SEXP.w)Is this an object with a class attribute.xControl copying information.yGeneral purpose data.zMark object as 'in use' in GC.{ Debug marker.| Trace marker.}Alignment (not in use).~GC Generation.GC Class of node.A  of unknown form.The basic type of all R expressions, classified by the form of the expression, and the memory region in which it has been allocated.5Flag that shows if computation should be interrupted.Signal handler switchGlobal environment.The empty environment.The base environment.LMissing argument marker. Constant throughout the lifetime of the R instance.CUnbound marker. Constant throughout the lifetime of the R instance.EGlobal nil value. Constant throughout the lifetime of the R instance. Add a type index to the pointer.'Remove the type index from the pointer.Like  but for .Release object into another region. Releasing is safe so long as the target region is "smaller" than the source region, in the sense of '(Control.Memory.Region.<=)'.Deconstruct a \. Takes a continuation since otherwise the existentially quantified variable hidden inside  would escape.6Return the "type" tag (aka the form tag) of the given q. This function is pure because the type of an object does not normally change over the lifetime of the object.>Set CAR field of object, when object is viewed as a cons cell.>Set CDR field of object, when object is viewed as a cons cell.>Set TAG field of object, when object is viewed as a cons cell.Cast 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.;Cast form of first argument to that of the second argument.Unsafe coercion from one form to another. This is unsafe, in the sense that using this function improperly could cause code to crash in unpredictable ways. Contrary to S, it has no runtime cost since it does not introduce any dynamic check at runtime.Length of the vector.'Extract the data pointer from a vector. Inverse of  vectorPtr."Extract the header from the given .Write a new header.Set the GC mark. Check if object is an S4 object.>This is a function call so it will be more precise than using .-Get the attribute list from the given object."Get attribute with the given name.Set the attribute list.Vtuvwxyz{|}~ValueAttribute nameQtuvwxyz{|}~Vtuvwxyz{|}~Ht uvwxyz{|}~ (C) 2013 Amgen, Inc.None$*+,ADIOQRT1Content encoding.# with no type index. This type and  / d are purely an artifact of c2hs (which doesn't support indexing a Ptr with an arbitrary type in a #pointer hook).read CAR object valueread CDR objectread object`s TagEnclosing environment.Environment frame.IHash table associated with the environment, used for faster name lookups.+Closure formals (aka the actual arguments).The code of the closure.The environment of the closure.The code of a promise.1The environment in which to evaluate the promise.8The value of the promise, if it has already been forced.Read True Length vector field.Read character vector dataRead real vector data.Read integer vector data.Read raw data.Read logical vector data.Read complex vector data.Read string vector data.Read a name from symbol.Read value from symbol. Read internal value from symbol.Initialize a new string vector.1Initialize a new character vector (aka a string)..Create Character value with specified encodingIntern a string name into the symbol table.If nameX is not found, it is added to the symbol table. The symbol corresponding to the string name is returned. Allocate a .Allocate a pairlist of s, chained together.Allocate Vector.5Allocate a so-called cons cell, in essence a pair of  pointers.JAllocate a so-called cons cell of language objects, in essence a pair of  pointers.#Print a string representation of a  on the console. 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. unprotect n unprotects the last n objects that were protected.4Unprotect a specific object, referred to by pointer.$Invoke an R garbage collector sweep.Preserve an object accross GCs.'Allow GC to remove an preserved object. Evaluate any  to its value.Try to evaluate expression.BTry to evaluate without printing error/warning messages to stdout."Construct a nullary function call.Construct unary function call.!Construct a binary function call.Find a function by name.Find a variable by name. zPerform an action with resource while protecting it from the garbage collection. This function is a safer alternative to  and  g, guaranteeing that a protected resource gets unprotected irrespective of the control flow, much like !".r      !"#$%&'()*+,-./01234   $!&"#-'. %()*+,/0>?@ABCDEFGHtuvwxyz{|}~  o tuvwxyz{|}~ l      !"#$%&'()*+,-./01234   (C) 2013 Amgen, Inc.None*,DR1Constraint synonym for all operations on vectors.1Constraint synonym for all operations on vectors., in the form of a relation, for convenience.YFunction from R types to the types of the representations of each element in the vector. (C) 2013 Amgen, Inc.None*,The return code of a call to 5, indicating whether the parser failed or succeeded."parseVector text num status source' parses the input string into an AST. source#, if provided, names the origin of text (e.g. a filename). num0 limits the number of expressions to parse, or -1 if no limit.55 2013 (C) Amgen, IncNone  !"#$%&'(  !"#$%&'(  !"#$%&'(  !"#$%&'((C) 2013 Amgen, Inc.None,6pStores R variables in a static location. This makes the variables' addresses accesible after reloading in GHCi.,RSpecial value to which all symbols unbound in the current environment resolve to.-R's NULL value..FValue substituted for all missing actual arguments of a function call./The base environment.0The empty environment.1The global environment. 76)8,-./012 )*+,-./012 /01-.,*+2) 76)8,-./012#(C) 2013 Amgen, Inc.None6DR7UThe class of R interaction monads. For safety, in compiled code we normally use the A monad. For convenience, in a GHCi session, we normally use the 9 monad directly (by means of a 7 instance for 9, imported only in GHCi).8:A reification of an R execution context, i.e. a "session".9Lift an 9 action.:Acquire ownership in the current region of the given object. This means that the liveness of the object is guaranteed so long as the current region remains active (the R garbage collector will not attempt to free it).;"Get the current execution context.<Provides no static guarantees that resources do not extrude the scope of their region. Acquired resources are not freed automatically upon exit. For internal use only.=: for .6789:;<=6789:;<=679::8;<=(C) 2013 Amgen, Inc.None>Declare memory management for this value to be automatic. That is, the memory associated with it may be freed as soon as the garbage collector notices that it is safe to do so.@Values with automatic memory management are tagged with the global region. The reason is that just like for other global values, deallocation of the value can never be observed. Indeed, it is a mere "optimization" to deallocate the value sooner - it would still be semantically correct to never deallocate it at all.?> for .>?>?>?>?(C) 2013 Amgen, Inc.None !",DIJOPRT@Configuration options for the R runtime. Configurations form monoids, so arguments can be accumulated left-to-right through monoidal composition.BProgram name. If : then the value of ; will be used.CCommand-line arguments.DSet 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.yN.B.* When program is terminated, haskell runtime will not have any chances to run any exception handlers or finalizers.EThe Ee monad, for sequencing actions interacting with a single instance of the R interpreter, much as the 9? monad sequences actions interacting with the real world. The E monad embeds the 9 monad, so all 9 actions can be lifted to E actions.<_A static address that survives GHCi reloadings which indicates whether R has been initialized.FInitialize 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).GRun 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 F. 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).IDefault argument to pass to J.=Populate environment with R_HOME variable if it does not exist.>0Allocate and initialize a new array of elements.?cAn MVar to make an atomic step of checking whether R is initialized and initializing it if needed.JCreate 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.KFinalize an R instance.@ABCDE@AB<FGHI=>Array elements Continuation?JKLMCNO @ABCDEFGHIJK EGH@ABCDIFJK@ABCDE@A<FGHI=>?JKLMNCBO(C) 2015 Tweag I/O Limited.None!"W+Iterate over each input handler in a chain.X Variant of W that throws away the result.YfRegister all R input handlers with the given event manager. Set an alarm to process polled events if  R_wait_usecD is non-zero. Returns keys useful for unregistering input handlers.ZProcess 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.[#Process events in a loop. Uses R's select()b mechanism under the hood. This function should be called from the main thread. It never returns.\sManually trigger processing all pending events. Useful when at an interactive prompt and no event loop is running.DEWXYZ[\WXYZ[\WXYZ[\DEWXYZ[\$(C) 2016 Tweag I/O Limited.None:OTFGHFGHFGH%(C) 2016 Tweag I/O Limited.None$9:;<=DQRTI[Internal wrapper type for reflection. First type parameter is the reified type to reflect.]@Mutable R vector. Represented in memory with the same header as t nodes. The second type parameter is phantom, reflecting at the type level the tag of the vector when viewed as a E. The tag of the vector and the representation type are related via .IJK]^_`aLMNbcO IJK]^_`aLMNbcIJK]^_`aLMNbcO(C) 2013 Amgen, Inc.None*,9:;<=DORTdO(1) Create a vector from a .eO(1) in the common case, O(n)3 for proper slices. Convert a mutable vector to a _. This can be done efficiently, without copy, because vectors in this module always include a 6 header immediately before the vector data in memory.fLength of the mutable vector.g"Check whether the vector is empty.h6Yield a part of the mutable vector without copying it.nWYield a part of the mutable vector without copying it. No bounds checks are performed.s"Check whether two vectors overlap.t,Create a mutable vector of the given length.uGCreate a mutable vector of the given length. The length is not checked.vmCreate a mutable vector of the given length (0 if the length is negative) and fill it with an initial value.wCreate a mutable vector of the given length (0 if the length is negative) and fill it with values produced by repeatedly executing the monadic action.x"Create a copy of a mutable vector.yReset all elements of the vector to some undefined value, clearing all references to external objects. This is usually a noop for unboxed vectors.z(Yield the element at the given position.{*Replace the element at the given position.|)Swap the elements at the given positions.}HYield the element at the given position. No bounds checks are performed.~JReplace the element at the given position. No bounds checks are performed.ISwap the elements at the given positions. No bounds checks are performed.2Set all elements of the vector to the given value.NCopy a vector. The two vectors must have the same length and may not overlap.cCopy a vector. The two vectors must have the same length and may not overlap. This is not checked.JMove the contents of a vector. The two vectors must have the same length.:If the vectors do not overlap, then this is equivalent to . Otherwise, the copying is performed as if the source vector were copied to a temporary vector and then the temporary vector was copied to the target vector.cMove the contents of a vector. The two vectors must have the same length, but this is not checked.:If the vectors do not overlap, then this is equivalent to . Otherwise, the copying is performed as if the source vector were copied to a temporary vector and then the temporary vector was copied to the target vector.#PQdefghijklmnstarting indexlength of the sliceopqrstuvwxyz{|}~targetsourcetargetsource$]bcdefghijklmnopqrstuvwxyz{|}~$]debcfgtuvwxhlmijknqropsyz{|}~#PQdefghijklmnopqrstuvwxyz{|}~(C) 2013 Amgen, Inc.None$*,29:;<=DIORTR[Internal wrapper type for reflection. First type parameter is the reified type to reflect.Immutable vectors. The second type paramater is a phantom parameter reflecting at the type level the tag of the vector when viewed as a E. The tag of the vector and the representation type are related via .S Create a T from .U:Return Pointer of the first element of the vector storage.O(n)# Create an immutable vector from a  . Because 2s are mutable, this function yields an immutable copy of the .O(1) Unsafe convert a mutable  to an immutable vector without copying. The mutable vector must not be used after this operation, lest one runs the risk of breaking referential transparency.O(n)+ Yield a (mutable) copy of the vector as a .O(1)5 Unsafely convert an immutable vector to a (mutable) N without copying. The immutable vector must not be used after this operation.O(n)# Convert a character vector into a V.O(n)* Convert a character vector into a strict W.O(1) Yield the length of the vector.O(1) Test whether a vector if empty O(1) IndexingO(1) Safe indexingO(1) First elementO(1) Last elementO(1)( Unsafe indexing without bounds checkingO(1)6 First element without checking if the vector is emptyO(1)5 Last element without checking if the vector is emptyO(1) Indexing in a monad.xThe monad allows operations to be strict in the vector when necessary. Suppose vector copying is implemented like this: &copy mv v = ... write mv i (v ! i) ...For lazy vectors, v ! i) would not be evaluated which means that mv, would unnecessarily retain a reference to v in each element written.With /, copying can be implemented like this instead: Scopy mv v = ... do x <- indexM v i write mv i xHere, no references to v$ are retained because indexing (but not% the elements) is evaluated eagerly.O(1)+ First element of a vector in a monad. See + for an explanation of why this is useful.O(1)* Last element of a vector in a monad. See + for an explanation of why this is useful.O(1)0 Indexing in a monad without bounds checks. See + for an explanation of why this is useful.O(1)C First element in a monad without checking for empty vectors. See * for an explanation of why this is useful.O(1)B Last element in a monad without checking for empty vectors. See * for an explanation of why this is useful.O(N)P Yield a slice of the vector with copying it. The vector must contain at least i+n elements.O(N)a Yield all but the last element, this operation will copy an array. The vector may not be empty.O(N)= Copy all but the first element. The vector may not be empty.O(N) Yield at the first n: elements with copying. The vector may contain less than n1 elements in which case it is returned unchanged.O(N) Yield all but the first n: elements with copying. The vector may contain less than n4 elements in which case an empty vector is returned.O(N) Yield the first n1 elements paired with the remainder with copying. Note that  n v is equivalent to ( n v,  n v) but slightly more efficient.O(N)M Yield a slice of the vector with copying. The vector must contain at least i+n" elements but this is not checked.O(N)c Yield all but the last element with copying. The vector may not be empty but this is not checked.O(N)d Yield all but the first element with copying. The vector may not be empty but this is not checked.O(N) Yield the first n: elements with copying. The vector must contain at least n" elements but this is not checked.O(N) Yield all but the first n: elements with copying. The vector must contain at least n" elements but this is not checked.O(1) Empty vectorO(1) Vector with exactly one elementO(n)@ Vector of the given length with the same value in each positionO(n)O Construct a vector of the given length by applying the function to each indexO(n)C Apply function n times to value. Zeroth element is original value.O(n)q Construct a Vector s ty by repeatedly applying the generator function to a seed. The generator function yields Just' the next element and the new seed or Nothing if there are no more elements. Uunfoldr (\n -> if n == 0 then Nothing else Just (n,n-1)) 10 = <10,9,8,7,6,5,4,3,2,1>O(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>O(n) Construct a vector with ng elements by repeatedly applying the generator function to the already constructed part of the vector. DconstructN 3 f = let a = f <> ; b = f <a> ; c = f <a,b> in f <a,b,c>O(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. DconstructrN 3 f = let a = f <> ; b = f<a> ; c = f <b,a> in f <c,b,a>O(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>O(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>O(n) Enumerate values from x to y.WARNING:B This operation can be very inefficient. If at all possible, use  instead.O(n) Enumerate values from x to y with a specific step z.WARNING:B This operation can be very inefficient. If at all possible, use  instead.O(n) Prepend an elementO(n) Append an elementO(m+n) Concatenate two vectorsO(n)$ Concatenate all vectors in the listO(n)Y Execute the monadic action the given number of times and store the results in a vector.O(n)U Construct a vector of the given length by applying the monadic action to each index;Execute the monadic action and freeze the resulting vector. Fcreate (do { v <- new 2; write v 0 'a'; write v 1 'b'; return v }) = <a,b> O(n)Y 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 <huge vector>)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.O(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> Same as () but without bounds checking.O(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>Same as  but without bounds checking.O(n) Reverse a vectorO(n) Map a function over a vectorO(n)A Apply a function to every element of a Vector s ty and its index>Map a function over a Vector s ty and concatenate the results.O(n)V Apply the monadic action to all elements of the vector, yielding a vector of resultsO(n)R Apply the monadic action to all elements of a Vector s ty and ignore the resultsO(n)e Apply the monadic action to all elements of the vector, yielding a vector of results. Equvalent to flip .O(n)b Apply the monadic action to all elements of a Vector s ty and ignore the results. Equivalent to flip . O(min(m,n))) Zip two vectors with the given function.*Zip three vectors with the given function. O(min(m,n))H Zip two vectors with a function that also takes the elements' indices.<Zip three vectors and their indices with the given function. O(min(m,n))K Zip the two vectors with the monadic action and yield a vector of results O(min(m,n))D Zip the two vectors with the monadic action and ignore the resultsO(n)0 Drop elements that do not satisfy the predicateO(n)^ Drop elements that do not satisfy the predicate which is applied to values and their indicesO(n)8 Drop elements that do not satisfy the monadic predicateO(n)M Yield the longest prefix of elements satisfying the predicate with copying.O(n)N Drop the longest prefix of elements that satisfy the predicate with copying.O(n) Split the vector in two parts, the first one containing those elements that satisfy the predicate and the second one those that don't. The relative order of the elements is preserved at the cost of a sometimes reduced performance compared to .O(n) Split the vector in two parts, the first one containing those elements that satisfy the predicate and the second one those that don't. The order of the elements is not preserved but the operation is often faster than .O(n)l Split the vector into the longest prefix of elements that satisfy the predicate and the rest with copying.O(n)s Split the vector into the longest prefix of elements that do not satisfy the predicate and the rest with copying.O(n)( Check if the vector contains an elementO(n)= Check if the vector does not contain an element (inverse of )O(n) Yield Just- the first element matching the predicate or Nothing if no such element exists.O(n) Yield Just; the index of the first element matching the predicate or Nothing if no such element exists.O(n) Yield Just; the index of the first occurence of the given element or NothingO if the vector does not contain the element. This is a specialised version of .O(n) Left foldO(n) Left fold on non-empty vectorsO(n)" Left fold with strict accumulatorO(n)7 Left fold on non-empty vectors with strict accumulatorO(n) Right foldO(n) Right fold on non-empty vectorsO(n)% Right fold with a strict accumulatorO(n)8 Right fold on non-empty vectors with strict accumulatorO(n); Left fold (function applied to each element and its index)O(n)T Left fold with strict accumulator (function applied to each element and its index)O(n)< Right fold (function applied to each element and its index)O(n)U Right fold with strict accumulator (function applied to each element and its index)O(n)- Check if all elements satisfy the predicate.O(n). Check if any element satisfies the predicate.O(n) Compute the sum of the elementsO(n)$ Compute the produce of the elementsO(n)G Yield the maximum element of the vector. The vector may not be empty.O(n)w Yield the maximum element of the Vector s ty according to the given comparison function. The vector may not be empty.O(n)G Yield the minimum element of the vector. The vector may not be empty.O(n)w Yield the minimum element of the Vector s ty according to the given comparison function. The vector may not be empty.O(n)T Yield the index of the maximum element of the vector. The vector may not be empty.O(n) Yield the index of the maximum element of the Vector s ty according to the given comparison function. The vector may not be empty.O(n)T Yield the index of the minimum element of the vector. The vector may not be empty.O(n) Yield the index of the minimum element of the Vector s ty according to the given comparison function. The vector may not be empty.O(n) Monadic foldO(n)$ Monadic fold over non-empty vectorsO(n)% Monadic fold with strict accumulatorO(n)< Monadic fold over non-empty vectors with strict accumulatorO(n)& Monadic fold that discards the resultO(n)= Monadic fold over non-empty vectors that discards the resultO(n)> Monadic fold with strict accumulator that discards the resultO(n)V Monadic fold over non-empty vectors with strict accumulator that discards the resultO(n) Prescan prescanl f z =  .   f z  Example: $prescanl (+) 0 <1,2,3,4> = <0,1,3,6>O(n) Prescan with strict accumulatorO(n) Scan postscanl f z =  .   f z  Example: &postscanl (+) 0 <1,2,3,4> = <1,3,6,10>O(n) Scan with strict accumulator O(n) Haskell-style scan Sscanl f z <x1,...,xn> = <y1,...,y(n+1)> where y1 = z yi = f y(i-1) x(i-1) Example: $scanl (+) 0 <1,2,3,4> = <0,1,3,6,10> O(n)+ Haskell-style scan with strict accumulator O(n) Scan over a non-empty vector Jscanl f <x1,...,xn> = <y1,...,yn> where y1 = x1 yi = f y(i-1) xi O(n)7 Scan over a non-empty vector with a strict accumulator O(n) Right-to-left prescan prescanr f z =  .  (flip f) z .  O(n). Right-to-left prescan with strict accumulatorO(n) Right-to-left scanO(n)+ Right-to-left scan with strict accumulatorO(n)! Right-to-left Haskell-style scanO(n)9 Right-to-left Haskell-style scan with strict accumulatorO(n)+ Right-to-left scan over a non-empty vectorO(n)F Right-to-left scan over a non-empty vector with a strict accumulatorO(n) Convert a vector to a listO(n) Convert a list to a vectorO(n) Convert the first n elements of a list to a vector fromListN n xs =  ( n xs) O(1)| Unsafe convert a mutable vector to an immutable one with copying. The mutable vector may not be used after this operation.O(1) Unsafely convert an immutable vector to a mutable one with copying. The immutable vector may not be used after this operation.O(n). Yield a mutable copy of the immutable vector.O(n)/ Yield an immutable copy of the mutable vector.O(n)n Copy an immutable vector into a mutable one. The two vectors must have the same length. This is not checked.O(n)Y Copy an immutable vector into a mutable one. The two vectors must have the same length.RXYTZS[\]^_Ui starting indexn lengthi starting indexn lengthinitial vector (of length m)%list of index/value pairs (of length n)accumulating function finitial vector (of length m)%list of index/value pairs (of length n)`     a !]^_`a     ]^_`a     RXYTZS[\]^_U`     a !544None$%&*+,BDEQRTjA 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).fNote further that Haddock does not currently support constructor comments when using the GADT syntax.b.Wrapper for partially applying a type synonym.9Heterogeneous equality.:%A view function projecting a view of J as an algebraic datatype, that can be analyzed through pattern matching.;fInverse hexp view to the real structure, note that for scalar types hexp will allocate new SEXP, and  unhexp . hexpU is not an identity function. however for vector types it will return original SEXP.<Project the vector out of s.$jbc"#$%&'()*+,-./0123456789de:;<=>?@j0+-#./"82$,(&%')*1345679:;<j"#$%&'()*+,-./0123456789:;< j"#$%&'()*+,-./012345678bc9de:;<=>?@(C) 2013 Amgen, Inc.None$%&*:ABCDEFAAABCDEF2013 (C) Amgen, IncNone$%&*,69:;<=?T[fBA class for functions that can be converted to functions on SEXPs.G Values that can be converted to .H0Internal function for converting a literal to a ' value. You probably want to be using J instead.J4Create a SEXP value and protect it in current regionKLike IV, but with no static type satefy. Performs a dynamic (i.e. at runtime) check instead.LLike K, 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.QLCreate a pairlist from an association list. Result is either a pairlist or nilValuew if the input is the null list. These are two distinct forms. Hence why the type of this function is not more precise.RtCreate an association list from a pairlist. R Pairlists are nil-terminated chains of nested cons cells, as in LISP.$fgGHIhJKLMNOPQRSTUVWXYZ[\]^_`abcdefg GIHJKLMNOPQRSGHIHIQRKJLMNOPS!fgGHIHIhJKLMNOPQRSTUVWXYZ[\]^_`abcdefg2013 (C) Amgen, IncNone$%&, i#Parse and then evaluate expression.q3Parse file and perform some actions on parsed file.XThis function uses continuation because this is an easy way to make operations GC-safe.sInternalize a symbol name.t3Create an R character string from a Haskell string.u0Create an R string vector from a Haskell string.vbEvaluate a (sequence of) expression(s) in the given environment, returning the value of the last.wAEvaluate a (sequence of) expression(s) in the global environment.xSilent version of w$ function that discards it's result.y!Throw an R error as an exception.zPCancel 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).{,Throw an R exception with specified message.jRead last error message. iqr Text to parse2Whether to annotate the AST with source locations.stuvwxy#Environment in which to find error.z{j$!&"#-'. %()*+,/0>?@ABCDEFGH)*+,-./012>?@ABCDEFGHIJKGIHJKLMNOPQRSqrstuvwxyz{ wxvszy{qrtu iqrstuvwxyz{jNone$,3Internalize a symbol name.4#Call a pure binary R function. See 5 for additional comments.5ICall a pure unary R function of the given name in the global environment.345k345543345k(C) 2013 Amgen, Inc.None$%&,9:;T[|8An R value, expressed as an R expression, in R's syntax.}cQuasiquoter for pure R code (no side effects) and that does not depend on the global environment (referential transparency). This means that all symbols must appear qualified with a package namespace (whose bindings are locked by default), the code must not affect R shared state in any way, including the global environment, and must not perform I/O.lSerialize quasiquotes using a global lock, because the compiler is allowed in theory to run them in parallel, yet the R runtime is not reentrant.mQChop antiquotation variable names to get the corresponding Haskell variable name.n Traverse 5 structure and find all occurences of antiquotations.oAn R quasiquote is syntactic sugar for a function that we generate, which closes over all antiquotation variables, and applies the function to the Haskell values to which those variables are bound. Example: Q[r| x_hs + y_hs |] ==> apply (apply [r| function(x_hs, y_hs) x_hs + y_hs |] x) y |}lpqrmno|}|} |}lpqrmnoNone12>?@ABCDEFGHj0+-#./"82$,(&%')*134567)*+,-./0126789:;<=>?@ABCDEFGHIJK\9:;<GIHJKLMNOPQRSqrstuvwxyz{|} 79::8;<6=(C) 2013 Amgen, Inc.NoneDRA form of the = function that is more convenient in an interactive session.A form of the = function that is more convenient in an interactive session. ~st12>?@ABCDEFGHj0+-#./"82$,(&%')*134567)*+,-./0126789:;<=>?@ABCDEGHIJK\9:;<GIHJKLMNOPQRSqrstuvwxyz{|}~~~ts(c) 2016, AlphaSheets, Inc ExperimentalPortableNone $%&,5LOTuException during matching.vGeneric error.w&SEXP's type differ from requested one.x"Requested attribute does not exit.A composition of  destructors. A  is bound to the region where I 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.Match 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.Returns current . Never fails.Returns current ; if it is of the requested type, fails otherwise, returns  TypeMissmatch in that case.Run 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.Succeeds if current SomeSEXP is &.Succeeds 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. Succeeds if H 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 v, becausee guardType does not see additional information about S3 types. And any raw object can be a class instance.Continue 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.=Returns any attribute by it's name if it exists. Fails with NoSuchAttribute otherwise.Typed version of the F call. In addition to retrieving value it's dynamically type checked.Match all attributes, takes a matcher and applies it to the each attribute exists, returns list of the attribute name, together with matcher result. If matcher returns Nothing - result is omitted..1Find an attribute in attribute list if it exists.'( lifted to Matcher, applies hexp to the current value and allow to run internal matcher on it. Is useful when you need to inspect data using high level functions from  Language.R.1Returns type of the current SEXP. Can never fail.3Return the class of the S3 object, fails otherwise.Convert String  to the list of Vs.Get  attribute.Get  attribute.Get  attribute.Get  attribute.)Execute first matcher that will not fail. Matches a List object.1Match a factor. Returns the levels of the factor.$uvwx+Upper bound on number of elements to match. Matcher to apply to each elementuvwxy)*+,,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[[\]^_`abcdefghijklJmnopqrstuvwxyz{|}~                                                   ! " # $ % & ' ( ) * +  , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H IJK5LMN#O#P#Q#R#S#T#U#VWXYYZ[\]^_`abcdefghijklmnopqrs%t%t%u%v%w%%xyz{|}~QQxyz{|}~     @ABDCEFGHIJKLMNOQRSTUVW( !"#$%&'()*+,-x./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUV WX#YZ[\]^_`abcdeffghizjklmnop(qrstuvwxyz{|}~K))))))))))*)*                                                     Q !"$#$#$$%%%%%&%'%(%)%*+,%-.'N/01%&.2)34(5+116789:;<=>?@ABCDQEFFGHI'inline-r-0.9.0.2-8tosaqsQxVEFQFeTOfxX68Foreign.R.TypeForeign.R.EventLoopForeign.R.ErrorForeign.R.EmbeddedForeign.R.ConstraintsLanguage.R.HExp"Language.R.Internal.FunWrappers.THControl.Memory.RegionForeign.R.Internal Foreign.RData.Vector.SEXP.BaseForeign.R.ParseLanguage.R.Internal.FunWrappersLanguage.R.GlobalsLanguage.R.Internal H.Prelude Language.R.GCLanguage.R.InstanceLanguage.R.EventData.Vector.SEXP.MutableData.Vector.SEXPLanguage.R.DebugLanguage.R.Literal Language.R Language.R.QQH.Prelude.InteractiveLanguage.R.MatcherInternal.Error withProtectedRprotect unprotectControl.Exceptionbracket_Control.Monad.R.ClassControl.Monad.R.Internal!Data.Vector.SEXP.Mutable.InternalNullLanguage.R.Hexphexp%singletons-2.2-7SusgPb3Xwh4rQBPvoIfNBData.SingletonsSing InputHandlerinputHandlerCallbackinputHandlerActivityinputHandlerActiveinputHandlerFDinputHandlerUserDatainputHandlerNext runHandlers checkActivity inputHandlersgraphicsPollingPeriodgraphicsPolledEvents pollingPeriod polledEventsaddInputHandlerremoveInputHandler$fStorableInputHandler$fEqInputHandler$fShowInputHandlerSEXPTYPENilSymbolListClosureEnvPromiseLangSpecialBuiltinCharLogicalIntRealComplexString DotDotDotAnyVectorExprBytecodeExtPtrWeakRefRawS4NewFreeFunRError$fExceptionRError $fShowRError initEmbeddedR endEmbeddedRIn:∈$fNFDataSEXPTYPE$fEnumSEXPTYPE $fEqSEXPTYPE $fOrdSEXPTYPE$fShowSEXPTYPE IsExpression IsPairListIsListIsGenericVectorIsVectorPairListFALSETRUENA SSEXPTYPE$fStorableLogical$fLiftSEXPTYPE$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$fSingKindSEXPTYPE $fEqLogical $fOrdLogical $fShowLogicalHExp thWrappers thWrapperthWrapperLiteralsthWrapperLiteral<=VGVoid GlobalRegionSEXPInfoinfoTypeinfoObj infoNamedinfoGpinfoMark infoDebug infoTrace infoSpare infoGcGen infoGcClsSomeSEXPSEXP0SEXPunSEXPSEXPRECcisS4 cgetAttrib csetAttribcAttrib cSET_GCCLS cSET_GCGEN cSET_RSTEP cSET_RTRACE cSET_RDEBUG cSET_MARK cSETLEVELS cSET_NAMED cSET_OBJECT cSET_TYPEOFcGCCLScGCGENcRSTEPcRTRACEcRDEBUGcMARKcLEVELScNAMEDcOBJECTinterruptsPendingsignalHandlers globalEnvemptyEnvbaseEnv missingArg unboundValuenilValueisRInteractivecTYPEOFsexpunsexpsomesexprelease unsafeRelease unSomeSEXPcIntConv cIntToEnumcUIntFromSingEnum cIntFromEnumtypeOfsetCarsetCdrsetTag unsafeCastcastasTypeOf unsafeCoercelengthunsafeSEXPToVectorPtrunsafeVectorPtrToSEXPpeekInfopokeInfomarknamedisS4 getAttributes getAttribute setAttributes$fNFDataSomeSEXP$fStorableSomeSEXP$fShowSomeSEXP $fNFDataSEXP $fShowSEXP$fEqSEXP $fOrdSEXP$fStorableSEXP$fShowSEXPInfoCEType CE_NATIVECE_UTF8 CE_LATIN1CE_BYTES CE_SYMBOLCE_ANYcarcdrtagenvFrame envEnclosing envHashtabclosureFormals closureBody closureEnv promiseCode promiseEnv promiseValue trueLengthcharrealintegerrawlogicalcomplexstring readVector indexVector writeVectorsymbolPrintName symbolValuesymbolInternalmkStringmkCharmkCharCEinstall allocSEXP allocList allocVectorallocVectorProtectedconslcons printValue unprotectPtrgcpreserveObject releaseObjectevaltryEval tryEvalSilentlang1lang2lang3findFunfindVar mkWeakRef $fEnumCEType $fEqCEType $fShowCETypeSVECTORVECTOREElemRep ParseStatus PARSE_NULLPARSE_OKPARSE_INCOMPLETE PARSE_ERROR PARSE_EOF parseVector$fEnumParseStatus$fEqParseStatus$fShowParseStatuswrap3wrap2wrap1wrap0wrap12wrap11wrap10wrap9wrap8wrap7wrap6wrap5wrap4pokeRVariablessignalHandlersPtr installIOr2r1RegionMonadR ExecContextioacquiregetExecContextunsafeRunWithExecContext acquireSome automatic automaticSomeConfigconfigProgName configArgsconfigSignalHandlers withEmbeddedR runRegionunsafeRunRegion defaultConfig initializefinalize$fMonoidConfig$fDefaultConfig $fMonadRR $fPrimMonadR$fApplicativeR $fFunctorR$fMonadR $fMonadIOR $fMonadCatchR $fMonadMaskR $fMonadThrowRforIHforIH_registerREvents eventLoopPolleventLoopSelectrefreshMVector mvectorBase mvectorOffset mvectorLengthfromSEXPtoSEXPnullslicetakedropsplitAtinittail unsafeSlice unsafeTake unsafeDrop unsafeInit unsafeTailoverlapsnew unsafeNew replicate replicateMcloneclearreadwriteswap unsafeRead unsafeWrite unsafeSwapsetcopy unsafeCopymove unsafeMove vectorBase vectorOffset vectorLengthunsafeFromSEXP unsafeToSEXPtoString toByteString!!?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 $fVectorWa $fShowVector $fEqVector===unhexpvector$fStorableHExp$fTestEqualitySEXPTYPEHExp$fTestEqualitySEXPTYPEE$fEqHExpinspect$fToJSONSomeSEXP $fToJSONSEXP$fToJSONComplex$fToJSONSEXPInfo$fToJSONSEXPTYPELiteralmkSEXPIOmkSEXP fromSomeSEXPdynSEXP mkSEXPVectormkSEXPVectorIOmkProtectedSEXPVectormkProtectedSEXPVectorIO toPairList fromPairList funToSEXP$fHFunWrap(->)(->) $fHFunWrapRIO$fLiteral(->)ExtPtr$fLiteral(->)ExtPtr0$fLiteralRExtPtr$fLiteralSomeSEXPAny$fLiteralSEXPa$fLiteralMVectorty$fLiteralVectorty$fLiteral[]String$fLiteralComplexComplex$fLiteralDoubleReal$fLiteralInt32Int$fLiteralLogicalLogical$fLiteral[]String0$fLiteral[]Complex$fLiteral[]Real$fLiteral[]Int$fLiteral[]Logical$fLiteral(->)ExtPtr1$fLiteral(->)ExtPtr2$fLiteral(->)ExtPtr3$fLiteral(->)ExtPtr4$fLiteral(->)ExtPtr5$fLiteral(->)ExtPtr6$fLiteral(->)ExtPtr7$fLiteral(->)ExtPtr8$fLiteral(->)ExtPtr9$fLiteral(->)ExtPtr10 parseFile parseTextstringsevalEnveval_throwRcancel throwRMessagerrsafePrintRprintRp printQuote$fPrintRSomeSEXP $fPrintRSEXP $fMonadRIOMatcher runMatcher matchOnlywiths4s3 guardType someAttribute attribute attributeslookupAttribute getS3ClasscharListdimdimnamesnamesrownameschoicelistfactor$fNFDataMatcherError$fMonoidMatcherError$fAlternativeMatcher$fFunctorMatcher$fApplicativeMatcher$fMonadMatcher$fShowMatcherError$fGenericMatcherErrorfailure violation impossible unimplementedFailure Violation$fExceptionFailure$fExceptionViolation$fShowViolation $fShowFailurebaseForeign.StorableStorablepeekpokeghc-prim GHC.TypesTrueFalseFdSetremoveInputHandler_addInputHandler_endEmbeddedR'_initEmbeddedR'_FunSym0FreeSym0NewSym0S4Sym0RawSym0 WeakRefSym0 ExtPtrSym0 BytecodeSym0ExprSym0 VectorSym0AnySym0 DotDotDotSym0 StringSym0 ComplexSym0RealSym0IntSym0 LogicalSym0CharSym0 BuiltinSym0 SpecialSym0LangSym0 PromiseSym0EnvSym0 ClosureSym0ListSym0 SymbolSym0NilSym0SNilSSymbolSListSClosureSEnvSPromiseSLangSSpecialSBuiltinSCharSLogicalSIntSRealSComplexSString SDotDotDotSAnySVectorSExpr SBytecodeSExtPtrSWeakRefSRawSS4SNewSFreeSFunD:R:DemoteRepSEXPTYPE!Data.Singletons.Prelude.InstancesSTrueSFalseSTuple0STuple7STuple6STuple5STuple4STuple3STuple2SLambda applySingnSEXP0 mkCharCE_RLogical mkWeakRef'_ findVar'_ findFun'_lang3'_lang2'_lang1'_tryEvalSilent'_ tryEval'_eval'_releaseObject'_preserveObject'_gc'_unprotectPtr'_ unprotect'_ protect'_ printValue'_lcons'_cons'_ allocVector'_ allocList'_ allocSEXP'_ install'_ mkCharCE_'_mkChar'_ mkString'_symbolInternal'_ symbolValue'_symbolPrintName'_ writeVector'_ readVector'_string'_ complex'_ logical'_raw'_ integer'_real'_char'_ trueLength'_promiseValue'_ promiseEnv'_ promiseCode'_ closureEnv'_ closureBody'_closureFormals'_ envHashtab'_envEnclosing'_ envFrame'_tag'_cdr'_car'_ parseVector'_ rVariables RVariables baseEnvPtrIOGHC.BaseNothingSystem.Environment getProgNameisRInitializedPtr populateEnv newCArrayinitLockunRD:R:ExecContextR0invokeCallbackinvokeIO AcquireIO withAcquireWunW unsafeToPtrproxyWwithW $fMVectorWaphonyphony2 foreignSEXP ForeignSEXPbytestring-0.10.8.1Data.ByteString.Internal ByteStringwithForeignSEXPproxyFWproxyFW2smallestpeekHExppokeHExpHFunWraphFunWrap funPtrToSEXP parseEvalgetErrorMessageinVoidqqLockchop collectAntisexpQQparse antiSuffixisAntiD:R:ExecContextIO0 MatcherError TypeMissmatchNoSuchAttribute