1. The Rhai Book
  5. User’s Guide
  6. Introduction
    ❱
    1. Features of Rhai
    2. What Rhai Isn't
    3. Benchmarks
    4. Supported Targets and Builds
    5. Dependencies
    6. Licensing
    7. Related Resources
  8. Getting Started
    ❱
    1. Online Playground
    2. Install the Rhai Crate
    3. Optional Features
    4. Packaged Utilities
  10. The Scripting Engine
    ❱
    1. “Hello, Rhai”
    2. Compile to AST
    3. Raw Engine
      ❱
      1. Built-in Operators
    5. Scope – Maintaining State
    6. Expressions Only
    7. Options
  12. Examples
    ❱
    1. Rust
    2. Scripts
  14. Special Builds
    ❱
    1. Performance
    2. Minimal
    3. no-std
    4. WebAssembly (WASM)
  19. Rust Integration
  20. Introduction
  21. Traits
  22. Register a Rust Function
    ❱
    1. Function Overloading
    2. Generic Functions
    3. String Parameters
    4. Dynamic Parameters
    5. Dynamic Return Value
    6. Fallible Functions
    7. NativeCallContext
      ❱
      1. Restore NativeCallContext
    9. Override a Built-in Function
  24. Call a Rhai Function from Rust
    ❱
    1. Create a Rust Closure from a Rhai Function
  26. Operator Overloading
  27. Working with Any Rust Type
    ❱
    1. Auto-Generate API
    2. Custom Type Builder
    3. Manually Register Custom Type
    4. Methods
      ❱
      1. Call Method as Function
    6. Property Getters and Setters
    7. Indexers
      ❱
      1. Fallback to Properties
    9. Collection Types
    10. Disable Custom Types
    11. Printing Custom Types
  29. Modules
    ❱
    1. Create in Rust
    2. Create from AST
    3. Use a Module
    4. Module Resolvers
      ❱
      1. Built-in Module Resolvers
        ❱
        1. DummyModuleResolver
        2. FileModuleResolver
        3. StaticModuleResolver
        4. ModuleResolversCollection
        5. DylibModuleResolver (external)
      3. Custom Module Resolvers
    6. Self-Contained AST
  31. Plugin Modules
  32. Packages
    ❱
    1. Built-in Packages
    2. Create Custom Packages
    3. Create Packages as Crates
    4. External Packages
      ❱
      1. Random Number Generation, Shuffling and Sampling
      2. Scientific Computing
      3. AI and Machine Learning
      4. Filesystem Access
      5. Working with Urls
  37. Scripting Language
  38. Comments
    ❱
    1. Doc-Comments
  40. Values and Types
    ❱
    1. Dynamic Values
      ❱
      1. type_of()
      2. Interop with Rust
      3. Value Tag
      4. Serialization/Deserialization with serde
    3. Numbers
      ❱
      1. Operators
      2. Standard Functions
      3. Value Conversions
      4. Ranges
      5. Bit-Fields
    5. Strings and Characters
      ❱
      1. String Interpolation
      2. ImmutableString
      3. Standard Functions and Operators
      4. Strings Interner
    7. Arrays
      ❱
      1. BLOB's (Byte Arrays)
      2. Out-of-Bounds Index
    9. Object Maps
      ❱
      1. Parse from JSON
      2. Special Support for OOP
      3. Non-Existent Property
    11. Timestamps
  42. Keywords
  43. Statements
    ❱
    1. Statement Expression
  45. Variables
    ❱
    1. Variable Shadowing
    2. Strict Variables Mode
    3. Variable Definition Filter
    4. Variable Resolver
  47. Constants
    ❱
    1. Automatic Global Module
  49. Assignments
  50. Compound Assignments
  51. Logic Operators
  52. In Operator
  53. If Statement
  54. Switch Statement
    ❱
    1. Switch Expression
  56. While Loop
  57. Do Loop
  58. Loop Statement
  59. For Loop
    ❱
    1. Standard Iterable Types
    2. Make a Custom Type Iterable
  61. Return Value
  62. Throw Exception on Error
  63. Catch Exceptions
  64. Functions
    ❱
    1. Method Calls
    2. Overloading
    3. Namespaces
    4. Function Pointers
      ❱
      1. Currying
      2. Anonymous Functions
      3. Closures
    6. Metadata
      ❱
      1. Get Scripted Functions Metadata in Rhai
      2. Get Scripted Functions Metadata from AST
      3. Get Native Function Signatures
      4. Export All Functions Metadata to JSON
      5. Generate Definition Files for Language Server
  66. Print and Debug
  67. Modules
    ❱
    1. Export Variables, Functions and Sub-Modules from Script
    2. Import Modules
  69. Eval Function
  73. Safety and Protection
  74. Introduction
  75. Sand-Boxing
  76. Limiting Run Time
  77. Limiting Memory Usage
  78. Limiting Stack Usage
  79. Built-in Safety Limits
    ❱
    1. Maximum Length of Strings
    2. Maximum Size of Arrays
    3. Maximum Size of Object Maps
    4. Maximum Number of Operations
    5. Maximum Number of Variables
    6. Maximum Number of Functions
    7. Maximum Number of Modules
    8. Maximum Call Stack Depth
    9. Maximum Expression Depth
  81. Turn Off Safety Checks
  85. Script Optimization
  86. Introduction
  87. Optimization Passes
    ❱
    1. Dead Code Elimination
    2. Constants Propagation
    3. Compound Assignment Rewrite
    4. Eager Operator Evaluation
    5. Eager Function Evaluation
      ❱
      1. Side-Effect Considerations
      2. Volatility Considerations
  89. Subtle Semantic Changes
  90. Re-Optimize an AST
  94. Advanced Topics
  95. Manage AST's
  96. Low-Level API to Register Functions
  97. Evaluation Context
  98. Call Function Within Caller's Scope
  99. Use Rhai in Dynamic Libraries
  100. Use Rhai as a DSL
    ❱
    1. Remap Tokens During Parsing
    2. Disable Keywords and/or Operators
    3. Disable Looping
    4. Custom Operators
      ❱
      1. Operator Precedence
    6. Extend with Custom Syntax
      ❱
      1. Custom Syntax Parsers
  102. Debugging Interface
    ❱
    1. Debugger
      ❱
      1. State
      2. Call Stack
      3. Break-Points
    3. Debugging Server
  107. Usage Patterns
  108. Object-Oriented Programming (OOP)
  109. Scriptable Event Handler with State
    ❱
    1. Main Style
    2. JS Style
    3. Map Style
  111. Control Layer Over Rust Backend
  112. Singleton Command Object
  113. Loadable Configuration
  114. Multi-Layered Functions
  115. Hot Reloading
  116. Builder Pattern / Fluent API
  117. Objects with Defined Behaviors
  118. Dynamic Constants Provider
  119. Global Constants
  120. Mutable Global State
  121. Working with Rust Enums
  122. Simulate Macros to Simplify Scripts
  123. One Engine Instance Per Call
  124. Multi-Threaded Synchronization
  125. Blocking/Async Function Calls
  126. External References (Unsafe)
  127. Static Hashing
  128. Serialize an AST
  129. Domain-Specific Tools
  130. Multiple Instantiation
  134. Language Reference
  135. Introduction
  136. Comments
  137. Value Types
    ❱
    1. Dynamic Values
      ❱
      1. type_of()
      2. Value Tag
    3. Numbers
      ❱
      1. Operators
      2. Standard Functions
      3. Value Conversions
      4. Ranges
      5. Bit-Fields
    5. Strings and Characters
      ❱
      1. Standard Functions and Operators
    7. Arrays
    8. BLOB's (Byte Arrays)
    9. Object Maps
    10. Timestamps
  139. Keywords
  140. Statements
  141. Variables
  142. Constants
  143. Assignments
    ❱
    1. Compound Assignments
  145. Operators
  146. Indexing
  147. Properties
  148. Methods
  149. If Statement
  150. Switch Statement
  151. While Loop
  152. Do Loop
  153. Infinite Loop
  154. For Loop
  155. Return Value
  156. Throw Exception on Error
    ❱
    1. Catch Exceptions
  158. Functions
    ❱
    1. Method Calls
    2. Overloading
    3. Function Pointers
    4. Closures
    5. Metadata
  160. Print and Debug
  161. Modules
    ❱
    1. Export Variables, Functions and Sub-Modules from Script
    2. Import Modules
  163. Eval Function
  167. Appendix
  168. External Tools
    ❱
    1. Online Playground
    2. Language Server
    3. rhai-doc
    4. Dynamic Loadable Libraries
    5. Generate MarkDown/MDX API Documentation
  170. Keywords
  171. Operators and Symbols
  172. Literals