@enjoys/context-engine 1.4.1 → 1.4.2

package/data/definition/r.json

@@ -1,84 +1,693 @@
-{
-  "language": "r",
-  "definitions": {
-    "data.frame": {
-      "signature": "data.frame(..., row.names = NULL, check.rows = FALSE, check.names = TRUE, stringsAsFactors = FALSE)",
-      "description": "A data frame is a table-like structure: a list of equal-length vectors. The fundamental data structure for tabular data in R.",
-      "type": "class",
-      "module": "base",
-      "members": {
-        "nrow": { "signature": "nrow(x) -> integer", "description": "Return the number of rows.", "type": "method" },
-        "ncol": { "signature": "ncol(x) -> integer", "description": "Return the number of columns.", "type": "method" },
-        "names": { "signature": "names(x) -> character", "description": "Get column names.", "type": "method" },
-        "colnames": { "signature": "colnames(x) -> character", "description": "Get or set column names.", "type": "method" },
-        "rownames": { "signature": "rownames(x) -> character", "description": "Get or set row names.", "type": "method" },
-        "str": { "signature": "str(x)", "description": "Compactly display structure.", "type": "method" },
-        "summary": { "signature": "summary(x)", "description": "Produce summary statistics.", "type": "method" },
-        "head": { "signature": "head(x, n = 6)", "description": "Return first n rows.", "type": "method" },
-        "tail": { "signature": "tail(x, n = 6)", "description": "Return last n rows.", "type": "method" },
-        "merge": { "signature": "merge(x, y, by, ...)", "description": "Merge two data frames by common columns.", "type": "method" },
-        "subset": { "signature": "subset(x, subset, select)", "description": "Return subsets matching conditions.", "type": "method" },
-        "transform": { "signature": "transform(x, ...)", "description": "Modify or add columns.", "type": "method" },
-        "rbind": { "signature": "rbind(x, ...)", "description": "Combine by rows.", "type": "method" },
-        "cbind": { "signature": "cbind(x, ...)", "description": "Combine by columns.", "type": "method" }
-      }
-    },
-    "list": {
-      "signature": "list(...)",
-      "description": "A generic container that can hold objects of any type, including other lists. Accessed with `[[`, `$`, or `[`.",
-      "type": "class",
-      "module": "base",
-      "members": {
-        "length": { "signature": "length(x) -> integer", "description": "Number of elements.", "type": "method" },
-        "names": { "signature": "names(x) -> character|NULL", "description": "Get or set names.", "type": "method" },
-        "append": { "signature": "append(x, values, after)", "description": "Append elements to a list.", "type": "method" },
-        "unlist": { "signature": "unlist(x, recursive = TRUE)", "description": "Flatten a list to a vector.", "type": "method" }
-      }
-    },
-    "matrix": {
-      "signature": "matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE, dimnames = NULL)",
-      "description": "A two-dimensional array of elements of the same type. Special case of array with 2 dimensions.",
-      "type": "class",
-      "module": "base",
-      "members": {
-        "nrow": { "signature": "nrow(x) -> integer", "description": "Number of rows.", "type": "method" },
-        "ncol": { "signature": "ncol(x) -> integer", "description": "Number of columns.", "type": "method" },
-        "dim": { "signature": "dim(x) -> integer(2)", "description": "Dimensions (nrow, ncol).", "type": "method" },
-        "t": { "signature": "t(x) -> matrix", "description": "Transpose the matrix.", "type": "method" },
-        "det": { "signature": "det(x) -> numeric", "description": "Compute the determinant.", "type": "method" },
-        "solve": { "signature": "solve(a, b) -> matrix", "description": "Solve a system of equations or compute inverse.", "type": "method" },
-        "crossprod": { "signature": "crossprod(x, y) -> matrix", "description": "Crossproduct: t(x) %*% y.", "type": "method" },
-        "rowSums": { "signature": "rowSums(x) -> numeric", "description": "Sum of each row.", "type": "method" },
-        "colSums": { "signature": "colSums(x) -> numeric", "description": "Sum of each column.", "type": "method" },
-        "rowMeans": { "signature": "rowMeans(x) -> numeric", "description": "Mean of each row.", "type": "method" },
-        "colMeans": { "signature": "colMeans(x) -> numeric", "description": "Mean of each column.", "type": "method" }
-      }
-    },
-    "factor": {
-      "signature": "factor(x, levels, labels = levels, exclude = NA, ordered = FALSE)",
-      "description": "Categorical variable with a fixed set of possible values (levels). Used extensively in statistical modeling.",
-      "type": "class",
-      "module": "base",
-      "members": {
-        "levels": { "signature": "levels(x) -> character", "description": "Get or set the levels.", "type": "method" },
-        "nlevels": { "signature": "nlevels(x) -> integer", "description": "Number of levels.", "type": "method" },
-        "droplevels": { "signature": "droplevels(x)", "description": "Drop unused levels.", "type": "method" },
-        "relevel": { "signature": "relevel(x, ref)", "description": "Reorder levels with ref first.", "type": "method" },
-        "table": { "signature": "table(x) -> table", "description": "Frequency table of levels.", "type": "method" }
-      }
-    },
-    "environment": {
-      "signature": "new.env(hash = TRUE, parent = parent.frame(), size = 29L)",
-      "description": "A frame for variable bindings. Every function has an associated environment. Environments form a tree via parent links.",
-      "type": "class",
-      "module": "base",
-      "members": {
-        "ls": { "signature": "ls(envir = env) -> character", "description": "List objects in environment.", "type": "method" },
-        "get": { "signature": "get(name, envir = env)", "description": "Get a value from the environment.", "type": "method" },
-        "assign": { "signature": "assign(name, value, envir = env)", "description": "Assign a value in the environment.", "type": "method" },
-        "parent.env": { "signature": "parent.env(env) -> environment", "description": "Get parent environment.", "type": "method" },
-        "environmentName": { "signature": "environmentName(env) -> character", "description": "Get environment name.", "type": "method" }
-      }
-    }
-  }
+{
+  "language": "r",
+  "definitions": {
+    "data.frame": {
+      "signature": "data.frame(..., row.names = NULL, check.rows = FALSE, check.names = TRUE, stringsAsFactors = FALSE)",
+      "description": "A data frame is a table-like structure: a list of equal-length vectors. The fundamental data structure for tabular data in R.",
+      "type": "class",
+      "module": "base",
+      "members": {
+        "nrow": {
+          "signature": "nrow(x) -> integer",
+          "description": "Return the number of rows.",
+          "type": "method"
+        },
+        "ncol": {
+          "signature": "ncol(x) -> integer",
+          "description": "Return the number of columns.",
+          "type": "method"
+        },
+        "names": {
+          "signature": "names(x) -> character",
+          "description": "Get column names.",
+          "type": "method"
+        },
+        "colnames": {
+          "signature": "colnames(x) -> character",
+          "description": "Get or set column names.",
+          "type": "method"
+        },
+        "rownames": {
+          "signature": "rownames(x) -> character",
+          "description": "Get or set row names.",
+          "type": "method"
+        },
+        "str": {
+          "signature": "str(x)",
+          "description": "Compactly display structure.",
+          "type": "method"
+        },
+        "summary": {
+          "signature": "summary(x)",
+          "description": "Produce summary statistics.",
+          "type": "method"
+        },
+        "head": {
+          "signature": "head(x, n = 6)",
+          "description": "Return first n rows.",
+          "type": "method"
+        },
+        "tail": {
+          "signature": "tail(x, n = 6)",
+          "description": "Return last n rows.",
+          "type": "method"
+        },
+        "merge": {
+          "signature": "merge(x, y, by, ...)",
+          "description": "Merge two data frames by common columns.",
+          "type": "method"
+        },
+        "subset": {
+          "signature": "subset(x, subset, select)",
+          "description": "Return subsets matching conditions.",
+          "type": "method"
+        },
+        "transform": {
+          "signature": "transform(x, ...)",
+          "description": "Modify or add columns.",
+          "type": "method"
+        },
+        "rbind": {
+          "signature": "rbind(x, ...)",
+          "description": "Combine by rows.",
+          "type": "method"
+        },
+        "cbind": {
+          "signature": "cbind(x, ...)",
+          "description": "Combine by columns.",
+          "type": "method"
+        }
+      }
+    },
+    "list": {
+      "signature": "list(...)",
+      "description": "A generic container that can hold objects of any type, including other lists. Accessed with `[[`, `$`, or `[`.",
+      "type": "class",
+      "module": "base",
+      "members": {
+        "length": {
+          "signature": "length(x) -> integer",
+          "description": "Number of elements.",
+          "type": "method"
+        },
+        "names": {
+          "signature": "names(x) -> character|NULL",
+          "description": "Get or set names.",
+          "type": "method"
+        },
+        "append": {
+          "signature": "append(x, values, after)",
+          "description": "Append elements to a list.",
+          "type": "method"
+        },
+        "unlist": {
+          "signature": "unlist(x, recursive = TRUE)",
+          "description": "Flatten a list to a vector.",
+          "type": "method"
+        }
+      }
+    },
+    "matrix": {
+      "signature": "matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE, dimnames = NULL)",
+      "description": "A two-dimensional array of elements of the same type. Special case of array with 2 dimensions.",
+      "type": "class",
+      "module": "base",
+      "members": {
+        "nrow": {
+          "signature": "nrow(x) -> integer",
+          "description": "Number of rows.",
+          "type": "method"
+        },
+        "ncol": {
+          "signature": "ncol(x) -> integer",
+          "description": "Number of columns.",
+          "type": "method"
+        },
+        "dim": {
+          "signature": "dim(x) -> integer(2)",
+          "description": "Dimensions (nrow, ncol).",
+          "type": "method"
+        },
+        "t": {
+          "signature": "t(x) -> matrix",
+          "description": "Transpose the matrix.",
+          "type": "method"
+        },
+        "det": {
+          "signature": "det(x) -> numeric",
+          "description": "Compute the determinant.",
+          "type": "method"
+        },
+        "solve": {
+          "signature": "solve(a, b) -> matrix",
+          "description": "Solve a system of equations or compute inverse.",
+          "type": "method"
+        },
+        "crossprod": {
+          "signature": "crossprod(x, y) -> matrix",
+          "description": "Crossproduct: t(x) %*% y.",
+          "type": "method"
+        },
+        "rowSums": {
+          "signature": "rowSums(x) -> numeric",
+          "description": "Sum of each row.",
+          "type": "method"
+        },
+        "colSums": {
+          "signature": "colSums(x) -> numeric",
+          "description": "Sum of each column.",
+          "type": "method"
+        },
+        "rowMeans": {
+          "signature": "rowMeans(x) -> numeric",
+          "description": "Mean of each row.",
+          "type": "method"
+        },
+        "colMeans": {
+          "signature": "colMeans(x) -> numeric",
+          "description": "Mean of each column.",
+          "type": "method"
+        }
+      }
+    },
+    "factor": {
+      "signature": "factor(x, levels, labels = levels, exclude = NA, ordered = FALSE)",
+      "description": "Categorical variable with a fixed set of possible values (levels). Used extensively in statistical modeling.",
+      "type": "class",
+      "module": "base",
+      "members": {
+        "levels": {
+          "signature": "levels(x) -> character",
+          "description": "Get or set the levels.",
+          "type": "method"
+        },
+        "nlevels": {
+          "signature": "nlevels(x) -> integer",
+          "description": "Number of levels.",
+          "type": "method"
+        },
+        "droplevels": {
+          "signature": "droplevels(x)",
+          "description": "Drop unused levels.",
+          "type": "method"
+        },
+        "relevel": {
+          "signature": "relevel(x, ref)",
+          "description": "Reorder levels with ref first.",
+          "type": "method"
+        },
+        "table": {
+          "signature": "table(x) -> table",
+          "description": "Frequency table of levels.",
+          "type": "method"
+        }
+      }
+    },
+    "environment": {
+      "signature": "new.env(hash = TRUE, parent = parent.frame(), size = 29L)",
+      "description": "A frame for variable bindings. Every function has an associated environment. Environments form a tree via parent links.",
+      "type": "class",
+      "module": "base",
+      "members": {
+        "ls": {
+          "signature": "ls(envir = env) -> character",
+          "description": "List objects in environment.",
+          "type": "method"
+        },
+        "get": {
+          "signature": "get(name, envir = env)",
+          "description": "Get a value from the environment.",
+          "type": "method"
+        },
+        "assign": {
+          "signature": "assign(name, value, envir = env)",
+          "description": "Assign a value in the environment.",
+          "type": "method"
+        },
+        "parent.env": {
+          "signature": "parent.env(env) -> environment",
+          "description": "Get parent environment.",
+          "type": "method"
+        },
+        "environmentName": {
+          "signature": "environmentName(env) -> character",
+          "description": "Get environment name.",
+          "type": "method"
+        }
+      }
+    },
+    "c": {
+      "signature": "c(...)",
+      "description": "Combine values into a vector or list. This is the most common way to create vectors in R.",
+      "type": "function",
+      "module": "base",
+      "returns": "vector"
+    },
+    "vector": {
+      "signature": "vector(mode = 'logical', length = 0)",
+      "description": "Creates a vector of the specified mode and length.",
+      "type": "function",
+      "module": "base",
+      "returns": "vector"
+    },
+    "apply": {
+      "signature": "apply(X, MARGIN, FUN, ...)",
+      "description": "Returns a vector or array or list of values obtained by applying a function to margins of an array or matrix.",
+      "type": "function",
+      "module": "base",
+      "parameters": [
+        {
+          "name": "X",
+          "type": "array",
+          "description": "the array to apply over"
+        },
+        {
+          "name": "MARGIN",
+          "type": "integer",
+          "description": "1 for rows, 2 for columns"
+        },
+        {
+          "name": "FUN",
+          "type": "function",
+          "description": "function to apply"
+        }
+      ],
+      "returns": "vector|array|list"
+    },
+    "sapply": {
+      "signature": "sapply(X, FUN, ..., simplify = TRUE, USE.NAMES = TRUE)",
+      "description": "A user-friendly version of lapply. Returns a vector or matrix by applying FUN to each element of X.",
+      "type": "function",
+      "module": "base",
+      "returns": "vector|matrix"
+    },
+    "lapply": {
+      "signature": "lapply(X, FUN, ...)",
+      "description": "Returns a list of the same length as X, each element of which is the result of applying FUN to the corresponding element of X.",
+      "type": "function",
+      "module": "base",
+      "returns": "list"
+    },
+    "tapply": {
+      "signature": "tapply(X, INDEX, FUN = NULL, ..., simplify = TRUE)",
+      "description": "Apply a function to each cell of a ragged array, that is, to each (non-empty) group of values given by a unique combination of the levels of certain factors.",
+      "type": "function",
+      "module": "base",
+      "returns": "array"
+    },
+    "read.csv": {
+      "signature": "read.csv(file, header = TRUE, sep = ',', ...)",
+      "description": "Reads a file in table format and creates a data frame from it, using comma as the default separator.",
+      "type": "function",
+      "module": "utils",
+      "returns": "data.frame"
+    },
+    "write.csv": {
+      "signature": "write.csv(x, file = '', row.names = TRUE, ...)",
+      "description": "Writes a data frame to a CSV file.",
+      "type": "function",
+      "module": "utils",
+      "returns": "NULL"
+    },
+    "library": {
+      "signature": "library(package, ...)",
+      "description": "Loads and attaches a package. This is the standard way to use external packages.",
+      "type": "function",
+      "module": "base",
+      "returns": "invisible"
+    },
+    "install.packages": {
+      "signature": "install.packages(pkgs, lib, repos = getOption('repos'), ...)",
+      "description": "Download and install packages from CRAN-like repositories or from local files.",
+      "type": "function",
+      "module": "utils",
+      "returns": "invisible"
+    },
+    "print": {
+      "signature": "print(x, ...)",
+      "description": "Generic function for printing its argument. This is the most common way to output values.",
+      "type": "function",
+      "module": "base",
+      "returns": "invisible(x)"
+    },
+    "cat": {
+      "signature": "cat(..., file = '', sep = ' ', fill = FALSE, labels = NULL, append = FALSE)",
+      "description": "Outputs the objects, concatenating the representations. Unlike print, cat does not add quotes or newlines.",
+      "type": "function",
+      "module": "base",
+      "returns": "invisible(NULL)"
+    },
+    "paste": {
+      "signature": "paste(..., sep = ' ', collapse = NULL)",
+      "description": "Concatenate vectors after converting to character. The most common string concatenation function.",
+      "type": "function",
+      "module": "base",
+      "returns": "character"
+    },
+    "paste0": {
+      "signature": "paste0(..., collapse = NULL)",
+      "description": "A faster version of paste with sep = ''.",
+      "type": "function",
+      "module": "base",
+      "returns": "character"
+    },
+    "nchar": {
+      "signature": "nchar(x, type = 'bytes', allowNA = FALSE)",
+      "description": "Returns the number of characters (or bytes or width) of a string.",
+      "type": "function",
+      "module": "base",
+      "returns": "integer"
+    },
+    "gsub": {
+      "signature": "gsub(pattern, replacement, x, ...)",
+      "description": "Replaces ALL occurrences of a pattern in a character vector.",
+      "type": "function",
+      "module": "base",
+      "returns": "character"
+    },
+    "sub": {
+      "signature": "sub(pattern, replacement, x, ...)",
+      "description": "Replaces the FIRST occurrence of a pattern in a character vector.",
+      "type": "function",
+      "module": "base",
+      "returns": "character"
+    },
+    "grep": {
+      "signature": "grep(pattern, x, value = FALSE, ...)",
+      "description": "Search for matches to argument pattern within each element of a character vector.",
+      "type": "function",
+      "module": "base",
+      "returns": "integer|character"
+    },
+    "grepl": {
+      "signature": "grepl(pattern, x, ...)",
+      "description": "Returns a logical vector indicating which elements of x match the pattern.",
+      "type": "function",
+      "module": "base",
+      "returns": "logical"
+    },
+    "seq": {
+      "signature": "seq(from = 1, to = 1, by, length.out, along.with, ...)",
+      "description": "Generate regular sequences.",
+      "type": "function",
+      "module": "base",
+      "returns": "vector"
+    },
+    "rep": {
+      "signature": "rep(x, times = 1, length.out, each)",
+      "description": "Replicates the values in x.",
+      "type": "function",
+      "module": "base",
+      "returns": "vector"
+    },
+    "sum": {
+      "signature": "sum(..., na.rm = FALSE)",
+      "description": "Returns the sum of all the values present in its arguments.",
+      "type": "function",
+      "module": "base",
+      "returns": "numeric"
+    },
+    "mean": {
+      "signature": "mean(x, trim = 0, na.rm = FALSE, ...)",
+      "description": "Arithmetic mean. Computes the average of the input values.",
+      "type": "function",
+      "module": "base",
+      "returns": "numeric"
+    },
+    "median": {
+      "signature": "median(x, na.rm = FALSE)",
+      "description": "Compute the sample median.",
+      "type": "function",
+      "module": "stats",
+      "returns": "numeric"
+    },
+    "sd": {
+      "signature": "sd(x, na.rm = FALSE)",
+      "description": "Computes the standard deviation of the values in x.",
+      "type": "function",
+      "module": "stats",
+      "returns": "numeric"
+    },
+    "var": {
+      "signature": "var(x, y = NULL, na.rm = FALSE, use)",
+      "description": "Computes the variance of x, or the covariance of x and y.",
+      "type": "function",
+      "module": "stats",
+      "returns": "numeric"
+    },
+    "which": {
+      "signature": "which(x, arr.ind = FALSE, useNames = TRUE)",
+      "description": "Give the TRUE indices of a logical object.",
+      "type": "function",
+      "module": "base",
+      "returns": "integer"
+    },
+    "ifelse": {
+      "signature": "ifelse(test, yes, no)",
+      "description": "Returns a value with the same shape as test, filled with elements from yes or no depending on the test.",
+      "type": "function",
+      "module": "base",
+      "returns": "vector"
+    },
+    "is.na": {
+      "signature": "is.na(x)",
+      "description": "Indicates which elements are missing (NA).",
+      "type": "function",
+      "module": "base",
+      "returns": "logical"
+    },
+    "na.rm": {
+      "signature": "na.rm = TRUE",
+      "description": "Common parameter in many functions that removes NA values before computation.",
+      "type": "keyword",
+      "module": "base"
+    },
+    "str": {
+      "signature": "str(object, ...)",
+      "description": "Compactly display the internal structure of an R object.",
+      "type": "function",
+      "module": "utils",
+      "returns": "invisible(NULL)"
+    },
+    "summary": {
+      "signature": "summary(object, ...)",
+      "description": "Produces result summaries of the results of various model fitting functions.",
+      "type": "function",
+      "module": "base",
+      "returns": "summary"
+    },
+    "head": {
+      "signature": "head(x, n = 6)",
+      "description": "Returns the first parts of a vector, matrix, table, data frame, or function.",
+      "type": "function",
+      "module": "utils",
+      "returns": "object"
+    },
+    "tail": {
+      "signature": "tail(x, n = 6)",
+      "description": "Returns the last parts of a vector, matrix, table, data frame, or function.",
+      "type": "function",
+      "module": "utils",
+      "returns": "object"
+    },
+    "length": {
+      "signature": "length(x)",
+      "description": "Get or set the length of vectors (including lists) and factors.",
+      "type": "function",
+      "module": "base",
+      "returns": "integer"
+    },
+    "nrow": {
+      "signature": "nrow(x)",
+      "description": "Returns the number of rows present in x.",
+      "type": "function",
+      "module": "base",
+      "returns": "integer"
+    },
+    "ncol": {
+      "signature": "ncol(x)",
+      "description": "Returns the number of columns present in x.",
+      "type": "function",
+      "module": "base",
+      "returns": "integer"
+    },
+    "names": {
+      "signature": "names(x)",
+      "description": "Get or set the names of an object.",
+      "type": "function",
+      "module": "base",
+      "returns": "character"
+    },
+    "dim": {
+      "signature": "dim(x)",
+      "description": "Retrieve or set the dimension of an object.",
+      "type": "function",
+      "module": "base",
+      "returns": "integer"
+    },
+    "class": {
+      "signature": "class(x)",
+      "description": "Returns the class(es) of the object.",
+      "type": "function",
+      "module": "base",
+      "returns": "character"
+    },
+    "typeof": {
+      "signature": "typeof(x)",
+      "description": "Returns the internal type or storage mode of any object.",
+      "type": "function",
+      "module": "base",
+      "returns": "character"
+    },
+    "as.character": {
+      "signature": "as.character(x, ...)",
+      "description": "Coerces x to character type.",
+      "type": "function",
+      "module": "base",
+      "returns": "character"
+    },
+    "as.numeric": {
+      "signature": "as.numeric(x, ...)",
+      "description": "Coerces x to numeric type.",
+      "type": "function",
+      "module": "base",
+      "returns": "numeric"
+    },
+    "as.integer": {
+      "signature": "as.integer(x, ...)",
+      "description": "Coerces x to integer type.",
+      "type": "function",
+      "module": "base",
+      "returns": "integer"
+    },
+    "as.logical": {
+      "signature": "as.logical(x, ...)",
+      "description": "Coerces x to logical type.",
+      "type": "function",
+      "module": "base",
+      "returns": "logical"
+    },
+    "is.character": {
+      "signature": "is.character(x)",
+      "description": "Tests whether x is of character type.",
+      "type": "function",
+      "module": "base",
+      "returns": "logical"
+    },
+    "is.numeric": {
+      "signature": "is.numeric(x)",
+      "description": "Tests whether x is of numeric type.",
+      "type": "function",
+      "module": "base",
+      "returns": "logical"
+    },
+    "for": {
+      "signature": "for (var in seq) expr",
+      "description": "Execute one or more statements a specified number of times.",
+      "type": "keyword",
+      "module": "base"
+    },
+    "while": {
+      "signature": "while (cond) expr",
+      "description": "Repeat a block of statements as long as a condition is true.",
+      "type": "keyword",
+      "module": "base"
+    },
+    "if": {
+      "signature": "if (cond) expr else expr",
+      "description": "Conditional execution of code.",
+      "type": "keyword",
+      "module": "base"
+    },
+    "function": {
+      "signature": "function(arglist) body",
+      "description": "Creates a new function.",
+      "type": "keyword",
+      "module": "base"
+    },
+    "tryCatch": {
+      "signature": "tryCatch(expr, ..., finally)",
+      "description": "Provides a mechanism for handling unusual conditions including errors and warnings.",
+      "type": "function",
+      "module": "base",
+      "returns": "value"
+    },
+    "stop": {
+      "signature": "stop(..., call. = TRUE, domain = NULL)",
+      "description": "Stops execution and creates an error condition.",
+      "type": "function",
+      "module": "base",
+      "returns": "error"
+    },
+    "warning": {
+      "signature": "warning(..., call. = TRUE, immediate. = FALSE, domain = NULL)",
+      "description": "Generates a warning message.",
+      "type": "function",
+      "module": "base",
+      "returns": "invisible(NULL)"
+    },
+    "message": {
+      "signature": "message(..., domain = NULL, appendLF = TRUE)",
+      "description": "Generates a diagnostic message.",
+      "type": "function",
+      "module": "base",
+      "returns": "invisible(NULL)"
+    },
+    "Sys.time": {
+      "signature": "Sys.time()",
+      "description": "Returns the current time as a POSIXct object.",
+      "type": "function",
+      "module": "base",
+      "returns": "POSIXct"
+    },
+    "Sys.getenv": {
+      "signature": "Sys.getenv(x = NULL, unset = '', names = NA)",
+      "description": "Gets the values of environment variables.",
+      "type": "function",
+      "module": "base",
+      "returns": "character"
+    },
+    "file.exists": {
+      "signature": "file.exists(...)",
+      "description": "Returns a logical vector indicating whether the files exist.",
+      "type": "function",
+      "module": "base",
+      "returns": "logical"
+    },
+    "readLines": {
+      "signature": "readLines(con, n = -1, ok = TRUE, warn = TRUE, encoding = 'unknown', skipNul = FALSE)",
+      "description": "Read lines from a connection.",
+      "type": "function",
+      "module": "base",
+      "returns": "character"
+    },
+    "writeLines": {
+      "signature": "writeLines(text, con = stdout(), sep = '\\n', useBytes = FALSE)",
+      "description": "Write text lines to a connection.",
+      "type": "function",
+      "module": "base",
+      "returns": "invisible(NULL)"
+    },
+    "source": {
+      "signature": "source(file, ...)",
+      "description": "Causes R to accept its input from the named file or URL.",
+      "type": "function",
+      "module": "base",
+      "returns": "invisible()"
+    },
+    "setwd": {
+      "signature": "setwd(dir)",
+      "description": "Set the current working directory.",
+      "type": "function",
+      "module": "base",
+      "returns": "invisible(old_dir)"
+    },
+    "getwd": {
+      "signature": "getwd()",
+      "description": "Get the current working directory.",
+      "type": "function",
+      "module": "base",
+      "returns": "character"
+    }
+  }
 }