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. Dynamic Constants Provider
  118. Global Constants
  119. Mutable Global State
  120. Working with Rust Enums
  121. Simulate Macros to Simplify Scripts
  122. One Engine Instance Per Call
  123. Multi-Threaded Synchronization
  124. Blocking/Async Function Calls
  125. External References (Unsafe)
  126. Static Hashing
  127. Serialize an AST
  128. Domain-Specific Tools
  129. Multiple Instantiation
  133. Language Reference
  134. Introduction
  135. Comments
  136. 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
  138. Keywords
  139. Statements
  140. Variables
  141. Constants
  142. Assignments
    ❱
    1. Compound Assignments
  144. Operators
  145. Indexing
  146. Properties
  147. Methods
  148. If Statement
  149. Switch Statement
  150. While Loop
  151. Do Loop
  152. Infinite Loop
  153. For Loop
  154. Return Value
  155. Throw Exception on Error
    ❱
    1. Catch Exceptions
  157. Functions
    ❱
    1. Method Calls
    2. Overloading
    3. Function Pointers
    4. Closures
    5. Metadata
  159. Print and Debug
  160. Modules
    ❱
    1. Export Variables, Functions and Sub-Modules from Script
    2. Import Modules
  162. Eval Function
  166. Appendix
  167. External Tools
    ❱
    1. Online Playground
    2. Language Server
    3. rhai-doc
    4. Dynamic Loadable Libraries
    5. Generate MarkDown/MDX API Documentation
  169. Keywords
  170. Operators and Symbols
  171. Literals