@enjoys/context-engine 1.1.0 → 1.1.2

package/data/defination/pascal.json

@@ -0,0 +1,175 @@
+{
+  "language": "pascal",
+  "definitions": {
+    "WriteLn": {
+      "signature": "WriteLn(args: ...)",
+      "description": "Writes one or more values to standard output followed by a newline character. Accepts mixed types including strings, integers, reals, and booleans with optional field width formatting specifiers.",
+      "type": "function",
+      "module": "System"
+    },
+    "ReadLn": {
+      "signature": "ReadLn(var args: ...)",
+      "description": "Reads a line of input from standard input, assigning values to the specified variables and consuming the newline character. Used for interactive console input in Pascal programs.",
+      "type": "function",
+      "module": "System"
+    },
+    "Write": {
+      "signature": "Write(args: ...)",
+      "description": "Writes one or more values to standard output without appending a newline, allowing multiple write calls to produce a single output line before the cursor remains on the same line.",
+      "type": "function",
+      "module": "System"
+    },
+    "Integer": {
+      "signature": "Integer",
+      "description": "The standard signed integer type in Pascal, typically 16-bit in Turbo Pascal or 32-bit in Free Pascal and Delphi. Supports arithmetic operations, comparisons, and ordinal functions.",
+      "type": "class",
+      "module": "System"
+    },
+    "String": {
+      "signature": "String[maxLength]",
+      "description": "The character string type in Pascal, storing a sequence of characters with a length byte prefix. Default maximum length is 255 characters. Supports concatenation, comparison, and index access.",
+      "type": "class",
+      "module": "System",
+      "members": {
+        "Length": {
+          "signature": "Length(s: String) -> Integer",
+          "description": "Returns the number of characters currently stored in the string.",
+          "type": "method"
+        },
+        "Copy": {
+          "signature": "Copy(s: String, index: Integer, count: Integer) -> String",
+          "description": "Returns a substring from s starting at index for count characters.",
+          "type": "method"
+        },
+        "Pos": {
+          "signature": "Pos(substr: String, s: String) -> Integer",
+          "description": "Returns the position of the first occurrence of substr in s, or 0 if not found.",
+          "type": "method"
+        },
+        "Delete": {
+          "signature": "Delete(var s: String, index: Integer, count: Integer)",
+          "description": "Removes count characters from string s starting at the specified index.",
+          "type": "method"
+        },
+        "Insert": {
+          "signature": "Insert(source: String, var s: String, index: Integer)",
+          "description": "Inserts the source string into s at the specified index position.",
+          "type": "method"
+        }
+      }
+    },
+    "Real": {
+      "signature": "Real",
+      "description": "The floating-point numeric type in Pascal for storing decimal numbers. Typically 48-bit in Turbo Pascal or mapped to Double (64-bit) in Free Pascal and Delphi for IEEE 754 compliance.",
+      "type": "class",
+      "module": "System"
+    },
+    "Boolean": {
+      "signature": "Boolean",
+      "description": "The logical type in Pascal with exactly two values: True and False. Used in conditional expressions, control flow statements, and as function return types for predicate operations.",
+      "type": "class",
+      "module": "System"
+    },
+    "Array": {
+      "signature": "Array[indexType] of elementType",
+      "description": "A fixed-size collection of elements of the same type, indexed by an ordinal type range. Arrays in Pascal are declared with explicit bounds and support multidimensional and packed variants.",
+      "type": "class",
+      "module": "System",
+      "members": {
+        "Low": {
+          "signature": "Low(a: Array) -> indexType",
+          "description": "Returns the lowest valid index value for the array.",
+          "type": "method"
+        },
+        "High": {
+          "signature": "High(a: Array) -> indexType",
+          "description": "Returns the highest valid index value for the array.",
+          "type": "method"
+        },
+        "Length": {
+          "signature": "Length(a: Array) -> Integer",
+          "description": "Returns the number of elements in the array (or dynamic array).",
+          "type": "method"
+        },
+        "SetLength": {
+          "signature": "SetLength(var a: DynArray, newLength: Integer)",
+          "description": "Resizes a dynamic array to the specified length, preserving existing elements.",
+          "type": "method"
+        }
+      }
+    },
+    "Record": {
+      "signature": "Record field1: Type1; field2: Type2; end",
+      "description": "A composite data type that groups related fields of different types under a single name. Records support variant parts, can be nested, and are used for structured data modeling in Pascal.",
+      "type": "class",
+      "module": "System"
+    },
+    "TStringList": {
+      "signature": "TStringList = class(TStrings)",
+      "description": "A powerful string collection class in the Classes unit providing sorted and unsorted string lists with name-value pair support, file I/O, and delimiter-separated text parsing capabilities.",
+      "type": "class",
+      "module": "Classes",
+      "members": {
+        "Add": {
+          "signature": "function Add(const S: string): Integer",
+          "description": "Adds a string to the list and returns its zero-based index.",
+          "type": "method"
+        },
+        "Delete": {
+          "signature": "procedure Delete(Index: Integer)",
+          "description": "Removes the string at the specified zero-based index from the list.",
+          "type": "method"
+        },
+        "IndexOf": {
+          "signature": "function IndexOf(const S: string): Integer",
+          "description": "Returns the zero-based index of the first matching string, or -1 if not found.",
+          "type": "method"
+        },
+        "Sort": {
+          "signature": "procedure Sort",
+          "description": "Sorts the string list in ascending alphabetical order.",
+          "type": "method"
+        },
+        "LoadFromFile": {
+          "signature": "procedure LoadFromFile(const FileName: string)",
+          "description": "Loads the contents of a text file into the string list, one line per entry.",
+          "type": "method"
+        },
+        "SaveToFile": {
+          "signature": "procedure SaveToFile(const FileName: string)",
+          "description": "Saves the contents of the string list to a text file, one line per entry.",
+          "type": "method"
+        },
+        "Count": {
+          "signature": "@property Count: Integer",
+          "description": "Returns the number of strings currently in the list.",
+          "type": "method"
+        }
+      }
+    },
+    "Ord": {
+      "signature": "Ord(x: ordinal) -> Integer",
+      "description": "Returns the ordinal value (integer position) of an ordinal-type expression, including characters, booleans, and enumeration values. For Char arguments, returns the ASCII code value.",
+      "type": "function",
+      "module": "System"
+    },
+    "Chr": {
+      "signature": "Chr(x: Byte) -> Char",
+      "description": "Returns the character corresponding to the specified ASCII code value. The inverse of the Ord function, converting an integer byte value back to its character representation.",
+      "type": "function",
+      "module": "System"
+    },
+    "Inc": {
+      "signature": "Inc(var x: ordinal [, n: Integer])",
+      "description": "Increments an ordinal variable by 1 or by the optional amount n. More efficient than x := x + 1 as it generates optimized machine code for the increment operation.",
+      "type": "function",
+      "module": "System"
+    },
+    "Dec": {
+      "signature": "Dec(var x: ordinal [, n: Integer])",
+      "description": "Decrements an ordinal variable by 1 or by the optional amount n. More efficient than x := x - 1 as it generates optimized machine code for the decrement operation.",
+      "type": "function",
+      "module": "System"
+    }
+  }
+}

package/data/defination/pascaligo.json

@@ -0,0 +1,183 @@
+{
+  "language": "pascaligo",
+  "definitions": {
+    "int": {
+      "signature": "int",
+      "description": "The signed integer type in PascaLIGO representing whole numbers of arbitrary precision on the Tezos blockchain. Supports standard arithmetic operations and comparison for smart contract logic.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "nat": {
+      "signature": "nat",
+      "description": "The natural number type in PascaLIGO representing non-negative integers. Used for counters, token amounts, and sizes where negative values are semantically invalid in smart contracts.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "string": {
+      "signature": "string",
+      "description": "The string type in PascaLIGO representing immutable sequences of characters. Supports concatenation with the caret operator and provides size and slice operations for text manipulation.",
+      "type": "class",
+      "module": "builtin",
+      "members": {
+        "String.concat": {
+          "signature": "String.concat(a: string, b: string) -> string",
+          "description": "Concatenates two strings and returns the combined result.",
+          "type": "method"
+        },
+        "String.length": {
+          "signature": "String.length(s: string) -> nat",
+          "description": "Returns the length of the string as a natural number.",
+          "type": "method"
+        },
+        "String.sub": {
+          "signature": "String.sub(offset: nat, length: nat, s: string) -> string",
+          "description": "Returns a substring starting at offset with the given length.",
+          "type": "method"
+        }
+      }
+    },
+    "tez": {
+      "signature": "tez",
+      "description": "The native currency type in PascaLIGO representing Tezos tokens (XTZ). Values are expressed in mutez (millionths of tez) internally and support arithmetic for financial smart contract operations.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "address": {
+      "signature": "address",
+      "description": "The Tezos account address type in PascaLIGO, representing implicit accounts (tz1/tz2/tz3) or originated contracts (KT1). Used for identifying transaction participants and contract targets.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "map": {
+      "signature": "map(key_type, value_type)",
+      "description": "An immutable key-value mapping type in PascaLIGO that stores associations between keys and values. Maps are suitable for small datasets and support lookup, update, and iteration operations.",
+      "type": "class",
+      "module": "builtin",
+      "members": {
+        "Map.find_opt": {
+          "signature": "Map.find_opt(key: k, m: map(k, v)) -> option(v)",
+          "description": "Looks up a key in the map and returns Some(value) if found, or None otherwise.",
+          "type": "method"
+        },
+        "Map.update": {
+          "signature": "Map.update(key: k, value: option(v), m: map(k, v)) -> map(k, v)",
+          "description": "Returns a new map with the key updated to the given value, or removed if None.",
+          "type": "method"
+        },
+        "Map.add": {
+          "signature": "Map.add(key: k, value: v, m: map(k, v)) -> map(k, v)",
+          "description": "Returns a new map with the key-value pair added or replaced.",
+          "type": "method"
+        },
+        "Map.remove": {
+          "signature": "Map.remove(key: k, m: map(k, v)) -> map(k, v)",
+          "description": "Returns a new map with the specified key removed.",
+          "type": "method"
+        },
+        "Map.size": {
+          "signature": "Map.size(m: map(k, v)) -> nat",
+          "description": "Returns the number of key-value pairs in the map.",
+          "type": "method"
+        }
+      }
+    },
+    "big_map": {
+      "signature": "big_map(key_type, value_type)",
+      "description": "A lazily deserialized key-value mapping optimized for large datasets on the Tezos blockchain. Unlike map, big_map entries are loaded on demand, reducing gas costs for contracts with many entries.",
+      "type": "class",
+      "module": "builtin",
+      "members": {
+        "Big_map.find_opt": {
+          "signature": "Big_map.find_opt(key: k, m: big_map(k, v)) -> option(v)",
+          "description": "Looks up a key in the big_map and returns Some(value) if found, or None.",
+          "type": "method"
+        },
+        "Big_map.update": {
+          "signature": "Big_map.update(key: k, value: option(v), m: big_map(k, v)) -> big_map(k, v)",
+          "description": "Returns a new big_map with the key updated or removed based on the option value.",
+          "type": "method"
+        }
+      }
+    },
+    "list": {
+      "signature": "list(element_type)",
+      "description": "An immutable singly-linked list type in PascaLIGO supporting prepend with cons operator, pattern matching for head/tail decomposition, and functional operations like map, fold, and iter.",
+      "type": "class",
+      "module": "builtin",
+      "members": {
+        "List.map": {
+          "signature": "List.map(f: (a -> b), l: list(a)) -> list(b)",
+          "description": "Applies a function to each element and returns a new list of results.",
+          "type": "method"
+        },
+        "List.fold": {
+          "signature": "List.fold(f: ((acc, a) -> acc), l: list(a), init: acc) -> acc",
+          "description": "Reduces the list to a single value by applying a function with an accumulator.",
+          "type": "method"
+        },
+        "List.iter": {
+          "signature": "List.iter(f: (a -> unit), l: list(a)) -> unit",
+          "description": "Applies a side-effecting function to each element of the list.",
+          "type": "method"
+        },
+        "List.size": {
+          "signature": "List.size(l: list(a)) -> nat",
+          "description": "Returns the number of elements in the list.",
+          "type": "method"
+        }
+      }
+    },
+    "set": {
+      "signature": "set(element_type)",
+      "description": "An immutable collection of unique elements in PascaLIGO. Sets are ordered and support membership testing, addition, removal, and iteration for managing distinct value collections in contracts.",
+      "type": "class",
+      "module": "builtin",
+      "members": {
+        "Set.mem": {
+          "signature": "Set.mem(element: a, s: set(a)) -> bool",
+          "description": "Returns true if the element is a member of the set.",
+          "type": "method"
+        },
+        "Set.add": {
+          "signature": "Set.add(element: a, s: set(a)) -> set(a)",
+          "description": "Returns a new set with the element added.",
+          "type": "method"
+        },
+        "Set.remove": {
+          "signature": "Set.remove(element: a, s: set(a)) -> set(a)",
+          "description": "Returns a new set with the element removed.",
+          "type": "method"
+        },
+        "Set.size": {
+          "signature": "Set.size(s: set(a)) -> nat",
+          "description": "Returns the number of elements in the set.",
+          "type": "method"
+        }
+      }
+    },
+    "option": {
+      "signature": "option(value_type)",
+      "description": "An algebraic type representing an optional value that is either Some(value) or None. Used extensively in PascaLIGO for safe handling of values that may or may not exist, such as map lookups.",
+      "type": "class",
+      "module": "builtin"
+    },
+    "Tezos.sender": {
+      "signature": "Tezos.sender -> address",
+      "description": "Returns the address of the account or contract that directly called the current entry point. Essential for access control and authorization logic in Tezos smart contracts.",
+      "type": "function",
+      "module": "Tezos"
+    },
+    "Tezos.amount": {
+      "signature": "Tezos.amount -> tez",
+      "description": "Returns the amount of tez sent with the current transaction. Used for payable entry point validation and ensuring correct payment amounts in financial smart contracts.",
+      "type": "function",
+      "module": "Tezos"
+    },
+    "failwith": {
+      "signature": "failwith(error_message: string) -> never",
+      "description": "Terminates the current contract execution and reverts all state changes with the given error message. The primary mechanism for enforcing preconditions and access control in PascaLIGO.",
+      "type": "function",
+      "module": "builtin"
+    }
+  }
+}

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"
+    }
+  }
+}