diff --git a/404.html b/404.html index af58d46c..83e3fb87 100644 --- a/404.html +++ b/404.html @@ -103,7 +103,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/about/benchmarks.html b/about/benchmarks.html index 7ab88666..57dc6196 100644 --- a/about/benchmarks.html +++ b/about/benchmarks.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/about/dependencies.html b/about/dependencies.html index 488caeb5..b65e6b28 100644 --- a/about/dependencies.html +++ b/about/dependencies.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/about/features.html b/about/features.html index 855ba988..7eb0fce6 100644 --- a/about/features.html +++ b/about/features.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/about/index.html b/about/index.html index 7b54f99b..6ca2254e 100644 --- a/about/index.html +++ b/about/index.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/about/license.html b/about/license.html index 5d3e54b0..957a3097 100644 --- a/about/license.html +++ b/about/license.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/about/non-design.html b/about/non-design.html index 4a00c9af..c874746e 100644 --- a/about/non-design.html +++ b/about/non-design.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/about/related.html b/about/related.html index 7a9c1858..83fb00ae 100644 --- a/about/related.html +++ b/about/related.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/about/targets.html b/about/targets.html index 4964e94b..ecb3194d 100644 --- a/about/targets.html +++ b/about/targets.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/appendix/keywords.html b/appendix/keywords.html index e85be300..0314f6a1 100644 --- a/appendix/keywords.html +++ b/appendix/keywords.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/appendix/literals.html b/appendix/literals.html index 16c26f0d..8cea1317 100644 --- a/appendix/literals.html +++ b/appendix/literals.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/appendix/operators.html b/appendix/operators.html index 7fe474df..95b65c6e 100644 --- a/appendix/operators.html +++ b/appendix/operators.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/ast.html b/engine/ast.html index 8906302c..de28b809 100644 --- a/engine/ast.html +++ b/engine/ast.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/builtin.html b/engine/builtin.html index a5cea322..ee7984da 100644 --- a/engine/builtin.html +++ b/engine/builtin.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/call-fn.html b/engine/call-fn.html index 9d1438e3..f61b88d7 100644 --- a/engine/call-fn.html +++ b/engine/call-fn.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/compile.html b/engine/compile.html index bd29e667..a3ab3c2a 100644 --- a/engine/compile.html +++ b/engine/compile.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/custom-op.html b/engine/custom-op.html index 8cfea339..8d75e407 100644 --- a/engine/custom-op.html +++ b/engine/custom-op.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/custom-syntax-parsers.html b/engine/custom-syntax-parsers.html index d215dbbc..0c26d90a 100644 --- a/engine/custom-syntax-parsers.html +++ b/engine/custom-syntax-parsers.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/custom-syntax.html b/engine/custom-syntax.html index 4981976d..2e87d52f 100644 --- a/engine/custom-syntax.html +++ b/engine/custom-syntax.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/debugging/break-points.html b/engine/debugging/break-points.html index d00c00ec..7535c2b0 100644 --- a/engine/debugging/break-points.html +++ b/engine/debugging/break-points.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/debugging/call-stack.html b/engine/debugging/call-stack.html index 948e4410..6513eee1 100644 --- a/engine/debugging/call-stack.html +++ b/engine/debugging/call-stack.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/debugging/debugger.html b/engine/debugging/debugger.html index 2dbd37de..790e20fb 100644 --- a/engine/debugging/debugger.html +++ b/engine/debugging/debugger.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/debugging/index.html b/engine/debugging/index.html index 1e74aa20..a94d25f3 100644 --- a/engine/debugging/index.html +++ b/engine/debugging/index.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/debugging/server.html b/engine/debugging/server.html index 0a4aac68..dae84b29 100644 --- a/engine/debugging/server.html +++ b/engine/debugging/server.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/debugging/state.html b/engine/debugging/state.html index a178a109..dedb857c 100644 --- a/engine/debugging/state.html +++ b/engine/debugging/state.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/def-var.html b/engine/def-var.html index b758f7ec..af15f3ed 100644 --- a/engine/def-var.html +++ b/engine/def-var.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/disable-keywords.html b/engine/disable-keywords.html index ae4ea226..1ec30da7 100644 --- a/engine/disable-keywords.html +++ b/engine/disable-keywords.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/disable-looping.html b/engine/disable-looping.html index 9b9d5633..8328d090 100644 --- a/engine/disable-looping.html +++ b/engine/disable-looping.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/dsl.html b/engine/dsl.html index a9a96157..2211046e 100644 --- a/engine/dsl.html +++ b/engine/dsl.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/dynamic-lib.html b/engine/dynamic-lib.html index cad42bae..7214c784 100644 --- a/engine/dynamic-lib.html +++ b/engine/dynamic-lib.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/eval-context.html b/engine/eval-context.html index 523a7180..cf4d11ae 100644 --- a/engine/eval-context.html +++ b/engine/eval-context.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/expressions.html b/engine/expressions.html index d8adb44c..de9bf2a9 100644 --- a/engine/expressions.html +++ b/engine/expressions.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/func.html b/engine/func.html index 5e75c5bc..0af7520b 100644 --- a/engine/func.html +++ b/engine/func.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/hello-world.html b/engine/hello-world.html index 0ff7399a..1e08f967 100644 --- a/engine/hello-world.html +++ b/engine/hello-world.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/index.html b/engine/index.html index e371f97a..df833847 100644 --- a/engine/index.html +++ b/engine/index.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/metadata/definitions.html b/engine/metadata/definitions.html index c184c23b..7c5a5d10 100644 --- a/engine/metadata/definitions.html +++ b/engine/metadata/definitions.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/metadata/export_to_json.html b/engine/metadata/export_to_json.html index 31760d7a..899aba6b 100644 --- a/engine/metadata/export_to_json.html +++ b/engine/metadata/export_to_json.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/metadata/gen_fn_sig.html b/engine/metadata/gen_fn_sig.html index e368cf81..156127cc 100644 --- a/engine/metadata/gen_fn_sig.html +++ b/engine/metadata/gen_fn_sig.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/metadata/index.html b/engine/metadata/index.html index 737bb16c..e9837c26 100644 --- a/engine/metadata/index.html +++ b/engine/metadata/index.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/optimize/constants.html b/engine/optimize/constants.html index 8c11e4e9..37b9a2a9 100644 --- a/engine/optimize/constants.html +++ b/engine/optimize/constants.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/optimize/dead-code.html b/engine/optimize/dead-code.html index 9fec70ee..dcdee81d 100644 --- a/engine/optimize/dead-code.html +++ b/engine/optimize/dead-code.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/optimize/eager.html b/engine/optimize/eager.html index 87cc635e..e7a876e8 100644 --- a/engine/optimize/eager.html +++ b/engine/optimize/eager.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/optimize/index.html b/engine/optimize/index.html index 1b0fd105..9854cdb6 100644 --- a/engine/optimize/index.html +++ b/engine/optimize/index.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/optimize/op-eval.html b/engine/optimize/op-eval.html index 669df64a..1ae39b0f 100644 --- a/engine/optimize/op-eval.html +++ b/engine/optimize/op-eval.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/optimize/passes.html b/engine/optimize/passes.html index c1e956e7..0f61a547 100644 --- a/engine/optimize/passes.html +++ b/engine/optimize/passes.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/optimize/reoptimize.html b/engine/optimize/reoptimize.html index 20805b0a..ca338d54 100644 --- a/engine/optimize/reoptimize.html +++ b/engine/optimize/reoptimize.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/optimize/rewrite.html b/engine/optimize/rewrite.html index 1ec14876..c04de922 100644 --- a/engine/optimize/rewrite.html +++ b/engine/optimize/rewrite.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/optimize/semantics.html b/engine/optimize/semantics.html index 874cc8cf..0c9836ee 100644 --- a/engine/optimize/semantics.html +++ b/engine/optimize/semantics.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/optimize/side-effects.html b/engine/optimize/side-effects.html index 1677e2f1..c00a94fc 100644 --- a/engine/optimize/side-effects.html +++ b/engine/optimize/side-effects.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/optimize/volatility.html b/engine/optimize/volatility.html index 56c2d323..18d057af 100644 --- a/engine/optimize/volatility.html +++ b/engine/optimize/volatility.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/options.html b/engine/options.html index f356ad2d..173d987e 100644 --- a/engine/options.html +++ b/engine/options.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/precedence.html b/engine/precedence.html index 2e4183d7..f4dfcc08 100644 --- a/engine/precedence.html +++ b/engine/precedence.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/raw.html b/engine/raw.html index 5e9f5889..19ace614 100644 --- a/engine/raw.html +++ b/engine/raw.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/scope.html b/engine/scope.html index d8199420..d605c18c 100644 --- a/engine/scope.html +++ b/engine/scope.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/strict-var.html b/engine/strict-var.html index df02a149..8aef186b 100644 --- a/engine/strict-var.html +++ b/engine/strict-var.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/engine/token-mapper.html b/engine/token-mapper.html index ff5d6fb6..447e2712 100644 --- a/engine/token-mapper.html +++ b/engine/token-mapper.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals @@ -198,6 +198,18 @@ Token which is only exported under internals. The function Engine::on_parse_token, available only under internals, allows registration of a mapper function that converts (remaps) a Token into another. + + +Hot Tips: Use as safety checks + + + +Since it is called for every token parsed from the script, this token mapper function +can also be used to implement safety checks against, say, stack-overflow or out-of-memory +situations during parsing. +See here for more details. + + Function Signature diff --git a/engine/var.html b/engine/var.html index 61358e89..d2bdcc8d 100644 --- a/engine/var.html +++ b/engine/var.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/index.html b/index.html index a27bb364..c581a7d4 100644 --- a/index.html +++ b/index.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/arrays.html b/language/arrays.html index b94d3de4..a83c7142 100644 --- a/language/arrays.html +++ b/language/arrays.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/assignment-op.html b/language/assignment-op.html index 8401f8b1..49cc6aeb 100644 --- a/language/assignment-op.html +++ b/language/assignment-op.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/assignment.html b/language/assignment.html index 18e0403a..0fbfede7 100644 --- a/language/assignment.html +++ b/language/assignment.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/bit-fields.html b/language/bit-fields.html index ffd623a9..75837839 100644 --- a/language/bit-fields.html +++ b/language/bit-fields.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/blobs.html b/language/blobs.html index f59489ea..686cdc4c 100644 --- a/language/blobs.html +++ b/language/blobs.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/comments.html b/language/comments.html index 7cf70770..59b1a690 100644 --- a/language/comments.html +++ b/language/comments.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/constants.html b/language/constants.html index d660eeb5..cf068331 100644 --- a/language/constants.html +++ b/language/constants.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/convert.html b/language/convert.html index 99284038..be97e00c 100644 --- a/language/convert.html +++ b/language/convert.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/do.html b/language/do.html index 001f0e23..9b4ad413 100644 --- a/language/do.html +++ b/language/do.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/doc-comments.html b/language/doc-comments.html index d089b297..711cee8e 100644 --- a/language/doc-comments.html +++ b/language/doc-comments.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/dynamic-rust.html b/language/dynamic-rust.html index 96222de4..e3a4d39d 100644 --- a/language/dynamic-rust.html +++ b/language/dynamic-rust.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/dynamic-tag.html b/language/dynamic-tag.html index b298aabb..9d42bb3c 100644 --- a/language/dynamic-tag.html +++ b/language/dynamic-tag.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/dynamic.html b/language/dynamic.html index 131d5cd8..1d8ff26f 100644 --- a/language/dynamic.html +++ b/language/dynamic.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/eval.html b/language/eval.html index a7d9ad68..0b6691a5 100644 --- a/language/eval.html +++ b/language/eval.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/fn-anon.html b/language/fn-anon.html index c9db911a..0e4a65b9 100644 --- a/language/fn-anon.html +++ b/language/fn-anon.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/fn-closure.html b/language/fn-closure.html index 23b4932b..feb89d2d 100644 --- a/language/fn-closure.html +++ b/language/fn-closure.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/fn-curry.html b/language/fn-curry.html index f0ea024f..1231af2c 100644 --- a/language/fn-curry.html +++ b/language/fn-curry.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/fn-metadata.html b/language/fn-metadata.html index de96b020..f4958713 100644 --- a/language/fn-metadata.html +++ b/language/fn-metadata.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/fn-method.html b/language/fn-method.html index 2837c8c9..4b4afd6b 100644 --- a/language/fn-method.html +++ b/language/fn-method.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/fn-namespaces.html b/language/fn-namespaces.html index 14afb2b7..a814ef5d 100644 --- a/language/fn-namespaces.html +++ b/language/fn-namespaces.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/fn-parent-scope.html b/language/fn-parent-scope.html index 8f4706f8..4159aef3 100644 --- a/language/fn-parent-scope.html +++ b/language/fn-parent-scope.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/fn-ptr.html b/language/fn-ptr.html index 21ae89c4..8835c986 100644 --- a/language/fn-ptr.html +++ b/language/fn-ptr.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/for.html b/language/for.html index 7be2f49e..e0744cb8 100644 --- a/language/for.html +++ b/language/for.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/functions.html b/language/functions.html index 2e236e7b..9e6bcae6 100644 --- a/language/functions.html +++ b/language/functions.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/global.html b/language/global.html index fefa0ae0..e6ed75cb 100644 --- a/language/global.html +++ b/language/global.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/if.html b/language/if.html index 4ca82ab4..e794d6bb 100644 --- a/language/if.html +++ b/language/if.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/in.html b/language/in.html index ceba6aca..d9980715 100644 --- a/language/in.html +++ b/language/in.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/iter.html b/language/iter.html index cee2dcc1..4f9ed273 100644 --- a/language/iter.html +++ b/language/iter.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/iterator.html b/language/iterator.html index 02bfa670..8903c7e2 100644 --- a/language/iterator.html +++ b/language/iterator.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/json.html b/language/json.html index 45e15377..2fd1c653 100644 --- a/language/json.html +++ b/language/json.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/keywords.html b/language/keywords.html index b1af15d4..dc8b2fdc 100644 --- a/language/keywords.html +++ b/language/keywords.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/logic.html b/language/logic.html index a2e6382b..c04a1bcb 100644 --- a/language/logic.html +++ b/language/logic.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/loop.html b/language/loop.html index 07423671..1cf10bb6 100644 --- a/language/loop.html +++ b/language/loop.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/modules/export.html b/language/modules/export.html index ec725730..ddc4de8f 100644 --- a/language/modules/export.html +++ b/language/modules/export.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/modules/import.html b/language/modules/import.html index cb4061c0..a6c3be62 100644 --- a/language/modules/import.html +++ b/language/modules/import.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/modules/index.html b/language/modules/index.html index 57b46033..2b4e9d30 100644 --- a/language/modules/index.html +++ b/language/modules/index.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/num-fn.html b/language/num-fn.html index 5edeaa74..5811a932 100644 --- a/language/num-fn.html +++ b/language/num-fn.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/num-op.html b/language/num-op.html index 3bbb1c32..a2e5307c 100644 --- a/language/num-op.html +++ b/language/num-op.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/numbers.html b/language/numbers.html index 8ab30f13..d7afb882 100644 --- a/language/numbers.html +++ b/language/numbers.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/object-maps-oop.html b/language/object-maps-oop.html index c2303480..b82681a7 100644 --- a/language/object-maps-oop.html +++ b/language/object-maps-oop.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/object-maps.html b/language/object-maps.html index 7bc806e9..c30824b7 100644 --- a/language/object-maps.html +++ b/language/object-maps.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/overload.html b/language/overload.html index 82368d3e..dbc86985 100644 --- a/language/overload.html +++ b/language/overload.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/print-debug.html b/language/print-debug.html index 095b6b9e..66b4ad32 100644 --- a/language/print-debug.html +++ b/language/print-debug.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/ranges.html b/language/ranges.html index a3613e29..1b4719ba 100644 --- a/language/ranges.html +++ b/language/ranges.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/return.html b/language/return.html index 866af911..fe0796f4 100644 --- a/language/return.html +++ b/language/return.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/shadow.html b/language/shadow.html index cd01d740..cd3ed097 100644 --- a/language/shadow.html +++ b/language/shadow.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/statement-expression.html b/language/statement-expression.html index ac4098a3..53c46aac 100644 --- a/language/statement-expression.html +++ b/language/statement-expression.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/statements.html b/language/statements.html index e88ece40..9c8ea144 100644 --- a/language/statements.html +++ b/language/statements.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/string-fn.html b/language/string-fn.html index b53bcbda..5596dffd 100644 --- a/language/string-fn.html +++ b/language/string-fn.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/string-interp.html b/language/string-interp.html index eacb3dae..28a42cd8 100644 --- a/language/string-interp.html +++ b/language/string-interp.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/strings-chars.html b/language/strings-chars.html index d393c844..5c7eb1f6 100644 --- a/language/strings-chars.html +++ b/language/strings-chars.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/switch-expression.html b/language/switch-expression.html index 9828f2b6..6bf0c78e 100644 --- a/language/switch-expression.html +++ b/language/switch-expression.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/switch.html b/language/switch.html index c7567287..a617948a 100644 --- a/language/switch.html +++ b/language/switch.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/throw.html b/language/throw.html index 5968ae0c..3de60b3f 100644 --- a/language/throw.html +++ b/language/throw.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/timestamps.html b/language/timestamps.html index 9256ef74..164ed978 100644 --- a/language/timestamps.html +++ b/language/timestamps.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/try-catch.html b/language/try-catch.html index dc4f7c8b..d52b941b 100644 --- a/language/try-catch.html +++ b/language/try-catch.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/type-of.html b/language/type-of.html index 0f34fc65..7c31887e 100644 --- a/language/type-of.html +++ b/language/type-of.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/values-and-types.html b/language/values-and-types.html index 3d5484aa..52935f92 100644 --- a/language/values-and-types.html +++ b/language/values-and-types.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/variables.html b/language/variables.html index 12a9e8a0..4806b83e 100644 --- a/language/variables.html +++ b/language/variables.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/language/while.html b/language/while.html index ea38d523..f985e864 100644 --- a/language/while.html +++ b/language/while.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/lib/index.html b/lib/index.html index 7a499c5b..d7355acd 100644 --- a/lib/index.html +++ b/lib/index.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/lib/rhai-autodocs.html b/lib/rhai-autodocs.html index 9e73a1ed..941a3ea3 100644 --- a/lib/rhai-autodocs.html +++ b/lib/rhai-autodocs.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/lib/rhai-dylib.html b/lib/rhai-dylib.html index 5cc41abb..1c6eeecb 100644 --- a/lib/rhai-dylib.html +++ b/lib/rhai-dylib.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingMaximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of Operations❱Tracking Progress and Force-TerminationMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals + The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱DummyModuleResolverFileModuleResolverStaticModuleResolverModuleResolversCollectionDylibModuleResolver (external)Custom Module ResolversSelf-Contained ASTPlugins❱Export as Rust ModuleExport as Rust FunctionPackages❱Built-in PackagesCreate Custom PackagesCreate Packages as CratesExternal Packages❱Random Number Generation, Shuffling and SamplingScientific ComputingAI and Machine LearningFilesystem AccessWorking with UrlsScripting LanguageComments❱Doc-CommentsValues and Types❱Dynamic Values❱type_of()Interop with RustValue TagSerialization/Deserialization with serdeNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱String InterpolationImmutableStringStandard Functions and OperatorsArrays❱BLOB's (Byte Arrays)Object Maps❱Parse from JSONSpecial Support for OOPTimestampsKeywordsStatements❱Statement ExpressionVariables❱Variable ShadowingStrict Variables ModeVariable Definition FilterVariable ResolverConstants❱Automatic Global ModuleAssignmentsCompound AssignmentsLogic OperatorsIn OperatorIf StatementSwitch Statement❱Switch ExpressionWhile LoopDo LoopLoop StatementFor Loop❱Standard Iterable TypesMake a Custom Type IterableReturn ValueThrow Exception on ErrorCatch ExceptionsFunctions❱Method CallsOverloadingNamespacesFunction Pointers❱CurryingAnonymous FunctionsClosuresMetadata❱Get Scripted Functions Metadata in RhaiGet Scripted Functions Metadata from ASTGet Native Function SignaturesExport All Functions Metadata to JSONGenerate Definition Files for Language ServerPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionSafety and ProtectionIntroductionSand-BoxingLimiting Run TimeLimiting Memory UsageLimiting Stack UsageBuilt-in Safety Limits❱Maximum Length of StringsMaximum Size of ArraysMaximum Size of Object MapsMaximum Number of OperationsMaximum Number of VariablesMaximum Number of FunctionsMaximum Number of ModulesMaximum Call Stack DepthMaximum Expression DepthTurn Off Safety ChecksScript OptimizationIntroductionOptimization Passes❱Dead Code EliminationConstants PropagationCompound Assignment RewriteEager Operator EvaluationEager Function Evaluation❱Side-Effect ConsiderationsVolatility ConsiderationsSubtle Semantic ChangesRe-Optimize an ASTAdvanced TopicsManage AST'sLow-Level API to Register FunctionsEvaluation ContextCall Function Within Caller's ScopeUse Rhai in Dynamic LibrariesUse Rhai as a DSL❱Remap Tokens During ParsingDisable Keywords and/or OperatorsDisable LoopingCustom Operators❱Operator PrecedenceExtend with Custom Syntax❱Custom Syntax ParsersDebugging Interface❱Debugger❱StateCall StackBreak-PointsDebugging ServerUsage PatternsObject-Oriented Programming (OOP)Scriptable Event Handler with State❱Main StyleJS StyleMap StyleControl Layer Over Rust BackendSingleton Command ObjectLoadable ConfigurationMulti-Layered FunctionsHot ReloadingBuilder Pattern / Fluent APIDynamic Constants ProviderGlobal ConstantsMutable Global StateWorking with Rust EnumsSimulate Macros to Simplify ScriptsOne Engine Instance Per CallMulti-Threaded SynchronizationBlocking/Async Function CallsExternal References (Unsafe)Static HashingSerialize an ASTDomain-Specific ToolsMultiple InstantiationLanguage ReferenceIntroductionCommentsValue Types❱Dynamic Values❱type_of()Value TagNumbers❱OperatorsStandard FunctionsValue ConversionsRangesBit-FieldsStrings and Characters❱Standard Functions and OperatorsArraysBLOB's (Byte Arrays)Object MapsTimestampsKeywordsStatementsVariablesConstantsAssignments❱Compound AssignmentsOperatorsIndexingPropertiesMethodsIf StatementSwitch StatementWhile LoopDo LoopInfinite LoopFor LoopReturn ValueThrow Exception on Error❱Catch ExceptionsFunctions❱Method CallsOverloadingFunction PointersClosuresMetadataPrint and DebugModules❱Export Variables, Functions and Sub-Modules from ScriptImport ModulesEval FunctionAppendixExternal Tools❱Online PlaygroundLanguage Serverrhai-docDynamic Loadable LibrariesGenerate MarkDown/MDX API DocumentationKeywordsOperators and SymbolsLiterals diff --git a/lib/rhai-fs.html b/lib/rhai-fs.html index bc47a46a..e80946bd 100644 --- a/lib/rhai-fs.html +++ b/lib/rhai-fs.html @@ -102,7 +102,7 @@ - The Rhai BookUser’s GuideIntroduction❱Features of RhaiWhat Rhai Isn'tBenchmarksSupported Targets and BuildsDependenciesLicensingRelated ResourcesGetting Started❱Online PlaygroundInstall the Rhai CrateOptional FeaturesPackaged UtilitiesThe Scripting Engine❱“Hello, Rhai”Compile to ASTRaw Engine❱Built-in OperatorsScope – Maintaining StateExpressions OnlyOptionsExamples❱RustScriptsSpecial Builds❱PerformanceMinimalno-stdWebAssembly (WASM)Rust IntegrationIntroductionTraitsRegister a Rust Function❱Function OverloadingGeneric FunctionsString ParametersDynamic ParametersDynamic Return ValueFallible FunctionsNativeCallContext❱Restore NativeCallContextOverride a Built-in FunctionCall a Rhai Function from Rust❱Create a Rust Closure from a Rhai FunctionOperator OverloadingWorking with Any Rust Type❱Auto-Generate APICustom Type BuilderManually Register Custom TypeMethods❱Call Method as FunctionProperty Getters and SettersIndexers❱Fallback to PropertiesCollection TypesDisable Custom TypesPrinting Custom TypesModules❱Create in RustCreate from ASTUse a ModuleModule Resolvers❱Built-in Module Resolvers❱
Token
internals
The function Engine::on_parse_token, available only under internals, allows registration of a mapper function that converts (remaps) a Token into another.
Engine::on_parse_token
Hot Tips: Use as safety checks
Since it is called for every token parsed from the script, this token mapper function +can also be used to implement safety checks against, say, stack-overflow or out-of-memory +situations during parsing.
See here for more details.