@enjoys/context-engine 1.1.1 → 1.1.2

package/data/defination/pgsql.json

@@ -0,0 +1,119 @@
+{
+  "language": "pgsql",
+  "definitions": {
+    "json_build_object": {
+      "signature": "json_build_object(key1, value1, key2, value2, ...) -> json",
+      "description": "Constructs a JSON object from a variadic list of alternating key-value pairs. Keys are coerced to text and values are converted to corresponding JSON types automatically.",
+      "type": "function",
+      "module": "JSON Functions"
+    },
+    "jsonb_build_object": {
+      "signature": "jsonb_build_object(key1, value1, key2, value2, ...) -> jsonb",
+      "description": "Constructs a JSONB object from alternating key-value pairs, stored in decomposed binary format for faster access and indexing compared to plain json type.",
+      "type": "function",
+      "module": "JSON Functions"
+    },
+    "array_agg": {
+      "signature": "array_agg(expression) -> anyarray",
+      "description": "Aggregate function that collects all input values including NULLs into a PostgreSQL array. Supports ORDER BY within the aggregate for deterministic element ordering in the result.",
+      "type": "function",
+      "module": "Aggregate Functions"
+    },
+    "string_agg": {
+      "signature": "string_agg(expression, delimiter) -> text",
+      "description": "Aggregate function that concatenates non-NULL input values into a single string separated by the specified delimiter. Supports ORDER BY for controlling concatenation sequence.",
+      "type": "function",
+      "module": "Aggregate Functions"
+    },
+    "COALESCE": {
+      "signature": "COALESCE(value1, value2, ...) -> anyelement",
+      "description": "Returns the first non-NULL argument from the list, or NULL if all arguments are NULL. A standard SQL function essential for providing default values and handling nullable expressions.",
+      "type": "function",
+      "module": "Conditional"
+    },
+    "generate_series": {
+      "signature": "generate_series(start, stop[, step]) -> setof",
+      "description": "Set-returning function that generates a series of integer, bigint, numeric, or timestamp values from start to stop with an optional step interval. Fundamental for table generation and sequences.",
+      "type": "function",
+      "module": "Set Returning Functions"
+    },
+    "pg_typeof": {
+      "signature": "pg_typeof(any) -> regtype",
+      "description": "Returns the OID-based type name of the given value as a regtype, useful for debugging type resolution, understanding implicit casts, and introspecting expression result types.",
+      "type": "function",
+      "module": "System Information"
+    },
+    "NOW": {
+      "signature": "NOW() -> timestamp with time zone",
+      "description": "Returns the current date and time with time zone as of the start of the current transaction. The value remains constant throughout the entire transaction for consistency.",
+      "type": "function",
+      "module": "Date/Time Functions"
+    },
+    "CURRENT_TIMESTAMP": {
+      "signature": "CURRENT_TIMESTAMP -> timestamp with time zone",
+      "description": "SQL-standard function returning the current transaction start timestamp with time zone. Equivalent to NOW() and remains constant within a transaction for deterministic behavior.",
+      "type": "function",
+      "module": "Date/Time Functions"
+    },
+    "date_trunc": {
+      "signature": "date_trunc(field, source[, time_zone]) -> timestamp/interval",
+      "description": "Truncates a timestamp or interval to the specified precision (microseconds, milliseconds, second, minute, hour, day, week, month, quarter, year). Essential for time-based grouping queries.",
+      "type": "function",
+      "module": "Date/Time Functions"
+    },
+    "to_char": {
+      "signature": "to_char(value, format) -> text",
+      "description": "Converts a timestamp, interval, integer, or numeric value to a formatted text string using template patterns like YYYY, MM, DD, HH24, MI, SS, and number formatting masks.",
+      "type": "function",
+      "module": "Formatting Functions"
+    },
+    "regexp_matches": {
+      "signature": "regexp_matches(string, pattern[, flags]) -> setof text[]",
+      "description": "Returns all captured substrings resulting from matching a POSIX regular expression against the input string. The g flag returns all matches; without it returns only the first match.",
+      "type": "function",
+      "module": "String Functions"
+    },
+    "ROW_NUMBER": {
+      "signature": "ROW_NUMBER() OVER (PARTITION BY col ORDER BY col) -> bigint",
+      "description": "Window function that assigns a unique sequential integer to each row within its partition, ordered by the specified columns. Essential for pagination, deduplication, and ranking queries.",
+      "type": "function",
+      "module": "Window Functions"
+    },
+    "LATERAL": {
+      "signature": "FROM table1, LATERAL subquery",
+      "description": "A join qualifier that allows a subquery in FROM to reference columns from preceding tables in the same FROM clause, enabling correlated subqueries in the FROM position for row-dependent expansions.",
+      "type": "function",
+      "module": "Query Syntax"
+    },
+    "CTE": {
+      "signature": "WITH cte_name AS (SELECT ...) SELECT ... FROM cte_name",
+      "description": "Common Table Expression that defines a temporary named result set within a single SQL statement. Supports recursive queries with WITH RECURSIVE for hierarchical data traversal.",
+      "type": "function",
+      "module": "Query Syntax"
+    },
+    "UNNEST": {
+      "signature": "UNNEST(array) -> setof anyelement",
+      "description": "Expands a PostgreSQL array into a set of rows, one row per array element. Commonly used with LATERAL joins and array_agg to transform between array and relational representations.",
+      "type": "function",
+      "module": "Array Functions"
+    },
+    "array_to_json": {
+      "signature": "array_to_json(anyarray[, pretty_bool]) -> json",
+      "description": "Converts a PostgreSQL array to a JSON array representation. With a multi-dimensional array, produces a JSON array of arrays matching the dimensionality of the input.",
+      "type": "function",
+      "module": "JSON Functions"
+    },
+    "jsonb_set": {
+      "signature": "jsonb_set(target jsonb, path text[], new_value jsonb[, create_missing]) -> jsonb",
+      "description": "Returns a JSONB value with the element at the specified path replaced or inserted. The create_missing flag (default true) controls whether new keys are created along the path.",
+      "type": "function",
+      "module": "JSON Functions"
+    },
+    "EXISTS": {
+      "signature": "EXISTS (subquery) -> boolean",
+      "description": "Returns TRUE if the subquery returns at least one row, regardless of column values. An efficient semi-join pattern that short-circuits evaluation after finding the first matching row.",
+      "type": "function",
+      "module": "Subquery Expressions"
+    }
+  }
+}

package/data/defination/pla.json

@@ -0,0 +1,83 @@
+{
+  "language": "pla",
+  "definitions": {
+    "PROGRAM": {
+      "signature": "PROGRAM program_name;",
+      "description": "Declares the beginning of a PL/A program unit, establishing the program name and scope. The program block contains all declarations, procedures, and executable statements for the application.",
+      "type": "function",
+      "module": "Structure"
+    },
+    "PROCEDURE": {
+      "signature": "PROCEDURE name(params) -> return_type;",
+      "description": "Declares a named procedure in PL/A that encapsulates a sequence of statements and optionally accepts parameters. Procedures support recursion and can be nested within other program blocks.",
+      "type": "function",
+      "module": "Structure"
+    },
+    "FUNCTION": {
+      "signature": "FUNCTION name(params): return_type;",
+      "description": "Declares a named function in PL/A that computes and returns a value of the specified type. Functions can be used in expressions and support parameter passing by value or reference.",
+      "type": "function",
+      "module": "Structure"
+    },
+    "RECORD": {
+      "signature": "RECORD field1: type1; field2: type2; END;",
+      "description": "Defines a composite data structure in PL/A containing named fields of potentially different types, allowing structured data grouping for complex state representation in programs.",
+      "type": "class",
+      "module": "Types"
+    },
+    "STRING": {
+      "signature": "STRING[maxlength]",
+      "description": "The character string type in PL/A representing a sequence of characters with a declared maximum length. Supports concatenation, substring extraction, and comparison operations.",
+      "type": "class",
+      "module": "Types"
+    },
+    "INTEGER": {
+      "signature": "INTEGER",
+      "description": "The signed whole number type in PL/A supporting standard arithmetic operations including addition, subtraction, multiplication, division, and modulo for numeric computing tasks.",
+      "type": "class",
+      "module": "Types"
+    },
+    "REAL": {
+      "signature": "REAL",
+      "description": "The floating-point numeric type in PL/A for representing decimal numbers with fractional components. Used for scientific computations and financial calculations requiring non-integer precision.",
+      "type": "class",
+      "module": "Types"
+    },
+    "BOOLEAN": {
+      "signature": "BOOLEAN",
+      "description": "The logical data type in PL/A with exactly two values TRUE and FALSE, used for conditional expressions, control flow decisions, and predicate evaluations in program logic.",
+      "type": "class",
+      "module": "Types"
+    },
+    "ARRAY": {
+      "signature": "ARRAY[lower..upper] OF element_type",
+      "description": "A fixed-size indexed collection of elements of uniform type in PL/A, declared with explicit lower and upper bounds. Supports element access by subscript and can be multidimensional.",
+      "type": "class",
+      "module": "Types"
+    },
+    "CONST": {
+      "signature": "CONST name = value;",
+      "description": "Declares a named constant in PL/A whose value is fixed at compile time and cannot be modified during program execution. Constants improve readability and prevent accidental value changes.",
+      "type": "function",
+      "module": "Declarations"
+    },
+    "VAR": {
+      "signature": "VAR name: type;",
+      "description": "Declares a variable in PL/A with a specified type, allocating storage for runtime data. Variables must be declared before use and can be initialized at the point of declaration.",
+      "type": "function",
+      "module": "Declarations"
+    },
+    "READ": {
+      "signature": "READ(var1, var2, ...)",
+      "description": "Reads input values from the standard input stream and assigns them to the specified variables in order. Performs implicit type conversion based on the variable types declared.",
+      "type": "function",
+      "module": "I/O"
+    },
+    "WRITE": {
+      "signature": "WRITE(expr1, expr2, ...)",
+      "description": "Outputs the values of the specified expressions to the standard output stream. Supports formatted output with field width specifiers for aligned tabular display of data.",
+      "type": "function",
+      "module": "I/O"
+    }
+  }
+}

package/data/defination/postiats.json

@@ -0,0 +1,89 @@
+{
+  "language": "postiats",
+  "definitions": {
+    "val": {
+      "signature": "val name: type = expression",
+      "description": "Declares an immutable value binding in ATS/Postiats, binding a name to the result of an expression with optional type annotation. Values are evaluated eagerly and cannot be reassigned after initialization.",
+      "type": "function",
+      "module": "Declarations"
+    },
+    "fun": {
+      "signature": "fun name(params): return_type = body",
+      "description": "Declares a recursive function in ATS/Postiats with explicit parameter types and return type. Unlike fn, fun allows self-referential calls enabling direct recursion within the function body.",
+      "type": "function",
+      "module": "Declarations"
+    },
+    "fn": {
+      "signature": "fn name(params): return_type = body",
+      "description": "Declares a non-recursive function in ATS/Postiats. The compiler verifies that fn functions do not call themselves, providing a guarantee of termination for simple non-recursive procedures.",
+      "type": "function",
+      "module": "Declarations"
+    },
+    "var": {
+      "signature": "var name: type = expression",
+      "description": "Declares a mutable variable in ATS/Postiats that can be updated with assignment operations. Variables require linear type tracking and proof obligations to ensure safe memory access.",
+      "type": "function",
+      "module": "Declarations"
+    },
+    "datatype": {
+      "signature": "datatype name = Constructor1 of type | Constructor2 of type",
+      "description": "Declares an algebraic data type in ATS/Postiats with named constructors for pattern matching. Datatypes are garbage-collected and support polymorphism through type parameters.",
+      "type": "function",
+      "module": "Type Declarations"
+    },
+    "datavtype": {
+      "signature": "datavtype name = Constructor1 of type | Constructor2 of type",
+      "description": "Declares a linear algebraic data type (viewtype) in ATS/Postiats that must be explicitly freed. Linear datatypes enable safe manual memory management enforced by the type system.",
+      "type": "function",
+      "module": "Type Declarations"
+    },
+    "sortdef": {
+      "signature": "sortdef name = sort_expression",
+      "description": "Defines a named sort abbreviation in the statics of ATS/Postiats. Sorts classify types and are used in dependent type specifications to constrain static indices for verified programming.",
+      "type": "function",
+      "module": "Statics"
+    },
+    "implement": {
+      "signature": "implement name(params) = body",
+      "description": "Provides the implementation for a previously declared function template or interface function in ATS/Postiats, separating specification from implementation for modular program design.",
+      "type": "function",
+      "module": "Declarations"
+    },
+    "stadef": {
+      "signature": "stadef name = static_expression",
+      "description": "Defines a static abbreviation in ATS/Postiats for use in dependent types and sort expressions. Static definitions enable reusable type-level computations and index expressions.",
+      "type": "function",
+      "module": "Statics"
+    },
+    "typedef": {
+      "signature": "typedef name = type_expression",
+      "description": "Creates a type alias in ATS/Postiats, providing a shorter name for a complex type expression. Type definitions improve readability and enable reuse of common type patterns.",
+      "type": "function",
+      "module": "Type Declarations"
+    },
+    "prval": {
+      "signature": "prval name: prop = proof_expression",
+      "description": "Declares a proof value in ATS/Postiats that exists only at compile time for theorem proving. Proof values are erased during compilation and have zero runtime cost.",
+      "type": "function",
+      "module": "Proofs"
+    },
+    "prfun": {
+      "signature": "prfun name(proof_params): prop",
+      "description": "Declares a proof function in ATS/Postiats that transforms proofs at compile time. Proof functions witness logical implications and are entirely erased from the generated executable code.",
+      "type": "function",
+      "module": "Proofs"
+    },
+    "let_in_end": {
+      "signature": "let declarations in expression end",
+      "description": "A scoping construct in ATS/Postiats that introduces local declarations visible only within the expression between in and end. Enables structured local bindings with controlled visibility.",
+      "type": "function",
+      "module": "Expressions"
+    },
+    "case": {
+      "signature": "case expression of pattern1 => result1 | pattern2 => result2",
+      "description": "Pattern matching expression in ATS/Postiats that deconstructs values against patterns and executes the first matching branch. The compiler checks exhaustiveness to prevent unhandled cases.",
+      "type": "function",
+      "module": "Expressions"
+    }
+  }
+}

package/data/defination/powerquery.json

@@ -0,0 +1,101 @@
+{
+  "language": "powerquery",
+  "definitions": {
+    "Table.FromRecords": {
+      "signature": "Table.FromRecords(records as list, optional columns as any, optional missingField as MissingField.Type) -> table",
+      "description": "Converts a list of record values into a table where each record becomes a row and record fields become columns. Handles missing fields according to the specified MissingField strategy.",
+      "type": "function",
+      "module": "Table"
+    },
+    "Table.SelectRows": {
+      "signature": "Table.SelectRows(table as table, condition as function) -> table",
+      "description": "Returns a table containing only the rows from the input table where the condition function evaluates to true, providing predicate-based row filtering for data transformation pipelines.",
+      "type": "function",
+      "module": "Table"
+    },
+    "Table.AddColumn": {
+      "signature": "Table.AddColumn(table as table, newColumnName as text, columnGenerator as function, optional columnType as type) -> table",
+      "description": "Adds a new column to the table with values computed by applying the generator function to each row, supporting derived columns and calculated fields in transformation steps.",
+      "type": "function",
+      "module": "Table"
+    },
+    "Table.TransformColumns": {
+      "signature": "Table.TransformColumns(table as table, transformOperations as list, optional defaultTransformation, optional missingField) -> table",
+      "description": "Applies transformation functions to the specified columns of a table, enabling type conversions, formatting changes, and value modifications across entire columns of data.",
+      "type": "function",
+      "module": "Table"
+    },
+    "Table.Group": {
+      "signature": "Table.Group(table as table, key as any, aggregatedColumns as list, optional groupKind, optional comparer) -> table",
+      "description": "Groups rows by the specified key columns and applies aggregate operations such as sum, count, and list to the remaining columns, equivalent to SQL GROUP BY functionality.",
+      "type": "function",
+      "module": "Table"
+    },
+    "Table.Join": {
+      "signature": "Table.Join(table1 as table, key1 as any, table2 as table, key2 as any, optional joinKind as JoinKind.Type, optional joinAlgorithm, optional keyEqualityComparers) -> table",
+      "description": "Combines rows from two tables based on matching key values, supporting inner, left outer, right outer, full outer, left anti, and right anti join operations.",
+      "type": "function",
+      "module": "Table"
+    },
+    "List.Transform": {
+      "signature": "List.Transform(list as list, transform as function) -> list",
+      "description": "Applies a transformation function to each element of the input list and returns a new list containing the transformed values, enabling functional mapping operations on collections.",
+      "type": "function",
+      "module": "List"
+    },
+    "List.Select": {
+      "signature": "List.Select(list as list, selection as function) -> list",
+      "description": "Returns a new list containing only the elements from the input list where the selection function returns true, providing predicate-based filtering for list values.",
+      "type": "function",
+      "module": "List"
+    },
+    "List.Accumulate": {
+      "signature": "List.Accumulate(list as list, seed as any, accumulator as function) -> any",
+      "description": "Reduces a list to a single value by applying an accumulator function that takes the current state and each element, producing a running aggregation similar to fold or reduce.",
+      "type": "function",
+      "module": "List"
+    },
+    "Record.Field": {
+      "signature": "Record.Field(record as record, field as text) -> any",
+      "description": "Returns the value of the specified field from the given record. Raises an error if the field does not exist, unlike the optional Record.FieldOrDefault which handles missing fields.",
+      "type": "function",
+      "module": "Record"
+    },
+    "Record.TransformFields": {
+      "signature": "Record.TransformFields(record as record, transformOperations as list, optional missingField) -> record",
+      "description": "Returns a new record with the specified fields transformed by applying the provided functions, enabling selective modification of record field values during data cleaning.",
+      "type": "function",
+      "module": "Record"
+    },
+    "Text.Contains": {
+      "signature": "Text.Contains(text as nullable text, substring as text, optional comparer as function) -> logical",
+      "description": "Returns true if the text value contains the specified substring. Supports an optional comparer function for case-insensitive or culture-aware string matching operations.",
+      "type": "function",
+      "module": "Text"
+    },
+    "Text.Combine": {
+      "signature": "Text.Combine(texts as list, optional separator as nullable text) -> text",
+      "description": "Concatenates a list of text values into a single string with an optional separator between each element, useful for building delimited strings from list-based data.",
+      "type": "function",
+      "module": "Text"
+    },
+    "Number.From": {
+      "signature": "Number.From(value as any, optional culture as nullable text) -> nullable number",
+      "description": "Converts a text, logical, date, time, or other value to a number using the specified culture for locale-aware parsing of decimal separators and number formatting conventions.",
+      "type": "function",
+      "module": "Number"
+    },
+    "Type.Is": {
+      "signature": "Type.Is(type1 as type, type2 as type) -> logical",
+      "description": "Returns true if type1 is compatible with type2, used for runtime type checking and conditional logic based on the data types of values flowing through query transformations.",
+      "type": "function",
+      "module": "Type"
+    },
+    "each": {
+      "signature": "each expression",
+      "description": "Shorthand syntax in Power Query M for creating a single-parameter function where the underscore represents the parameter. Equivalent to writing (_) => expression for concise lambda definitions.",
+      "type": "function",
+      "module": "Language"
+    }
+  }
+}

package/data/defination/qsharp.json

@@ -0,0 +1,95 @@
+{
+  "language": "qsharp",
+  "definitions": {
+    "Qubit": {
+      "signature": "Qubit",
+      "description": "The fundamental quantum data type in Q# representing a single quantum bit that exists in a superposition of states. Qubits are allocated using the use statement and cannot be directly copied or inspected.",
+      "type": "class",
+      "module": "Microsoft.Quantum.Intrinsic"
+    },
+    "Result": {
+      "signature": "Result = Zero | One",
+      "description": "A classical discriminated union type in Q# representing the outcome of a quantum measurement, with two possible values Zero and One corresponding to the computational basis states.",
+      "type": "class",
+      "module": "Microsoft.Quantum.Intrinsic"
+    },
+    "operation": {
+      "signature": "operation Name(params : ParamTypes) : ReturnType { body }",
+      "description": "Declares a Q# operation that can perform quantum side effects including qubit allocation, gate application, and measurement. Operations are the primary callable type for quantum algorithms.",
+      "type": "function",
+      "module": "Language"
+    },
+    "function": {
+      "signature": "function Name(params : ParamTypes) : ReturnType { body }",
+      "description": "Declares a purely classical Q# function with no quantum side effects. Functions cannot allocate qubits, apply gates, or call operations, enabling safe classical computation and optimization.",
+      "type": "function",
+      "module": "Language"
+    },
+    "H": {
+      "signature": "operation H(qubit : Qubit) : Unit is Adj + Ctl",
+      "description": "Applies the Hadamard gate to a single qubit, transforming the basis state |0> into an equal superposition of |0> and |1>. Essential for creating quantum superpositions and interference patterns.",
+      "type": "function",
+      "module": "Microsoft.Quantum.Intrinsic"
+    },
+    "CNOT": {
+      "signature": "operation CNOT(control : Qubit, target : Qubit) : Unit is Adj + Ctl",
+      "description": "Applies the Controlled-NOT gate that flips the target qubit if and only if the control qubit is in state |1>. The fundamental two-qubit gate for creating entanglement in quantum circuits.",
+      "type": "function",
+      "module": "Microsoft.Quantum.Intrinsic"
+    },
+    "M": {
+      "signature": "operation M(qubit : Qubit) : Result",
+      "description": "Performs a single-qubit measurement in the computational (Z) basis, collapsing the qubit superposition to either Zero or One and returning the classical Result value.",
+      "type": "function",
+      "module": "Microsoft.Quantum.Intrinsic"
+    },
+    "X": {
+      "signature": "operation X(qubit : Qubit) : Unit is Adj + Ctl",
+      "description": "Applies the Pauli-X gate (quantum NOT) to a single qubit, flipping |0> to |1> and |1> to |0>. Equivalent to a classical bit flip operation on the quantum state.",
+      "type": "function",
+      "module": "Microsoft.Quantum.Intrinsic"
+    },
+    "Z": {
+      "signature": "operation Z(qubit : Qubit) : Unit is Adj + Ctl",
+      "description": "Applies the Pauli-Z gate to a single qubit, adding a phase of -1 to the |1> component while leaving |0> unchanged. Used for phase kickback and quantum error correction.",
+      "type": "function",
+      "module": "Microsoft.Quantum.Intrinsic"
+    },
+    "Y": {
+      "signature": "operation Y(qubit : Qubit) : Unit is Adj + Ctl",
+      "description": "Applies the Pauli-Y gate to a single qubit, combining X and Z operations with an imaginary phase factor. Rotates the quantum state around the Y-axis of the Bloch sphere.",
+      "type": "function",
+      "module": "Microsoft.Quantum.Intrinsic"
+    },
+    "Rx": {
+      "signature": "operation Rx(theta : Double, qubit : Qubit) : Unit is Adj + Ctl",
+      "description": "Applies a rotation around the X-axis of the Bloch sphere by the specified angle theta in radians. Used for parameterized quantum circuits and variational quantum algorithms.",
+      "type": "function",
+      "module": "Microsoft.Quantum.Intrinsic"
+    },
+    "Rz": {
+      "signature": "operation Rz(theta : Double, qubit : Qubit) : Unit is Adj + Ctl",
+      "description": "Applies a rotation around the Z-axis of the Bloch sphere by the specified angle theta in radians. Commonly used for phase manipulation in quantum Fourier transforms.",
+      "type": "function",
+      "module": "Microsoft.Quantum.Intrinsic"
+    },
+    "use": {
+      "signature": "use qubit = Qubit() { ... }",
+      "description": "Allocates one or more fresh qubits initialized in the |0> state for use within the block scope. Qubits must be returned to |0> state before deallocation at scope exit.",
+      "type": "function",
+      "module": "Language"
+    },
+    "MeasureAllZ": {
+      "signature": "operation MeasureAllZ(qubits : Qubit[]) : Result",
+      "description": "Measures all qubits in the given array jointly in the Z-basis and returns a single Result, collapsing the joint quantum state to a computational basis state.",
+      "type": "function",
+      "module": "Microsoft.Quantum.Measurement"
+    },
+    "ApplyToEach": {
+      "signature": "operation ApplyToEach<'T>(singleElementOperation : ('T => Unit), register : 'T[]) : Unit",
+      "description": "Applies a single-qubit operation to every element in a qubit register array. A convenience operation for broadcasting gates across multiple qubits uniformly.",
+      "type": "function",
+      "module": "Microsoft.Quantum.Canon"
+    }
+  }
+}

package/data/defination/r.json

@@ -0,0 +1,84 @@
+{
+  "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" }
+      }
+    }
+  }
+}