📚 Concept Index

This index provides quick access to key concepts, language features, and important terms in the Verse documentation. Each entry links to the specific subsection where the concept is defined or explained in detail.

Type System

Primitive Types

• any - universal supertype: Primitives - Any, Type System
• void - empty type: Primitives - Void, Type System
• logic - boolean values: Primitives - Booleans, Type System
• int - integers: Overview, Primitives - Integers, Type System
• nat - natural numbers: Type System
• float - floating-point: Overview, Primitives - Floats, Type System
• rational - exact fractions: Primitives - Rationals, Operators, Type System
• char - UTF-8 character: Primitives - Characters and Strings, Type System
• char32 - UTF-32 character: Primitives - Characters and Strings, Type System
• string - text values: Overview, Primitives - Characters and Strings, Type System

Composite Types

• array - ordered collections: Overview, Containers - Arrays, Type System
• map - key-value pairs: Containers - Maps, Type System
• tuple - fixed-size collections: Containers - Tuple, Expressions, Type System
• option - nullable values: Overview, Containers - Optionals, Type System
• class - reference types: Overview, Classes - Classes, Type System
• struct - value types: Structs - Structs, Type System
• interface - contracts: Classes - Interfaces, Type System
• enum - named values: Overview, Enums - Enums

Type Features

• subtyping - type relationships: Type System - Understanding Subtyping
• comparable - equality testing: Type System
• parametric types - generics: Classes - Parametric Classes, Type System
• type{} - type expressions: Expressions, Primitives - Type type, Type System
• where clauses - type constraints: Overview, Functions, Classes - Parameter Constraints, Type System

Type Variance

• covariance - type compatibility: Classes - Covariant, Type System - Covariance
• contravariance - reverse compatibility: Type System
• invariance - exact type match: Type System
• bivariance - both directions: Type System

Type Casting

• casting - type conversion: Type System - Class and Interface Casting
• dynamic casts - runtime type checking: Type System - Dynamic Type-Based Casting
• fallible casts - casts that may fail: Type System - Fallible Casts

Type Predicates and Metatypes

• subtype - runtime type values: Type System - subtype
• concrete_subtype - instantiable types: Type System - concrete_subtype
• castable_subtype - castable relationship: Type System - castable_subtype, Classes - Using castable_subtype
• classifiable_subset - type set tracking: Type System - classifiable_subset
• classifiable_subset_var - mutable type set: Type System - classifiable_subset
• classifiable_subset_key - type set keys: Type System - classifiable_subset

Type Query Functions

• GetCastableFinalSuperClass - get cast root from instance: Type System - GetCastableFinalSuperClass
• GetCastableFinalSuperClassFromType - get cast root from type: Type System - GetCastableFinalSuperClassFromType
• MakeClassifiableSubset - create immutable type set: Type System - classifiable_subset
• MakeClassifiableSubsetVar - create mutable type set: Type System - classifiable_subset

Effects

Effect Specifiers

• <computes> - pure computation: Overview, Effects, Mutability
• <reads> - observe state: Overview, Effects, Mutability
• <writes> - modify state: Effects, Mutability
• <allocates> - create unique values: Effects
• <transacts> - full heap access: Overview, Classes - Classes, Effects
• <decides> - can fail: Overview, Functions, Failure, Effects
• <suspends> - async execution: Overview, Effects, Concurrency
• <converges> - guaranteed termination: Effects
• <diverges> - may not terminate: Effects
• <predicts> - client execution: Effects
• <dictates> - server-only: Effects

Control Flow

Basic Control

• if/then/else - conditional execution: Overview, Expressions, Control Flow, Failure
• case - pattern matching: Overview, Enums - Using Enums, Control Flow
• for - iteration: Overview, Control Flow, Failure
• loop - infinite loops: Control Flow, Failure, Concurrency
• block - statement sequences: Control Flow, Failure, Classes - Blocks for Initialization, Concurrency
• break - exit loops: Control Flow
• continue - skip iteration: Control Flow
• defer - cleanup code: Control Flow
• return - exit functions: Functions

Failure System

• failure - control through failure: Overview, Failure, Effects
• failable expressions - can fail: Containers - Optionals, Functions, Failure
• query operator (?) - test values: Overview, Containers - Optionals, Operators, Failure
• speculative execution - rollback on failure: Overview, Failure

Concurrency

Structured Concurrency

• sync - wait for all: Overview, Concurrency
• race - first to complete: Overview, Concurrency
• rush - first to succeed: Concurrency
• branch - all that succeed: Concurrency

Unstructured Concurrency

• spawn - independent tasks: Overview, Effects, Concurrency
• task - concurrent execution: Concurrency
• async expressions - time-taking operations: Concurrency
• cancellation - stopping tasks: Concurrency

Timing Functions

• Sleep() - pause execution: Concurrency
• Await() - suspend for task completion: Concurrency
• NextTick() - defer to next update: Concurrency
• GetSecondsSinceEpoch - get current time: Concurrency

Live Variables

Reactive Programming

• live - reactive variables: Live Variables
• await - suspend until condition: Live Variables - The await Expression
• upon - one-shot reactive behavior: Live Variables - The upon Expression
• when - continuous reactive behavior: Live Variables - The when Expression
• batch - group variable updates: Live Variables - The batch Expression
• Old() - access previous value: Live Variables - Recursive Targets

Live Variable Features

• input-output variables - bidirectional sync: Live Variables - Input-Output Variables
• live expressions - dynamic relationships: Live Variables - Live Expressions

Mutability

Mutation Control

• var - mutable variables: Mutability, Effects
• set - assignment: Overview, Mutability
• immutability - default behavior: Overview, Effects, Mutability
• deep copying - struct semantics: Mutability, Structs - Structs
• reference semantics - class behavior: Classes - Classes, Mutability
• value semantics - struct behavior: Structs - Structs, Mutability

Class & Type Specifiers

Structure Specifiers

• <unique> - identity equality: Overview, Classes - Unique, Mutability, Access Specifiers
• <abstract> - cannot instantiate: Classes - Abstract, Access Specifiers
• <concrete> - can instantiate: Classes - Concrete, Access Specifiers
• <final> - cannot inherit: Classes - Final, Persistable Types, Access Specifiers
• <final_super> - terminal inheritance: Classes - Final, Access Specifiers
• <final_super_base> - inheritance root: Classes - Final
• <castable> - runtime type checking: Classes - Castable, Access Specifiers, Code Evolution
• <persistable> - saveable data: Overview, Classes - Persistable, Structs - Persistable Structs, Persistable Types
• <constructor> - factory methods: Classes - Constructor Functions

Enum Specifiers

• <open> - extensible enums: Enums - Open vs Closed Enums, Access Specifiers, Code Evolution
• <closed> - fixed enums: Enums - Open vs Closed Enums, Access Specifiers, Code Evolution

Access Control

Visibility Specifiers

• <public> - universal access: Overview, Classes - Access Specifiers, Modules and Paths, Access Specifiers
• <private> - class/module only: Classes - Access Specifiers, Modules and Paths, Access Specifiers
• <protected> - subclass access: Classes - Access Specifiers, Modules and Paths, Access Specifiers
• <internal> - module access: Modules and Paths, Access Specifiers
• <scoped> - path-based access: Access Specifiers

Method Specifiers

• <override> - replace parent method: Classes - Method Overriding, Access Specifiers
• <native> - implemented in C++: Access Specifiers

Operators

Arithmetic

• +, -, *, /, % - math operations: Primitives - Mathematical Functions, Operators
• +=, -=, *=, /= - compound assignment: Operators

Comparison

• <, <=, >, >= - ordering: Operators
• =, <> - equality/inequality: Operators, Type System

Logical

• and - logical AND: Operators, Failure
• or - logical OR: Operators, Failure
• not - logical NOT: Operators, Failure

Access

• . - member access: Operators, Expressions
• [] - indexing: Containers - Arrays, Operators, Expressions
• () - function call: Operators, Expressions
• {} - object construction: Operators, Expressions

Special

• := - initialization: Operators, Expressions
• .. - range operator: Operators, Expressions
• ? - query operator: Overview, Containers - Optionals, Operators, Failure

Functions

Function Features

• parameters - function inputs: Functions
• named arguments - explicit parameter names: Functions
• return values - function outputs: Functions
• function types - function signatures: Functions, Type System
• overloading - multiple definitions: Functions, Operators
• lambdas - anonymous functions (not yet supported, use nested functions): Functions, Expressions
• nested functions - local function definitions: Functions
• higher-order functions - functions as values: Overview, Functions

Modules & Organization

Module System

• module - code organization: Modules and Paths
• using - import statements: Overview, Modules and Paths
• module paths - hierarchical names: Modules and Paths
• qualified names - full paths: Modules and Paths
• qualified access - explicit paths: Modules and Paths
• nested modules - module hierarchy: Modules and Paths

Persistence

Save System

• weak_map(player, t) - player data: Containers - Weak Maps, Persistable Types
• weak_map(session, t) - session data: Containers - Weak Maps, Persistable Types
• persistable types - saveable data: Overview, Classes - Persistable, Structs - Persistable Structs, Persistable Types
• module-scoped variables - persistent storage: Modules and Paths, Persistable Types

Evolution & Compatibility

Version Management

• backward compatibility - preserving APIs: Overview, Effects, Code Evolution
• versioning - tracking changes: Code Evolution
• deprecation - phasing out features: Code Evolution
• publication - making code public: Modules and Paths, Access Specifiers, Code Evolution
• breaking changes - incompatible updates: Code Evolution
• schema evolution - data structure changes: Classes - Classes, Code Evolution

Annotations

• @deprecated - mark as deprecated: Code Evolution
• @experimental - mark as experimental: Code Evolution
• @available - version availability: Code Evolution

Built-in Functions

Math Functions

• Abs() - absolute value: Primitives - Mathematical Functions
• Floor() - round down: Primitives - Mathematical Functions
• Ceil() - round up: Primitives - Mathematical Functions
• Round() - round to nearest: Primitives - Mathematical Functions
• Sqrt() - square root: Primitives - Mathematical Functions
• Min() - minimum value: Primitives - Mathematical Functions
• Max() - maximum value: Primitives - Mathematical Functions

Utility Functions

• Print() - output text: Overview, Effects
• ToString() - convert to string: Primitives - ToString()
• GetSession() - current session: Modules and Paths

Array Methods

• Find() - find element index: Containers - Array Methods
• Remove() - remove by index: Containers - Array Methods
• RemoveFirstElement() - remove first occurrence: Containers - Array Methods
• RemoveAllElements() - remove all occurrences: Containers - Array Methods
• ReplaceElement() - replace by index: Containers - Array Methods
• ReplaceFirstElement() - replace first occurrence: Containers - Array Methods
• ReplaceAllElements() - replace all occurrences: Containers - Array Methods
• ReplaceAll() - pattern-based replacement: Containers - Array Methods

Syntax Elements

Literals

• integer literals - whole number values: Expressions
• float literals - decimal values: Expressions
• string literals - text values: Expressions
• character literals - single characters: Expressions
• boolean literals - true/false: Expressions

Special Values

• false - failure value, empty optional: Primitives - Booleans, Containers - Optionals, Failure
• true - success value: Primitives - Booleans
• NaN - not a number: Primitives - Floats
• Inf - infinity: Primitives - Floats

Language Constructs

• comments - code documentation: Overview
• identifiers - names: Expressions

Special Concepts

Language Features

• archetype expression - prototype patterns: Classes - Object Construction, Expressions
• string interpolation - embedded expressions: Primitives - Characters and Strings
• pattern matching - structural matching: Overview, Enums - Using Enums, Control Flow
• inheritance - class hierarchy: Classes - Inheritance, Type System, Access Specifiers
• polymorphism - multiple forms: Classes - Method Overriding, Type System
• transactional semantics - rollback behavior: Overview, Failure, Effects
• option{} constructor: Overview, Containers - Optionals
• array{} constructor: Overview, Containers - Arrays
• map{} constructor: Containers - Maps

Note: This index covers all major concepts in the Verse documentation. Each entry links directly to the subsection where the concept is defined or explained in detail. Use your browser's search function (Ctrl+F or Cmd+F) to quickly find specific terms.