@enjoys/context-engine 1.1.1 → 1.2.0

package/data/hover/r.json

@@ -0,0 +1,845 @@
+{
+  "language": "r",
+  "hovers": {
+    "if": {
+      "contents": [
+        { "value": "```r\nif (condition) expr\nif (condition) expr1 else expr2\n```\nConditional execution. Evaluates `expr` (or `expr1`/`expr2`) depending on the logical value of `condition`." }
+      ]
+    },
+    "else": {
+      "contents": [
+        { "value": "```r\nif (condition) expr1 else expr2\n```\nAlternative branch of an `if` statement. Must appear on the same line as the closing `}` of the if-block." }
+      ]
+    },
+    "for": {
+      "contents": [
+        { "value": "```r\nfor (var in seq) expr\n```\nIterate over the elements of a vector or list. `var` takes each value in `seq` in turn." }
+      ]
+    },
+    "while": {
+      "contents": [
+        { "value": "```r\nwhile (condition) expr\n```\nRepeatedly evaluate `expr` as long as `condition` is `TRUE`." }
+      ]
+    },
+    "repeat": {
+      "contents": [
+        { "value": "```r\nrepeat expr\n```\nInfinite loop. Must use `break` to exit." }
+      ]
+    },
+    "in": {
+      "contents": [
+        { "value": "```r\nfor (var in seq) ...\n```\nUsed in `for` loops to specify the sequence to iterate over." }
+      ]
+    },
+    "next": {
+      "contents": [
+        { "value": "```r\nnext\n```\nSkip the remainder of the current loop iteration and proceed to the next iteration." }
+      ]
+    },
+    "break": {
+      "contents": [
+        { "value": "```r\nbreak\n```\nExit the innermost `for`, `while`, or `repeat` loop immediately." }
+      ]
+    },
+    "function": {
+      "contents": [
+        { "value": "```r\nfunction(arglist) body\n```\nCreate a function object. The last evaluated expression is the return value. Use `return()` for early exit." }
+      ]
+    },
+    "return": {
+      "contents": [
+        { "value": "```r\nreturn(value)\n```\nExplicitly return a value from a function and exit the function body." }
+      ]
+    },
+    "TRUE": {
+      "contents": [
+        { "value": "```r\nTRUE\n```\nLogical constant for truth. `T` is an abbreviation but can be overwritten; `TRUE` cannot." }
+      ]
+    },
+    "FALSE": {
+      "contents": [
+        { "value": "```r\nFALSE\n```\nLogical constant for false. `F` is an abbreviation but can be overwritten; `FALSE` cannot." }
+      ]
+    },
+    "NULL": {
+      "contents": [
+        { "value": "```r\nNULL\n```\nThe null object representing the absence of a value. Has length 0 and no type." }
+      ]
+    },
+    "NA": {
+      "contents": [
+        { "value": "```r\nNA\n```\nLogical constant representing a missing value. Propagates through most operations. Use `is.na()` to test." }
+      ]
+    },
+    "NA_integer_": {
+      "contents": [
+        { "value": "```r\nNA_integer_\n```\nMissing value constant of type integer. Useful when explicit type is needed." }
+      ]
+    },
+    "NA_real_": {
+      "contents": [
+        { "value": "```r\nNA_real_\n```\nMissing value constant of type double." }
+      ]
+    },
+    "NA_complex_": {
+      "contents": [
+        { "value": "```r\nNA_complex_\n```\nMissing value constant of type complex." }
+      ]
+    },
+    "NA_character_": {
+      "contents": [
+        { "value": "```r\nNA_character_\n```\nMissing value constant of type character." }
+      ]
+    },
+    "Inf": {
+      "contents": [
+        { "value": "```r\nInf\n```\nPositive infinity. Result of `1/0`. Use `is.infinite()` to test." }
+      ]
+    },
+    "NaN": {
+      "contents": [
+        { "value": "```r\nNaN\n```\nNot a Number. Result of `0/0`. Use `is.nan()` to test. `is.na(NaN)` is also `TRUE`." }
+      ]
+    },
+    "library": {
+      "contents": [
+        { "value": "```r\nlibrary(package, help, pos = 2, lib.loc = NULL, character.only = FALSE, logical.return = FALSE, warn.conflicts = TRUE, quietly = FALSE, verbose = getOption(\"verbose\"))\n```\nLoad and attach an add-on package. Stops with an error if the package is not found." }
+      ]
+    },
+    "require": {
+      "contents": [
+        { "value": "```r\nrequire(package, lib.loc = NULL, quietly = FALSE, warn.conflicts = TRUE, character.only = FALSE) -> logical\n```\nTry to load and attach a package. Returns `TRUE` if successful, `FALSE` otherwise (unlike `library` which errors)." }
+      ]
+    },
+    "source": {
+      "contents": [
+        { "value": "```r\nsource(file, local = FALSE, echo = verbose, print.eval = echo, verbose = getOption(\"verbose\"), encoding = \"unknown\")\n```\nRead R expressions from a file and evaluate them in the specified environment." }
+      ]
+    },
+    "local": {
+      "contents": [
+        { "value": "```r\nlocal(expr, envir = new.env())\n```\nEvaluate an expression in a temporary local environment. Variables created inside do not persist." }
+      ]
+    },
+    "switch": {
+      "contents": [
+        { "value": "```r\nswitch(EXPR, ...)\n```\nSelect one of several alternatives. If `EXPR` is character, matches named arguments. If numeric, selects by position." }
+      ]
+    },
+    "print": {
+      "contents": [
+        { "value": "```r\nprint(x, ...)\n```\nGeneric function for printing its argument. Methods dispatch on the class of `x`." }
+      ]
+    },
+    "cat": {
+      "contents": [
+        { "value": "```r\ncat(..., file = \"\", sep = \" \", fill = FALSE, labels = NULL, append = FALSE)\n```\nConcatenate and print. Outputs the objects, concatenating with `sep`. Does not add a newline by default." }
+      ]
+    },
+    "paste": {
+      "contents": [
+        { "value": "```r\npaste(..., sep = \" \", collapse = NULL) -> character\n```\nConcatenate strings. `sep` separates elements pairwise; `collapse` collapses the resulting vector into one string." }
+      ]
+    },
+    "paste0": {
+      "contents": [
+        { "value": "```r\npaste0(..., collapse = NULL) -> character\n```\nEquivalent to `paste(..., sep = \"\")`. Concatenates with no separator." }
+      ]
+    },
+    "sprintf": {
+      "contents": [
+        { "value": "```r\nsprintf(fmt, ...) -> character\n```\nC-style formatted string. Supports `%s`, `%d`, `%f`, `%e`, `%g`, `%x`, `%%`, and width/precision modifiers." }
+      ]
+    },
+    "c": {
+      "contents": [
+        { "value": "```r\nc(..., recursive = FALSE) -> vector\n```\nCombine values into a vector or list. All arguments are coerced to a common type (hierarchy: NULL < raw < logical < integer < double < complex < character < list < expression)." }
+      ]
+    },
+    "length": {
+      "contents": [
+        { "value": "```r\nlength(x) -> integer\nlength(x) <- value\n```\nGet or set the length of vectors, lists, and other objects." }
+      ]
+    },
+    "nchar": {
+      "contents": [
+        { "value": "```r\nnchar(x, type = \"chars\", allowNA = FALSE, keepNA = NA) -> integer\n```\nReturn the number of characters (or bytes/width) in each element of a character vector." }
+      ]
+    },
+    "seq": {
+      "contents": [
+        { "value": "```r\nseq(from, to, by, length.out, along.with) -> vector\n```\nGenerate regular sequences. Arguments: starting value, end value, step size, desired length, or template object." }
+      ]
+    },
+    "seq_along": {
+      "contents": [
+        { "value": "```r\nseq_along(along.with) -> integer\n```\nGenerate a sequence `1, 2, ..., length(along.with)`. Faster and safer than `1:length(x)` when `x` may be empty." }
+      ]
+    },
+    "seq_len": {
+      "contents": [
+        { "value": "```r\nseq_len(length.out) -> integer\n```\nGenerate the sequence `1, 2, ..., length.out`. Safer than `1:n` when `n` may be 0." }
+      ]
+    },
+    "rep": {
+      "contents": [
+        { "value": "```r\nrep(x, times = 1, length.out = NA, each = 1) -> vector\n```\nReplicate elements of a vector. `times` replicates the whole vector; `each` replicates each element." }
+      ]
+    },
+    "rev": {
+      "contents": [
+        { "value": "```r\nrev(x) -> vector\n```\nReverse the order of elements in a vector or list." }
+      ]
+    },
+    "sort": {
+      "contents": [
+        { "value": "```r\nsort(x, decreasing = FALSE, na.last = NA, ...) -> vector\n```\nSort a vector. By default ascending; set `decreasing = TRUE` for descending. NAs are removed by default." }
+      ]
+    },
+    "order": {
+      "contents": [
+        { "value": "```r\norder(..., na.last = TRUE, decreasing = FALSE, method = c(\"auto\", \"shell\", \"radix\")) -> integer\n```\nReturn a permutation that rearranges its first argument into ascending or descending order." }
+      ]
+    },
+    "which": {
+      "contents": [
+        { "value": "```r\nwhich(x, arr.ind = FALSE, useNames = TRUE) -> integer\n```\nReturn the indices of elements that are `TRUE`. `which.min()` / `which.max()` return the index of the extremum." }
+      ]
+    },
+    "match": {
+      "contents": [
+        { "value": "```r\nmatch(x, table, nomatch = NA_integer_, incomparables = NULL) -> integer\n```\nReturn the positions of first matches of `x` in `table`. The `%in%` operator uses `match` internally." }
+      ]
+    },
+    "unique": {
+      "contents": [
+        { "value": "```r\nunique(x, incomparables = FALSE, fromLast = FALSE, ...) -> vector\n```\nReturn a vector with duplicate elements removed. Preserves original order." }
+      ]
+    },
+    "duplicated": {
+      "contents": [
+        { "value": "```r\nduplicated(x, incomparables = FALSE, fromLast = FALSE, ...) -> logical\n```\nReturn a logical vector indicating which elements are duplicates of elements with smaller subscripts." }
+      ]
+    },
+    "table": {
+      "contents": [
+        { "value": "```r\ntable(..., exclude = if (useNA == \"no\") c(NA, NaN), useNA = c(\"no\", \"ifany\", \"always\"), dnn, deparse.level = 1) -> table\n```\nBuild a contingency table of factor level counts." }
+      ]
+    },
+    "sum": {
+      "contents": [
+        { "value": "```r\nsum(..., na.rm = FALSE) -> numeric\n```\nReturn the sum of all values in its arguments. Set `na.rm = TRUE` to remove NA values." }
+      ]
+    },
+    "mean": {
+      "contents": [
+        { "value": "```r\nmean(x, trim = 0, na.rm = FALSE, ...) -> numeric\n```\nCompute the arithmetic mean. `trim` specifies the fraction (0 to 0.5) of observations to trim from each end." }
+      ]
+    },
+    "median": {
+      "contents": [
+        { "value": "```r\nmedian(x, na.rm = FALSE) -> numeric\n```\nCompute the sample median." }
+      ]
+    },
+    "sd": {
+      "contents": [
+        { "value": "```r\nsd(x, na.rm = FALSE) -> numeric\n```\nCompute the standard deviation (uses `n-1` denominator)." }
+      ]
+    },
+    "var": {
+      "contents": [
+        { "value": "```r\nvar(x, y = NULL, na.rm = FALSE, use) -> numeric|matrix\n```\nCompute the variance of `x`, or the covariance between `x` and `y`." }
+      ]
+    },
+    "min": {
+      "contents": [
+        { "value": "```r\nmin(..., na.rm = FALSE) -> numeric\n```\nReturn the minimum of all input values." }
+      ]
+    },
+    "max": {
+      "contents": [
+        { "value": "```r\nmax(..., na.rm = FALSE) -> numeric\n```\nReturn the maximum of all input values." }
+      ]
+    },
+    "range": {
+      "contents": [
+        { "value": "```r\nrange(..., na.rm = FALSE, finite = FALSE) -> numeric(2)\n```\nReturn a vector containing the minimum and maximum of all the given arguments." }
+      ]
+    },
+    "abs": {
+      "contents": [
+        { "value": "```r\nabs(x) -> numeric\n```\nCompute the absolute (non-negative) value." }
+      ]
+    },
+    "sqrt": {
+      "contents": [
+        { "value": "```r\nsqrt(x) -> numeric\n```\nCompute the square root. Returns `NaN` for negative values (use `sqrt(as.complex(x))` for complex result)." }
+      ]
+    },
+    "log": {
+      "contents": [
+        { "value": "```r\nlog(x, base = exp(1)) -> numeric\n```\nCompute the logarithm. Default is natural log; specify `base` for others." }
+      ]
+    },
+    "log2": {
+      "contents": [
+        { "value": "```r\nlog2(x) -> numeric\n```\nCompute the base-2 logarithm." }
+      ]
+    },
+    "log10": {
+      "contents": [
+        { "value": "```r\nlog10(x) -> numeric\n```\nCompute the base-10 (common) logarithm." }
+      ]
+    },
+    "exp": {
+      "contents": [
+        { "value": "```r\nexp(x) -> numeric\n```\nCompute the exponential function e^x." }
+      ]
+    },
+    "ceiling": {
+      "contents": [
+        { "value": "```r\nceiling(x) -> numeric\n```\nRound up to the smallest integer not less than `x`." }
+      ]
+    },
+    "floor": {
+      "contents": [
+        { "value": "```r\nfloor(x) -> numeric\n```\nRound down to the largest integer not greater than `x`." }
+      ]
+    },
+    "round": {
+      "contents": [
+        { "value": "```r\nround(x, digits = 0) -> numeric\n```\nRound to the specified number of decimal places. Uses IEC 60559 (banker's) rounding." }
+      ]
+    },
+    "trunc": {
+      "contents": [
+        { "value": "```r\ntrunc(x, ...) -> numeric\n```\nTruncate towards zero (round towards zero)." }
+      ]
+    },
+    "sign": {
+      "contents": [
+        { "value": "```r\nsign(x) -> numeric\n```\nReturn the signs of the elements: -1 for negative, 0 for zero, 1 for positive." }
+      ]
+    },
+    "cumsum": {
+      "contents": [
+        { "value": "```r\ncumsum(x) -> numeric\n```\nReturn a vector of cumulative sums." }
+      ]
+    },
+    "cumprod": {
+      "contents": [
+        { "value": "```r\ncumprod(x) -> numeric\n```\nReturn a vector of cumulative products." }
+      ]
+    },
+    "cummax": {
+      "contents": [
+        { "value": "```r\ncummax(x) -> numeric\n```\nReturn a vector of cumulative maxima." }
+      ]
+    },
+    "cummin": {
+      "contents": [
+        { "value": "```r\ncummin(x) -> numeric\n```\nReturn a vector of cumulative minima." }
+      ]
+    },
+    "diff": {
+      "contents": [
+        { "value": "```r\ndiff(x, lag = 1, differences = 1, ...) -> numeric\n```\nReturn lagged differences. `differences` controls how many times to apply the differencing." }
+      ]
+    },
+    "head": {
+      "contents": [
+        { "value": "```r\nhead(x, n = 6L) -> object\n```\nReturn the first `n` elements or rows. Negative `n` returns all but the last `|n|` elements." }
+      ]
+    },
+    "tail": {
+      "contents": [
+        { "value": "```r\ntail(x, n = 6L) -> object\n```\nReturn the last `n` elements or rows." }
+      ]
+    },
+    "nrow": {
+      "contents": [
+        { "value": "```r\nnrow(x) -> integer|NULL\n```\nReturn the number of rows of a matrix, array, or data frame. Returns `NULL` for vectors." }
+      ]
+    },
+    "ncol": {
+      "contents": [
+        { "value": "```r\nncol(x) -> integer|NULL\n```\nReturn the number of columns of a matrix, array, or data frame." }
+      ]
+    },
+    "dim": {
+      "contents": [
+        { "value": "```r\ndim(x) -> integer|NULL\ndim(x) <- value\n```\nGet or set the dimension attribute. For a matrix, returns c(nrow, ncol)." }
+      ]
+    },
+    "names": {
+      "contents": [
+        { "value": "```r\nnames(x) -> character|NULL\nnames(x) <- value\n```\nGet or set the names attribute of an object." }
+      ]
+    },
+    "colnames": {
+      "contents": [
+        { "value": "```r\ncolnames(x, do.NULL = TRUE, prefix = \"col\") -> character|NULL\ncolnames(x) <- value\n```\nGet or set column names of a matrix-like object." }
+      ]
+    },
+    "rownames": {
+      "contents": [
+        { "value": "```r\nrownames(x, do.NULL = TRUE, prefix = \"row\") -> character|NULL\nrownames(x) <- value\n```\nGet or set row names of a matrix-like object." }
+      ]
+    },
+    "str": {
+      "contents": [
+        { "value": "```r\nstr(object, max.level = NA, vec.len = 4, ...) -> invisible(NULL)\n```\nCompactly display the internal structure of an R object. A diagnostic function." }
+      ]
+    },
+    "summary": {
+      "contents": [
+        { "value": "```r\nsummary(object, ...) -> varies\n```\nGeneric function for producing result summaries. Output depends on the class of the object." }
+      ]
+    },
+    "class": {
+      "contents": [
+        { "value": "```r\nclass(x) -> character\nclass(x) <- value\n```\nGet or set the class attribute. Determines method dispatch for S3 generic functions." }
+      ]
+    },
+    "typeof": {
+      "contents": [
+        { "value": "```r\ntypeof(x) -> character\n```\nReturn the internal type/storage mode: \"logical\", \"integer\", \"double\", \"complex\", \"character\", \"list\", etc." }
+      ]
+    },
+    "is.numeric": {
+      "contents": [
+        { "value": "```r\nis.numeric(x) -> logical\n```\nReturn `TRUE` if `x` is of numeric type (integer or double) and not a factor." }
+      ]
+    },
+    "is.character": {
+      "contents": [
+        { "value": "```r\nis.character(x) -> logical\n```\nReturn `TRUE` if `x` is of type character." }
+      ]
+    },
+    "is.logical": {
+      "contents": [
+        { "value": "```r\nis.logical(x) -> logical\n```\nReturn `TRUE` if `x` is of type logical." }
+      ]
+    },
+    "is.na": {
+      "contents": [
+        { "value": "```r\nis.na(x) -> logical\n```\nReturn a logical vector indicating which elements are `NA` or `NaN`." }
+      ]
+    },
+    "is.null": {
+      "contents": [
+        { "value": "```r\nis.null(x) -> logical\n```\nReturn `TRUE` if `x` is `NULL`." }
+      ]
+    },
+    "as.numeric": {
+      "contents": [
+        { "value": "```r\nas.numeric(x, ...) -> double\n```\nCoerce to double-precision numeric. Identical to `as.double()`." }
+      ]
+    },
+    "as.character": {
+      "contents": [
+        { "value": "```r\nas.character(x, ...) -> character\n```\nCoerce to character (string) representation." }
+      ]
+    },
+    "as.logical": {
+      "contents": [
+        { "value": "```r\nas.logical(x, ...) -> logical\n```\nCoerce to logical. Numbers: 0 → FALSE, non-zero → TRUE. Strings: \"TRUE\"/\"FALSE\"." }
+      ]
+    },
+    "as.integer": {
+      "contents": [
+        { "value": "```r\nas.integer(x, ...) -> integer\n```\nCoerce to integer. Truncates doubles towards zero." }
+      ]
+    },
+    "as.double": {
+      "contents": [
+        { "value": "```r\nas.double(x, ...) -> double\n```\nCoerce to double-precision floating point number." }
+      ]
+    },
+    "as.data.frame": {
+      "contents": [
+        { "value": "```r\nas.data.frame(x, row.names = NULL, optional = FALSE, ...) -> data.frame\n```\nCoerce to data frame. Handles matrices, lists, vectors, and other objects." }
+      ]
+    },
+    "data.frame": {
+      "contents": [
+        { "value": "```r\ndata.frame(..., row.names = NULL, check.rows = FALSE, check.names = TRUE, fix.empty.names = TRUE, stringsAsFactors = FALSE) -> data.frame\n```\nCreate a data frame from the supplied column vectors or lists." }
+      ]
+    },
+    "matrix": {
+      "contents": [
+        { "value": "```r\nmatrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE, dimnames = NULL) -> matrix\n```\nCreate a matrix from the given data, filled column-wise by default." }
+      ]
+    },
+    "array": {
+      "contents": [
+        { "value": "```r\narray(data = NA, dim = length(data), dimnames = NULL) -> array\n```\nCreate a multi-dimensional array." }
+      ]
+    },
+    "list": {
+      "contents": [
+        { "value": "```r\nlist(...) -> list\n```\nConstruct a list. Lists can contain elements of different types and are accessed with `[[` or `$`." }
+      ]
+    },
+    "vector": {
+      "contents": [
+        { "value": "```r\nvector(mode = \"logical\", length = 0L) -> vector\n```\nCreate a vector of the specified mode and length, initialized to default values." }
+      ]
+    },
+    "factor": {
+      "contents": [
+        { "value": "```r\nfactor(x, levels, labels = levels, exclude = NA, ordered = is.ordered(x)) -> factor\n```\nEncode a vector as a factor. Levels define the set of allowed values." }
+      ]
+    },
+    "read.csv": {
+      "contents": [
+        { "value": "```r\nread.csv(file, header = TRUE, sep = \",\", quote = \"\\\"\", dec = \".\", fill = TRUE, comment.char = \"\", ...) -> data.frame\n```\nRead a comma-separated values file into a data frame." }
+      ]
+    },
+    "read.table": {
+      "contents": [
+        { "value": "```r\nread.table(file, header = FALSE, sep = \"\", quote = \"\\\"'\", dec = \".\", ...) -> data.frame\n```\nRead a file in table format into a data frame." }
+      ]
+    },
+    "write.csv": {
+      "contents": [
+        { "value": "```r\nwrite.csv(x, file = \"\", row.names = TRUE, ...) -> invisible(NULL)\n```\nWrite a data frame to a comma-separated values file." }
+      ]
+    },
+    "write.table": {
+      "contents": [
+        { "value": "```r\nwrite.table(x, file = \"\", append = FALSE, quote = TRUE, sep = \" \", eol = \"\\n\", na = \"NA\", dec = \".\", row.names = TRUE, col.names = TRUE) -> invisible(NULL)\n```\nWrite a data frame or matrix to a file." }
+      ]
+    },
+    "readRDS": {
+      "contents": [
+        { "value": "```r\nreadRDS(file, refhook = NULL) -> object\n```\nRead a single R object from a file serialized with `saveRDS()`." }
+      ]
+    },
+    "saveRDS": {
+      "contents": [
+        { "value": "```r\nsaveRDS(object, file = \"\", ascii = FALSE, version = NULL, compress = TRUE, refhook = NULL)\n```\nSerialize a single R object to a file. Use `readRDS()` to restore." }
+      ]
+    },
+    "file.path": {
+      "contents": [
+        { "value": "```r\nfile.path(..., fsep = .Platform$file.sep) -> character\n```\nConstruct file paths from components in a platform-independent way." }
+      ]
+    },
+    "file.exists": {
+      "contents": [
+        { "value": "```r\nfile.exists(...) -> logical\n```\nReturn `TRUE` for each argument that is an existing file (not directory, by default)." }
+      ]
+    },
+    "dir.create": {
+      "contents": [
+        { "value": "```r\ndir.create(path, showWarnings = TRUE, recursive = FALSE, mode = \"0777\")\n```\nCreate a directory. With `recursive = TRUE`, create parent directories as needed." }
+      ]
+    },
+    "getwd": {
+      "contents": [
+        { "value": "```r\ngetwd() -> character\n```\nReturn the absolute path of the current working directory." }
+      ]
+    },
+    "setwd": {
+      "contents": [
+        { "value": "```r\nsetwd(dir) -> character\n```\nSet the working directory. Returns the previous working directory (invisibly)." }
+      ]
+    },
+    "Sys.time": {
+      "contents": [
+        { "value": "```r\nSys.time() -> POSIXct\n```\nReturn the current date and time as a POSIXct object." }
+      ]
+    },
+    "Sys.sleep": {
+      "contents": [
+        { "value": "```r\nSys.sleep(time)\n```\nSuspend execution for `time` seconds (can be fractional)." }
+      ]
+    },
+    "system": {
+      "contents": [
+        { "value": "```r\nsystem(command, intern = FALSE, ignore.stdout = FALSE, ignore.stderr = FALSE, wait = TRUE, input = NULL, ...) -> integer|character\n```\nInvoke an OS command. With `intern = TRUE`, captures stdout as a character vector." }
+      ]
+    },
+    "system2": {
+      "contents": [
+        { "value": "```r\nsystem2(command, args = character(), stdout = \"\", stderr = \"\", stdin = \"\", input = NULL, env = character(), wait = TRUE, ...) -> integer|character\n```\nInterface to OS commands. Safer than `system()` — command and args are separate." }
+      ]
+    },
+    "tryCatch": {
+      "contents": [
+        { "value": "```r\ntryCatch(expr, ..., finally)\n```\nEvaluate `expr` with condition handlers. Handlers are named arguments matching condition classes (e.g., `error`, `warning`, `message`). `finally` is always evaluated." }
+      ]
+    },
+    "withCallingHandlers": {
+      "contents": [
+        { "value": "```r\nwithCallingHandlers(expr, ...)\n```\nEstablish calling handlers. Unlike `tryCatch`, execution continues in the calling context after the handler returns." }
+      ]
+    },
+    "stop": {
+      "contents": [
+        { "value": "```r\nstop(..., call. = TRUE, domain = NULL)\n```\nStop execution and signal an error condition with the given message." }
+      ]
+    },
+    "warning": {
+      "contents": [
+        { "value": "```r\nwarning(..., call. = TRUE, immediate. = FALSE, noBreaks. = FALSE, domain = NULL)\n```\nGenerate a warning message." }
+      ]
+    },
+    "message": {
+      "contents": [
+        { "value": "```r\nmessage(..., domain = NULL, appendLF = TRUE)\n```\nGenerate a diagnostic message to stderr. Can be suppressed with `suppressMessages()`." }
+      ]
+    },
+    "format": {
+      "contents": [
+        { "value": "```r\nformat(x, ...) -> character\n```\nFormat an R object for pretty printing. Many classes have specific methods." }
+      ]
+    },
+    "substr": {
+      "contents": [
+        { "value": "```r\nsubstr(x, start, stop) -> character\nsubstr(x, start, stop) <- value\n```\nExtract or replace substrings in character vectors." }
+      ]
+    },
+    "substring": {
+      "contents": [
+        { "value": "```r\nsubstring(text, first, last = 1000000L) -> character\n```\nExtract substrings. Compatible with replacement and vectorized over all arguments." }
+      ]
+    },
+    "gsub": {
+      "contents": [
+        { "value": "```r\ngsub(pattern, replacement, x, ignore.case = FALSE, perl = FALSE, fixed = FALSE, useBytes = FALSE) -> character\n```\nReplace all occurrences of `pattern` in `x` with `replacement`." }
+      ]
+    },
+    "sub": {
+      "contents": [
+        { "value": "```r\nsub(pattern, replacement, x, ignore.case = FALSE, perl = FALSE, fixed = FALSE, useBytes = FALSE) -> character\n```\nReplace the first occurrence of `pattern` in `x` with `replacement`." }
+      ]
+    },
+    "grep": {
+      "contents": [
+        { "value": "```r\ngrep(pattern, x, ignore.case = FALSE, perl = FALSE, value = FALSE, fixed = FALSE, useBytes = FALSE, invert = FALSE) -> integer|character\n```\nSearch for matches to `pattern`. Returns indices by default, or matching values if `value = TRUE`." }
+      ]
+    },
+    "grepl": {
+      "contents": [
+        { "value": "```r\ngrepl(pattern, x, ignore.case = FALSE, perl = FALSE, fixed = FALSE, useBytes = FALSE) -> logical\n```\nReturn a logical vector indicating which elements of `x` match `pattern`." }
+      ]
+    },
+    "regexpr": {
+      "contents": [
+        { "value": "```r\nregexpr(pattern, text, ignore.case = FALSE, perl = FALSE, fixed = FALSE, useBytes = FALSE) -> integer\n```\nFind the first match of `pattern` in each element of `text`. Returns starting position with `match.length` attribute." }
+      ]
+    },
+    "gregexpr": {
+      "contents": [
+        { "value": "```r\ngregexpr(pattern, text, ignore.case = FALSE, perl = FALSE, fixed = FALSE, useBytes = FALSE) -> list\n```\nFind all matches of `pattern` in each element of `text`." }
+      ]
+    },
+    "strsplit": {
+      "contents": [
+        { "value": "```r\nstrsplit(x, split, fixed = FALSE, perl = FALSE, useBytes = FALSE) -> list\n```\nSplit elements of a character vector by a pattern. Returns a list of character vectors." }
+      ]
+    },
+    "trimws": {
+      "contents": [
+        { "value": "```r\ntrimws(x, which = c(\"both\", \"left\", \"right\"), whitespace = \"[ \\t\\r\\n]\") -> character\n```\nRemove leading and/or trailing whitespace from character strings." }
+      ]
+    },
+    "toupper": {
+      "contents": [
+        { "value": "```r\ntoupper(x) -> character\n```\nConvert all characters to upper case." }
+      ]
+    },
+    "tolower": {
+      "contents": [
+        { "value": "```r\ntolower(x) -> character\n```\nConvert all characters to lower case." }
+      ]
+    },
+    "startsWith": {
+      "contents": [
+        { "value": "```r\nstartsWith(x, prefix) -> logical\n```\nTest whether elements of `x` start with `prefix`." }
+      ]
+    },
+    "endsWith": {
+      "contents": [
+        { "value": "```r\nendsWith(x, suffix) -> logical\n```\nTest whether elements of `x` end with `suffix`." }
+      ]
+    },
+    "apply": {
+      "contents": [
+        { "value": "```r\napply(X, MARGIN, FUN, ..., simplify = TRUE) -> array|list\n```\nApply a function over array margins. `MARGIN = 1` for rows, `2` for columns." }
+      ]
+    },
+    "sapply": {
+      "contents": [
+        { "value": "```r\nsapply(X, FUN, ..., simplify = TRUE, USE.NAMES = TRUE) -> vector|matrix|list\n```\nApply a function and simplify the result to a vector or matrix if possible." }
+      ]
+    },
+    "lapply": {
+      "contents": [
+        { "value": "```r\nlapply(X, FUN, ...) -> list\n```\nApply a function over a list or vector and return a list." }
+      ]
+    },
+    "vapply": {
+      "contents": [
+        { "value": "```r\nvapply(X, FUN, FUN.VALUE, ..., USE.NAMES = TRUE) -> array\n```\nApply a function with a pre-specified return type. Safer than `sapply` because the return type is checked." }
+      ]
+    },
+    "tapply": {
+      "contents": [
+        { "value": "```r\ntapply(X, INDEX, FUN = NULL, ..., default = NA, simplify = TRUE) -> array\n```\nApply a function to groups of values defined by a factor or list of factors." }
+      ]
+    },
+    "mapply": {
+      "contents": [
+        { "value": "```r\nmapply(FUN, ..., MoreArgs = NULL, SIMPLIFY = TRUE, USE.NAMES = TRUE) -> list|vector\n```\nMultivariate version of `sapply`. Applies `FUN` to the corresponding elements of each argument." }
+      ]
+    },
+    "Map": {
+      "contents": [
+        { "value": "```r\nMap(f, ...) -> list\n```\nApply `f` to corresponding elements. Wrapper for `mapply(..., SIMPLIFY = FALSE)`." }
+      ]
+    },
+    "Reduce": {
+      "contents": [
+        { "value": "```r\nReduce(f, x, init, right = FALSE, accumulate = FALSE) -> object\n```\nReduce a list to a single value by applying a binary function cumulatively." }
+      ]
+    },
+    "Filter": {
+      "contents": [
+        { "value": "```r\nFilter(f, x) -> list|vector\n```\nExtract elements of `x` for which `f(element)` is `TRUE`." }
+      ]
+    },
+    "do.call": {
+      "contents": [
+        { "value": "```r\ndo.call(what, args, quote = FALSE, envir = parent.frame()) -> object\n```\nExecute a function call with arguments supplied as a list." }
+      ]
+    },
+    "Vectorize": {
+      "contents": [
+        { "value": "```r\nVectorize(FUN, vectorize.args = arg.names, SIMPLIFY = TRUE, USE.NAMES = TRUE) -> function\n```\nCreate a vectorized version of a function that is not already vectorized." }
+      ]
+    },
+    "ifelse": {
+      "contents": [
+        { "value": "```r\nifelse(test, yes, no) -> vector\n```\nVectorized conditional. Returns `yes` where `test` is TRUE, `no` where FALSE." }
+      ]
+    },
+    "plot": {
+      "contents": [
+        { "value": "```r\nplot(x, y, ...) -> NULL\n```\nGeneric X-Y plotting function. Dispatches on the class of the first argument." }
+      ]
+    },
+    "hist": {
+      "contents": [
+        { "value": "```r\nhist(x, breaks = \"Sturges\", freq = NULL, col = NULL, main = paste(\"Histogram of\", xname), ...) -> histogram\n```\nCompute and plot a histogram of the given data." }
+      ]
+    },
+    "barplot": {
+      "contents": [
+        { "value": "```r\nbarplot(height, ..., width = 1, space = NULL, names.arg = NULL, col = NULL) -> numeric\n```\nCreate a bar plot with vertical or horizontal bars." }
+      ]
+    },
+    "boxplot": {
+      "contents": [
+        { "value": "```r\nboxplot(formula, data = NULL, ..., range = 1.5, col = NULL) -> list\n```\nProduce box-and-whisker plot(s) of the given (grouped) values." }
+      ]
+    },
+    "ggplot": {
+      "contents": [
+        { "value": "```r\nggplot(data = NULL, mapping = aes(), ..., environment = parent.frame()) -> ggplot\n```\nInitialize a ggplot object. Use `+` to add layers, scales, and themes." }
+      ]
+    },
+    "aes": {
+      "contents": [
+        { "value": "```r\naes(x, y, ...) -> mapping\n```\nConstruct aesthetic mappings for ggplot2 layers. Maps data variables to visual properties." }
+      ]
+    },
+    "install.packages": {
+      "contents": [
+        { "value": "```r\ninstall.packages(pkgs, lib, repos = getOption(\"repos\"), ...) -> invisible(NULL)\n```\nDownload and install packages from CRAN or other repositories." }
+      ]
+    },
+    "lm": {
+      "contents": [
+        { "value": "```r\nlm(formula, data, subset, weights, na.action, method = \"qr\", model = TRUE, ...) -> lm\n```\nFit a linear model using ordinary least squares." }
+      ]
+    },
+    "glm": {
+      "contents": [
+        { "value": "```r\nglm(formula, family = gaussian, data, weights, subset, na.action, ...) -> glm\n```\nFit a generalized linear model with the specified family (binomial, poisson, etc.)." }
+      ]
+    },
+    "t.test": {
+      "contents": [
+        { "value": "```r\nt.test(x, y = NULL, alternative = c(\"two.sided\", \"less\", \"greater\"), mu = 0, paired = FALSE, var.equal = FALSE, conf.level = 0.95) -> htest\n```\nPerform one-sample or two-sample Student's t-test." }
+      ]
+    },
+    "cor": {
+      "contents": [
+        { "value": "```r\ncor(x, y = NULL, use = \"everything\", method = c(\"pearson\", \"kendall\", \"spearman\")) -> numeric|matrix\n```\nCompute correlation coefficients between vectors or columns of a matrix." }
+      ]
+    },
+    "predict": {
+      "contents": [
+        { "value": "```r\npredict(object, newdata, ...) -> varies\n```\nGeneric function for predictions from model fits. Output depends on model class." }
+      ]
+    },
+    "setClass": {
+      "contents": [
+        { "value": "```r\nsetClass(Class, representation, prototype, contains, validity, sealed, ...) -> Class\n```\nDefine an S4 class with typed slots and optional inheritance." }
+      ]
+    },
+    "setGeneric": {
+      "contents": [
+        { "value": "```r\nsetGeneric(name, def, ...) -> name\n```\nDefine an S4 generic function for method dispatch." }
+      ]
+    },
+    "setMethod": {
+      "contents": [
+        { "value": "```r\nsetMethod(f, signature, definition, ...) -> f\n```\nDefine an S4 method for a generic function and signature." }
+      ]
+    },
+    "R6Class": {
+      "contents": [
+        { "value": "```r\nR6Class(classname, public, private, active, inherit, lock_objects, class, portable, lock_class, cloneable, parent_env) -> R6ClassGenerator\n```\nCreate an R6 class generator (requires R6 package). Supports public/private fields, active bindings, and inheritance." }
+      ]
+    },
+    "new.env": {
+      "contents": [
+        { "value": "```r\nnew.env(hash = TRUE, parent = parent.frame(), size = 29L) -> environment\n```\nCreate a new environment with the specified parent." }
+      ]
+    },
+    "environment": {
+      "contents": [
+        { "value": "```r\nenvironment(fun = NULL) -> environment\nenvironment(fun) <- value\n```\nGet or set the environment of a function. `environment()` with no args returns the current environment." }
+      ]
+    },
+    "exists": {
+      "contents": [
+        { "value": "```r\nexists(x, where = -1, envir, frame, mode = \"any\", inherits = TRUE) -> logical\n```\nReturn `TRUE` if a variable with the given name exists in the specified environment." }
+      ]
+    },
+    "get": {
+      "contents": [
+        { "value": "```r\nget(x, envir = parent.frame(), mode = \"any\", inherits = TRUE) -> object\n```\nSearch for an object by name and return it." }
+      ]
+    },
+    "assign": {
+      "contents": [
+        { "value": "```r\nassign(x, value, envir = parent.frame(), inherits = FALSE, immediate = TRUE)\n```\nAssign a value to a name in the specified environment." }
+      ]
+    },
+    "rm": {
+      "contents": [
+        { "value": "```r\nrm(..., list = character(), envir = parent.frame(), inherits = FALSE)\n```\nRemove objects from the specified environment." }
+      ]
+    },
+    "ls": {
+      "contents": [
+        { "value": "```r\nls(name, envir, all.names = FALSE, pattern, sorted = TRUE) -> character\n```\nReturn a character vector of the names of objects in the specified environment." }
+      ]
+    }
+  }
+}