From 8ebc50bea850131b8d9b13dcd101da311f1f0b81 Mon Sep 17 00:00:00 2001 From: tamasfe Date: Tue, 26 Jul 2022 13:39:50 +0200 Subject: [PATCH] feat(defs): builtin definitions --- .../definitions/__builtin-operators__.d.rhai | 251 + .../.rhai/definitions/__builtin__.d.rhai | 170 + .../.rhai/definitions/__static__.d.rhai | 4202 ++++++++--------- src/definitions/builtin-operators.d.rhai | 251 + src/definitions/builtin.d.rhai | 170 + src/{definitions.rs => definitions/mod.rs} | 3 + 6 files changed, 2946 insertions(+), 2101 deletions(-) create mode 100644 examples/definitions/.rhai/definitions/__builtin-operators__.d.rhai create mode 100644 examples/definitions/.rhai/definitions/__builtin__.d.rhai create mode 100644 src/definitions/builtin-operators.d.rhai create mode 100644 src/definitions/builtin.d.rhai rename src/{definitions.rs => definitions/mod.rs} (97%) diff --git a/examples/definitions/.rhai/definitions/__builtin-operators__.d.rhai b/examples/definitions/.rhai/definitions/__builtin-operators__.d.rhai new file mode 100644 index 00000000..d907afcf --- /dev/null +++ b/examples/definitions/.rhai/definitions/__builtin-operators__.d.rhai @@ -0,0 +1,251 @@ +module static; + +op ==(i64, i64) -> bool; +op !=(i64, i64) -> bool; +op >(i64, i64) -> bool; +op >=(i64, i64) -> bool; +op <(i64, i64) -> bool; +op <=(i64, i64) -> bool; +op &(i64, i64) -> i64; +op |(i64, i64) -> i64; +op ^(i64, i64) -> i64; +op ..(i64, i64) -> Range; +op ..=(i64, i64) -> RangeInclusive; + +op ==(bool, bool) -> bool; +op !=(bool, bool) -> bool; +op >(bool, bool) -> bool; +op >=(bool, bool) -> bool; +op <(bool, bool) -> bool; +op <=(bool, bool) -> bool; +op &(bool, bool) -> bool; +op |(bool, bool) -> bool; +op ^(bool, bool) -> bool; + +op ==((), ()) -> bool; +op !=((), ()) -> bool; +op >((), ()) -> bool; +op >=((), ()) -> bool; +op <((), ()) -> bool; +op <=((), ()) -> bool; + +op +(i64, i64) -> i64; +op -(i64, i64) -> i64; +op *(i64, i64) -> i64; +op /(i64, i64) -> i64; +op %(i64, i64) -> i64; +op **(i64, i64) -> i64; +op >>(i64, i64) -> i64; +op <<(i64, i64) -> i64; + +op +(f64, f64) -> f64; +op -(f64, f64) -> f64; +op *(f64, f64) -> f64; +op /(f64, f64) -> f64; +op %(f64, f64) -> f64; +op **(f64, f64) -> f64; +op ==(f64, f64) -> bool; +op !=(f64, f64) -> bool; +op >(f64, f64) -> bool; +op >=(f64, f64) -> bool; +op <(f64, f64) -> bool; +op <=(f64, f64) -> bool; + +op +(f64, i64) -> f64; +op -(f64, i64) -> f64; +op *(f64, i64) -> f64; +op /(f64, i64) -> f64; +op %(f64, i64) -> f64; +op **(f64, i64) -> f64; +op ==(f64, i64) -> bool; +op !=(f64, i64) -> bool; +op >(f64, i64) -> bool; +op >=(f64, i64) -> bool; +op <(f64, i64) -> bool; +op <=(f64, i64) -> bool; + +op +(i64, f64) -> f64; +op -(i64, f64) -> f64; +op *(i64, f64) -> f64; +op /(i64, f64) -> f64; +op %(i64, f64) -> f64; +op **(i64, f64) -> f64; +op ==(i64, f64) -> bool; +op !=(i64, f64) -> bool; +op >(i64, f64) -> bool; +op >=(i64, f64) -> bool; +op <(i64, f64) -> bool; +op <=(i64, f64) -> bool; + +op +(Decimal, Decimal) -> Decimal; +op -(Decimal, Decimal) -> Decimal; +op *(Decimal, Decimal) -> Decimal; +op /(Decimal, Decimal) -> Decimal; +op %(Decimal, Decimal) -> Decimal; +op **(Decimal, Decimal) -> Decimal; +op ==(Decimal, Decimal) -> bool; +op !=(Decimal, Decimal) -> bool; +op >(Decimal, Decimal) -> bool; +op >=(Decimal, Decimal) -> bool; +op <(Decimal, Decimal) -> bool; +op <=(Decimal, Decimal) -> bool; + +op +(Decimal, i64) -> Decimal; +op -(Decimal, i64) -> Decimal; +op *(Decimal, i64) -> Decimal; +op /(Decimal, i64) -> Decimal; +op %(Decimal, i64) -> Decimal; +op **(Decimal, i64) -> Decimal; +op ==(Decimal, i64) -> bool; +op !=(Decimal, i64) -> bool; +op >(Decimal, i64) -> bool; +op >=(Decimal, i64) -> bool; +op <(Decimal, i64) -> bool; +op <=(Decimal, i64) -> bool; + +op +(i64, Decimal) -> Decimal; +op -(i64, Decimal) -> Decimal; +op *(i64, Decimal) -> Decimal; +op /(i64, Decimal) -> Decimal; +op %(i64, Decimal) -> Decimal; +op **(i64, Decimal) -> Decimal; +op ==(i64, Decimal) -> bool; +op !=(i64, Decimal) -> bool; +op >(i64, Decimal) -> bool; +op >=(i64, Decimal) -> bool; +op <(i64, Decimal) -> bool; +op <=(i64, Decimal) -> bool; + +op +(String, String) -> String; +op -(String, String) -> String; +op ==(String, String) -> bool; +op !=(String, String) -> bool; +op >(String, String) -> bool; +op >=(String, String) -> bool; +op <(String, String) -> bool; +op <=(String, String) -> bool; + +op +(char, char) -> String; +op ==(char, char) -> bool; +op !=(char, char) -> bool; +op >(char, char) -> bool; +op >=(char, char) -> bool; +op <(char, char) -> bool; +op <=(char, char) -> bool; + +op +(char, String) -> String; +op ==(char, String) -> bool; +op !=(char, String) -> bool; +op >(char, String) -> bool; +op >=(char, String) -> bool; +op <(char, String) -> bool; +op <=(char, String) -> bool; + +op +(String, char) -> String; +op -(String, char) -> String; +op ==(String, char) -> bool; +op !=(String, char) -> bool; +op >(String, char) -> bool; +op >=(String, char) -> bool; +op <(String, char) -> bool; +op <=(String, char) -> bool; + +op +((), String) -> String; +op ==((), String) -> bool; +op !=((), String) -> bool; +op >((), String) -> bool; +op >=((), String) -> bool; +op <((), String) -> bool; +op <=((), String) -> bool; + +op +(String, ()) -> String; +op ==(String, ()) -> bool; +op !=(String, ()) -> bool; +op >(String, ()) -> bool; +op >=(String, ()) -> bool; +op <(String, ()) -> bool; +op <=(String, ()) -> bool; + +op +(Blob, Blob) -> Blob; +op +(Blob, char) -> Blob; +op ==(Blob, Blob) -> bool; +op !=(Blob, Blob) -> bool; + + +op ==(Range, RangeInclusive) -> bool; +op !=(Range, RangeInclusive) -> bool; + +op ==(RangeInclusive, Range) -> bool; +op !=(RangeInclusive, Range) -> bool; + +op ==(Range, Range) -> bool; +op !=(Range, Range) -> bool; + +op ==(RangeInclusive, RangeInclusive) -> bool; +op !=(RangeInclusive, RangeInclusive) -> bool; + +op ==(?, ?) -> bool; +op !=(?, ?) -> bool; +op >(?, ?) -> bool; +op >=(?, ?) -> bool; +op <(?, ?) -> bool; +op <=(?, ?) -> bool; + + +op &=(bool, bool); +op |=(bool, bool); + +op +=(i64, i64); +op -=(i64, i64); +op *=(i64, i64); +op /=(i64, i64); +op %=(i64, i64); +op **=(i64, i64); +op >>=(i64, i64); +op <<=(i64, i64); +op &=(i64, i64); +op |=(i64, i64); +op ^=(i64, i64); + +op +=(f64, f64); +op -=(f64, f64); +op *=(f64, f64); +op /=(f64, f64); +op %=(f64, f64); +op **=(f64, f64); + +op +=(f64, i64); +op -=(f64, i64); +op *=(f64, i64); +op /=(f64, i64); +op %=(f64, i64); +op **=(f64, i64); + +op +=(Decimal, Decimal); +op -=(Decimal, Decimal); +op *=(Decimal, Decimal); +op /=(Decimal, Decimal); +op %=(Decimal, Decimal); +op **=(Decimal, Decimal); + +op +=(Decimal, i64); +op -=(Decimal, i64); +op *=(Decimal, i64); +op /=(Decimal, i64); +op %=(Decimal, i64); +op **=(Decimal, i64); + +op +=(String, String); +op -=(String, String); +op +=(String, char); +op -=(String, char); +op +=(char, String); +op +=(char, char); + +op +=(arraArray, item: Array); +op +=(arraArray, item: ?); + +op +=(Blob, Blob); +op +=(Blob, value: i64); +op +=(Blob, char); +op +=(Blob, String); diff --git a/examples/definitions/.rhai/definitions/__builtin__.d.rhai b/examples/definitions/.rhai/definitions/__builtin__.d.rhai new file mode 100644 index 00000000..2e08fa44 --- /dev/null +++ b/examples/definitions/.rhai/definitions/__builtin__.d.rhai @@ -0,0 +1,170 @@ +module static; + +/// Display any data to the standard output. +/// +/// # Example +/// +/// ```rhai +/// let answer = 42; +/// +/// print(`The Answer is ${answer}`); +/// ``` +fn print(data: ?); + +/// Display any data to the standard output in debug format. +/// +/// # Example +/// +/// ```rhai +/// let answer = 42; +/// +/// debug(answer); +/// ``` +fn debug(data: ?); + +/// Get the type of a value. +/// +/// # Example +/// +/// ```rhai +/// let x = "hello, world!"; +/// +/// print(x.type_of()); // prints "string" +/// ``` +fn type_of(data: ?) -> String; + +/// Create a function pointer to a named function. +/// +/// If the specified name is not a valid function name, an error is raised. +/// +/// # Example +/// +/// ```rhai +/// let f = Fn("foo"); // function pointer to 'foo' +/// +/// f.call(42); // call: foo(42) +/// ``` +fn Fn(fn_name: String) -> FnPtr; + +/// Call a function pointed to by a function pointer, +/// passing following arguments to the function call. +/// +/// If an appropriate function is not found, an error is raised. +/// +/// # Example +/// +/// ```rhai +/// let f = Fn("foo"); // function pointer to 'foo' +/// +/// f.call(1, 2, 3); // call: foo(1, 2, 3) +/// ``` +fn call(fn_ptr: FnPtr, ...args: ?) -> ?; + +/// Call a function pointed to by a function pointer, binding the `this` pointer +/// to the object of the method call, and passing on following arguments to the function call. +/// +/// If an appropriate function is not found, an error is raised. +/// +/// # Example +/// +/// ```rhai +/// fn add(x) { +/// this + x +/// } +/// +/// let f = Fn("add"); // function pointer to 'add' +/// +/// let x = 41; +/// +/// let r = x.call(f, 1); // call: add(1) with 'this' = 'x' +/// +/// print(r); // prints 42 +/// ``` +fn call(obj: ?, fn_ptr: FnPtr, ...args: ?) -> ?; + +/// Curry a number of arguments into a function pointer and return it as a new function pointer. +/// +/// # Example +/// +/// ```rhai +/// fn foo(x, y, z) { +/// x + y + z +/// } +/// +/// let f = Fn("foo"); +/// +/// let g = f.curry(1, 2); // curried arguments: 1, 2 +/// +/// g.call(3); // call: foo(1, 2, 3) +/// ``` +fn curry(fn_ptr: FnPtr, ...args: ?) -> FnPtr; + +/// Return `true` if a script-defined function exists with a specified name and +/// number of parameters. +/// +/// # Example +/// +/// ```rhai +/// fn foo(x) { } +/// +/// print(is_def_fn("foo", 1)); // prints true +/// print(is_def_fn("foo", 2)); // prints false +/// print(is_def_fn("foo", 0)); // prints false +/// print(is_def_fn("bar", 1)); // prints false +/// ``` +fn is_def_fn(fn_name: String, num_params: i64) -> bool; + +/// Return `true` if a variable matching a specified name is defined. +/// +/// # Example +/// +/// ```rhai +/// let x = 42; +/// +/// print(is_def_var("x")); // prints true +/// print(is_def_var("foo")); // prints false +/// +/// { +/// let y = 1; +/// print(is_def_var("y")); // prints true +/// } +/// +/// print(is_def_var("y")); // prints false +/// ``` +fn is_def_var(var_name: String) -> bool; + +/// Return `true` if the variable is shared. +/// +/// # Example +/// +/// ```rhai +/// let x = 42; +/// +/// print(is_shared(x)); // prints false +/// +/// let f = || x; // capture 'x', making it shared +/// +/// print(is_shared(x)); // prints true +/// ``` +fn is_shared(variable: ?) -> bool; + +/// Evaluate a text script within the current scope. +/// +/// # Example +/// +/// ```rhai +/// let x = 42; +/// +/// eval("let y = x; x = 123;"); +/// +/// print(x); // prints 123 +/// print(y); // prints 42 +/// ``` +fn eval(script: String) -> ?; + +fn contains(string: String, find: String) -> bool; +fn contains(range: Range, value: i64) -> bool; +fn contains(range: RangeInclusive, value: i64) -> bool; +fn contains(map: Map, string: String) -> bool; +fn contains(blob: Blob, value: i64) -> bool; +fn contains(string: String, ch: char) -> bool; diff --git a/examples/definitions/.rhai/definitions/__static__.d.rhai b/examples/definitions/.rhai/definitions/__static__.d.rhai index 10d7b8c4..c422f26a 100644 --- a/examples/definitions/.rhai/definitions/__static__.d.rhai +++ b/examples/definitions/.rhai/definitions/__static__.d.rhai @@ -4,6 +4,17 @@ op minus(i64, i64) -> i64; op !(bool) -> bool; +/// Return `true` if two timestamps are not equal. +op !=(Instant, Instant) -> bool; + +op !=(f32, int) -> bool; + +op !=(f32, f32) -> bool; + +op !=(f64, int) -> bool; + +op !=(u16, u16) -> bool; + /// Return `true` if two arrays are not-equal (i.e. any element not equal or not in the same order). /// /// The operator `==` is used to compare elements and must be defined, @@ -22,13 +33,7 @@ op !(bool) -> bool; /// ``` op !=(Array, Array) -> bool; -op !=(u16, u16) -> bool; - -op !=(f32, f32) -> bool; - -op !=(int, f32) -> bool; - -op !=(i32, i32) -> bool; +op !=(int, f64) -> bool; /// Return `true` if two object maps are not equal (i.e. at least one property value is not equal). /// @@ -48,189 +53,111 @@ op !=(i32, i32) -> bool; /// ``` op !=(Map, Map) -> bool; -op !=(u64, u64) -> bool; - op !=(u32, u32) -> bool; -op !=(i8, i8) -> bool; - -op !=(f32, int) -> bool; - -op !=(i16, i16) -> bool; - -/// Return `true` if two timestamps are not equal. -op !=(Instant, Instant) -> bool; - op !=(u128, u128) -> bool; -op !=(u8, u8) -> bool; +op !=(i8, i8) -> bool; -op !=(f64, int) -> bool; - -op !=(int, f64) -> bool; +op !=(u64, u64) -> bool; op !=(i128, i128) -> bool; -op %(u8, u8) -> u8; +op !=(u8, u8) -> bool; -op %(i128, i128) -> i128; +op !=(i16, i16) -> bool; -op %(i32, i32) -> i32; +op !=(i32, i32) -> bool; + +op !=(int, f32) -> bool; op %(int, f32) -> f32; -op %(f32, f32) -> f32; - -op %(u32, u32) -> u32; +op %(i128, i128) -> i128; op %(u64, u64) -> u64; -op %(u16, u16) -> u16; +op %(u8, u8) -> u8; op %(i16, i16) -> i16; -op %(u128, u128) -> u128; - -op %(i8, i8) -> i8; +op %(i32, i32) -> i32; op %(f32, int) -> f32; -op &(i128, i128) -> i128; +op %(u16, u16) -> u16; -op &(u8, u8) -> u8; +op %(f32, f32) -> f32; + +op %(u128, u128) -> u128; + +op %(u32, u32) -> u32; + +op %(i8, i8) -> i8; op &(i8, i8) -> i8; op &(u128, u128) -> u128; -op &(i16, i16) -> i16; +op &(u32, u32) -> u32; op &(u16, u16) -> u16; -op &(u32, u32) -> u32; - -op &(u64, u64) -> u64; +op &(i16, i16) -> i16; op &(i32, i32) -> i32; -op *(i8, i8) -> i8; +op &(u64, u64) -> u64; -op *(f32, int) -> f32; +op &(i128, i128) -> i128; -op *(i16, i16) -> i16; - -op *(u128, u128) -> u128; +op &(u8, u8) -> u8; op *(u16, u16) -> u16; op *(f32, f32) -> f32; -op *(int, f32) -> f32; +op *(f32, int) -> f32; -op *(i32, i32) -> i32; +op *(i8, i8) -> i8; -op *(u64, u64) -> u64; +op *(u128, u128) -> u128; op *(u32, u32) -> u32; -op *(i128, i128) -> i128; - op *(u8, u8) -> u8; -op **(f32, int) -> f32; +op *(i128, i128) -> i128; -op **(u32, int) -> u32; +op *(u64, u64) -> u64; -op **(i128, int) -> i128; +op *(i32, i32) -> i32; -op **(f32, f32) -> f32; +op *(i16, i16) -> i16; + +op *(int, f32) -> f32; op **(u8, int) -> u8; -op **(i8, int) -> i8; +op **(i16, int) -> i16; -op **(u64, int) -> u64; +op **(i128, int) -> i128; -op **(u128, int) -> u128; +op **(f32, int) -> f32; + +op **(f32, f32) -> f32; op **(u16, int) -> u16; -op **(i16, int) -> i16; +op **(i8, int) -> i8; op **(i32, int) -> i32; -op +(i128, i128) -> i128; +op **(u32, int) -> u32; -op +(String, ()) -> String; +op **(u128, int) -> u128; -/// Add the specified number of `seconds` to the timestamp and return it as a new timestamp. -op +(Instant, int) -> Instant; - -op +(char, String) -> String; - -op +(i32) -> i32; - -op +(f32) -> f32; - -op +(String, String) -> String; - -op +(u8, u8) -> u8; - -/// Add the specified number of `seconds` to the timestamp and return it as a new timestamp. -op +(Instant, float) -> Instant; - -op +(String, ?) -> String; - -op +(f64) -> f64; - -op +(int) -> int; - -op +(u128, u128) -> u128; - -op +(Blob, String) -> String; - -op +(i16, i16) -> i16; - -op +((), String) -> String; - -op +(i16) -> i16; - -op +(i8) -> i8; - -op +(f32, int) -> f32; - -op +(i8, i8) -> i8; - -op +(?, String) -> String; - -op +(u32, u32) -> u32; - -/// Make a copy of the object map, add all property values of another object map -/// (existing property values of the same names are replaced), then returning it. -/// -/// # Example -/// -/// ```rhai -/// let m = #{a:1, b:2, c:3}; -/// let n = #{a: 42, d:0}; -/// -/// print(m + n); // prints "#{a:42, b:2, c:3, d:0}" -/// -/// print(m); // prints "#{a:1, b:2, c:3}" -/// ``` -op +(Map, Map) -> Map; - -op +(u64, u64) -> u64; - -op +(i32, i32) -> i32; - -op +(String, Blob) -> String; - -op +(int, f32) -> f32; - -op +(f32, f32) -> f32; - -op +(u16, u16) -> u16; +op **(u64, int) -> u64; op +(i128) -> i128; @@ -248,16 +175,84 @@ op +(i128) -> i128; /// ``` op +(Array, Array) -> Array; +op +(i8) -> i8; + +op +(String, ()) -> String; + +op +(u16, u16) -> u16; + +op +(f32, f32) -> f32; + +op +(f32, int) -> f32; + +op +(i8, i8) -> i8; + +op +(int) -> i64; + +op +(u128, u128) -> u128; + +op +(u32, u32) -> u32; + +/// Add the specified number of `seconds` to the timestamp and return it as a new timestamp. +op +(Instant, int) -> Instant; + +op +(i32) -> i32; + +/// Make a copy of the object map, add all property values of another object map +/// (existing property values of the same names are replaced), then returning it. +/// +/// # Example +/// +/// ```rhai +/// let m = #{a:1, b:2, c:3}; +/// let n = #{a: 42, d:0}; +/// +/// print(m + n); // prints "#{a:42, b:2, c:3, d:0}" +/// +/// print(m); // prints "#{a:1, b:2, c:3}" +/// ``` +op +(Map, Map) -> Map; + op +(String, char) -> String; +op +(u8, u8) -> u8; + +/// Add the specified number of `seconds` to the timestamp and return it as a new timestamp. +op +(Instant, float) -> Instant; + +op +(String, ?) -> String; + +op +(Blob, String) -> String; + +op +(i128, i128) -> i128; + +op +(u64, u64) -> u64; + +op +(f32) -> f32; + +op +(String, Blob) -> String; + +op +(i32, i32) -> i32; + +op +((), String) -> String; + +op +(f64) -> f64; + +op +(i16) -> i16; + +op +(?, String) -> String; + +op +(i16, i16) -> i16; + +op +(int, f32) -> f32; + +op +(String, String) -> String; + +op +(char, String) -> String; + /// Add the specified number of `seconds` to the timestamp. op +=(Instant, int) -> (); -/// Add the specified number of `seconds` to the timestamp. -op +=(Instant, float) -> (); - -op +=(String, ?) -> (); - /// Add all property values of another object map into the object map. /// Existing property values of the same names are replaced. /// @@ -273,89 +268,93 @@ op +=(String, ?) -> (); /// ``` op +=(Map, Map) -> (); +/// Add the specified number of `seconds` to the timestamp. +op +=(Instant, float) -> (); + +op +=(String, ?) -> (); + op +=(String, Blob) -> (); -op -(i128, i128) -> i128; +op -(f32, f32) -> f32; -op -(f32) -> f32; +op -(u16, u16) -> u16; + +op -(f32, int) -> f32; + +op -(i8, i8) -> i8; /// Subtract the specified number of `seconds` from the timestamp and return it as a new timestamp. op -(Instant, int) -> Instant; +op -(u32, u32) -> u32; + +op -(u128, u128) -> u128; + +op -(i128) -> i128; + op -(i32) -> i32; +op -(int) -> int; + +op -(i8) -> i8; + +/// Return the number of seconds between two timestamps. +op -(Instant, Instant) -> RhaiResult; + +op -(int, f32) -> f32; + +op -(i16) -> i16; + +op -(f64) -> f64; + +op -(f32) -> f32; + /// Subtract the specified number of `seconds` from the timestamp and return it as a new timestamp. op -(Instant, float) -> Instant; op -(u8, u8) -> u8; -op -(f64) -> f64; +op -(u64, u64) -> u64; -op -(int) -> int; - -op -(i16, i16) -> i16; - -op -(i16) -> i16; - -/// Return the number of seconds between two timestamps. -op -(Instant, Instant) -> RhaiResult; - -op -(u128, u128) -> u128; - -op -(i8, i8) -> i8; - -op -(i8) -> i8; - -op -(f32, int) -> f32; - -op -(f32, f32) -> f32; +op -(i128, i128) -> i128; op -(i32, i32) -> i32; -op -(int, f32) -> f32; - -op -(u64, u64) -> u64; - -op -(u32, u32) -> u32; - -op -(i128) -> i128; - -op -(u16, u16) -> u16; - -/// Subtract the specified number of `seconds` from the timestamp. -op -=(Instant, float) -> (); +op -(i16, i16) -> i16; /// Subtract the specified number of `seconds` from the timestamp. op -=(Instant, int) -> (); -op /(u8, u8) -> u8; - -op /(i128, i128) -> i128; - -op /(u32, u32) -> u32; - -op /(u64, u64) -> u64; - -op /(int, f32) -> f32; - -op /(i32, i32) -> i32; - -op /(f32, f32) -> f32; - -op /(u16, u16) -> u16; - -op /(u128, u128) -> u128; - -op /(i16, i16) -> i16; +/// Subtract the specified number of `seconds` from the timestamp. +op -=(Instant, float) -> (); op /(f32, int) -> f32; +op /(u16, u16) -> u16; + +op /(f32, f32) -> f32; + +op /(u32, u32) -> u32; + +op /(u128, u128) -> u128; + op /(i8, i8) -> i8; -op <(i16, i16) -> bool; +op /(int, f32) -> f32; -/// Return `true` if the first timestamp is earlier than the second. -op <(Instant, Instant) -> bool; +op /(i128, i128) -> i128; + +op /(u64, u64) -> u64; + +op /(u8, u8) -> u8; + +op /(i16, i16) -> i16; + +op /(i32, i32) -> i32; + +op <(int, f64) -> bool; + +op <(u32, u32) -> bool; op <(u128, u128) -> bool; @@ -365,89 +364,118 @@ op <(f32, int) -> bool; op <(f32, f32) -> bool; +op <(f64, int) -> bool; + +op <(u16, u16) -> bool; + +/// Return `true` if the first timestamp is earlier than the second. +op <(Instant, Instant) -> bool; + op <(int, f32) -> bool; +op <(i16, i16) -> bool; + op <(i32, i32) -> bool; op <(u64, u64) -> bool; -op <(u32, u32) -> bool; - -op <(u16, u16) -> bool; - -op <(int, f64) -> bool; - op <(i128, i128) -> bool; -op <(f64, int) -> bool; - op <(u8, u8) -> bool; -op <<(u32, int) -> u32; - -op <<(i128, int) -> i128; - -op <<(u8, int) -> u8; +op <<(u16, int) -> u16; op <<(i8, int) -> i8; -op <<(u64, int) -> u64; - -op <<(u128, int) -> u128; - -op <<(u16, int) -> u16; +op <<(u8, int) -> u8; op <<(i16, int) -> i16; +op <<(i128, int) -> i128; + +op <<(u128, int) -> u128; + +op <<(u64, int) -> u64; + op <<(i32, int) -> i32; -op <=(int, f64) -> bool; +op <<(u32, int) -> u32; + +op <=(int, f32) -> bool; op <=(i128, i128) -> bool; -op <=(f64, int) -> bool; +op <=(u64, u64) -> bool; op <=(u8, u8) -> bool; op <=(i16, i16) -> bool; -/// Return `true` if the first timestamp is earlier than or equals to the second. -op <=(Instant, Instant) -> bool; - -op <=(u128, u128) -> bool; - -op <=(i8, i8) -> bool; +op <=(i32, i32) -> bool; op <=(f32, int) -> bool; +op <=(u16, u16) -> bool; + +op <=(f64, int) -> bool; + op <=(f32, f32) -> bool; -op <=(i32, i32) -> bool; +op <=(int, f64) -> bool; -op <=(int, f32) -> bool; +op <=(i8, i8) -> bool; -op <=(u64, u64) -> bool; +op <=(u128, u128) -> bool; op <=(u32, u32) -> bool; -op <=(u16, u16) -> bool; +/// Return `true` if the first timestamp is earlier than or equals to the second. +op <=(Instant, Instant) -> bool; + +op ==(u8, u8) -> bool; + +op ==(u64, u64) -> bool; + +op ==(i128, i128) -> bool; + +op ==(i32, i32) -> bool; + +op ==(i16, i16) -> bool; + +op ==(int, f32) -> bool; /// Return `true` if two timestamps are equal. op ==(Instant, Instant) -> bool; -op ==(i16, i16) -> bool; +/// Return `true` if two arrays are equal (i.e. all elements are equal and in the same order). +/// +/// The operator `==` is used to compare elements and must be defined, +/// otherwise `false` is assumed. +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 3, 4, 5]; +/// let y = [1, 2, 3, 4, 5]; +/// let z = [1, 2, 3, 4]; +/// +/// print(x == y); // prints true +/// +/// print(x == z); // prints false +/// ``` +op ==(Array, Array) -> bool; -op ==(u128, u128) -> bool; +op ==(f32, f32) -> bool; -op ==(i8, i8) -> bool; +op ==(u16, u16) -> bool; + +op ==(f64, int) -> bool; op ==(f32, int) -> bool; -op ==(int, f32) -> bool; +op ==(i8, i8) -> bool; -op ==(i32, i32) -> bool; - -op ==(f32, f32) -> bool; +op ==(u128, u128) -> bool; op ==(u32, u32) -> bool; @@ -469,166 +497,158 @@ op ==(u32, u32) -> bool; /// ``` op ==(Map, Map) -> bool; -op ==(u64, u64) -> bool; - -/// Return `true` if two arrays are equal (i.e. all elements are equal and in the same order). -/// -/// The operator `==` is used to compare elements and must be defined, -/// otherwise `false` is assumed. -/// -/// # Example -/// -/// ```rhai -/// let x = [1, 2, 3, 4, 5]; -/// let y = [1, 2, 3, 4, 5]; -/// let z = [1, 2, 3, 4]; -/// -/// print(x == y); // prints true -/// -/// print(x == z); // prints false -/// ``` -op ==(Array, Array) -> bool; - -op ==(u16, u16) -> bool; - -op ==(i128, i128) -> bool; - op ==(int, f64) -> bool; -op ==(f64, int) -> bool; +/// Return `true` if the first timestamp is later than the second. +op >(Instant, Instant) -> bool; -op ==(u8, u8) -> bool; +op >(f32, int) -> bool; + +op >(f32, f32) -> bool; + +op >(u16, u16) -> bool; op >(f64, int) -> bool; -op >(i128, i128) -> bool; - op >(int, f64) -> bool; -op >(u8, u8) -> bool; - -op >(f32, int) -> bool; - op >(i8, i8) -> bool; op >(u128, u128) -> bool; -/// Return `true` if the first timestamp is later than the second. -op >(Instant, Instant) -> bool; - -op >(i16, i16) -> bool; - -op >(u16, u16) -> bool; - op >(u32, u32) -> bool; op >(u64, u64) -> bool; +op >(i128, i128) -> bool; + +op >(u8, u8) -> bool; + +op >(i16, i16) -> bool; + op >(i32, i32) -> bool; op >(int, f32) -> bool; -op >(f32, f32) -> bool; - -op >=(u16, u16) -> bool; - -op >=(u32, u32) -> bool; - -op >=(u64, u64) -> bool; - op >=(int, f32) -> bool; +op >=(i16, i16) -> bool; + op >=(i32, i32) -> bool; -op >=(f32, f32) -> bool; +op >=(u64, u64) -> bool; -op >=(f32, int) -> bool; +op >=(i128, i128) -> bool; + +op >=(u8, u8) -> bool; + +op >=(int, f64) -> bool; op >=(i8, i8) -> bool; op >=(u128, u128) -> bool; -/// Return `true` if the first timestamp is later than or equals to the second. -op >=(Instant, Instant) -> bool; +op >=(u32, u32) -> bool; -op >=(i16, i16) -> bool; +op >=(f32, int) -> bool; -op >=(u8, u8) -> bool; +op >=(f32, f32) -> bool; + +op >=(u16, u16) -> bool; op >=(f64, int) -> bool; -op >=(i128, i128) -> bool; +/// Return `true` if the first timestamp is later than or equals to the second. +op >=(Instant, Instant) -> bool; -op >=(int, f64) -> bool; +op >>(u8, int) -> u8; + +op >>(i16, int) -> i16; + +op >>(i128, int) -> i128; + +op >>(u16, int) -> u16; + +op >>(i8, int) -> i8; + +op >>(i32, int) -> i32; + +op >>(u32, int) -> u32; op >>(u128, int) -> u128; op >>(u64, int) -> u64; -op >>(i8, int) -> i8; - -op >>(u8, int) -> u8; - -op >>(i32, int) -> i32; - -op >>(i16, int) -> i16; - -op >>(u16, int) -> u16; - -op >>(i128, int) -> i128; - -op >>(u32, int) -> u32; - /// Return the natural number _e_. -fn E() -> float; +fn E() -> f64; /// Return the number π. -fn PI() -> float; - -op ^(u8, u8) -> u8; - -op ^(i128, i128) -> i128; - -op ^(u16, u16) -> u16; - -op ^(u64, u64) -> u64; - -op ^(u32, u32) -> u32; - -op ^(i32, i32) -> i32; +fn PI() -> f64; op ^(i8, i8) -> i8; +op ^(u32, u32) -> u32; + op ^(u128, u128) -> u128; +op ^(u16, u16) -> u16; + +op ^(i32, i32) -> i32; + op ^(i16, i16) -> i16; -/// Return the absolute value of the number. -fn abs(x: int) -> int; +op ^(u8, u8) -> u8; -/// Return the absolute value of the floating-point number. -fn abs(x: f64) -> f64; +op ^(u64, u64) -> u64; + +op ^(i128, i128) -> i128; /// Return the absolute value of the floating-point number. fn abs(x: f32) -> f32; /// Return the absolute value of the number. -fn abs(x: i32) -> i32; +fn abs(x: i16) -> i16; + +/// Return the absolute value of the floating-point number. +fn abs(x: f64) -> f64; /// Return the absolute value of the number. fn abs(x: i128) -> i128; -/// Return the absolute value of the number. -fn abs(x: i16) -> i16; - /// Return the absolute value of the number. fn abs(x: i8) -> i8; +/// Return the absolute value of the number. +fn abs(x: i32) -> i32; + +/// Return the absolute value of the number. +fn abs(x: int) -> int; + /// Return the arc-cosine of the floating-point number, in radians. -fn acos(x: float) -> float; +fn acos(x: float) -> f64; /// Return the arc-hyperbolic-cosine of the floating-point number, in radians. -fn acosh(x: float) -> float; +fn acosh(x: float) -> f64; + +/// Return `true` if all elements in the array return `true` when applied the `filter` function. +/// +/// # Function Parameters +/// +/// * `element`: copy of array element +/// * `index` _(optional)_: current index in the array +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 5]; +/// +/// print(x.all(|v| v > 3)); // prints false +/// +/// print(x.all(|v| v > 1)); // prints true +/// +/// print(x.all(|v, i| i > v)); // prints false +/// ``` +fn all(array: Array, filter: FnPtr) -> bool; /// Return `true` if all elements in the array return `true` when applied a function named by `filter`. /// @@ -652,25 +672,18 @@ fn acosh(x: float) -> float; /// ``` fn all(array: Array, filter: String) -> bool; -/// Return `true` if all elements in the array return `true` when applied the `filter` function. -/// -/// # Function Parameters -/// -/// * `element`: copy of array element -/// * `index` _(optional)_: current index in the array +/// Add a character (as UTF-8 encoded byte-stream) to the end of the BLOB /// /// # Example /// /// ```rhai -/// let x = [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 5]; +/// let b = blob(5, 0x42); /// -/// print(x.all(|v| v > 3)); // prints false +/// b.append('!'); /// -/// print(x.all(|v| v > 1)); // prints true -/// -/// print(x.all(|v, i| i > v)); // prints false +/// print(b); // prints "[424242424221]" /// ``` -fn all(array: Array, filter: FnPtr) -> bool; +fn append(blob: Blob, character: char) -> (); /// Add another BLOB to the end of the BLOB. /// @@ -686,34 +699,6 @@ fn all(array: Array, filter: FnPtr) -> bool; /// ``` fn append(blob1: Blob, blob2: Blob) -> (); -/// Add a string (as UTF-8 encoded byte-stream) to the end of the BLOB -/// -/// # Example -/// -/// ```rhai -/// let b = blob(5, 0x42); -/// -/// b.append("hello"); -/// -/// print(b); // prints "[424242424268656c 6c6f]" -/// ``` -fn append(blob: Blob, string: String) -> (); - -/// Add a character (as UTF-8 encoded byte-stream) to the end of the BLOB -/// -/// # Example -/// -/// ```rhai -/// let b = blob(5, 0x42); -/// -/// b.append('!'); -/// -/// print(b); // prints "[424242424221]" -/// ``` -fn append(blob: Blob, character: char) -> (); - -fn append(string: String, utf8: Blob) -> (); - /// Add all the elements of another array to the end of the array. /// /// # Example @@ -743,6 +728,21 @@ fn append(array: Array, new_array: Array) -> (); /// ``` fn append(blob: Blob, value: int) -> (); +fn append(string: String, utf8: Blob) -> (); + +/// Add a string (as UTF-8 encoded byte-stream) to the end of the BLOB +/// +/// # Example +/// +/// ```rhai +/// let b = blob(5, 0x42); +/// +/// b.append("hello"); +/// +/// print(b); // prints "[424242424268656c 6c6f]" +/// ``` +fn append(blob: Blob, string: String) -> (); + fn append(string: String, item: ?) -> (); /// Convert the BLOB into a string. @@ -761,34 +761,19 @@ fn append(string: String, item: ?) -> (); fn as_string(blob: Blob) -> String; /// Return the arc-sine of the floating-point number, in radians. -fn asin(x: float) -> float; +fn asin(x: float) -> f64; /// Return the arc-hyperbolic-sine of the floating-point number, in radians. -fn asinh(x: float) -> float; +fn asinh(x: float) -> f64; /// Return the arc-tangent of the floating-point numbers `x` and `y`, in radians. -fn atan(x: float, y: float) -> float; +fn atan(x: float, y: float) -> f64; /// Return the arc-tangent of the floating-point number, in radians. -fn atan(x: float) -> float; +fn atan(x: float) -> f64; /// Return the arc-hyperbolic-tangent of the floating-point number, in radians. -fn atanh(x: float) -> float; - -/// Return an iterator over the bits in the number starting from the specified `start` position. -/// -/// If `start` < 0, position counts from the MSB (Most Significant Bit)>. -/// -/// # Example -/// -/// ```rhai -/// let x = 123456; -/// -/// for bit in x.bits(10) { -/// print(bit); -/// } -/// ``` -fn bits(value: int, from: int) -> Iterator; +fn atanh(x: float) -> f64; /// Return an iterator over an inclusive range of bits in the number. /// @@ -846,8 +831,20 @@ fn bits(value: int, range: Range) -> Iterator; /// ``` fn bits(value: int, from: int, len: int) -> Iterator; -/// Return a new, empty BLOB. -fn blob() -> Blob; +/// Return an iterator over the bits in the number starting from the specified `start` position. +/// +/// If `start` < 0, position counts from the MSB (Most Significant Bit)>. +/// +/// # Example +/// +/// ```rhai +/// let x = 123456; +/// +/// for bit in x.bits(10) { +/// print(bit); +/// } +/// ``` +fn bits(value: int, from: int) -> Iterator; /// Return a new BLOB of the specified length, filled with copies of the initial `value`. /// @@ -877,6 +874,9 @@ fn blob(len: int, value: int) -> Blob; /// ``` fn blob(len: int) -> Blob; +/// Return a new, empty BLOB. +fn blob() -> Blob; + /// Return the length of the string, in number of bytes used to store it in UTF-8 encoding. /// /// # Example @@ -886,10 +886,25 @@ fn blob(len: int) -> Blob; /// /// print(text.bytes); // prints 51 /// ``` -fn bytes(string: String) -> int; +fn bytes(string: String) -> i64; /// Return the smallest whole number larger than or equals to the floating-point number. -fn ceiling(x: float) -> float; +fn ceiling(x: float) -> f64; + +/// Return an iterator over the characters in the string starting from the `start` position. +/// +/// * If `start` < 0, position counts from the end of the string (`-1` is the last character). +/// * If `start` < -length of string, position counts from the beginning of the string. +/// * If `start` ≥ length of string, an empty iterator is returned. +/// +/// # Example +/// +/// ```rhai +/// for ch in "hello, world!".chars(2) { +/// print(ch); +/// } +/// ``` +fn chars(string: String, from: int) -> Iterator; /// Return an iterator over the characters in the string. /// @@ -913,32 +928,6 @@ fn chars(string: String) -> Iterator; /// ``` fn chars(string: String, range: Range) -> Iterator; -/// Return an iterator over an inclusive range of characters in the string. -/// -/// # Example -/// -/// ```rhai -/// for ch in "hello, world!".chars(2..=6) { -/// print(ch); -/// } -/// ``` -fn chars(string: String, range: RangeInclusive) -> Iterator; - -/// Return an iterator over the characters in the string starting from the `start` position. -/// -/// * If `start` < 0, position counts from the end of the string (`-1` is the last character). -/// * If `start` < -length of string, position counts from the beginning of the string. -/// * If `start` ≥ length of string, an empty iterator is returned. -/// -/// # Example -/// -/// ```rhai -/// for ch in "hello, world!".chars(2) { -/// print(ch); -/// } -/// ``` -fn chars(string: String, from: int) -> Iterator; - /// Return an iterator over a portion of characters in the string. /// /// * If `start` < 0, position counts from the end of the string (`-1` is the last character). @@ -956,6 +945,37 @@ fn chars(string: String, from: int) -> Iterator; /// ``` fn chars(string: String, start: int, len: int) -> Iterator; +/// Return an iterator over an inclusive range of characters in the string. +/// +/// # Example +/// +/// ```rhai +/// for ch in "hello, world!".chars(2..=6) { +/// print(ch); +/// } +/// ``` +fn chars(string: String, range: RangeInclusive) -> Iterator; + +/// Cut off the head of the array, leaving a tail of the specified length. +/// +/// * If `len` ≤ 0, the array is cleared. +/// * If `len` ≥ length of array, the array is not modified. +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 3, 4, 5]; +/// +/// x.chop(3); +/// +/// print(x); // prints "[3, 4, 5]" +/// +/// x.chop(10); +/// +/// print(x); // prints "[3, 4, 5]" +/// ``` +fn chop(array: Array, len: int) -> (); + /// Cut off the head of the BLOB, leaving a tail of the specified length. /// /// * If `len` ≤ 0, the BLOB is cleared. @@ -978,32 +998,12 @@ fn chars(string: String, start: int, len: int) -> Iterator; /// ``` fn chop(blob: Blob, len: int) -> (); -/// Cut off the head of the array, leaving a tail of the specified length. -/// -/// * If `len` ≤ 0, the array is cleared. -/// * If `len` ≥ length of array, the array is not modified. -/// -/// # Example -/// -/// ```rhai -/// let x = [1, 2, 3, 4, 5]; -/// -/// x.chop(3); -/// -/// print(x); // prints "[3, 4, 5]" -/// -/// x.chop(10); -/// -/// print(x); // prints "[3, 4, 5]" -/// ``` -fn chop(array: Array, len: int) -> (); +/// Clear the string, making it empty. +fn clear(string: String) -> (); /// Clear the object map. fn clear(map: Map) -> (); -/// Clear the string, making it empty. -fn clear(string: String) -> (); - /// Clear the BLOB. fn clear(blob: Blob) -> (); @@ -1030,31 +1030,10 @@ fn clear(array: Array) -> (); fn contains(array: Array, value: ?) -> bool; /// Return the cosine of the floating-point number in radians. -fn cos(x: float) -> float; +fn cos(x: float) -> f64; /// Return the hyperbolic cosine of the floating-point number in radians. -fn cosh(x: float) -> float; - -/// Remove all characters from the string except until the `start` position. -/// -/// * If `start` < 0, position counts from the end of the string (`-1` is the last character). -/// * If `start` < -length of string, the string is not modified. -/// * If `start` ≥ length of string, the entire string is cleared. -/// -/// # Example -/// -/// ```rhai -/// let text = "hello, world!"; -/// -/// text.crop(5); -/// -/// print(text); // prints ", world!" -/// -/// text.crop(-3); -/// -/// print(text); // prints "ld!" -/// ``` -fn crop(string: String, start: int) -> (); +fn cosh(x: float) -> f64; /// Remove all characters from the string except those within a range. /// @@ -1079,6 +1058,27 @@ fn crop(string: String, start: int) -> (); /// ``` fn crop(string: String, start: int, len: int) -> (); +/// Remove all characters from the string except until the `start` position. +/// +/// * If `start` < 0, position counts from the end of the string (`-1` is the last character). +/// * If `start` < -length of string, the string is not modified. +/// * If `start` ≥ length of string, the entire string is cleared. +/// +/// # Example +/// +/// ```rhai +/// let text = "hello, world!"; +/// +/// text.crop(5); +/// +/// print(text); // prints ", world!" +/// +/// text.crop(-3); +/// +/// print(text); // prints "ld!" +/// ``` +fn crop(string: String, start: int) -> (); + /// Remove all characters from the string except those within an exclusive `range`. /// /// # Example @@ -1090,7 +1090,7 @@ fn crop(string: String, start: int, len: int) -> (); /// /// print(text); // prints "llo, w" /// ``` -fn crop(string: String, range: ExclusiveRange) -> (); +fn crop(string: String, range: Range) -> (); /// Remove all characters from the string except those within an inclusive `range`. /// @@ -1103,28 +1103,19 @@ fn crop(string: String, range: ExclusiveRange) -> (); /// /// print(text); // prints "llo, wo" /// ``` -fn crop(string: String, range: InclusiveRange) -> (); - -/// Convert the boolean value into a string in debug format. -fn debug(value: bool) -> String; +fn crop(string: String, range: RangeInclusive) -> (); /// Convert the array into a string. fn debug(array: Array) -> String; -/// Convert the string into debug format. -fn debug(character: char) -> String; +/// Return the empty string. +fn debug() -> String; /// Convert the unit into a string in debug format. fn debug(unit: ()) -> String; -/// Return the empty string. -fn debug() -> String; - -/// Convert the value of the `item` into a string in debug format. -fn debug(item: ?) -> String; - -/// Convert the function pointer into a string in debug format. -fn debug(f: FnPtr) -> String; +/// Convert the value of `number` into a string. +fn debug(number: f64) -> String; /// Convert the object map into a string. fn debug(map: Map) -> String; @@ -1132,11 +1123,61 @@ fn debug(map: Map) -> String; /// Convert the value of `number` into a string. fn debug(number: f32) -> String; +/// Convert the string into debug format. +fn debug(character: char) -> String; + +/// Convert the function pointer into a string in debug format. +fn debug(f: FnPtr) -> String; + /// Convert the string into debug format. fn debug(string: String) -> String; -/// Convert the value of `number` into a string. -fn debug(number: f64) -> String; +/// Convert the boolean value into a string in debug format. +fn debug(value: bool) -> String; + +/// Convert the value of the `item` into a string in debug format. +fn debug(item: ?) -> String; + +/// Remove duplicated _consecutive_ elements from the array that return `true` when applied the +/// `comparer` function. +/// +/// No element is removed if the correct `comparer` function does not exist. +/// +/// # Function Parameters +/// +/// * `element1`: copy of the current array element to compare +/// * `element2`: copy of the next array element to compare +/// +/// ## Return Value +/// +/// `true` if `element1 == element2`, otherwise `false`. +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 2, 2, 3, 1, 2, 3, 4, 3, 3, 2, 1]; +/// +/// x.dedup(|a, b| a >= b); +/// +/// print(x); // prints "[1, 2, 3, 4]" +/// ``` +fn dedup(array: Array, comparer: FnPtr) -> (); + +/// Remove duplicated _consecutive_ elements from the array. +/// +/// The operator `==` is used to compare elements and must be defined, +/// otherwise `false` is assumed. +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 2, 2, 3, 4, 3, 3, 2, 1]; +/// +/// x.dedup(); +/// +/// print(x); // prints "[1, 2, 3, 4, 3, 2, 1]" +/// ``` +fn dedup(array: Array) -> (); /// Remove duplicated _consecutive_ elements from the array that return `true` when applied a /// function named by `comparer`. @@ -1165,46 +1206,32 @@ fn debug(number: f64) -> String; /// ``` fn dedup(array: Array, comparer: String) -> (); -/// Remove duplicated _consecutive_ elements from the array. +/// Remove all elements within a portion of the array and return them as a new array. /// -/// The operator `==` is used to compare elements and must be defined, -/// otherwise `false` is assumed. +/// * If `start` < 0, position counts from the end of the array (`-1` is the last element). +/// * If `start` < -length of array, position counts from the beginning of the array. +/// * If `start` ≥ length of array, no element is removed and an empty array is returned. +/// * If `len` ≤ 0, no element is removed and an empty array is returned. +/// * If `start` position + `len` ≥ length of array, entire portion of the array after the `start` position is removed and returned. /// /// # Example /// /// ```rhai -/// let x = [1, 2, 2, 2, 3, 4, 3, 3, 2, 1]; +/// let x = [1, 2, 3, 4, 5]; /// -/// x.dedup(); +/// let y = x.drain(1, 2); /// -/// print(x); // prints "[1, 2, 3, 4, 3, 2, 1]" +/// print(x); // prints "[1, 4, 5]" +/// +/// print(y); // prints "[2, 3]" +/// +/// let z = x.drain(-1, 1); +/// +/// print(x); // prints "[1, 4]" +/// +/// print(z); // prints "[5]" /// ``` -fn dedup(array: Array) -> (); - -/// Remove duplicated _consecutive_ elements from the array that return `true` when applied the -/// `comparer` function. -/// -/// No element is removed if the correct `comparer` function does not exist. -/// -/// # Function Parameters -/// -/// * `element1`: copy of the current array element to compare -/// * `element2`: copy of the next array element to compare -/// -/// ## Return Value -/// -/// `true` if `element1 == element2`, otherwise `false`. -/// -/// # Example -/// -/// ```rhai -/// let x = [1, 2, 2, 2, 3, 1, 2, 3, 4, 3, 3, 2, 1]; -/// -/// x.dedup(|a, b| a >= b); -/// -/// print(x); // prints "[1, 2, 3, 4]" -/// ``` -fn dedup(array: Array, comparer: FnPtr) -> (); +fn drain(array: Array, start: int, len: int) -> Array; /// Remove all bytes in the BLOB within an exclusive `range` and return them as a new BLOB. /// @@ -1227,7 +1254,49 @@ fn dedup(array: Array, comparer: FnPtr) -> (); /// /// print(b3); // prints "[05]" /// ``` -fn drain(blob: Blob, range: ExclusiveRange) -> Blob; +fn drain(blob: Blob, range: Range) -> Blob; + +/// Remove all elements in the array within an exclusive `range` and return them as a new array. +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 3, 4, 5]; +/// +/// let y = x.drain(1..3); +/// +/// print(x); // prints "[1, 4, 5]" +/// +/// print(y); // prints "[2, 3]" +/// +/// let z = x.drain(2..3); +/// +/// print(x); // prints "[1, 4]" +/// +/// print(z); // prints "[5]" +/// ``` +fn drain(array: Array, range: Range) -> Array; + +/// Remove all elements in the array within an inclusive `range` and return them as a new array. +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 3, 4, 5]; +/// +/// let y = x.drain(1..=2); +/// +/// print(x); // prints "[1, 4, 5]" +/// +/// print(y); // prints "[2, 3]" +/// +/// let z = x.drain(2..=2); +/// +/// print(x); // prints "[1, 4]" +/// +/// print(z); // prints "[5]" +/// ``` +fn drain(array: Array, range: RangeInclusive) -> Array; /// Remove all bytes within a portion of the BLOB and return them as a new BLOB. /// @@ -1291,77 +1360,6 @@ fn drain(blob: Blob, start: int, len: int) -> Blob; /// ``` fn drain(array: Array, filter: String) -> Array; -/// Remove all elements in the array within an inclusive `range` and return them as a new array. -/// -/// # Example -/// -/// ```rhai -/// let x = [1, 2, 3, 4, 5]; -/// -/// let y = x.drain(1..=2); -/// -/// print(x); // prints "[1, 4, 5]" -/// -/// print(y); // prints "[2, 3]" -/// -/// let z = x.drain(2..=2); -/// -/// print(x); // prints "[1, 4]" -/// -/// print(z); // prints "[5]" -/// ``` -fn drain(array: Array, range: InclusiveRange) -> Array; - -/// Remove all bytes in the BLOB within an inclusive `range` and return them as a new BLOB. -/// -/// # Example -/// -/// ```rhai -/// let b1 = blob(); -/// -/// b1 += 1; b1 += 2; b1 += 3; b1 += 4; b1 += 5; -/// -/// let b2 = b1.drain(1..=2); -/// -/// print(b1); // prints "[010405]" -/// -/// print(b2); // prints "[0203]" -/// -/// let b3 = b1.drain(2..=2); -/// -/// print(b1); // prints "[0104]" -/// -/// print(b3); // prints "[05]" -/// ``` -fn drain(blob: Blob, range: InclusiveRange) -> Blob; - -/// Remove all elements within a portion of the array and return them as a new array. -/// -/// * If `start` < 0, position counts from the end of the array (`-1` is the last element). -/// * If `start` < -length of array, position counts from the beginning of the array. -/// * If `start` ≥ length of array, no element is removed and an empty array is returned. -/// * If `len` ≤ 0, no element is removed and an empty array is returned. -/// * If `start` position + `len` ≥ length of array, entire portion of the array after the `start` position is removed and returned. -/// -/// # Example -/// -/// ```rhai -/// let x = [1, 2, 3, 4, 5]; -/// -/// let y = x.drain(1, 2); -/// -/// print(x); // prints "[1, 4, 5]" -/// -/// print(y); // prints "[2, 3]" -/// -/// let z = x.drain(-1, 1); -/// -/// print(x); // prints "[1, 4]" -/// -/// print(z); // prints "[5]" -/// ``` -fn drain(array: Array, start: int, len: int) -> Array; - /// Remove all elements in the array that returns `true` when applied the `filter` function and /// return them as a new array. /// @@ -1389,26 +1387,28 @@ fn drain(array: Array, start: int, len: int) -> Array; /// ``` fn drain(array: Array, filter: FnPtr) -> Array; -/// Remove all elements in the array within an exclusive `range` and return them as a new array. +/// Remove all bytes in the BLOB within an inclusive `range` and return them as a new BLOB. /// /// # Example /// /// ```rhai -/// let x = [1, 2, 3, 4, 5]; +/// let b1 = blob(); /// -/// let y = x.drain(1..3); +/// b1 += 1; b1 += 2; b1 += 3; b1 += 4; b1 += 5; /// -/// print(x); // prints "[1, 4, 5]" +/// let b2 = b1.drain(1..=2); /// -/// print(y); // prints "[2, 3]" +/// print(b1); // prints "[010405]" /// -/// let z = x.drain(2..3); +/// print(b2); // prints "[0203]" /// -/// print(x); // prints "[1, 4]" +/// let b3 = b1.drain(2..=2); /// -/// print(z); // prints "[5]" +/// print(b1); // prints "[0104]" +/// +/// print(b3); // prints "[05]" /// ``` -fn drain(array: Array, range: ExclusiveRange) -> Array; +fn drain(blob: Blob, range: RangeInclusive) -> Blob; /// Return the number of seconds between the current system time and the timestamp. /// @@ -1423,11 +1423,11 @@ fn drain(array: Array, range: ExclusiveRange) -> Array; /// ``` fn elapsed(timestamp: Instant) -> RhaiResult; -/// Return the end of the exclusive range. -fn end(range: ExclusiveRange) -> int; - /// Return the end of the inclusive range. -fn end(range: InclusiveRange) -> int; +fn end(range: InclusiveRange) -> i64; + +/// Return the end of the exclusive range. +fn end(range: ExclusiveRange) -> i64; /// Return `true` if the string ends with a specified string. /// @@ -1443,126 +1443,7 @@ fn end(range: InclusiveRange) -> int; fn ends_with(string: String, match_string: String) -> bool; /// Return the exponential of the floating-point number. -fn exp(x: float) -> float; - -/// Copy an inclusive `range` of the BLOB and return it as a new BLOB. -/// -/// # Example -/// -/// ```rhai -/// let b = blob(); -/// -/// b += 1; b += 2; b += 3; b += 4; b += 5; -/// -/// print(b.extract(1..=3)); // prints "[020304]" -/// -/// print(b); // prints "[0102030405]" -/// ``` -fn extract(blob: Blob, range: InclusiveRange) -> Blob; - -/// Copy an inclusive range of the array and return it as a new array. -/// -/// # Example -/// -/// ```rhai -/// let x = [1, 2, 3, 4, 5]; -/// -/// print(x.extract(1..=3)); // prints "[2, 3, 4]" -/// -/// print(x); // prints "[1, 2, 3, 4, 5]" -/// ``` -fn extract(array: Array, range: InclusiveRange) -> Array; - -/// Copy a portion of the array and return it as a new array. -/// -/// * If `start` < 0, position counts from the end of the array (`-1` is the last element). -/// * If `start` < -length of array, position counts from the beginning of the array. -/// * If `start` ≥ length of array, an empty array is returned. -/// * If `len` ≤ 0, an empty array is returned. -/// * If `start` position + `len` ≥ length of array, entire portion of the array after the `start` position is copied and returned. -/// -/// # Example -/// -/// ```rhai -/// let x = [1, 2, 3, 4, 5]; -/// -/// print(x.extract(1, 3)); // prints "[2, 3, 4]" -/// -/// print(x.extract(-3, 2)); // prints "[3, 4]" -/// -/// print(x); // prints "[1, 2, 3, 4, 5]" -/// ``` -fn extract(array: Array, start: int, len: int) -> Array; - -/// Copy a portion of the array beginning at the `start` position till the end and return it as -/// a new array. -/// -/// * If `start` < 0, position counts from the end of the array (`-1` is the last element). -/// * If `start` < -length of array, the entire array is copied and returned. -/// * If `start` ≥ length of array, an empty array is returned. -/// -/// # Example -/// -/// ```rhai -/// let x = [1, 2, 3, 4, 5]; -/// -/// print(x.extract(2)); // prints "[3, 4, 5]" -/// -/// print(x.extract(-3)); // prints "[3, 4, 5]" -/// -/// print(x); // prints "[1, 2, 3, 4, 5]" -/// ``` -fn extract(array: Array, start: int) -> Array; - -/// Copy a portion of the BLOB beginning at the `start` position till the end and return it as -/// a new BLOB. -/// -/// * If `start` < 0, position counts from the end of the BLOB (`-1` is the last byte). -/// * If `start` < -length of BLOB, the entire BLOB is copied and returned. -/// * If `start` ≥ length of BLOB, an empty BLOB is returned. -/// -/// # Example -/// -/// ```rhai -/// let b = blob(); -/// -/// b += 1; b += 2; b += 3; b += 4; b += 5; -/// -/// print(b.extract(2)); // prints "[030405]" -/// -/// print(b.extract(-3)); // prints "[030405]" -/// -/// print(b); // prints "[0102030405]" -/// ``` -fn extract(blob: Blob, start: int) -> Blob; - -/// Copy an exclusive `range` of the BLOB and return it as a new BLOB. -/// -/// # Example -/// -/// ```rhai -/// let b = blob(); -/// -/// b += 1; b += 2; b += 3; b += 4; b += 5; -/// -/// print(b.extract(1..3)); // prints "[0203]" -/// -/// print(b); // prints "[0102030405]" -/// ``` -fn extract(blob: Blob, range: ExclusiveRange) -> Blob; - -/// Copy an exclusive range of the array and return it as a new array. -/// -/// # Example -/// -/// ```rhai -/// let x = [1, 2, 3, 4, 5]; -/// -/// print(x.extract(1..3)); // prints "[2, 3]" -/// -/// print(x); // prints "[1, 2, 3, 4, 5]" -/// ``` -fn extract(array: Array, range: ExclusiveRange) -> Array; +fn exp(x: float) -> f64; /// Copy a portion of the BLOB and return it as a new BLOB. /// @@ -1587,6 +1468,125 @@ fn extract(array: Array, range: ExclusiveRange) -> Array; /// ``` fn extract(blob: Blob, start: int, len: int) -> Blob; +/// Copy a portion of the BLOB beginning at the `start` position till the end and return it as +/// a new BLOB. +/// +/// * If `start` < 0, position counts from the end of the BLOB (`-1` is the last byte). +/// * If `start` < -length of BLOB, the entire BLOB is copied and returned. +/// * If `start` ≥ length of BLOB, an empty BLOB is returned. +/// +/// # Example +/// +/// ```rhai +/// let b = blob(); +/// +/// b += 1; b += 2; b += 3; b += 4; b += 5; +/// +/// print(b.extract(2)); // prints "[030405]" +/// +/// print(b.extract(-3)); // prints "[030405]" +/// +/// print(b); // prints "[0102030405]" +/// ``` +fn extract(blob: Blob, start: int) -> Blob; + +/// Copy an inclusive `range` of the BLOB and return it as a new BLOB. +/// +/// # Example +/// +/// ```rhai +/// let b = blob(); +/// +/// b += 1; b += 2; b += 3; b += 4; b += 5; +/// +/// print(b.extract(1..=3)); // prints "[020304]" +/// +/// print(b); // prints "[0102030405]" +/// ``` +fn extract(blob: Blob, range: RangeInclusive) -> Blob; + +/// Copy a portion of the array and return it as a new array. +/// +/// * If `start` < 0, position counts from the end of the array (`-1` is the last element). +/// * If `start` < -length of array, position counts from the beginning of the array. +/// * If `start` ≥ length of array, an empty array is returned. +/// * If `len` ≤ 0, an empty array is returned. +/// * If `start` position + `len` ≥ length of array, entire portion of the array after the `start` position is copied and returned. +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 3, 4, 5]; +/// +/// print(x.extract(1, 3)); // prints "[2, 3, 4]" +/// +/// print(x.extract(-3, 2)); // prints "[3, 4]" +/// +/// print(x); // prints "[1, 2, 3, 4, 5]" +/// ``` +fn extract(array: Array, start: int, len: int) -> Array; + +/// Copy an exclusive `range` of the BLOB and return it as a new BLOB. +/// +/// # Example +/// +/// ```rhai +/// let b = blob(); +/// +/// b += 1; b += 2; b += 3; b += 4; b += 5; +/// +/// print(b.extract(1..3)); // prints "[0203]" +/// +/// print(b); // prints "[0102030405]" +/// ``` +fn extract(blob: Blob, range: Range) -> Blob; + +/// Copy an exclusive range of the array and return it as a new array. +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 3, 4, 5]; +/// +/// print(x.extract(1..3)); // prints "[2, 3]" +/// +/// print(x); // prints "[1, 2, 3, 4, 5]" +/// ``` +fn extract(array: Array, range: Range) -> Array; + +/// Copy an inclusive range of the array and return it as a new array. +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 3, 4, 5]; +/// +/// print(x.extract(1..=3)); // prints "[2, 3, 4]" +/// +/// print(x); // prints "[1, 2, 3, 4, 5]" +/// ``` +fn extract(array: Array, range: RangeInclusive) -> Array; + +/// Copy a portion of the array beginning at the `start` position till the end and return it as +/// a new array. +/// +/// * If `start` < 0, position counts from the end of the array (`-1` is the last element). +/// * If `start` < -length of array, the entire array is copied and returned. +/// * If `start` ≥ length of array, an empty array is returned. +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 3, 4, 5]; +/// +/// print(x.extract(2)); // prints "[3, 4, 5]" +/// +/// print(x.extract(-3)); // prints "[3, 4, 5]" +/// +/// print(x); // prints "[1, 2, 3, 4, 5]" +/// ``` +fn extract(array: Array, start: int) -> Array; + /// Add all property values of another object map into the object map. /// Only properties that do not originally exist in the object map are added. /// @@ -1602,29 +1602,6 @@ fn extract(blob: Blob, start: int, len: int) -> Blob; /// ``` fn fill_with(map: Map, map2: Map) -> (); -/// Iterate through all the elements in the array, applying a `filter` function to each element -/// in turn, and return a copy of all elements (in order) that return `true` as a new array. -/// -/// # Function Parameters -/// -/// * `element`: copy of array element -/// * `index` _(optional)_: current index in the array -/// -/// # Example -/// -/// ```rhai -/// let x = [1, 2, 3, 4, 5]; -/// -/// let y = x.filter(|v| v >= 3); -/// -/// print(y); // prints "[3, 4, 5]" -/// -/// let y = x.filter(|v, i| v * i >= 10); -/// -/// print(y); // prints "[12, 20]" -/// ``` -fn filter(array: Array, filter: FnPtr) -> Array; - /// Iterate through all the elements in the array, applying a function named by `filter` to each /// element in turn, and return a copy of all elements (in order) that return `true` as a new array. /// @@ -1652,30 +1629,34 @@ fn filter(array: Array, filter: FnPtr) -> Array; /// ``` fn filter(array: Array, filter_func: String) -> Array; -/// Return the largest whole number less than or equals to the floating-point number. -fn floor(x: float) -> float; - -/// Return the fractional part of the floating-point number. -fn fraction(x: float) -> float; - -/// Get the character at the `index` position in the string. +/// Iterate through all the elements in the array, applying a `filter` function to each element +/// in turn, and return a copy of all elements (in order) that return `true` as a new array. /// -/// * If `index` < 0, position counts from the end of the string (`-1` is the last character). -/// * If `index` < -length of string, zero is returned. -/// * If `index` ≥ length of string, zero is returned. +/// # Function Parameters +/// +/// * `element`: copy of array element +/// * `index` _(optional)_: current index in the array /// /// # Example /// /// ```rhai -/// let text = "hello, world!"; +/// let x = [1, 2, 3, 4, 5]; /// -/// print(text.get(0)); // prints 'h' +/// let y = x.filter(|v| v >= 3); /// -/// print(text.get(-1)); // prints '!' +/// print(y); // prints "[3, 4, 5]" /// -/// print(text.get(99)); // prints empty (for '()')' +/// let y = x.filter(|v, i| v * i >= 10); +/// +/// print(y); // prints "[12, 20]" /// ``` -fn get(string: String, index: int) -> ?; +fn filter(array: Array, filter: FnPtr) -> Array; + +/// Return the largest whole number less than or equals to the floating-point number. +fn floor(x: float) -> f64; + +/// Return the fractional part of the floating-point number. +fn fraction(x: float) -> f64; /// Get the byte value at the `index` position in the BLOB. /// @@ -1696,7 +1677,26 @@ fn get(string: String, index: int) -> ?; /// /// print(b.get(99)); // prints 0 /// ``` -fn get(blob: Blob, index: int) -> int; +fn get(blob: Blob, index: int) -> i64; + +/// Get the character at the `index` position in the string. +/// +/// * If `index` < 0, position counts from the end of the string (`-1` is the last character). +/// * If `index` < -length of string, zero is returned. +/// * If `index` ≥ length of string, zero is returned. +/// +/// # Example +/// +/// ```rhai +/// let text = "hello, world!"; +/// +/// print(text.get(0)); // prints 'h' +/// +/// print(text.get(-1)); // prints '!' +/// +/// print(text.get(99)); // prints empty (for '()')' +/// ``` +fn get(string: String, index: int) -> ?; /// Get the value of the `property` in the object map and return a copy. /// @@ -1754,10 +1754,10 @@ fn get bits(value: int) -> Iterator; /// /// print(text.bytes); // prints 51 /// ``` -fn get bytes(string: String) -> int; +fn get bytes(string: String) -> i64; /// Return the smallest whole number larger than or equals to the floating-point number. -fn get ceiling(x: float) -> float; +fn get ceiling(x: float) -> f64; /// Return an iterator over all the characters in the string. /// @@ -1784,19 +1784,19 @@ fn get chars(string: String) -> Iterator; fn get elapsed(timestamp: Instant) -> RhaiResult; /// Return the end of the inclusive range. -fn get end(range: InclusiveRange) -> int; +fn get end(range: InclusiveRange) -> i64; /// Return the end of the exclusive range. -fn get end(range: ExclusiveRange) -> int; +fn get end(range: ExclusiveRange) -> i64; /// Return the largest whole number less than or equals to the floating-point number. -fn get floor(x: float) -> float; +fn get floor(x: float) -> f64; /// Return the fractional part of the floating-point number. -fn get fraction(x: float) -> float; +fn get fraction(x: float) -> f64; /// Return the integral part of the floating-point number. -fn get int(x: float) -> float; +fn get int(x: float) -> f64; /// Return `true` if the function is an anonymous function. /// @@ -1809,36 +1809,36 @@ fn get int(x: float) -> float; /// ``` fn get is_anonymous(fn_ptr: FnPtr) -> bool; -/// Return true if the number is even. -fn get is_even(x: i128) -> bool; - -/// Return true if the number is even. -fn get is_even(x: u32) -> bool; - -/// Return true if the number is even. -fn get is_even(x: i8) -> bool; - /// Return true if the number is even. fn get is_even(x: u16) -> bool; +/// Return true if the number is even. +fn get is_even(x: u128) -> bool; + /// Return true if the number is even. fn get is_even(x: i16) -> bool; /// Return true if the number is even. fn get is_even(x: int) -> bool; -/// Return true if the number is even. -fn get is_even(x: u8) -> bool; - -/// Return true if the number is even. -fn get is_even(x: u128) -> bool; - /// Return true if the number is even. fn get is_even(x: i32) -> bool; /// Return true if the number is even. fn get is_even(x: u64) -> bool; +/// Return true if the number is even. +fn get is_even(x: u8) -> bool; + +/// Return true if the number is even. +fn get is_even(x: i8) -> bool; + +/// Return true if the number is even. +fn get is_even(x: u32) -> bool; + +/// Return true if the number is even. +fn get is_even(x: i128) -> bool; + /// Return `true` if the range is exclusive. fn get is_exclusive(range: ExclusiveRange) -> bool; @@ -1849,10 +1849,10 @@ fn get is_exclusive(range: InclusiveRange) -> bool; fn get is_finite(x: float) -> bool; /// Return `true` if the range is inclusive. -fn get is_inclusive(range: ExclusiveRange) -> bool; +fn get is_inclusive(range: InclusiveRange) -> bool; /// Return `true` if the range is inclusive. -fn get is_inclusive(range: InclusiveRange) -> bool; +fn get is_inclusive(range: ExclusiveRange) -> bool; /// Return `true` if the floating-point number is infinite. fn get is_infinite(x: float) -> bool; @@ -1860,26 +1860,14 @@ fn get is_infinite(x: float) -> bool; /// Return `true` if the floating-point number is `NaN` (Not A Number). fn get is_nan(x: float) -> bool; -/// Return true if the number is odd. -fn get is_odd(x: u32) -> bool; - -/// Return true if the number is odd. -fn get is_odd(x: i128) -> bool; - -/// Return true if the number is odd. -fn get is_odd(x: i16) -> bool; - /// Return true if the number is odd. fn get is_odd(x: u16) -> bool; -/// Return true if the number is odd. -fn get is_odd(x: i8) -> bool; - /// Return true if the number is odd. fn get is_odd(x: u128) -> bool; /// Return true if the number is odd. -fn get is_odd(x: u8) -> bool; +fn get is_odd(x: i16) -> bool; /// Return true if the number is odd. fn get is_odd(x: int) -> bool; @@ -1890,14 +1878,32 @@ fn get is_odd(x: u64) -> bool; /// Return true if the number is odd. fn get is_odd(x: i32) -> bool; +/// Return true if the number is odd. +fn get is_odd(x: u8) -> bool; + +/// Return true if the number is odd. +fn get is_odd(x: i8) -> bool; + +/// Return true if the number is odd. +fn get is_odd(x: u32) -> bool; + +/// Return true if the number is odd. +fn get is_odd(x: i128) -> bool; + +/// Return true if the floating-point number is zero. +fn get is_zero(x: f32) -> bool; + /// Return true if the number is zero. -fn get is_zero(x: i8) -> bool; +fn get is_zero(x: i16) -> bool; + +/// Return true if the floating-point number is zero. +fn get is_zero(x: f64) -> bool; /// Return true if the number is zero. fn get is_zero(x: u16) -> bool; /// Return true if the number is zero. -fn get is_zero(x: i16) -> bool; +fn get is_zero(x: u128) -> bool; /// Return true if the number is zero. fn get is_zero(x: i128) -> bool; @@ -1906,36 +1912,19 @@ fn get is_zero(x: i128) -> bool; fn get is_zero(x: u32) -> bool; /// Return true if the number is zero. -fn get is_zero(x: i32) -> bool; - -/// Return true if the floating-point number is zero. -fn get is_zero(x: f32) -> bool; - -/// Return true if the number is zero. -fn get is_zero(x: u64) -> bool; - -/// Return true if the number is zero. -fn get is_zero(x: int) -> bool; - -/// Return true if the floating-point number is zero. -fn get is_zero(x: f64) -> bool; +fn get is_zero(x: i8) -> bool; /// Return true if the number is zero. fn get is_zero(x: u8) -> bool; /// Return true if the number is zero. -fn get is_zero(x: u128) -> bool; +fn get is_zero(x: u64) -> bool; -/// Return the length of the string, in number of characters. -/// -/// # Example -/// -/// ```rhai -/// let text = "朝には紅顔ありて夕べには白骨となる"; -/// -/// print(text.len); // prints 17 -/// ``` -fn get len(string: String) -> int; +/// Return true if the number is zero. +fn get is_zero(x: i32) -> bool; + +/// Return true if the number is zero. +fn get is_zero(x: int) -> bool; /// Return the length of the BLOB. /// @@ -1948,10 +1937,21 @@ fn get len(string: String) -> int; /// /// print(b.len()); // prints 10 /// ``` -fn get len(blob: Blob) -> int; +fn get len(blob: Blob) -> i64; + +/// Return the length of the string, in number of characters. +/// +/// # Example +/// +/// ```rhai +/// let text = "朝には紅顔ありて夕べには白骨となる"; +/// +/// print(text.len); // prints 17 +/// ``` +fn get len(string: String) -> i64; /// Number of elements in the array. -fn get len(array: Array) -> int; +fn get len(array: Array) -> i64; /// Return the name of the function. /// @@ -1968,13 +1968,13 @@ fn get name(fn_ptr: FnPtr) -> String; /// Return the nearest whole number closest to the floating-point number. /// Rounds away from zero. -fn get round(x: float) -> float; - -/// Return the start of the inclusive range. -fn get start(range: InclusiveRange) -> int; +fn get round(x: float) -> f64; /// Return the start of the exclusive range. -fn get start(range: ExclusiveRange) -> int; +fn get start(range: ExclusiveRange) -> i64; + +/// Return the start of the inclusive range. +fn get start(range: InclusiveRange) -> i64; /// Return the _tag_ of a `Dynamic` value. /// @@ -1987,7 +1987,7 @@ fn get start(range: ExclusiveRange) -> int; /// /// print(x.tag); // prints 42 /// ``` -fn get tag(value: ?) -> int; +fn get tag(value: ?) -> i64; /// Return `true` if the specified `bit` in the number is set. /// @@ -2006,6 +2006,17 @@ fn get tag(value: ?) -> int; /// ``` fn get_bit(value: int, bit: int) -> bool; +/// Return an exclusive range of bits in the number as a new number. +/// +/// # Example +/// +/// ```rhai +/// let x = 123456; +/// +/// print(x.get_bits(5..10)); // print 18 +/// ``` +fn get_bits(value: int, range: Range) -> int; + /// Return a portion of bits in the number as a new number. /// /// * If `start` < 0, position counts from the MSB (Most Significant Bit). @@ -2030,82 +2041,37 @@ fn get_bits(value: int, start: int, bits: int) -> int; /// /// print(x.get_bits(5..=9)); // print 18 /// ``` -fn get_bits(value: int, range: InclusiveRange) -> int; - -/// Return an exclusive range of bits in the number as a new number. -/// -/// # Example -/// -/// ```rhai -/// let x = 123456; -/// -/// print(x.get_bits(5..10)); // print 18 -/// ``` -fn get_bits(value: int, range: ExclusiveRange) -> int; +fn get_bits(value: int, range: RangeInclusive) -> int; fn get_fn_metadata_list(name: String) -> Array; -fn get_fn_metadata_list(name: String, params: int) -> Array; - fn get_fn_metadata_list() -> Array; +fn get_fn_metadata_list(name: String, params: int) -> Array; + /// Return the hypotenuse of a triangle with sides `x` and `y`. -fn hypot(x: float, y: float) -> float; +fn hypot(x: float, y: float) -> f64; -/// Find the first element in the array that equals a particular `value` and return its index. -/// If no element equals `value`, `-1` is returned. +/// Find the specified sub-string in the string, starting from the specified `start` position, +/// and return the first index where it is found. +/// If the sub-string is not found, `-1` is returned. /// -/// The operator `==` is used to compare elements with `value` and must be defined, -/// otherwise `false` is assumed. +/// * If `start` < 0, position counts from the end of the string (`-1` is the last character). +/// * If `start` < -length of string, position counts from the beginning of the string. +/// * If `start` ≥ length of string, `-1` is returned. /// /// # Example /// /// ```rhai -/// let x = [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 5]; +/// let text = "hello, world! hello, foobar!"; /// -/// print(x.index_of(4)); // prints 3 (first index) +/// print(text.index_of("ll", 5)); // prints 16 (first index after 5) /// -/// print(x.index_of(9)); // prints -1 +/// print(text.index_of("ll", -15)); // prints 16 /// -/// print(x.index_of("foo")); // prints -1: strings do not equal numbers +/// print(text.index_of("xx", 0)); // prints -1 /// ``` -fn index_of(array: Array, value: ?) -> int; - -/// Iterate through all the elements in the array, applying a `filter` function to each element -/// in turn, and return the index of the first element that returns `true`. -/// If no element returns `true`, `-1` is returned. -/// -/// # Function Parameters -/// -/// * `element`: copy of array element -/// * `index` _(optional)_: current index in the array -/// -/// # Example -/// -/// ```rhai -/// let x = [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 5]; -/// -/// print(x.index_of(|v| v > 3)); // prints 3: 4 > 3 -/// -/// print(x.index_of(|v| v > 8)); // prints -1: nothing is > 8 -/// -/// print(x.index_of(|v, i| v * i > 20)); // prints 7: 4 * 7 > 20 -/// ``` -fn index_of(array: Array, filter: FnPtr) -> int; - -/// Find the specified `character` in the string and return the first index where it is found. -/// If the `character` is not found, `-1` is returned. -/// -/// # Example -/// -/// ```rhai -/// let text = "hello, world!"; -/// -/// print(text.index_of('l')); // prints 2 (first index) -/// -/// print(text.index_of('x')); // prints -1 -/// ``` -fn index_of(string: String, character: char) -> int; +fn index_of(string: String, find_string: String, start: int) -> i64; /// Iterate through all the elements in the array, applying a function named by `filter` to each /// element in turn, and return the index of the first element that returns `true`. @@ -2133,27 +2099,6 @@ fn index_of(string: String, character: char) -> int; /// ``` fn index_of(array: Array, filter: String) -> int; -/// Find the specified `character` in the string, starting from the specified `start` position, -/// and return the first index where it is found. -/// If the `character` is not found, `-1` is returned. -/// -/// * If `start` < 0, position counts from the end of the string (`-1` is the last character). -/// * If `start` < -length of string, position counts from the beginning of the string. -/// * If `start` ≥ length of string, `-1` is returned. -/// -/// # Example -/// -/// ```rhai -/// let text = "hello, world!"; -/// -/// print(text.index_of('l', 5)); // prints 10 (first index after 5) -/// -/// print(text.index_of('o', -7)); // prints 8 -/// -/// print(text.index_of('x', 0)); // prints -1 -/// ``` -fn index_of(string: String, character: char, start: int) -> int; - /// Find the specified `character` in the string and return the first index where it is found. /// If the `character` is not found, `-1` is returned. /// @@ -2166,7 +2111,29 @@ fn index_of(string: String, character: char, start: int) -> int; /// /// print(text.index_of("xx:)); // prints -1 /// ``` -fn index_of(string: String, find_string: String) -> int; +fn index_of(string: String, find_string: String) -> i64; + +/// Iterate through all the elements in the array, applying a `filter` function to each element +/// in turn, and return the index of the first element that returns `true`. +/// If no element returns `true`, `-1` is returned. +/// +/// # Function Parameters +/// +/// * `element`: copy of array element +/// * `index` _(optional)_: current index in the array +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 5]; +/// +/// print(x.index_of(|v| v > 3)); // prints 3: 4 > 3 +/// +/// print(x.index_of(|v| v > 8)); // prints -1: nothing is > 8 +/// +/// print(x.index_of(|v, i| v * i > 20)); // prints 7: 4 * 7 > 20 +/// ``` +fn index_of(array: Array, filter: FnPtr) -> int; /// Iterate through all the elements in the array, starting from a particular `start` position, /// applying a `filter` function to each element in turn, and return the index of the first @@ -2200,56 +2167,6 @@ fn index_of(string: String, find_string: String) -> int; /// ``` fn index_of(array: Array, filter: FnPtr, start: int) -> int; -/// Find the specified sub-string in the string, starting from the specified `start` position, -/// and return the first index where it is found. -/// If the sub-string is not found, `-1` is returned. -/// -/// * If `start` < 0, position counts from the end of the string (`-1` is the last character). -/// * If `start` < -length of string, position counts from the beginning of the string. -/// * If `start` ≥ length of string, `-1` is returned. -/// -/// # Example -/// -/// ```rhai -/// let text = "hello, world! hello, foobar!"; -/// -/// print(text.index_of("ll", 5)); // prints 16 (first index after 5) -/// -/// print(text.index_of("ll", -15)); // prints 16 -/// -/// print(text.index_of("xx", 0)); // prints -1 -/// ``` -fn index_of(string: String, find_string: String, start: int) -> int; - -/// Find the first element in the array, starting from a particular `start` position, that -/// equals a particular `value` and return its index. If no element equals `value`, `-1` is returned. -/// -/// * If `start` < 0, position counts from the end of the array (`-1` is the last element). -/// * If `start` < -length of array, position counts from the beginning of the array. -/// * If `start` ≥ length of array, `-1` is returned. -/// -/// The operator `==` is used to compare elements with `value` and must be defined, -/// otherwise `false` is assumed. -/// -/// # Example -/// -/// ```rhai -/// let x = [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 5]; -/// -/// print(x.index_of(4, 2)); // prints 3 -/// -/// print(x.index_of(4, 5)); // prints 7 -/// -/// print(x.index_of(4, 15)); // prints -1: nothing found past end of array -/// -/// print(x.index_of(4, -5)); // prints 11: -5 = start from index 8 -/// -/// print(x.index_of(9, 1)); // prints -1: nothing equals 9 -/// -/// print(x.index_of("foo", 1)); // prints -1: strings do not equal numbers -/// ``` -fn index_of(array: Array, value: ?, start: int) -> int; - /// Iterate through all the elements in the array, starting from a particular `start` position, /// applying a function named by `filter` to each element in turn, and return the index of the /// first element that returns `true`. If no element returns `true`, `-1` is returned. @@ -2290,6 +2207,89 @@ fn index_of(array: Array, value: ?, start: int) -> int; /// ``` fn index_of(array: Array, filter: String, start: int) -> int; +/// Find the first element in the array that equals a particular `value` and return its index. +/// If no element equals `value`, `-1` is returned. +/// +/// The operator `==` is used to compare elements with `value` and must be defined, +/// otherwise `false` is assumed. +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 5]; +/// +/// print(x.index_of(4)); // prints 3 (first index) +/// +/// print(x.index_of(9)); // prints -1 +/// +/// print(x.index_of("foo")); // prints -1: strings do not equal numbers +/// ``` +fn index_of(array: Array, value: ?) -> int; + +/// Find the specified `character` in the string, starting from the specified `start` position, +/// and return the first index where it is found. +/// If the `character` is not found, `-1` is returned. +/// +/// * If `start` < 0, position counts from the end of the string (`-1` is the last character). +/// * If `start` < -length of string, position counts from the beginning of the string. +/// * If `start` ≥ length of string, `-1` is returned. +/// +/// # Example +/// +/// ```rhai +/// let text = "hello, world!"; +/// +/// print(text.index_of('l', 5)); // prints 10 (first index after 5) +/// +/// print(text.index_of('o', -7)); // prints 8 +/// +/// print(text.index_of('x', 0)); // prints -1 +/// ``` +fn index_of(string: String, character: char, start: int) -> i64; + +/// Find the first element in the array, starting from a particular `start` position, that +/// equals a particular `value` and return its index. If no element equals `value`, `-1` is returned. +/// +/// * If `start` < 0, position counts from the end of the array (`-1` is the last element). +/// * If `start` < -length of array, position counts from the beginning of the array. +/// * If `start` ≥ length of array, `-1` is returned. +/// +/// The operator `==` is used to compare elements with `value` and must be defined, +/// otherwise `false` is assumed. +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 5]; +/// +/// print(x.index_of(4, 2)); // prints 3 +/// +/// print(x.index_of(4, 5)); // prints 7 +/// +/// print(x.index_of(4, 15)); // prints -1: nothing found past end of array +/// +/// print(x.index_of(4, -5)); // prints 11: -5 = start from index 8 +/// +/// print(x.index_of(9, 1)); // prints -1: nothing equals 9 +/// +/// print(x.index_of("foo", 1)); // prints -1: strings do not equal numbers +/// ``` +fn index_of(array: Array, value: ?, start: int) -> int; + +/// Find the specified `character` in the string and return the first index where it is found. +/// If the `character` is not found, `-1` is returned. +/// +/// # Example +/// +/// ```rhai +/// let text = "hello, world!"; +/// +/// print(text.index_of('l')); // prints 2 (first index) +/// +/// print(text.index_of('x')); // prints -1 +/// ``` +fn index_of(string: String, character: char) -> i64; + /// Add a new element into the array at a particular `index` position. /// /// * If `index` < 0, position counts from the end of the array (`-1` is the last element). @@ -2331,7 +2331,7 @@ fn insert(array: Array, index: int, item: ?) -> (); fn insert(blob: Blob, index: int, value: int) -> (); /// Return the integral part of the floating-point number. -fn int(x: float) -> float; +fn int(x: float) -> f64; /// Return `true` if the function is an anonymous function. /// @@ -2345,28 +2345,19 @@ fn int(x: float) -> float; fn is_anonymous(fn_ptr: FnPtr) -> bool; /// Return true if the number is even. -fn is_even(x: i128) -> bool; - -/// Return true if the number is even. -fn is_even(x: u32) -> bool; +fn is_even(x: i16) -> bool; /// Return true if the number is even. fn is_even(x: u16) -> bool; -/// Return true if the number is even. -fn is_even(x: i8) -> bool; - -/// Return true if the number is even. -fn is_even(x: i16) -> bool; - -/// Return true if the number is even. -fn is_even(x: int) -> bool; - /// Return true if the number is even. fn is_even(x: u128) -> bool; /// Return true if the number is even. -fn is_even(x: u8) -> bool; +fn is_even(x: i128) -> bool; + +/// Return true if the number is even. +fn is_even(x: int) -> bool; /// Return true if the number is even. fn is_even(x: u64) -> bool; @@ -2374,12 +2365,21 @@ fn is_even(x: u64) -> bool; /// Return true if the number is even. fn is_even(x: i32) -> bool; -/// Return `true` if the range is exclusive. -fn is_exclusive(range: InclusiveRange) -> bool; +/// Return true if the number is even. +fn is_even(x: u8) -> bool; + +/// Return true if the number is even. +fn is_even(x: i8) -> bool; + +/// Return true if the number is even. +fn is_even(x: u32) -> bool; /// Return `true` if the range is exclusive. fn is_exclusive(range: ExclusiveRange) -> bool; +/// Return `true` if the range is exclusive. +fn is_exclusive(range: InclusiveRange) -> bool; + /// Return `true` if the floating-point number is finite. fn is_finite(x: float) -> bool; @@ -2398,9 +2398,6 @@ fn is_nan(x: float) -> bool; /// Return true if the number is odd. fn is_odd(x: u8) -> bool; -/// Return true if the number is odd. -fn is_odd(x: u128) -> bool; - /// Return true if the number is odd. fn is_odd(x: int) -> bool; @@ -2413,32 +2410,26 @@ fn is_odd(x: u64) -> bool; /// Return true if the number is odd. fn is_odd(x: u32) -> bool; +/// Return true if the number is odd. +fn is_odd(x: i8) -> bool; + /// Return true if the number is odd. fn is_odd(x: i128) -> bool; /// Return true if the number is odd. -fn is_odd(x: i16) -> bool; - -/// Return true if the number is odd. -fn is_odd(x: i8) -> bool; +fn is_odd(x: u128) -> bool; /// Return true if the number is odd. fn is_odd(x: u16) -> bool; -/// Return true if the number is zero. -fn is_zero(x: u8) -> bool; +/// Return true if the number is odd. +fn is_odd(x: i16) -> bool; /// Return true if the number is zero. -fn is_zero(x: u128) -> bool; +fn is_zero(x: i8) -> bool; /// Return true if the number is zero. -fn is_zero(x: int) -> bool; - -/// Return true if the floating-point number is zero. -fn is_zero(x: f64) -> bool; - -/// Return true if the floating-point number is zero. -fn is_zero(x: f32) -> bool; +fn is_zero(x: u32) -> bool; /// Return true if the number is zero. fn is_zero(x: i32) -> bool; @@ -2447,19 +2438,28 @@ fn is_zero(x: i32) -> bool; fn is_zero(x: u64) -> bool; /// Return true if the number is zero. -fn is_zero(x: u32) -> bool; +fn is_zero(x: int) -> bool; + +/// Return true if the number is zero. +fn is_zero(x: u8) -> bool; /// Return true if the number is zero. fn is_zero(x: i128) -> bool; +/// Return true if the number is zero. +fn is_zero(x: u16) -> bool; + +/// Return true if the number is zero. +fn is_zero(x: u128) -> bool; + +/// Return true if the floating-point number is zero. +fn is_zero(x: f32) -> bool; + /// Return true if the number is zero. fn is_zero(x: i16) -> bool; -/// Return true if the number is zero. -fn is_zero(x: i8) -> bool; - -/// Return true if the number is zero. -fn is_zero(x: u16) -> bool; +/// Return true if the floating-point number is zero. +fn is_zero(x: f64) -> bool; /// Return an array with all the property names in the object map. /// @@ -2473,7 +2473,7 @@ fn is_zero(x: u16) -> bool; fn keys(map: Map) -> Array; /// Return the number of properties in the object map. -fn len(map: Map) -> int; +fn len(map: Map) -> i64; /// Return the length of the string, in number of characters. /// @@ -2484,7 +2484,7 @@ fn len(map: Map) -> int; /// /// print(text.len); // prints 17 /// ``` -fn len(string: String) -> int; +fn len(string: String) -> i64; /// Return the length of the BLOB. /// @@ -2497,32 +2497,19 @@ fn len(string: String) -> int; /// /// print(b.len()); // prints 10 /// ``` -fn len(blob: Blob) -> int; +fn len(blob: Blob) -> i64; /// Number of elements in the array. -fn len(array: Array) -> int; +fn len(array: Array) -> i64; /// Return the natural log of the floating-point number. -fn ln(x: float) -> float; - -/// Return the log of the floating-point number with `base`. -fn log(x: float, base: float) -> float; +fn ln(x: float) -> f64; /// Return the log of the floating-point number with base 10. -fn log(x: float) -> float; +fn log(x: float) -> f64; -/// Convert the string to all lower-case. -/// -/// # Example -/// -/// ```rhai -/// let text = "HELLO, WORLD!" -/// -/// text.make_lower(); -/// -/// print(text); // prints "hello, world!"; -/// ``` -fn make_lower(string: String) -> (); +/// Return the log of the floating-point number with `base`. +fn log(x: float, base: float) -> f64; /// Convert the character to lower-case. /// @@ -2537,18 +2524,18 @@ fn make_lower(string: String) -> (); /// ``` fn make_lower(character: char) -> (); -/// Convert the character to upper-case. +/// Convert the string to all lower-case. /// /// # Example /// /// ```rhai -/// let ch = 'a'; +/// let text = "HELLO, WORLD!" /// -/// ch.make_upper(); +/// text.make_lower(); /// -/// print(ch); // prints 'A' +/// print(text); // prints "hello, world!"; /// ``` -fn make_upper(character: char) -> (); +fn make_lower(string: String) -> (); /// Convert the string to all upper-case. /// @@ -2563,6 +2550,19 @@ fn make_upper(character: char) -> (); /// ``` fn make_upper(string: String) -> (); +/// Convert the character to upper-case. +/// +/// # Example +/// +/// ```rhai +/// let ch = 'a'; +/// +/// ch.make_upper(); +/// +/// print(ch); // prints 'A' +/// ``` +fn make_upper(character: char) -> (); + /// Iterate through all the elements in the array, applying a function named by `mapper` to each /// element in turn, and return the results as a new array. /// @@ -2643,6 +2643,25 @@ fn mixin(map: Map, map2: Map) -> (); /// ``` fn name(fn_ptr: FnPtr) -> String; +/// Pad the array to at least the specified length with copies of a specified element. +/// +/// If `len` ≤ length of array, no padding is done. +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 3]; +/// +/// x.pad(5, 42); +/// +/// print(x); // prints "[1, 2, 3, 42, 42]" +/// +/// x.pad(3, 123); +/// +/// print(x); // prints "[1, 2, 3, 42, 42]" +/// ``` +fn pad(array: Array, len: int, item: ?) -> (); + /// Pad the string to at least the specified number of characters with the specified string. /// /// If `len` ≤ length of string, no padding is done. @@ -2683,25 +2702,6 @@ fn pad(string: String, len: int, padding: String) -> (); /// ``` fn pad(blob: Blob, len: int, value: int) -> (); -/// Pad the array to at least the specified length with copies of a specified element. -/// -/// If `len` ≤ length of array, no padding is done. -/// -/// # Example -/// -/// ```rhai -/// let x = [1, 2, 3]; -/// -/// x.pad(5, 42); -/// -/// print(x); // prints "[1, 2, 3, 42, 42]" -/// -/// x.pad(3, 123); -/// -/// print(x); // prints "[1, 2, 3, 42, 42]" -/// ``` -fn pad(array: Array, len: int, item: ?) -> (); - /// Pad the string to at least the specified number of characters with the specified `character`. /// /// If `len` ≤ length of string, no padding is done. @@ -2721,19 +2721,12 @@ fn pad(array: Array, len: int, item: ?) -> (); /// ``` fn pad(string: String, len: int, character: char) -> (); -/// Parse the bytes within an inclusive `range` in the BLOB as a `FLOAT` -/// in big-endian byte order. -/// -/// * If number of bytes in `range` < number of bytes for `FLOAT`, zeros are padded. -/// * If number of bytes in `range` > number of bytes for `FLOAT`, extra bytes are ignored. -fn parse_be_float(blob: Blob, range: InclusiveRange) -> float; - /// Parse the bytes within an exclusive `range` in the BLOB as a `FLOAT` /// in big-endian byte order. /// /// * If number of bytes in `range` < number of bytes for `FLOAT`, zeros are padded. /// * If number of bytes in `range` > number of bytes for `FLOAT`, extra bytes are ignored. -fn parse_be_float(blob: Blob, range: ExclusiveRange) -> float; +fn parse_be_float(blob: Blob, range: Range) -> f64; /// Parse the bytes beginning at the `start` position in the BLOB as a `FLOAT` /// in big-endian byte order. @@ -2746,7 +2739,31 @@ fn parse_be_float(blob: Blob, range: ExclusiveRange) -> float; /// /// * If number of bytes in range < number of bytes for `FLOAT`, zeros are padded. /// * If number of bytes in range > number of bytes for `FLOAT`, extra bytes are ignored. -fn parse_be_float(blob: Blob, start: int, len: int) -> float; +fn parse_be_float(blob: Blob, start: int, len: int) -> f64; + +/// Parse the bytes within an inclusive `range` in the BLOB as a `FLOAT` +/// in big-endian byte order. +/// +/// * If number of bytes in `range` < number of bytes for `FLOAT`, zeros are padded. +/// * If number of bytes in `range` > number of bytes for `FLOAT`, extra bytes are ignored. +fn parse_be_float(blob: Blob, range: RangeInclusive) -> f64; + +/// Parse the bytes within an exclusive `range` in the BLOB as an `INT` +/// in big-endian byte order. +/// +/// * If number of bytes in `range` < number of bytes for `INT`, zeros are padded. +/// * If number of bytes in `range` > number of bytes for `INT`, extra bytes are ignored. +/// +/// ```rhai +/// let b = blob(); +/// +/// b += 1; b += 2; b += 3; b += 4; b += 5; +/// +/// let x = b.parse_be_int(1..3); // parse two bytes +/// +/// print(x.to_hex()); // prints "02030000...00" +/// ``` +fn parse_be_int(blob: Blob, range: Range) -> i64; /// Parse the bytes beginning at the `start` position in the BLOB as an `INT` /// in big-endian byte order. @@ -2769,24 +2786,7 @@ fn parse_be_float(blob: Blob, start: int, len: int) -> float; /// /// print(x.to_hex()); // prints "02030000...00" /// ``` -fn parse_be_int(blob: Blob, start: int, len: int) -> int; - -/// Parse the bytes within an exclusive `range` in the BLOB as an `INT` -/// in big-endian byte order. -/// -/// * If number of bytes in `range` < number of bytes for `INT`, zeros are padded. -/// * If number of bytes in `range` > number of bytes for `INT`, extra bytes are ignored. -/// -/// ```rhai -/// let b = blob(); -/// -/// b += 1; b += 2; b += 3; b += 4; b += 5; -/// -/// let x = b.parse_be_int(1..3); // parse two bytes -/// -/// print(x.to_hex()); // prints "02030000...00" -/// ``` -fn parse_be_int(blob: Blob, range: ExclusiveRange) -> int; +fn parse_be_int(blob: Blob, start: int, len: int) -> i64; /// Parse the bytes within an inclusive `range` in the BLOB as an `INT` /// in big-endian byte order. @@ -2803,7 +2803,7 @@ fn parse_be_int(blob: Blob, range: ExclusiveRange) -> int; /// /// print(x.to_hex()); // prints "0203040000...00" /// ``` -fn parse_be_int(blob: Blob, range: InclusiveRange) -> int; +fn parse_be_int(blob: Blob, range: RangeInclusive) -> i64; /// Parse a string into a floating-point number. /// @@ -2816,17 +2816,6 @@ fn parse_be_int(blob: Blob, range: InclusiveRange) -> int; /// ``` fn parse_float(string: String) -> float; -/// Parse a string into an integer number. -/// -/// # Example -/// -/// ```rhai -/// let x = parse_int("123"); -/// -/// print(x); // prints 123 -/// ``` -fn parse_int(string: String) -> int; - /// Parse a string into an integer number of the specified `radix`. /// /// `radix` must be between 2 and 36. @@ -2844,12 +2833,16 @@ fn parse_int(string: String) -> int; /// ``` fn parse_int(string: String, radix: int) -> int; -/// Parse the bytes within an inclusive `range` in the BLOB as a `FLOAT` -/// in little-endian byte order. +/// Parse a string into an integer number. /// -/// * If number of bytes in `range` < number of bytes for `FLOAT`, zeros are padded. -/// * If number of bytes in `range` > number of bytes for `FLOAT`, extra bytes are ignored. -fn parse_le_float(blob: Blob, range: InclusiveRange) -> float; +/// # Example +/// +/// ```rhai +/// let x = parse_int("123"); +/// +/// print(x); // prints 123 +/// ``` +fn parse_int(string: String) -> int; /// Parse the bytes beginning at the `start` position in the BLOB as a `FLOAT` /// in little-endian byte order. @@ -2862,14 +2855,21 @@ fn parse_le_float(blob: Blob, range: InclusiveRange) -> float; /// /// * If number of bytes in range < number of bytes for `FLOAT`, zeros are padded. /// * If number of bytes in range > number of bytes for `FLOAT`, extra bytes are ignored. -fn parse_le_float(blob: Blob, start: int, len: int) -> float; +fn parse_le_float(blob: Blob, start: int, len: int) -> f64; /// Parse the bytes within an exclusive `range` in the BLOB as a `FLOAT` /// in little-endian byte order. /// /// * If number of bytes in `range` < number of bytes for `FLOAT`, zeros are padded. /// * If number of bytes in `range` > number of bytes for `FLOAT`, extra bytes are ignored. -fn parse_le_float(blob: Blob, range: ExclusiveRange) -> float; +fn parse_le_float(blob: Blob, range: Range) -> f64; + +/// Parse the bytes within an inclusive `range` in the BLOB as a `FLOAT` +/// in little-endian byte order. +/// +/// * If number of bytes in `range` < number of bytes for `FLOAT`, zeros are padded. +/// * If number of bytes in `range` > number of bytes for `FLOAT`, extra bytes are ignored. +fn parse_le_float(blob: Blob, range: RangeInclusive) -> f64; /// Parse the bytes within an exclusive `range` in the BLOB as an `INT` /// in little-endian byte order. @@ -2886,7 +2886,7 @@ fn parse_le_float(blob: Blob, range: ExclusiveRange) -> float; /// /// print(x.to_hex()); // prints "0302" /// ``` -fn parse_le_int(blob: Blob, range: ExclusiveRange) -> int; +fn parse_le_int(blob: Blob, range: Range) -> i64; /// Parse the bytes beginning at the `start` position in the BLOB as an `INT` /// in little-endian byte order. @@ -2909,7 +2909,7 @@ fn parse_le_int(blob: Blob, range: ExclusiveRange) -> int; /// /// print(x.to_hex()); // prints "0302" /// ``` -fn parse_le_int(blob: Blob, start: int, len: int) -> int; +fn parse_le_int(blob: Blob, start: int, len: int) -> i64; /// Parse the bytes within an inclusive `range` in the BLOB as an `INT` /// in little-endian byte order. @@ -2926,7 +2926,39 @@ fn parse_le_int(blob: Blob, start: int, len: int) -> int; /// /// print(x.to_hex()); // prints "040302" /// ``` -fn parse_le_int(blob: Blob, range: InclusiveRange) -> int; +fn parse_le_int(blob: Blob, range: RangeInclusive) -> i64; + +/// Remove the last byte from the BLOB and return it. +/// +/// If the BLOB is empty, zero is returned. +/// +/// # Example +/// +/// ```rhai +/// let b = blob(); +/// +/// b += 1; b += 2; b += 3; b += 4; b += 5; +/// +/// print(b.pop()); // prints 5 +/// +/// print(b); // prints "[01020304]" +/// ``` +fn pop(blob: Blob) -> i64; + +/// Remove the last character from the string and return it. +/// +/// If the string is empty, `()` is returned. +/// +/// # Example +/// +/// ```rhai +/// let text = "hello, world!"; +/// +/// print(text.pop()); // prints '!' +/// +/// print(text); // prints "hello, world" +/// ``` +fn pop(string: String) -> ?; /// Remove a specified number of characters from the end of the string and return it as a /// new string. @@ -2945,38 +2977,6 @@ fn parse_le_int(blob: Blob, range: InclusiveRange) -> int; /// ``` fn pop(string: String, len: int) -> String; -/// Remove the last character from the string and return it. -/// -/// If the string is empty, `()` is returned. -/// -/// # Example -/// -/// ```rhai -/// let text = "hello, world!"; -/// -/// print(text.pop()); // prints '!' -/// -/// print(text); // prints "hello, world" -/// ``` -fn pop(string: String) -> ?; - -/// Remove the last byte from the BLOB and return it. -/// -/// If the BLOB is empty, zero is returned. -/// -/// # Example -/// -/// ```rhai -/// let b = blob(); -/// -/// b += 1; b += 2; b += 3; b += 4; b += 5; -/// -/// print(b.pop()); // prints 5 -/// -/// print(b); // prints "[01020304]" -/// ``` -fn pop(blob: Blob) -> int; - /// Remove the last element from the array and return it. /// /// If the array is empty, `()` is returned. @@ -2992,9 +2992,21 @@ fn pop(blob: Blob) -> int; /// ``` fn pop(array: Array) -> ?; +/// Convert the array into a string. +fn print(array: Array) -> String; + +/// Return the empty string. +fn print(unit: ()) -> String; + +/// Return the character into a string. +fn print(character: char) -> String; + /// Return the `string`. fn print(string: String) -> String; +/// Convert the value of `number` into a string. +fn print(number: f32) -> String; + /// Return the empty string. fn print() -> String; @@ -3004,38 +3016,11 @@ fn print(number: f64) -> String; /// Convert the object map into a string. fn print(map: Map) -> String; -/// Convert the value of `number` into a string. -fn print(number: f32) -> String; - -/// Convert the value of the `item` into a string. -fn print(item: ?) -> String; - /// Return the boolean value into a string. fn print(value: bool) -> String; -/// Convert the array into a string. -fn print(array: Array) -> String; - -/// Return the character into a string. -fn print(character: char) -> String; - -/// Return the empty string. -fn print(unit: ()) -> String; - -/// Add a new byte `value` to the end of the BLOB. -/// -/// Only the lower 8 bits of the `value` are used; all other bits are ignored. -/// -/// # Example -/// -/// ```rhai -/// let b = blob(); -/// -/// b.push(0x42); -/// -/// print(b); // prints "[42]" -/// ``` -fn push(blob: Blob, value: int) -> (); +/// Convert the value of the `item` into a string. +fn print(item: ?) -> String; /// Add a new element, which is not another array, to the end of the array. /// @@ -3052,27 +3037,20 @@ fn push(blob: Blob, value: int) -> (); /// ``` fn push(array: Array, item: ?) -> (); -/// Return an iterator over the exclusive range of `from..to`, each iteration increasing by `step`. -/// The value `to` is never included. +/// Add a new byte `value` to the end of the BLOB. /// -/// If `from` > `to` and `step` < 0, iteration goes backwards. -/// -/// If `from` > `to` and `step` > 0 or `from` < `to` and `step` < 0, an empty iterator is returned. +/// Only the lower 8 bits of the `value` are used; all other bits are ignored. /// /// # Example /// /// ```rhai -/// // prints all values from 8 to 17 in steps of 3 -/// for n in range(8, 18, 3) { -/// print(n); -/// } +/// let b = blob(); /// -/// // prints all values down from 18 to 9 in steps of -3 -/// for n in range(18, 8, -3) { -/// print(n); -/// } +/// b.push(0x42); +/// +/// print(b); // prints "[42]" /// ``` -fn range(from: i16, to: i16, step: i16) -> Iterator; +fn push(blob: Blob, value: int) -> (); /// Return an iterator over the exclusive range of `from..to`, each iteration increasing by `step`. /// The value `to` is never included. @@ -3094,20 +3072,7 @@ fn range(from: i16, to: i16, step: i16) -> Iterator; /// print(n); /// } /// ``` -fn range(from: i8, to: i8, step: i8) -> Iterator; - -/// Return an iterator over the exclusive range of `from..to`. -/// The value `to` is never included. -/// -/// # Example -/// -/// ```rhai -/// // prints all values from 8 to 17 -/// for n in range(8, 18) { -/// print(n); -/// } -/// ``` -fn range(from: u16, to: u16) -> Iterator; +fn range(from: u8, to: u8, step: u8) -> Iterator; /// Return an iterator over the exclusive range of `from..to`, each iteration increasing by `step`. /// The value `to` is never included. @@ -3129,7 +3094,7 @@ fn range(from: u16, to: u16) -> Iterator; /// print(n); /// } /// ``` -fn range(from: i32, to: i32, step: i32) -> Iterator; +fn range(from: i128, to: i128, step: i128) -> Iterator; /// Return an iterator over an exclusive range, each iteration increasing by `step`. /// @@ -3150,7 +3115,64 @@ fn range(from: i32, to: i32, step: i32) -> Iterator; /// print(n); /// } /// ``` -fn range(range: Range, step: u32) -> Iterator; +fn range(range: Range, step: float) -> Iterator; + +/// Return an iterator over the exclusive range of `from..to`, each iteration increasing by `step`. +/// The value `to` is never included. +/// +/// If `from` > `to` and `step` < 0, iteration goes backwards. +/// +/// If `from` > `to` and `step` > 0 or `from` < `to` and `step` < 0, an empty iterator is returned. +/// +/// # Example +/// +/// ```rhai +/// // prints all values from 8 to 17 in steps of 3 +/// for n in range(8, 18, 3) { +/// print(n); +/// } +/// +/// // prints all values down from 18 to 9 in steps of -3 +/// for n in range(18, 8, -3) { +/// print(n); +/// } +/// ``` +fn range(from: float, to: float, step: float) -> Iterator; + +/// Return an iterator over the exclusive range of `from..to`. +/// The value `to` is never included. +/// +/// # Example +/// +/// ```rhai +/// // prints all values from 8 to 17 +/// for n in range(8, 18) { +/// print(n); +/// } +/// ``` +fn range(from: i16, to: i16) -> Iterator; + +/// Return an iterator over the exclusive range of `from..to`, each iteration increasing by `step`. +/// The value `to` is never included. +/// +/// If `from` > `to` and `step` < 0, iteration goes backwards. +/// +/// If `from` > `to` and `step` > 0 or `from` < `to` and `step` < 0, an empty iterator is returned. +/// +/// # Example +/// +/// ```rhai +/// // prints all values from 8 to 17 in steps of 3 +/// for n in range(8, 18, 3) { +/// print(n); +/// } +/// +/// // prints all values down from 18 to 9 in steps of -3 +/// for n in range(18, 8, -3) { +/// print(n); +/// } +/// ``` +fn range(from: u64, to: u64, step: u64) -> Iterator; /// Return an iterator over the exclusive range of `from..to`. /// The value `to` is never included. @@ -3165,6 +3187,19 @@ fn range(range: Range, step: u32) -> Iterator; /// ``` fn range(from: i32, to: i32) -> Iterator; +/// Return an iterator over the exclusive range of `from..to`. +/// The value `to` is never included. +/// +/// # Example +/// +/// ```rhai +/// // prints all values from 8 to 17 +/// for n in range(8, 18) { +/// print(n); +/// } +/// ``` +fn range(from: i128, to: i128) -> Iterator; + /// Return an iterator over the exclusive range of `from..to`. /// The value `to` is never included. /// @@ -3210,7 +3245,7 @@ fn range(range: Range, step: i32) -> Iterator; /// print(n); /// } /// ``` -fn range(from: u32, to: u32) -> Iterator; +fn range(from: u8, to: u8) -> Iterator; /// Return an iterator over the exclusive range of `from..to`, each iteration increasing by `step`. /// The value `to` is never included. @@ -3232,7 +3267,7 @@ fn range(from: u32, to: u32) -> Iterator; /// print(n); /// } /// ``` -fn range(from: i128, to: i128, step: i128) -> Iterator; +fn range(from: u16, to: u16, step: u16) -> Iterator; /// Return an iterator over an exclusive range, each iteration increasing by `step`. /// @@ -3253,41 +3288,7 @@ fn range(from: i128, to: i128, step: i128) -> Iterator; /// print(n); /// } /// ``` -fn range(range: Range, step: u128) -> Iterator; - -/// Return an iterator over the exclusive range of `from..to`. -/// The value `to` is never included. -/// -/// # Example -/// -/// ```rhai -/// // prints all values from 8 to 17 -/// for n in range(8, 18) { -/// print(n); -/// } -/// ``` -fn range(from: i8, to: i8) -> Iterator; - -/// Return an iterator over an exclusive range, each iteration increasing by `step`. -/// -/// If `range` is reversed and `step` < 0, iteration goes backwards. -/// -/// Otherwise, if `range` is empty, an empty iterator is returned. -/// -/// # Example -/// -/// ```rhai -/// // prints all values from 8 to 17 in steps of 3 -/// for n in range(8..18, 3) { -/// print(n); -/// } -/// -/// // prints all values down from 18 to 9 in steps of -3 -/// for n in range(18..8, -3) { -/// print(n); -/// } -/// ``` -fn range(range: Range, step: i8) -> Iterator; +fn range(range: Range, step: u64) -> Iterator; /// Return an iterator over an exclusive range, each iteration increasing by `step`. /// @@ -3321,7 +3322,98 @@ fn range(range: Range, step: u8) -> Iterator; /// print(n); /// } /// ``` -fn range(from: i16, to: i16) -> Iterator; +fn range(from: u32, to: u32) -> Iterator; + +/// Return an iterator over the exclusive range of `from..to`, each iteration increasing by `step`. +/// The value `to` is never included. +/// +/// If `from` > `to` and `step` < 0, iteration goes backwards. +/// +/// If `from` > `to` and `step` > 0 or `from` < `to` and `step` < 0, an empty iterator is returned. +/// +/// # Example +/// +/// ```rhai +/// // prints all values from 8 to 17 in steps of 3 +/// for n in range(8, 18, 3) { +/// print(n); +/// } +/// +/// // prints all values down from 18 to 9 in steps of -3 +/// for n in range(18, 8, -3) { +/// print(n); +/// } +/// ``` +fn range(from: i32, to: i32, step: i32) -> Iterator; + +/// Return an iterator over the exclusive range of `from..to`. +/// The value `to` is never included. +/// +/// # Example +/// +/// ```rhai +/// // prints all values from 8 to 17 +/// for n in range(8, 18) { +/// print(n); +/// } +/// ``` +fn range(from: u128, to: u128) -> Iterator; + +/// Return an iterator over an exclusive range, each iteration increasing by `step`. +/// +/// If `range` is reversed and `step` < 0, iteration goes backwards. +/// +/// Otherwise, if `range` is empty, an empty iterator is returned. +/// +/// # Example +/// +/// ```rhai +/// // prints all values from 8 to 17 in steps of 3 +/// for n in range(8..18, 3) { +/// print(n); +/// } +/// +/// // prints all values down from 18 to 9 in steps of -3 +/// for n in range(18..8, -3) { +/// print(n); +/// } +/// ``` +fn range(range: Range, step: u128) -> Iterator; + +/// Return an iterator over the exclusive range of `from..to`, each iteration increasing by `step`. +/// The value `to` is never included. +/// +/// If `from` > `to` and `step` < 0, iteration goes backwards. +/// +/// If `from` > `to` and `step` > 0 or `from` < `to` and `step` < 0, an empty iterator is returned. +/// +/// # Example +/// +/// ```rhai +/// // prints all values from 8 to 17 in steps of 3 +/// for n in range(8, 18, 3) { +/// print(n); +/// } +/// +/// // prints all values down from 18 to 9 in steps of -3 +/// for n in range(18, 8, -3) { +/// print(n); +/// } +/// ``` +fn range(from: i16, to: i16, step: i16) -> Iterator; + +/// Return an iterator over the exclusive range of `from..to`. +/// The value `to` is never included. +/// +/// # Example +/// +/// ```rhai +/// // prints all values from 8 to 17 +/// for n in range(8, 18) { +/// print(n); +/// } +/// ``` +fn range(from: i8, to: i8) -> Iterator; /// Return an iterator over the exclusive range of `from..to`, each iteration increasing by `step`. /// The value `to` is never included. @@ -3345,140 +3437,6 @@ fn range(from: i16, to: i16) -> Iterator; /// ``` fn range(from: u128, to: u128, step: u128) -> Iterator; -/// Return an iterator over an exclusive range, each iteration increasing by `step`. -/// -/// If `range` is reversed and `step` < 0, iteration goes backwards. -/// -/// Otherwise, if `range` is empty, an empty iterator is returned. -/// -/// # Example -/// -/// ```rhai -/// // prints all values from 8 to 17 in steps of 3 -/// for n in range(8..18, 3) { -/// print(n); -/// } -/// -/// // prints all values down from 18 to 9 in steps of -3 -/// for n in range(18..8, -3) { -/// print(n); -/// } -/// ``` -fn range(range: Range, step: u16) -> Iterator; - -/// Return an iterator over the exclusive range of `from..to`. -/// The value `to` is never included. -/// -/// # Example -/// -/// ```rhai -/// // prints all values from 8 to 17 -/// for n in range(8, 18) { -/// print(n); -/// } -/// ``` -fn range(from: u128, to: u128) -> Iterator; - -/// Return an iterator over the exclusive range of `from..to`, each iteration increasing by `step`. -/// The value `to` is never included. -/// -/// If `from` > `to` and `step` < 0, iteration goes backwards. -/// -/// If `from` > `to` and `step` > 0 or `from` < `to` and `step` < 0, an empty iterator is returned. -/// -/// # Example -/// -/// ```rhai -/// // prints all values from 8 to 17 in steps of 3 -/// for n in range(8, 18, 3) { -/// print(n); -/// } -/// -/// // prints all values down from 18 to 9 in steps of -3 -/// for n in range(18, 8, -3) { -/// print(n); -/// } -/// ``` -fn range(from: ?, to: ?, step: ?) -> Iterator; - -/// Return an iterator over the exclusive range of `from..to`, each iteration increasing by `step`. -/// The value `to` is never included. -/// -/// If `from` > `to` and `step` < 0, iteration goes backwards. -/// -/// If `from` > `to` and `step` > 0 or `from` < `to` and `step` < 0, an empty iterator is returned. -/// -/// # Example -/// -/// ```rhai -/// // prints all values from 8 to 17 in steps of 3 -/// for n in range(8, 18, 3) { -/// print(n); -/// } -/// -/// // prints all values down from 18 to 9 in steps of -3 -/// for n in range(18, 8, -3) { -/// print(n); -/// } -/// ``` -fn range(from: i64, to: i64, step: i64) -> Iterator; - -/// Return an iterator over an exclusive range, each iteration increasing by `step`. -/// -/// If `range` is reversed and `step` < 0, iteration goes backwards. -/// -/// Otherwise, if `range` is empty, an empty iterator is returned. -/// -/// # Example -/// -/// ```rhai -/// // prints all values from 8 to 17 in steps of 3 -/// for n in range(8..18, 3) { -/// print(n); -/// } -/// -/// // prints all values down from 18 to 9 in steps of -3 -/// for n in range(18..8, -3) { -/// print(n); -/// } -/// ``` -fn range(range: Range, step: u64) -> Iterator; - -/// Return an iterator over the exclusive range of `from..to`, each iteration increasing by `step`. -/// The value `to` is never included. -/// -/// If `from` > `to` and `step` < 0, iteration goes backwards. -/// -/// If `from` > `to` and `step` > 0 or `from` < `to` and `step` < 0, an empty iterator is returned. -/// -/// # Example -/// -/// ```rhai -/// // prints all values from 8 to 17 in steps of 3 -/// for n in range(8, 18, 3) { -/// print(n); -/// } -/// -/// // prints all values down from 18 to 9 in steps of -3 -/// for n in range(18, 8, -3) { -/// print(n); -/// } -/// ``` -fn range(from: u8, to: u8, step: u8) -> Iterator; - -/// Return an iterator over the exclusive range of `from..to`. -/// The value `to` is never included. -/// -/// # Example -/// -/// ```rhai -/// // prints all values from 8 to 17 -/// for n in range(8, 18) { -/// print(n); -/// } -/// ``` -fn range(from: u8, to: u8) -> Iterator; - /// Return an iterator over an exclusive range, each iteration increasing by `step`. /// /// If `range` is reversed and `step` < 0, iteration goes backwards. @@ -3500,26 +3458,40 @@ fn range(from: u8, to: u8) -> Iterator; /// ``` fn range(range: Range, step: i128) -> Iterator; -/// Return an iterator over an exclusive range, each iteration increasing by `step`. +/// Return an iterator over the exclusive range of `from..to`. +/// The value `to` is never included. /// -/// If `range` is reversed and `step` < 0, iteration goes backwards. +/// # Example /// -/// Otherwise, if `range` is empty, an empty iterator is returned. +/// ```rhai +/// // prints all values from 8 to 17 +/// for n in range(8, 18) { +/// print(n); +/// } +/// ``` +fn range(from: u16, to: u16) -> Iterator; + +/// Return an iterator over the exclusive range of `from..to`, each iteration increasing by `step`. +/// The value `to` is never included. +/// +/// If `from` > `to` and `step` < 0, iteration goes backwards. +/// +/// If `from` > `to` and `step` > 0 or `from` < `to` and `step` < 0, an empty iterator is returned. /// /// # Example /// /// ```rhai /// // prints all values from 8 to 17 in steps of 3 -/// for n in range(8..18, 3) { +/// for n in range(8, 18, 3) { /// print(n); /// } /// /// // prints all values down from 18 to 9 in steps of -3 -/// for n in range(18..8, -3) { +/// for n in range(18, 8, -3) { /// print(n); /// } /// ``` -fn range(range: ?, step: ?) -> Iterator; +fn range(from: u32, to: u32, step: u32) -> Iterator; /// Return an iterator over an exclusive range, each iteration increasing by `step`. /// @@ -3542,27 +3514,89 @@ fn range(range: ?, step: ?) -> Iterator; /// ``` fn range(range: Range, step: i64) -> Iterator; -/// Return an iterator over the exclusive range of `from..to`, each iteration increasing by `step`. -/// The value `to` is never included. +/// Return an iterator over an exclusive range, each iteration increasing by `step`. /// -/// If `from` > `to` and `step` < 0, iteration goes backwards. +/// If `range` is reversed and `step` < 0, iteration goes backwards. /// -/// If `from` > `to` and `step` > 0 or `from` < `to` and `step` < 0, an empty iterator is returned. +/// Otherwise, if `range` is empty, an empty iterator is returned. /// /// # Example /// /// ```rhai /// // prints all values from 8 to 17 in steps of 3 -/// for n in range(8, 18, 3) { +/// for n in range(8..18, 3) { /// print(n); /// } /// /// // prints all values down from 18 to 9 in steps of -3 -/// for n in range(18, 8, -3) { +/// for n in range(18..8, -3) { /// print(n); /// } /// ``` -fn range(from: u16, to: u16, step: u16) -> Iterator; +fn range(range: Range, step: i16) -> Iterator; + +/// Return an iterator over an exclusive range, each iteration increasing by `step`. +/// +/// If `range` is reversed and `step` < 0, iteration goes backwards. +/// +/// Otherwise, if `range` is empty, an empty iterator is returned. +/// +/// # Example +/// +/// ```rhai +/// // prints all values from 8 to 17 in steps of 3 +/// for n in range(8..18, 3) { +/// print(n); +/// } +/// +/// // prints all values down from 18 to 9 in steps of -3 +/// for n in range(18..8, -3) { +/// print(n); +/// } +/// ``` +fn range(range: Range, step: u32) -> Iterator; + +/// Return an iterator over an exclusive range, each iteration increasing by `step`. +/// +/// If `range` is reversed and `step` < 0, iteration goes backwards. +/// +/// Otherwise, if `range` is empty, an empty iterator is returned. +/// +/// # Example +/// +/// ```rhai +/// // prints all values from 8 to 17 in steps of 3 +/// for n in range(8..18, 3) { +/// print(n); +/// } +/// +/// // prints all values down from 18 to 9 in steps of -3 +/// for n in range(18..8, -3) { +/// print(n); +/// } +/// ``` +fn range(range: Range, step: i8) -> Iterator; + +/// Return an iterator over an exclusive range, each iteration increasing by `step`. +/// +/// If `range` is reversed and `step` < 0, iteration goes backwards. +/// +/// Otherwise, if `range` is empty, an empty iterator is returned. +/// +/// # Example +/// +/// ```rhai +/// // prints all values from 8 to 17 in steps of 3 +/// for n in range(8..18, 3) { +/// print(n); +/// } +/// +/// // prints all values down from 18 to 9 in steps of -3 +/// for n in range(18..8, -3) { +/// print(n); +/// } +/// ``` +fn range(range: Range, step: u16) -> Iterator; /// Return an iterator over the exclusive range of `from..to`. /// The value `to` is never included. @@ -3597,41 +3631,7 @@ fn range(from: i64, to: i64) -> Iterator; /// print(n); /// } /// ``` -fn range(from: u64, to: u64, step: u64) -> Iterator; - -/// Return an iterator over the exclusive range of `from..to`. -/// The value `to` is never included. -/// -/// # Example -/// -/// ```rhai -/// // prints all values from 8 to 17 -/// for n in range(8, 18) { -/// print(n); -/// } -/// ``` -fn range(from: i128, to: i128) -> Iterator; - -/// Return an iterator over an exclusive range, each iteration increasing by `step`. -/// -/// If `range` is reversed and `step` < 0, iteration goes backwards. -/// -/// Otherwise, if `range` is empty, an empty iterator is returned. -/// -/// # Example -/// -/// ```rhai -/// // prints all values from 8 to 17 in steps of 3 -/// for n in range(8..18, 3) { -/// print(n); -/// } -/// -/// // prints all values down from 18 to 9 in steps of -3 -/// for n in range(18..8, -3) { -/// print(n); -/// } -/// ``` -fn range(range: Range, step: i16) -> Iterator; +fn range(from: i8, to: i8, step: i8) -> Iterator; /// Return an iterator over the exclusive range of `from..to`, each iteration increasing by `step`. /// The value `to` is never included. @@ -3653,7 +3653,59 @@ fn range(range: Range, step: i16) -> Iterator; /// print(n); /// } /// ``` -fn range(from: u32, to: u32, step: u32) -> Iterator; +fn range(from: i64, to: i64, step: i64) -> Iterator; + +/// Reduce an array by iterating through all elements while applying the `reducer` function. +/// +/// # Function Parameters +/// +/// * `result`: accumulated result, starting with the value of `initial` +/// * `element`: copy of array element +/// * `index` _(optional)_: current index in the array +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 3, 4, 5]; +/// +/// let y = x.reduce(|r, v| v + r, 5); +/// +/// print(y); // prints 20 +/// +/// let y = x.reduce(|r, v, i| v + i + r, 5); +/// +/// print(y); // prints 30 +/// ``` +fn reduce(array: Array, reducer: FnPtr, initial: ?) -> RhaiResult; + +/// Reduce an array by iterating through all elements while applying a function named by `reducer`. +/// +/// # Function Parameters +/// +/// A function with the same name as the value of `reducer` must exist taking these parameters: +/// +/// * `result`: accumulated result, starting with the value of `initial` +/// * `element`: copy of array element +/// * `index` _(optional)_: current index in the array +/// +/// # Example +/// +/// ```rhai +/// fn process(r, x) { x + r } +/// +/// fn process_extra(r, x, i) { x + i + r } +/// +/// let x = [1, 2, 3, 4, 5]; +/// +/// let y = x.reduce("process", 5); +/// +/// print(y); // prints 20 +/// +/// let y = x.reduce("process_extra", 5); +/// +/// print(y); // prints 30 +/// ``` +fn reduce(array: Array, reducer: String, initial: ?) -> RhaiResult; /// Reduce an array by iterating through all elements while applying a function named by `reducer`. /// @@ -3687,58 +3739,6 @@ fn range(from: u32, to: u32, step: u32) -> Iterator; /// ``` fn reduce(array: Array, reducer: String) -> RhaiResult; -/// Reduce an array by iterating through all elements while applying a function named by `reducer`. -/// -/// # Function Parameters -/// -/// A function with the same name as the value of `reducer` must exist taking these parameters: -/// -/// * `result`: accumulated result, starting with the value of `initial` -/// * `element`: copy of array element -/// * `index` _(optional)_: current index in the array -/// -/// # Example -/// -/// ```rhai -/// fn process(r, x) { x + r } -/// -/// fn process_extra(r, x, i) { x + i + r } -/// -/// let x = [1, 2, 3, 4, 5]; -/// -/// let y = x.reduce("process", 5); -/// -/// print(y); // prints 20 -/// -/// let y = x.reduce("process_extra", 5); -/// -/// print(y); // prints 30 -/// ``` -fn reduce(array: Array, reducer: String, initial: ?) -> RhaiResult; - -/// Reduce an array by iterating through all elements while applying the `reducer` function. -/// -/// # Function Parameters -/// -/// * `result`: accumulated result, starting with the value of `initial` -/// * `element`: copy of array element -/// * `index` _(optional)_: current index in the array -/// -/// # Example -/// -/// ```rhai -/// let x = [1, 2, 3, 4, 5]; -/// -/// let y = x.reduce(|r, v| v + r, 5); -/// -/// print(y); // prints 20 -/// -/// let y = x.reduce(|r, v, i| v + i + r, 5); -/// -/// print(y); // prints 30 -/// ``` -fn reduce(array: Array, reducer: FnPtr, initial: ?) -> RhaiResult; - /// Reduce an array by iterating through all elements while applying the `reducer` function. /// /// # Function Parameters @@ -3762,39 +3762,6 @@ fn reduce(array: Array, reducer: FnPtr, initial: ?) -> RhaiResult; /// ``` fn reduce(array: Array, reducer: FnPtr) -> RhaiResult; -/// Reduce an array by iterating through all elements, in _reverse_ order, -/// while applying a function named by `reducer`. -/// -/// # Function Parameters -/// -/// A function with the same name as the value of `reducer` must exist taking these parameters: -/// -/// * `result`: accumulated result, initially `()` -/// * `element`: copy of array element -/// * `index` _(optional)_: current index in the array -/// -/// # Example -/// -/// ```rhai -/// fn process(r, x) { -/// x + (r ?? 0) -/// } -/// fn process_extra(r, x, i) { -/// x + i + (r ?? 0) -/// } -/// -/// let x = [1, 2, 3, 4, 5]; -/// -/// let y = x.reduce_rev("process"); -/// -/// print(y); // prints 15 -/// -/// let y = x.reduce_rev("process_extra"); -/// -/// print(y); // prints 25 -/// ``` -fn reduce_rev(array: Array, reducer: String) -> RhaiResult; - /// Reduce an array by iterating through all elements, in _reverse_ order, /// while applying the `reducer` function. /// @@ -3873,6 +3840,62 @@ fn reduce_rev(array: Array, reducer: String, initial: ?) -> RhaiResult; /// ``` fn reduce_rev(array: Array, reducer: FnPtr) -> RhaiResult; +/// Reduce an array by iterating through all elements, in _reverse_ order, +/// while applying a function named by `reducer`. +/// +/// # Function Parameters +/// +/// A function with the same name as the value of `reducer` must exist taking these parameters: +/// +/// * `result`: accumulated result, initially `()` +/// * `element`: copy of array element +/// * `index` _(optional)_: current index in the array +/// +/// # Example +/// +/// ```rhai +/// fn process(r, x) { +/// x + (r ?? 0) +/// } +/// fn process_extra(r, x, i) { +/// x + i + (r ?? 0) +/// } +/// +/// let x = [1, 2, 3, 4, 5]; +/// +/// let y = x.reduce_rev("process"); +/// +/// print(y); // prints 15 +/// +/// let y = x.reduce_rev("process_extra"); +/// +/// print(y); // prints 25 +/// ``` +fn reduce_rev(array: Array, reducer: String) -> RhaiResult; + +/// Remove the byte at the specified `index` from the BLOB and return it. +/// +/// * If `index` < 0, position counts from the end of the BLOB (`-1` is the last byte). +/// * If `index` < -length of BLOB, zero is returned. +/// * If `index` ≥ length of BLOB, zero is returned. +/// +/// # Example +/// +/// ```rhai +/// let b = blob(); +/// +/// b += 1; b += 2; b += 3; b += 4; b += 5; +/// +/// print(x.remove(1)); // prints 2 +/// +/// print(x); // prints "[01030405]" +/// +/// print(x.remove(-2)); // prints 4 +/// +/// print(x); // prints "[010305]" +/// ``` +fn remove(blob: Blob, index: int) -> i64; + /// Remove any property of the specified `name` from the object map, returning its value. /// /// If the property does not exist, `()` is returned. @@ -3924,29 +3947,6 @@ fn remove(string: String, sub_string: String) -> (); /// ``` fn remove(array: Array, index: int) -> ?; -/// Remove the byte at the specified `index` from the BLOB and return it. -/// -/// * If `index` < 0, position counts from the end of the BLOB (`-1` is the last byte). -/// * If `index` < -length of BLOB, zero is returned. -/// * If `index` ≥ length of BLOB, zero is returned. -/// -/// # Example -/// -/// ```rhai -/// let b = blob(); -/// -/// b += 1; b += 2; b += 3; b += 4; b += 5; -/// -/// print(x.remove(1)); // prints 2 -/// -/// print(x); // prints "[01030405]" -/// -/// print(x.remove(-2)); // prints 4 -/// -/// print(x); // prints "[010305]" -/// ``` -fn remove(blob: Blob, index: int) -> int; - /// Remove all occurrences of a character from the string. /// /// # Example @@ -3960,18 +3960,18 @@ fn remove(blob: Blob, index: int) -> int; /// ``` fn remove(string: String, character: char) -> (); -/// Replace all occurrences of the specified character in the string with another character. +/// Replace all occurrences of the specified sub-string in the string with the specified character. /// /// # Example /// /// ```rhai /// let text = "hello, world! hello, foobar!"; /// -/// text.replace("l", '*'); +/// text.replace("hello", '*'); /// -/// print(text); // prints "he**o, wor*d! he**o, foobar!" +/// print(text); // prints "*, world! *, foobar!" /// ``` -fn replace(string: String, find_character: char, substitute_character: char) -> (); +fn replace(string: String, find_string: String, substitute_character: char) -> (); /// Replace all occurrences of the specified sub-string in the string with another string. /// @@ -3986,18 +3986,18 @@ fn replace(string: String, find_character: char, substitute_character: char) -> /// ``` fn replace(string: String, find_string: String, substitute_string: String) -> (); -/// Replace all occurrences of the specified sub-string in the string with the specified character. +/// Replace all occurrences of the specified character in the string with another character. /// /// # Example /// /// ```rhai /// let text = "hello, world! hello, foobar!"; /// -/// text.replace("hello", '*'); +/// text.replace("l", '*'); /// -/// print(text); // prints "*, world! *, foobar!" +/// print(text); // prints "he**o, wor*d! he**o, foobar!" /// ``` -fn replace(string: String, find_string: String, substitute_character: char) -> (); +fn replace(string: String, find_character: char, substitute_character: char) -> (); /// Replace all occurrences of the specified character in the string with another string. /// @@ -4062,28 +4062,34 @@ fn retain(blob: Blob, start: int, len: int) -> Blob; /// /// print(b2); // prints "[01]" /// ``` -fn retain(blob: Blob, range: InclusiveRange) -> Blob; +fn retain(blob: Blob, range: RangeInclusive) -> Blob; -/// Remove all elements in the array not within an inclusive `range` and return them as a new array. +/// Remove all elements in the array that do not return `true` when applied the `filter` +/// function and return them as a new array. +/// +/// # Function Parameters +/// +/// * `element`: copy of array element +/// * `index` _(optional)_: current index in the array /// /// # Example /// /// ```rhai /// let x = [1, 2, 3, 4, 5]; /// -/// let y = x.retain(1..=3); +/// let y = x.retain(|v| v >= 3); /// -/// print(x); // prints "[2, 3, 4]" +/// print(x); // prints "[3, 4, 5]" /// -/// print(y); // prints "[1, 5]" +/// print(y); // prints "[1, 2]" /// -/// let z = x.retain(1..=2); +/// let z = x.retain(|v, i| v + i <= 5); /// /// print(x); // prints "[3, 4]" /// -/// print(z); // prints "[1]" +/// print(z); // prints "[5]" /// ``` -fn retain(array: Array, range: InclusiveRange) -> Array; +fn retain(array: Array, filter: FnPtr) -> Array; /// Remove all elements in the array that do not return `true` when applied a function named by /// `filter` and return them as a new array. @@ -4118,50 +4124,6 @@ fn retain(array: Array, range: InclusiveRange) -> Array; /// ``` fn retain(array: Array, filter: String) -> Array; -/// Remove all bytes in the BLOB not within an exclusive `range` and return them as a new BLOB. -/// -/// # Example -/// -/// ```rhai -/// let b1 = blob(); -/// -/// b1 += 1; b1 += 2; b1 += 3; b1 += 4; b1 += 5; -/// -/// let b2 = b1.retain(1..4); -/// -/// print(b1); // prints "[020304]" -/// -/// print(b2); // prints "[0105]" -/// -/// let b3 = b1.retain(1..3); -/// -/// print(b1); // prints "[0304]" -/// -/// print(b2); // prints "[01]" -/// ``` -fn retain(blob: Blob, range: ExclusiveRange) -> Blob; - -/// Remove all elements in the array not within an exclusive `range` and return them as a new array. -/// -/// # Example -/// -/// ```rhai -/// let x = [1, 2, 3, 4, 5]; -/// -/// let y = x.retain(1..4); -/// -/// print(x); // prints "[2, 3, 4]" -/// -/// print(y); // prints "[1, 5]" -/// -/// let z = x.retain(1..3); -/// -/// print(x); // prints "[3, 4]" -/// -/// print(z); // prints "[1]" -/// ``` -fn retain(array: Array, range: ExclusiveRange) -> Array; - /// Remove all elements not within a portion of the array and return them as a new array. /// /// * If `start` < 0, position counts from the end of the array (`-1` is the last element). @@ -4189,32 +4151,83 @@ fn retain(array: Array, range: ExclusiveRange) -> Array; /// ``` fn retain(array: Array, start: int, len: int) -> Array; -/// Remove all elements in the array that do not return `true` when applied the `filter` -/// function and return them as a new array. -/// -/// # Function Parameters -/// -/// * `element`: copy of array element -/// * `index` _(optional)_: current index in the array +/// Remove all elements in the array not within an exclusive `range` and return them as a new array. /// /// # Example /// /// ```rhai /// let x = [1, 2, 3, 4, 5]; /// -/// let y = x.retain(|v| v >= 3); +/// let y = x.retain(1..4); /// -/// print(x); // prints "[3, 4, 5]" +/// print(x); // prints "[2, 3, 4]" /// -/// print(y); // prints "[1, 2]" +/// print(y); // prints "[1, 5]" /// -/// let z = x.retain(|v, i| v + i <= 5); +/// let z = x.retain(1..3); /// /// print(x); // prints "[3, 4]" /// -/// print(z); // prints "[5]" +/// print(z); // prints "[1]" /// ``` -fn retain(array: Array, filter: FnPtr) -> Array; +fn retain(array: Array, range: Range) -> Array; + +/// Remove all elements in the array not within an inclusive `range` and return them as a new array. +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 3, 4, 5]; +/// +/// let y = x.retain(1..=3); +/// +/// print(x); // prints "[2, 3, 4]" +/// +/// print(y); // prints "[1, 5]" +/// +/// let z = x.retain(1..=2); +/// +/// print(x); // prints "[3, 4]" +/// +/// print(z); // prints "[1]" +/// ``` +fn retain(array: Array, range: RangeInclusive) -> Array; + +/// Remove all bytes in the BLOB not within an exclusive `range` and return them as a new BLOB. +/// +/// # Example +/// +/// ```rhai +/// let b1 = blob(); +/// +/// b1 += 1; b1 += 2; b1 += 3; b1 += 4; b1 += 5; +/// +/// let b2 = b1.retain(1..4); +/// +/// print(b1); // prints "[020304]" +/// +/// print(b2); // prints "[0105]" +/// +/// let b3 = b1.retain(1..3); +/// +/// print(b1); // prints "[0304]" +/// +/// print(b2); // prints "[01]" +/// ``` +fn retain(blob: Blob, range: Range) -> Blob; + +/// Reverse all the elements in the array. +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 3, 4, 5]; +/// +/// x.reverse(); +/// +/// print(x); // prints "[5, 4, 3, 2, 1]" +/// ``` +fn reverse(array: Array) -> (); /// Reverse the BLOB. /// @@ -4233,68 +4246,9 @@ fn retain(array: Array, filter: FnPtr) -> Array; /// ``` fn reverse(blob: Blob) -> (); -/// Reverse all the elements in the array. -/// -/// # Example -/// -/// ```rhai -/// let x = [1, 2, 3, 4, 5]; -/// -/// x.reverse(); -/// -/// print(x); // prints "[5, 4, 3, 2, 1]" -/// ``` -fn reverse(array: Array) -> (); - /// Return the nearest whole number closest to the floating-point number. /// Rounds away from zero. -fn round(x: float) -> float; - -/// Set the particular `index` position in the BLOB to a new byte `value`. -/// -/// * If `index` < 0, position counts from the end of the BLOB (`-1` is the last byte). -/// * If `index` < -length of BLOB, the BLOB is not modified. -/// * If `index` ≥ length of BLOB, the BLOB is not modified. -/// -/// # Example -/// -/// ```rhai -/// let b = blob(); -/// -/// b += 1; b += 2; b += 3; b += 4; b += 5; -/// -/// b.set(0, 0x42); -/// -/// print(b); // prints "[4202030405]" -/// -/// b.set(-3, 0); -/// -/// print(b); // prints "[4202000405]" -/// -/// b.set(99, 123); -/// -/// print(b); // prints "[4202000405]" -/// ``` -fn set(blob: Blob, index: int, value: int) -> (); - -/// Set the value of the `property` in the object map to a new `value`. -/// -/// If `property` does not exist in the object map, it is added. -/// -/// # Example -/// -/// ```rhai -/// let m = #{a: 1, b: 2, c: 3}; -/// -/// m.set("b", 42)' -/// -/// print(m); // prints "#{a: 1, b: 42, c: 3}" -/// -/// x.set("x", 0); -/// -/// print(m); // prints "#{a: 1, b: 42, c: 3, x: 0}" -/// ``` -fn set(map: Map, property: String, value: ?) -> (); +fn round(x: float) -> f64; /// Set the `index` position in the string to a new `character`. /// @@ -4346,6 +4300,52 @@ fn set(string: String, index: int, character: char) -> (); /// ``` fn set(array: Array, index: int, value: ?) -> (); +/// Set the particular `index` position in the BLOB to a new byte `value`. +/// +/// * If `index` < 0, position counts from the end of the BLOB (`-1` is the last byte). +/// * If `index` < -length of BLOB, the BLOB is not modified. +/// * If `index` ≥ length of BLOB, the BLOB is not modified. +/// +/// # Example +/// +/// ```rhai +/// let b = blob(); +/// +/// b += 1; b += 2; b += 3; b += 4; b += 5; +/// +/// b.set(0, 0x42); +/// +/// print(b); // prints "[4202030405]" +/// +/// b.set(-3, 0); +/// +/// print(b); // prints "[4202000405]" +/// +/// b.set(99, 123); +/// +/// print(b); // prints "[4202000405]" +/// ``` +fn set(blob: Blob, index: int, value: int) -> (); + +/// Set the value of the `property` in the object map to a new `value`. +/// +/// If `property` does not exist in the object map, it is added. +/// +/// # Example +/// +/// ```rhai +/// let m = #{a: 1, b: 2, c: 3}; +/// +/// m.set("b", 42)' +/// +/// print(m); // prints "#{a: 1, b: 42, c: 3}" +/// +/// x.set("x", 0); +/// +/// print(m); // prints "#{a: 1, b: 42, c: 3, x: 0}" +/// ``` +fn set(map: Map, property: String, value: ?) -> (); + /// Set the _tag_ of a `Dynamic` value. /// /// # Example @@ -4383,19 +4383,6 @@ fn set tag(value: ?, tag: int) -> (); /// ``` fn set_bit(value: int, bit: int, new_value: bool) -> (); -/// Replace an exclusive range of bits in the number with a new value. -/// -/// # Example -/// -/// ```rhai -/// let x = 123456; -/// -/// x.set_bits(5..10, 42); -/// -/// print(x); // print 123200 -/// ``` -fn set_bits(value: int, range: ExclusiveRange, new_value: int) -> (); - /// Replace an inclusive range of bits in the number with a new value. /// /// # Example @@ -4407,7 +4394,20 @@ fn set_bits(value: int, range: ExclusiveRange, new_value: int) -> (); /// /// print(x); // print 123200 /// ``` -fn set_bits(value: int, range: InclusiveRange, new_value: int) -> (); +fn set_bits(value: int, range: RangeInclusive, new_value: int) -> (); + +/// Replace an exclusive range of bits in the number with a new value. +/// +/// # Example +/// +/// ```rhai +/// let x = 123456; +/// +/// x.set_bits(5..10, 42); +/// +/// print(x); // print 123200 +/// ``` +fn set_bits(value: int, range: Range, new_value: int) -> (); /// Replace a portion of bits in the number with a new value. /// @@ -4443,23 +4443,6 @@ fn set_bits(value: int, bit: int, bits: int, new_value: int) -> (); /// ``` fn set_tag(value: ?, tag: int) -> (); -/// Remove the first byte from the BLOB and return it. -/// -/// If the BLOB is empty, zero is returned. -/// -/// # Example -/// -/// ```rhai -/// let b = blob(); -/// -/// b += 1; b += 2; b += 3; b += 4; b += 5; -/// -/// print(b.shift()); // prints 1 -/// -/// print(b); // prints "[02030405]" -/// ``` -fn shift(blob: Blob) -> int; - /// Remove the first element from the array and return it. /// /// If the array is empty, `()` is returned. @@ -4475,33 +4458,50 @@ fn shift(blob: Blob) -> int; /// ``` fn shift(array: Array) -> ?; -/// Return the sign (as an integer) of the number according to the following: +/// Remove the first byte from the BLOB and return it. /// -/// * `0` if the number is zero -/// * `1` if the number is positive -/// * `-1` if the number is negative -fn sign(x: i8) -> int; +/// If the BLOB is empty, zero is returned. +/// +/// # Example +/// +/// ```rhai +/// let b = blob(); +/// +/// b += 1; b += 2; b += 3; b += 4; b += 5; +/// +/// print(b.shift()); // prints 1 +/// +/// print(b); // prints "[02030405]" +/// ``` +fn shift(blob: Blob) -> i64; /// Return the sign (as an integer) of the number according to the following: /// /// * `0` if the number is zero /// * `1` if the number is positive /// * `-1` if the number is negative -fn sign(x: i16) -> int; +fn sign(x: i128) -> i64; /// Return the sign (as an integer) of the number according to the following: /// /// * `0` if the number is zero /// * `1` if the number is positive /// * `-1` if the number is negative -fn sign(x: i128) -> int; +fn sign(x: i8) -> i64; /// Return the sign (as an integer) of the number according to the following: /// /// * `0` if the number is zero /// * `1` if the number is positive /// * `-1` if the number is negative -fn sign(x: i32) -> int; +fn sign(x: int) -> i64; + +/// Return the sign (as an integer) of the number according to the following: +/// +/// * `0` if the number is zero +/// * `1` if the number is positive +/// * `-1` if the number is negative +fn sign(x: i32) -> i64; /// Return the sign (as an integer) of the floating-point number according to the following: /// @@ -4510,13 +4510,6 @@ fn sign(x: i32) -> int; /// * `-1` if the number is negative fn sign(x: f32) -> int; -/// Return the sign (as an integer) of the number according to the following: -/// -/// * `0` if the number is zero -/// * `1` if the number is positive -/// * `-1` if the number is negative -fn sign(x: int) -> int; - /// Return the sign (as an integer) of the floating-point number according to the following: /// /// * `0` if the number is zero @@ -4524,18 +4517,45 @@ fn sign(x: int) -> int; /// * `-1` if the number is negative fn sign(x: f64) -> int; +/// Return the sign (as an integer) of the number according to the following: +/// +/// * `0` if the number is zero +/// * `1` if the number is positive +/// * `-1` if the number is negative +fn sign(x: i16) -> i64; + /// Return the sine of the floating-point number in radians. -fn sin(x: float) -> float; +fn sin(x: float) -> f64; /// Return the hyperbolic sine of the floating-point number in radians. -fn sinh(x: float) -> float; - -/// Block the current thread for a particular number of `seconds`. -fn sleep(seconds: ?) -> (); +fn sinh(x: float) -> f64; /// Block the current thread for a particular number of `seconds`. fn sleep(seconds: int) -> (); +/// Block the current thread for a particular number of `seconds`. +fn sleep(seconds: float) -> (); + +/// Return `true` if any element in the array that returns `true` when applied the `filter` function. +/// +/// # Function Parameters +/// +/// * `element`: copy of array element +/// * `index` _(optional)_: current index in the array +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 5]; +/// +/// print(x.some(|v| v > 3)); // prints true +/// +/// print(x.some(|v| v > 10)); // prints false +/// +/// print(x.some(|v, i| i > v)); // prints true +/// ``` +fn some(array: Array, filter: FnPtr) -> bool; + /// Return `true` if any element in the array that returns `true` when applied a function named /// by `filter`. /// @@ -4565,25 +4585,30 @@ fn sleep(seconds: int) -> (); /// ``` fn some(array: Array, filter: String) -> bool; -/// Return `true` if any element in the array that returns `true` when applied the `filter` function. +/// Sort the array based on applying the `comparer` function. /// /// # Function Parameters /// -/// * `element`: copy of array element -/// * `index` _(optional)_: current index in the array +/// * `element1`: copy of the current array element to compare +/// * `element2`: copy of the next array element to compare +/// +/// ## Return Value +/// +/// * Any integer > 0 if `element1 > element2` +/// * Zero if `element1 == element2` +/// * Any integer < 0 if `element1 < element2` /// /// # Example /// /// ```rhai -/// let x = [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 5]; +/// let x = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]; /// -/// print(x.some(|v| v > 3)); // prints true +/// // Do comparisons in reverse +/// x.sort(|a, b| if a > b { -1 } else if a < b { 1 } else { 0 }); /// -/// print(x.some(|v| v > 10)); // prints false -/// -/// print(x.some(|v, i| i > v)); // prints true +/// print(x); // prints "[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]" /// ``` -fn some(array: Array, filter: FnPtr) -> bool; +fn sort(array: Array, comparer: FnPtr) -> (); /// Sort the array based on applying a function named by `comparer`. /// @@ -4620,31 +4645,6 @@ fn some(array: Array, filter: FnPtr) -> bool; /// ``` fn sort(array: Array, comparer: String) -> (); -/// Sort the array based on applying the `comparer` function. -/// -/// # Function Parameters -/// -/// * `element1`: copy of the current array element to compare -/// * `element2`: copy of the next array element to compare -/// -/// ## Return Value -/// -/// * Any integer > 0 if `element1 > element2` -/// * Zero if `element1 == element2` -/// * Any integer < 0 if `element1 < element2` -/// -/// # Example -/// -/// ```rhai -/// let x = [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]; -/// -/// // Do comparisons in reverse -/// x.sort(|a, b| if a > b { -1 } else if a < b { 1 } else { 0 }); -/// -/// print(x); // prints "[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]" -/// ``` -fn sort(array: Array, comparer: FnPtr) -> (); - /// Sort the array. /// /// All elements in the array must be of the same data type. @@ -4670,34 +4670,6 @@ fn sort(array: Array, comparer: FnPtr) -> (); /// ``` fn sort(array: Array) -> (); -/// Replace an exclusive `range` of the BLOB with another BLOB. -/// -/// # Example -/// -/// ```rhai -/// let b1 = blob(10, 0x42); -/// let b2 = blob(5, 0x18); -/// -/// b1.splice(1..4, b2); -/// -/// print(b1); // prints "[4218181818184242 42424242]" -/// ``` -fn splice(blob: Blob, range: ExclusiveRange, replace: Blob) -> (); - -/// Replace an inclusive `range` of the BLOB with another BLOB. -/// -/// # Example -/// -/// ```rhai -/// let b1 = blob(10, 0x42); -/// let b2 = blob(5, 0x18); -/// -/// b1.splice(1..=4, b2); -/// -/// print(b1); // prints "[4218181818184242 424242]" -/// ``` -fn splice(blob: Blob, range: InclusiveRange, replace: Blob) -> (); - /// Replace an exclusive range of the array with another array. /// /// # Example @@ -4710,7 +4682,7 @@ fn splice(blob: Blob, range: InclusiveRange, replace: Blob) -> (); /// /// print(x); // prints "[1, 7, 8, 9, 10, 4, 5]" /// ``` -fn splice(array: Array, range: ExclusiveRange, replace: Array) -> (); +fn splice(array: Array, range: Range, replace: Array) -> (); /// Replace a portion of the array with another array. /// @@ -4736,19 +4708,33 @@ fn splice(array: Array, range: ExclusiveRange, replace: Array) -> (); /// ``` fn splice(array: Array, start: int, len: int, replace: Array) -> (); -/// Replace an inclusive range of the array with another array. +/// Replace an exclusive `range` of the BLOB with another BLOB. /// /// # Example /// /// ```rhai -/// let x = [1, 2, 3, 4, 5]; -/// let y = [7, 8, 9, 10]; +/// let b1 = blob(10, 0x42); +/// let b2 = blob(5, 0x18); /// -/// x.splice(1..=3, y); +/// b1.splice(1..4, b2); /// -/// print(x); // prints "[1, 7, 8, 9, 10, 5]" +/// print(b1); // prints "[4218181818184242 42424242]" /// ``` -fn splice(array: Array, range: InclusiveRange, replace: Array) -> (); +fn splice(blob: Blob, range: Range, replace: Blob) -> (); + +/// Replace an inclusive `range` of the BLOB with another BLOB. +/// +/// # Example +/// +/// ```rhai +/// let b1 = blob(10, 0x42); +/// let b2 = blob(5, 0x18); +/// +/// b1.splice(1..=4, b2); +/// +/// print(b1); // prints "[4218181818184242 424242]" +/// ``` +fn splice(blob: Blob, range: RangeInclusive, replace: Blob) -> (); /// Replace a portion of the BLOB with another BLOB. /// @@ -4774,6 +4760,45 @@ fn splice(array: Array, range: InclusiveRange, replace: Array) -> (); /// ``` fn splice(blob: Blob, start: int, len: int, replace: Blob) -> (); +/// Replace an inclusive range of the array with another array. +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 3, 4, 5]; +/// let y = [7, 8, 9, 10]; +/// +/// x.splice(1..=3, y); +/// +/// print(x); // prints "[1, 7, 8, 9, 10, 5]" +/// ``` +fn splice(array: Array, range: RangeInclusive, replace: Array) -> (); + +/// Split the string into at most the specified number of `segments` based on a `delimiter` string, +/// returning an array of the segments. +/// +/// If `segments` < 1, only one segment is returned. +/// +/// # Example +/// +/// ```rhai +/// let text = "hello, world! hello, foo!"; +/// +/// print(text.split("ll", 2)); // prints ["he", "o, world! hello, foo!"] +/// ``` +fn split(string: String, delimiter: String, segments: int) -> Array; + +/// Split the string into segments based on a `delimiter` string, returning an array of the segments. +/// +/// # Example +/// +/// ```rhai +/// let text = "hello, world! hello, foo!"; +/// +/// print(text.split("ll")); // prints ["he", "o, world! he", "o, foo!"] +/// ``` +fn split(string: String, delimiter: String) -> Array; + /// Cut off the BLOB at `index` and return it as a new BLOB. /// /// * If `index` < 0, position counts from the end of the BLOB (`-1` is the last byte). @@ -4796,16 +4821,40 @@ fn splice(blob: Blob, start: int, len: int, replace: Blob) -> (); /// ``` fn split(blob: Blob, index: int) -> Blob; -/// Split the string into segments based on a `delimiter` string, returning an array of the segments. +/// Split the string into two at the specified `index` position and return it both strings +/// as an array. +/// +/// The character at the `index` position (if any) is returned in the _second_ string. +/// +/// * If `index` < 0, position counts from the end of the string (`-1` is the last character). +/// * If `index` < -length of string, it is equivalent to cutting at position 0. +/// * If `index` ≥ length of string, it is equivalent to cutting at the end of the string. +/// +/// # Example +/// +/// ```rhai +/// let text = "hello, world!"; +/// +/// print(text.split(6)); // prints ["hello,", " world!"] +/// +/// print(text.split(13)); // prints ["hello, world!", ""] +/// +/// print(text.split(-6)); // prints ["hello, ", "world!"] +/// +/// print(text.split(-99)); // prints ["", "hello, world!"] +/// ``` +fn split(string: String, index: int) -> Array; + +/// Split the string into segments based on a `delimiter` character, returning an array of the segments. /// /// # Example /// /// ```rhai /// let text = "hello, world! hello, foo!"; /// -/// print(text.split("ll")); // prints ["he", "o, world! he", "o, foo!"] +/// print(text.split('l')); // prints ["he", "", "o, wor", "d! he", "", "o, foo!"] /// ``` -fn split(string: String, delimiter: String) -> Array; +fn split(string: String, delimiter: char) -> Array; /// Cut off the array at `index` and return it as a new array. /// @@ -4838,44 +4887,6 @@ fn split(array: Array, index: int) -> Array; /// ``` fn split(string: String) -> Array; -/// Split the string into two at the specified `index` position and return it both strings -/// as an array. -/// -/// The character at the `index` position (if any) is returned in the _second_ string. -/// -/// * If `index` < 0, position counts from the end of the string (`-1` is the last character). -/// * If `index` < -length of string, it is equivalent to cutting at position 0. -/// * If `index` ≥ length of string, it is equivalent to cutting at the end of the string. -/// -/// # Example -/// -/// ```rhai -/// let text = "hello, world!"; -/// -/// print(text.split(6)); // prints ["hello,", " world!"] -/// -/// print(text.split(13)); // prints ["hello, world!", ""] -/// -/// print(text.split(-6)); // prints ["hello, ", "world!"] -/// -/// print(text.split(-99)); // prints ["", "hello, world!"] -/// ``` -fn split(string: String, index: int) -> Array; - -/// Split the string into at most the specified number of `segments` based on a `delimiter` string, -/// returning an array of the segments. -/// -/// If `segments` < 1, only one segment is returned. -/// -/// # Example -/// -/// ```rhai -/// let text = "hello, world! hello, foo!"; -/// -/// print(text.split("ll", 2)); // prints ["he", "o, world! hello, foo!"] -/// ``` -fn split(string: String, delimiter: String, segments: int) -> Array; - /// Split the string into at most the specified number of `segments` based on a `delimiter` character, /// returning an array of the segments. /// @@ -4890,28 +4901,17 @@ fn split(string: String, delimiter: String, segments: int) -> Array; /// ``` fn split(string: String, delimiter: char, segments: int) -> Array; -/// Split the string into segments based on a `delimiter` character, returning an array of the segments. +/// Split the string into segments based on a `delimiter` string, returning an array of the +/// segments in _reverse_ order. /// /// # Example /// /// ```rhai /// let text = "hello, world! hello, foo!"; /// -/// print(text.split('l')); // prints ["he", "", "o, wor", "d! he", "", "o, foo!"] +/// print(text.split_rev("ll")); // prints ["o, foo!", "o, world! he", "he"] /// ``` -fn split(string: String, delimiter: char) -> Array; - -/// Split the string into segments based on a `delimiter` character, returning an array of -/// the segments in _reverse_ order. -/// -/// # Example -/// -/// ```rhai -/// let text = "hello, world! hello, foo!"; -/// -/// print(text.split_rev('l')); // prints ["o, foo!", "", "d! he", "o, wor", "", "he"] -/// ``` -fn split_rev(string: String, delimiter: char) -> Array; +fn split_rev(string: String, delimiter: String) -> Array; /// Split the string into at most a specified number of `segments` based on a `delimiter` string, /// returning an array of the segments in _reverse_ order. @@ -4927,6 +4927,18 @@ fn split_rev(string: String, delimiter: char) -> Array; /// ``` fn split_rev(string: String, delimiter: String, segments: int) -> Array; +/// Split the string into segments based on a `delimiter` character, returning an array of +/// the segments in _reverse_ order. +/// +/// # Example +/// +/// ```rhai +/// let text = "hello, world! hello, foo!"; +/// +/// print(text.split_rev('l')); // prints ["o, foo!", "", "d! he", "o, wor", "", "he"] +/// ``` +fn split_rev(string: String, delimiter: char) -> Array; + /// Split the string into at most the specified number of `segments` based on a `delimiter` character, /// returning an array of the segments. /// @@ -4941,26 +4953,14 @@ fn split_rev(string: String, delimiter: String, segments: int) -> Array; /// ``` fn split_rev(string: String, delimiter: char, segments: int) -> Array; -/// Split the string into segments based on a `delimiter` string, returning an array of the -/// segments in _reverse_ order. -/// -/// # Example -/// -/// ```rhai -/// let text = "hello, world! hello, foo!"; -/// -/// print(text.split_rev("ll")); // prints ["o, foo!", "o, world! he", "he"] -/// ``` -fn split_rev(string: String, delimiter: String) -> Array; - /// Return the square root of the floating-point number. -fn sqrt(x: float) -> float; - -/// Return the start of the exclusive range. -fn start(range: ExclusiveRange) -> int; +fn sqrt(x: float) -> f64; /// Return the start of the inclusive range. -fn start(range: InclusiveRange) -> int; +fn start(range: InclusiveRange) -> i64; + +/// Return the start of the exclusive range. +fn start(range: ExclusiveRange) -> i64; /// Return `true` if the string starts with a specified string. /// @@ -4975,24 +4975,6 @@ fn start(range: InclusiveRange) -> int; /// ``` fn starts_with(string: String, match_string: String) -> bool; -/// Copy a portion of the string beginning at the `start` position till the end and return it as -/// a new string. -/// -/// * If `start` < 0, position counts from the end of the string (`-1` is the last character). -/// * If `start` < -length of string, the entire string is copied and returned. -/// * If `start` ≥ length of string, an empty string is returned. -/// -/// # Example -/// -/// ```rhai -/// let text = "hello, world!"; -/// -/// print(text.sub_string(5)); // prints ", world!" -/// -/// print(text.sub_string(-5)); // prints "orld!" -/// ``` -fn sub_string(string: String, start: int) -> String; - /// Copy an exclusive range of characters from the string and return it as a new string. /// /// # Example @@ -5002,7 +4984,7 @@ fn sub_string(string: String, start: int) -> String; /// /// print(text.sub_string(3..7)); // prints "lo, " /// ``` -fn sub_string(string: String, range: ExclusiveRange) -> String; +fn sub_string(string: String, range: Range) -> String; /// Copy a portion of the string and return it as a new string. /// @@ -5023,6 +5005,24 @@ fn sub_string(string: String, range: ExclusiveRange) -> String; /// ``` fn sub_string(string: String, start: int, len: int) -> String; +/// Copy a portion of the string beginning at the `start` position till the end and return it as +/// a new string. +/// +/// * If `start` < 0, position counts from the end of the string (`-1` is the last character). +/// * If `start` < -length of string, the entire string is copied and returned. +/// * If `start` ≥ length of string, an empty string is returned. +/// +/// # Example +/// +/// ```rhai +/// let text = "hello, world!"; +/// +/// print(text.sub_string(5)); // prints ", world!" +/// +/// print(text.sub_string(-5)); // prints "orld!" +/// ``` +fn sub_string(string: String, start: int) -> String; + /// Copy an inclusive range of characters from the string and return it as a new string. /// /// # Example @@ -5032,7 +5032,7 @@ fn sub_string(string: String, start: int, len: int) -> String; /// /// print(text.sub_string(3..=7)); // prints "lo, w" /// ``` -fn sub_string(string: String, range: InclusiveRange) -> String; +fn sub_string(string: String, range: RangeInclusive) -> String; /// Return the _tag_ of a `Dynamic` value. /// @@ -5045,13 +5045,13 @@ fn sub_string(string: String, range: InclusiveRange) -> String; /// /// print(x.tag); // prints 42 /// ``` -fn tag(value: ?) -> int; +fn tag(value: ?) -> i64; /// Return the tangent of the floating-point number in radians. -fn tan(x: float) -> float; +fn tan(x: float) -> f64; /// Return the hyperbolic tangent of the floating-point number in radians. -fn tanh(x: float) -> float; +fn tanh(x: float) -> f64; /// Create a timestamp containing the current system time. fn timestamp() -> Instant; @@ -5070,34 +5070,34 @@ fn timestamp() -> Instant; fn to_array(blob: Blob) -> Array; /// Convert the `value` into a string in binary format. -fn to_binary(value: u8) -> String; +fn to_binary(value: i16) -> String; + +/// Convert the `value` into a string in binary format. +fn to_binary(value: u16) -> String; /// Convert the `value` into a string in binary format. fn to_binary(value: u128) -> String; /// Convert the `value` into a string in binary format. -fn to_binary(value: i64) -> String; +fn to_binary(value: i128) -> String; /// Convert the `value` into a string in binary format. -fn to_binary(value: i32) -> String; +fn to_binary(value: i64) -> String; /// Convert the `value` into a string in binary format. fn to_binary(value: u64) -> String; /// Convert the `value` into a string in binary format. -fn to_binary(value: u32) -> String; +fn to_binary(value: i32) -> String; /// Convert the `value` into a string in binary format. -fn to_binary(value: i128) -> String; - -/// Convert the `value` into a string in binary format. -fn to_binary(value: i16) -> String; +fn to_binary(value: u8) -> String; /// Convert the `value` into a string in binary format. fn to_binary(value: i8) -> String; /// Convert the `value` into a string in binary format. -fn to_binary(value: u16) -> String; +fn to_binary(value: u32) -> String; /// Convert the string into an UTF-8 encoded byte-stream as a BLOB. /// @@ -5124,13 +5124,16 @@ fn to_blob(string: String) -> Blob; fn to_chars(string: String) -> Array; /// Convert the value of `number` into a string. -fn to_debug(number: f32) -> String; +fn to_debug(number: f64) -> String; /// Convert the object map into a string. fn to_debug(map: Map) -> String; /// Convert the value of `number` into a string. -fn to_debug(number: f64) -> String; +fn to_debug(number: f32) -> String; + +/// Convert the function pointer into a string in debug format. +fn to_debug(f: FnPtr) -> String; /// Convert the string into debug format. fn to_debug(string: String) -> String; @@ -5138,102 +5141,99 @@ fn to_debug(string: String) -> String; /// Convert the string into debug format. fn to_debug(character: char) -> String; -/// Convert the unit into a string in debug format. -fn to_debug(unit: ()) -> String; - /// Convert the boolean value into a string in debug format. fn to_debug(value: bool) -> String; -/// Convert the array into a string. -fn to_debug(array: Array) -> String; - -/// Convert the function pointer into a string in debug format. -fn to_debug(f: FnPtr) -> String; - /// Convert the value of the `item` into a string in debug format. fn to_debug(item: ?) -> String; +/// Convert the array into a string. +fn to_debug(array: Array) -> String; + +/// Convert the unit into a string in debug format. +fn to_debug(unit: ()) -> String; + /// Convert radians to degrees. -fn to_degrees(x: float) -> float; +fn to_degrees(x: float) -> f64; -fn to_float(x: u8) -> float; - -fn to_float(x: u128) -> float; - -fn to_float(x: i64) -> float; +fn to_float(x: i16) -> f64; /// Convert the 32-bit floating-point number to 64-bit. fn to_float(x: f32) -> f64; -fn to_float(x: i32) -> float; +fn to_float(x: u128) -> f64; -fn to_float(x: u32) -> float; +fn to_float(x: u16) -> f64; -fn to_float(x: i128) -> float; +fn to_float(x: i128) -> f64; -fn to_float(x: i16) -> float; +fn to_float(x: i32) -> f64; -fn to_float(x: i8) -> float; +fn to_float(x: i64) -> f64; -fn to_float(x: u16) -> float; +fn to_float(x: u8) -> f64; -/// Convert the `value` into a string in hex format. -fn to_hex(value: i32) -> String; +fn to_float(x: i8) -> f64; -/// Convert the `value` into a string in hex format. -fn to_hex(value: u64) -> String; - -/// Convert the `value` into a string in hex format. -fn to_hex(value: i64) -> String; - -/// Convert the `value` into a string in hex format. -fn to_hex(value: u8) -> String; - -/// Convert the `value` into a string in hex format. -fn to_hex(value: u128) -> String; - -/// Convert the `value` into a string in hex format. -fn to_hex(value: i8) -> String; - -/// Convert the `value` into a string in hex format. -fn to_hex(value: u16) -> String; +fn to_float(x: u32) -> f64; /// Convert the `value` into a string in hex format. fn to_hex(value: i16) -> String; +/// Convert the `value` into a string in hex format. +fn to_hex(value: u16) -> String; + +/// Convert the `value` into a string in hex format. +fn to_hex(value: u128) -> String; + /// Convert the `value` into a string in hex format. fn to_hex(value: i128) -> String; +/// Convert the `value` into a string in hex format. +fn to_hex(value: i64) -> String; + +/// Convert the `value` into a string in hex format. +fn to_hex(value: u64) -> String; + +/// Convert the `value` into a string in hex format. +fn to_hex(value: i32) -> String; + +/// Convert the `value` into a string in hex format. +fn to_hex(value: u8) -> String; + +/// Convert the `value` into a string in hex format. +fn to_hex(value: i8) -> String; + /// Convert the `value` into a string in hex format. fn to_hex(value: u32) -> String; -fn to_int(x: i128) -> int; - -fn to_int(x: u32) -> int; - -fn to_int(x: i8) -> int; - -fn to_int(x: char) -> int; - -fn to_int(x: u16) -> int; - -fn to_int(x: i16) -> int; - -/// Convert the floating-point number into an integer. -fn to_int(x: f64) -> int; - -fn to_int(x: i64) -> int; - -fn to_int(x: u8) -> int; - -fn to_int(x: u128) -> int; - -fn to_int(x: i32) -> int; +fn to_int(x: char) -> i64; /// Convert the floating-point number into an integer. fn to_int(x: f32) -> int; -fn to_int(x: u64) -> int; +fn to_int(x: i16) -> i64; + +/// Convert the floating-point number into an integer. +fn to_int(x: f64) -> int; + +fn to_int(x: u128) -> i64; + +fn to_int(x: u16) -> i64; + +fn to_int(x: i128) -> i64; + +fn to_int(x: i8) -> i64; + +fn to_int(x: u32) -> i64; + +fn to_int(x: i32) -> i64; + +fn to_int(x: u64) -> i64; + +fn to_int(x: i64) -> i64; + +fn to_int(x: u8) -> i64; /// Return the JSON representation of the object map. /// @@ -5256,19 +5256,6 @@ fn to_int(x: u64) -> int; /// ``` fn to_json(map: Map) -> String; -/// Convert the character to lower-case and return it as a new character. -/// -/// # Example -/// -/// ```rhai -/// let ch = 'A'; -/// -/// print(ch.to_lower()); // prints 'a' -/// -/// print(ch); // prints 'A' -/// ``` -fn to_lower(character: char) -> char; - /// Convert the string to all lower-case and return it as a new string. /// /// # Example @@ -5282,8 +5269,18 @@ fn to_lower(character: char) -> char; /// ``` fn to_lower(string: String) -> String; -/// Convert the `value` into a string in octal format. -fn to_octal(value: i128) -> String; +/// Convert the character to lower-case and return it as a new character. +/// +/// # Example +/// +/// ```rhai +/// let ch = 'A'; +/// +/// print(ch.to_lower()); // prints 'a' +/// +/// print(ch); // prints 'A' +/// ``` +fn to_lower(character: char) -> char; /// Convert the `value` into a string in octal format. fn to_octal(value: u32) -> String; @@ -5291,47 +5288,32 @@ fn to_octal(value: u32) -> String; /// Convert the `value` into a string in octal format. fn to_octal(value: i8) -> String; -/// Convert the `value` into a string in octal format. -fn to_octal(value: u16) -> String; - -/// Convert the `value` into a string in octal format. -fn to_octal(value: i16) -> String; - -/// Convert the `value` into a string in octal format. -fn to_octal(value: i64) -> String; - /// Convert the `value` into a string in octal format. fn to_octal(value: u8) -> String; /// Convert the `value` into a string in octal format. -fn to_octal(value: u128) -> String; +fn to_octal(value: u64) -> String; /// Convert the `value` into a string in octal format. fn to_octal(value: i32) -> String; /// Convert the `value` into a string in octal format. -fn to_octal(value: u64) -> String; +fn to_octal(value: i64) -> String; + +/// Convert the `value` into a string in octal format. +fn to_octal(value: i128) -> String; + +/// Convert the `value` into a string in octal format. +fn to_octal(value: u128) -> String; + +/// Convert the `value` into a string in octal format. +fn to_octal(value: u16) -> String; + +/// Convert the `value` into a string in octal format. +fn to_octal(value: i16) -> String; /// Convert degrees to radians. -fn to_radians(x: float) -> float; - -/// Return the `string`. -fn to_string(string: String) -> String; - -/// Convert the value of `number` into a string. -fn to_string(number: f64) -> String; - -/// Convert the object map into a string. -fn to_string(map: Map) -> String; - -/// Convert the value of `number` into a string. -fn to_string(number: f32) -> String; - -/// Convert the value of the `item` into a string. -fn to_string(item: ?) -> String; - -/// Return the boolean value into a string. -fn to_string(value: bool) -> String; +fn to_radians(x: float) -> f64; /// Convert the array into a string. fn to_string(array: Array) -> String; @@ -5342,18 +5324,23 @@ fn to_string(unit: ()) -> String; /// Return the character into a string. fn to_string(character: char) -> String; -/// Convert the string to all upper-case and return it as a new string. -/// -/// # Example -/// -/// ```rhai -/// let text = "hello, world!" -/// -/// print(text.to_upper()); // prints "HELLO, WORLD!" -/// -/// print(text); // prints "hello, world!" -/// ``` -fn to_upper(string: String) -> String; +/// Return the `string`. +fn to_string(string: String) -> String; + +/// Convert the value of `number` into a string. +fn to_string(number: f32) -> String; + +/// Convert the object map into a string. +fn to_string(map: Map) -> String; + +/// Convert the value of `number` into a string. +fn to_string(number: f64) -> String; + +/// Return the boolean value into a string. +fn to_string(value: bool) -> String; + +/// Convert the value of the `item` into a string. +fn to_string(item: ?) -> String; /// Convert the character to upper-case and return it as a new character. /// @@ -5368,6 +5355,19 @@ fn to_upper(string: String) -> String; /// ``` fn to_upper(character: char) -> char; +/// Convert the string to all upper-case and return it as a new string. +/// +/// # Example +/// +/// ```rhai +/// let text = "hello, world!" +/// +/// print(text.to_upper()); // prints "HELLO, WORLD!" +/// +/// print(text); // prints "hello, world!" +/// ``` +fn to_upper(string: String) -> String; + /// Remove whitespace characters from both ends of the string. /// /// # Example @@ -5401,26 +5401,6 @@ fn trim(string: String) -> (); /// ``` fn truncate(string: String, len: int) -> (); -/// Cut off the array at the specified length. -/// -/// * If `len` ≤ 0, the array is cleared. -/// * If `len` ≥ length of array, the array is not truncated. -/// -/// # Example -/// -/// ```rhai -/// let x = [1, 2, 3, 4, 5]; -/// -/// x.truncate(3); -/// -/// print(x); // prints "[1, 2, 3]" -/// -/// x.truncate(10); -/// -/// print(x); // prints "[1, 2, 3]" -/// ``` -fn truncate(array: Array, len: int) -> (); - /// Cut off the BLOB at the specified length. /// /// * If `len` ≤ 0, the BLOB is cleared. @@ -5443,6 +5423,26 @@ fn truncate(array: Array, len: int) -> (); /// ``` fn truncate(blob: Blob, len: int) -> (); +/// Cut off the array at the specified length. +/// +/// * If `len` ≤ 0, the array is cleared. +/// * If `len` ≥ length of array, the array is not truncated. +/// +/// # Example +/// +/// ```rhai +/// let x = [1, 2, 3, 4, 5]; +/// +/// x.truncate(3); +/// +/// print(x); // prints "[1, 2, 3]" +/// +/// x.truncate(10); +/// +/// print(x); // prints "[1, 2, 3]" +/// ``` +fn truncate(array: Array, len: int) -> (); + /// Return an array with all the property values in the object map. /// /// # Example @@ -5469,24 +5469,7 @@ fn values(map: Map) -> Array; /// /// print(b); // prints "[0068656c6c6f0000]" /// ``` -fn write_ascii(blob: Blob, range: InclusiveRange, string: String) -> (); - -/// Write an ASCII string to the bytes within an exclusive `range` in the BLOB. -/// -/// Each ASCII character encodes to one single byte in the BLOB. -/// Non-ASCII characters are ignored. -/// -/// * If number of bytes in `range` < length of `string`, extra bytes in `string` are not written. -/// * If number of bytes in `range` > length of `string`, extra bytes in `range` are not modified. -/// -/// ```rhai -/// let b = blob(8); -/// -/// b.write_ascii(1..5, "hello, world!"); -/// -/// print(b); // prints "[0068656c6c000000]" -/// ``` -fn write_ascii(blob: Blob, range: ExclusiveRange, string: String) -> (); +fn write_ascii(blob: Blob, range: RangeInclusive, string: String) -> (); /// Write an ASCII string to the bytes within an exclusive `range` in the BLOB. /// @@ -5508,34 +5491,22 @@ fn write_ascii(blob: Blob, range: ExclusiveRange, string: String) -> (); /// ``` fn write_ascii(blob: Blob, start: int, len: int, string: String) -> (); -/// Write an `INT` value to the bytes within an inclusive `range` in the BLOB -/// in big-endian byte order. +/// Write an ASCII string to the bytes within an exclusive `range` in the BLOB. /// -/// * If number of bytes in `range` < number of bytes for `INT`, extra bytes in `INT` are not written. -/// * If number of bytes in `range` > number of bytes for `INT`, extra bytes in `range` are not modified. +/// Each ASCII character encodes to one single byte in the BLOB. +/// Non-ASCII characters are ignored. +/// +/// * If number of bytes in `range` < length of `string`, extra bytes in `string` are not written. +/// * If number of bytes in `range` > length of `string`, extra bytes in `range` are not modified. /// /// ```rhai -/// let b = blob(8, 0x42); +/// let b = blob(8); /// -/// b.write_be_int(1..=3, 0x99); +/// b.write_ascii(1..5, "hello, world!"); /// -/// print(b); // prints "[4200000042424242]" +/// print(b); // prints "[0068656c6c000000]" /// ``` -fn write_be(blob: Blob, range: InclusiveRange, value: int) -> (); - -/// Write a `FLOAT` value to the bytes within an exclusive `range` in the BLOB -/// in big-endian byte order. -/// -/// * If number of bytes in `range` < number of bytes for `FLOAT`, extra bytes in `FLOAT` are not written. -/// * If number of bytes in `range` > number of bytes for `FLOAT`, extra bytes in `range` are not modified. -fn write_be(blob: Blob, range: ExclusiveRange, value: float) -> (); - -/// Write a `FLOAT` value to the bytes within an inclusive `range` in the BLOB -/// in big-endian byte order. -/// -/// * If number of bytes in `range` < number of bytes for `FLOAT`, extra bytes in `FLOAT` are not written. -/// * If number of bytes in `range` > number of bytes for `FLOAT`, extra bytes in `range` are not modified. -fn write_be(blob: Blob, range: InclusiveRange, value: float) -> (); +fn write_ascii(blob: Blob, range: Range, string: String) -> (); /// Write an `INT` value to the bytes within an exclusive `range` in the BLOB /// in big-endian byte order. @@ -5550,7 +5521,29 @@ fn write_be(blob: Blob, range: InclusiveRange, value: float) -> (); /// /// print(b); // prints "[4200004242424242]" /// ``` -fn write_be(blob: Blob, range: ExclusiveRange, value: int) -> (); +fn write_be(blob: Blob, range: Range, value: int) -> (); + +/// Write an `INT` value to the bytes within an inclusive `range` in the BLOB +/// in big-endian byte order. +/// +/// * If number of bytes in `range` < number of bytes for `INT`, extra bytes in `INT` are not written. +/// * If number of bytes in `range` > number of bytes for `INT`, extra bytes in `range` are not modified. +/// +/// ```rhai +/// let b = blob(8, 0x42); +/// +/// b.write_be_int(1..=3, 0x99); +/// +/// print(b); // prints "[4200000042424242]" +/// ``` +fn write_be(blob: Blob, range: RangeInclusive, value: int) -> (); + +/// Write a `FLOAT` value to the bytes within an inclusive `range` in the BLOB +/// in big-endian byte order. +/// +/// * If number of bytes in `range` < number of bytes for `FLOAT`, extra bytes in `FLOAT` are not written. +/// * If number of bytes in `range` > number of bytes for `FLOAT`, extra bytes in `range` are not modified. +fn write_be(blob: Blob, range: RangeInclusive, value: float) -> (); /// Write an `INT` value to the bytes beginning at the `start` position in the BLOB /// in big-endian byte order. @@ -5573,6 +5566,13 @@ fn write_be(blob: Blob, range: ExclusiveRange, value: int) -> (); /// ``` fn write_be(blob: Blob, start: int, len: int, value: int) -> (); +/// Write a `FLOAT` value to the bytes within an exclusive `range` in the BLOB +/// in big-endian byte order. +/// +/// * If number of bytes in `range` < number of bytes for `FLOAT`, extra bytes in `FLOAT` are not written. +/// * If number of bytes in `range` > number of bytes for `FLOAT`, extra bytes in `range` are not modified. +fn write_be(blob: Blob, range: Range, value: float) -> (); + /// Write a `FLOAT` value to the bytes beginning at the `start` position in the BLOB /// in big-endian byte order. /// @@ -5586,6 +5586,26 @@ fn write_be(blob: Blob, start: int, len: int, value: int) -> (); /// * If number of bytes in `range` > number of bytes for `FLOAT`, extra bytes in `range` are not modified. fn write_be(blob: Blob, start: int, len: int, value: float) -> (); +/// Write a `FLOAT` value to the bytes beginning at the `start` position in the BLOB +/// in little-endian byte order. +/// +/// * If `start` < 0, position counts from the end of the BLOB (`-1` is the last byte). +/// * If `start` < -length of BLOB, position counts from the beginning of the BLOB. +/// * If `start` ≥ length of BLOB, zero is returned. +/// * If `len` ≤ 0, zero is returned. +/// * If `start` position + `len` ≥ length of BLOB, entire portion of the BLOB after the `start` position is parsed. +/// +/// * If number of bytes in `range` < number of bytes for `FLOAT`, extra bytes in `FLOAT` are not written. +/// * If number of bytes in `range` > number of bytes for `FLOAT`, extra bytes in `range` are not modified. +fn write_le(blob: Blob, start: int, len: int, value: float) -> (); + +/// Write a `FLOAT` value to the bytes within an exclusive `range` in the BLOB +/// in little-endian byte order. +/// +/// * If number of bytes in `range` < number of bytes for `FLOAT`, extra bytes in `FLOAT` are not written. +/// * If number of bytes in `range` > number of bytes for `FLOAT`, extra bytes in `range` are not modified. +fn write_le(blob: Blob, range: Range, value: float) -> (); + /// Write an `INT` value to the bytes beginning at the `start` position in the BLOB /// in little-endian byte order. /// @@ -5607,12 +5627,27 @@ fn write_be(blob: Blob, start: int, len: int, value: float) -> (); /// ``` fn write_le(blob: Blob, start: int, len: int, value: int) -> (); +/// Write an `INT` value to the bytes within an exclusive `range` in the BLOB +/// in little-endian byte order. +/// +/// * If number of bytes in `range` < number of bytes for `INT`, extra bytes in `INT` are not written. +/// * If number of bytes in `range` > number of bytes for `INT`, extra bytes in `range` are not modified. +/// +/// ```rhai +/// let b = blob(8); +/// +/// b.write_le_int(1..3, 0x12345678); +/// +/// print(b); // prints "[0078560000000000]" +/// ``` +fn write_le(blob: Blob, range: Range, value: int) -> (); + /// Write a `FLOAT` value to the bytes within an inclusive `range` in the BLOB /// in little-endian byte order. /// /// * If number of bytes in `range` < number of bytes for `FLOAT`, extra bytes in `FLOAT` are not written. /// * If number of bytes in `range` > number of bytes for `FLOAT`, extra bytes in `range` are not modified. -fn write_le(blob: Blob, range: InclusiveRange, value: float) -> (); +fn write_le(blob: Blob, range: RangeInclusive, value: float) -> (); /// Write an `INT` value to the bytes within an inclusive `range` in the BLOB /// in little-endian byte order. @@ -5627,42 +5662,7 @@ fn write_le(blob: Blob, range: InclusiveRange, value: float) -> (); /// /// print(b); // prints "[0078563400000000]" /// ``` -fn write_le(blob: Blob, range: InclusiveRange, value: int) -> (); - -/// Write a `FLOAT` value to the bytes beginning at the `start` position in the BLOB -/// in little-endian byte order. -/// -/// * If `start` < 0, position counts from the end of the BLOB (`-1` is the last byte). -/// * If `start` < -length of BLOB, position counts from the beginning of the BLOB. -/// * If `start` ≥ length of BLOB, zero is returned. -/// * If `len` ≤ 0, zero is returned. -/// * If `start` position + `len` ≥ length of BLOB, entire portion of the BLOB after the `start` position is parsed. -/// -/// * If number of bytes in `range` < number of bytes for `FLOAT`, extra bytes in `FLOAT` are not written. -/// * If number of bytes in `range` > number of bytes for `FLOAT`, extra bytes in `range` are not modified. -fn write_le(blob: Blob, start: int, len: int, value: float) -> (); - -/// Write a `FLOAT` value to the bytes within an exclusive `range` in the BLOB -/// in little-endian byte order. -/// -/// * If number of bytes in `range` < number of bytes for `FLOAT`, extra bytes in `FLOAT` are not written. -/// * If number of bytes in `range` > number of bytes for `FLOAT`, extra bytes in `range` are not modified. -fn write_le(blob: Blob, range: ExclusiveRange, value: float) -> (); - -/// Write an `INT` value to the bytes within an exclusive `range` in the BLOB -/// in little-endian byte order. -/// -/// * If number of bytes in `range` < number of bytes for `INT`, extra bytes in `INT` are not written. -/// * If number of bytes in `range` > number of bytes for `INT`, extra bytes in `range` are not modified. -/// -/// ```rhai -/// let b = blob(8); -/// -/// b.write_le_int(1..3, 0x12345678); -/// -/// print(b); // prints "[0078560000000000]" -/// ``` -fn write_le(blob: Blob, range: ExclusiveRange, value: int) -> (); +fn write_le(blob: Blob, range: RangeInclusive, value: int) -> (); /// Write a string to the bytes within an inclusive `range` in the BLOB in UTF-8 encoding. /// @@ -5676,21 +5676,7 @@ fn write_le(blob: Blob, range: ExclusiveRange, value: int) -> (); /// /// print(b); // prints "[00e69c9de3810000]" /// ``` -fn write_utf8(blob: Blob, range: InclusiveRange, string: String) -> (); - -/// Write a string to the bytes within an exclusive `range` in the BLOB in UTF-8 encoding. -/// -/// * If number of bytes in `range` < length of `string`, extra bytes in `string` are not written. -/// * If number of bytes in `range` > length of `string`, extra bytes in `range` are not modified. -/// -/// ```rhai -/// let b = blob(8); -/// -/// b.write_utf8(1..5, "朝には紅顔ありて夕べには白骨となる"); -/// -/// print(b); // prints "[00e69c9de3000000]" -/// ``` -fn write_utf8(blob: Blob, range: ExclusiveRange, string: String) -> (); +fn write_utf8(blob: Blob, range: RangeInclusive, string: String) -> (); /// Write a string to the bytes within an inclusive `range` in the BLOB in UTF-8 encoding. /// @@ -5712,20 +5698,34 @@ fn write_utf8(blob: Blob, range: ExclusiveRange, string: String) -> (); /// ``` fn write_utf8(blob: Blob, start: int, len: int, string: String) -> (); -op |(i32, i32) -> i32; - -op |(u64, u64) -> u64; - -op |(u32, u32) -> u32; +/// Write a string to the bytes within an exclusive `range` in the BLOB in UTF-8 encoding. +/// +/// * If number of bytes in `range` < length of `string`, extra bytes in `string` are not written. +/// * If number of bytes in `range` > length of `string`, extra bytes in `range` are not modified. +/// +/// ```rhai +/// let b = blob(8); +/// +/// b.write_utf8(1..5, "朝には紅顔ありて夕べには白骨となる"); +/// +/// print(b); // prints "[00e69c9de3000000]" +/// ``` +fn write_utf8(blob: Blob, range: Range, string: String) -> (); op |(u16, u16) -> u16; -op |(i16, i16) -> i16; +op |(u32, u32) -> u32; op |(u128, u128) -> u128; op |(i8, i8) -> i8; +op |(i128, i128) -> i128; + +op |(u64, u64) -> u64; + op |(u8, u8) -> u8; -op |(i128, i128) -> i128; \ No newline at end of file +op |(i16, i16) -> i16; + +op |(i32, i32) -> i32; \ No newline at end of file diff --git a/src/definitions/builtin-operators.d.rhai b/src/definitions/builtin-operators.d.rhai new file mode 100644 index 00000000..d907afcf --- /dev/null +++ b/src/definitions/builtin-operators.d.rhai @@ -0,0 +1,251 @@ +module static; + +op ==(i64, i64) -> bool; +op !=(i64, i64) -> bool; +op >(i64, i64) -> bool; +op >=(i64, i64) -> bool; +op <(i64, i64) -> bool; +op <=(i64, i64) -> bool; +op &(i64, i64) -> i64; +op |(i64, i64) -> i64; +op ^(i64, i64) -> i64; +op ..(i64, i64) -> Range; +op ..=(i64, i64) -> RangeInclusive; + +op ==(bool, bool) -> bool; +op !=(bool, bool) -> bool; +op >(bool, bool) -> bool; +op >=(bool, bool) -> bool; +op <(bool, bool) -> bool; +op <=(bool, bool) -> bool; +op &(bool, bool) -> bool; +op |(bool, bool) -> bool; +op ^(bool, bool) -> bool; + +op ==((), ()) -> bool; +op !=((), ()) -> bool; +op >((), ()) -> bool; +op >=((), ()) -> bool; +op <((), ()) -> bool; +op <=((), ()) -> bool; + +op +(i64, i64) -> i64; +op -(i64, i64) -> i64; +op *(i64, i64) -> i64; +op /(i64, i64) -> i64; +op %(i64, i64) -> i64; +op **(i64, i64) -> i64; +op >>(i64, i64) -> i64; +op <<(i64, i64) -> i64; + +op +(f64, f64) -> f64; +op -(f64, f64) -> f64; +op *(f64, f64) -> f64; +op /(f64, f64) -> f64; +op %(f64, f64) -> f64; +op **(f64, f64) -> f64; +op ==(f64, f64) -> bool; +op !=(f64, f64) -> bool; +op >(f64, f64) -> bool; +op >=(f64, f64) -> bool; +op <(f64, f64) -> bool; +op <=(f64, f64) -> bool; + +op +(f64, i64) -> f64; +op -(f64, i64) -> f64; +op *(f64, i64) -> f64; +op /(f64, i64) -> f64; +op %(f64, i64) -> f64; +op **(f64, i64) -> f64; +op ==(f64, i64) -> bool; +op !=(f64, i64) -> bool; +op >(f64, i64) -> bool; +op >=(f64, i64) -> bool; +op <(f64, i64) -> bool; +op <=(f64, i64) -> bool; + +op +(i64, f64) -> f64; +op -(i64, f64) -> f64; +op *(i64, f64) -> f64; +op /(i64, f64) -> f64; +op %(i64, f64) -> f64; +op **(i64, f64) -> f64; +op ==(i64, f64) -> bool; +op !=(i64, f64) -> bool; +op >(i64, f64) -> bool; +op >=(i64, f64) -> bool; +op <(i64, f64) -> bool; +op <=(i64, f64) -> bool; + +op +(Decimal, Decimal) -> Decimal; +op -(Decimal, Decimal) -> Decimal; +op *(Decimal, Decimal) -> Decimal; +op /(Decimal, Decimal) -> Decimal; +op %(Decimal, Decimal) -> Decimal; +op **(Decimal, Decimal) -> Decimal; +op ==(Decimal, Decimal) -> bool; +op !=(Decimal, Decimal) -> bool; +op >(Decimal, Decimal) -> bool; +op >=(Decimal, Decimal) -> bool; +op <(Decimal, Decimal) -> bool; +op <=(Decimal, Decimal) -> bool; + +op +(Decimal, i64) -> Decimal; +op -(Decimal, i64) -> Decimal; +op *(Decimal, i64) -> Decimal; +op /(Decimal, i64) -> Decimal; +op %(Decimal, i64) -> Decimal; +op **(Decimal, i64) -> Decimal; +op ==(Decimal, i64) -> bool; +op !=(Decimal, i64) -> bool; +op >(Decimal, i64) -> bool; +op >=(Decimal, i64) -> bool; +op <(Decimal, i64) -> bool; +op <=(Decimal, i64) -> bool; + +op +(i64, Decimal) -> Decimal; +op -(i64, Decimal) -> Decimal; +op *(i64, Decimal) -> Decimal; +op /(i64, Decimal) -> Decimal; +op %(i64, Decimal) -> Decimal; +op **(i64, Decimal) -> Decimal; +op ==(i64, Decimal) -> bool; +op !=(i64, Decimal) -> bool; +op >(i64, Decimal) -> bool; +op >=(i64, Decimal) -> bool; +op <(i64, Decimal) -> bool; +op <=(i64, Decimal) -> bool; + +op +(String, String) -> String; +op -(String, String) -> String; +op ==(String, String) -> bool; +op !=(String, String) -> bool; +op >(String, String) -> bool; +op >=(String, String) -> bool; +op <(String, String) -> bool; +op <=(String, String) -> bool; + +op +(char, char) -> String; +op ==(char, char) -> bool; +op !=(char, char) -> bool; +op >(char, char) -> bool; +op >=(char, char) -> bool; +op <(char, char) -> bool; +op <=(char, char) -> bool; + +op +(char, String) -> String; +op ==(char, String) -> bool; +op !=(char, String) -> bool; +op >(char, String) -> bool; +op >=(char, String) -> bool; +op <(char, String) -> bool; +op <=(char, String) -> bool; + +op +(String, char) -> String; +op -(String, char) -> String; +op ==(String, char) -> bool; +op !=(String, char) -> bool; +op >(String, char) -> bool; +op >=(String, char) -> bool; +op <(String, char) -> bool; +op <=(String, char) -> bool; + +op +((), String) -> String; +op ==((), String) -> bool; +op !=((), String) -> bool; +op >((), String) -> bool; +op >=((), String) -> bool; +op <((), String) -> bool; +op <=((), String) -> bool; + +op +(String, ()) -> String; +op ==(String, ()) -> bool; +op !=(String, ()) -> bool; +op >(String, ()) -> bool; +op >=(String, ()) -> bool; +op <(String, ()) -> bool; +op <=(String, ()) -> bool; + +op +(Blob, Blob) -> Blob; +op +(Blob, char) -> Blob; +op ==(Blob, Blob) -> bool; +op !=(Blob, Blob) -> bool; + + +op ==(Range, RangeInclusive) -> bool; +op !=(Range, RangeInclusive) -> bool; + +op ==(RangeInclusive, Range) -> bool; +op !=(RangeInclusive, Range) -> bool; + +op ==(Range, Range) -> bool; +op !=(Range, Range) -> bool; + +op ==(RangeInclusive, RangeInclusive) -> bool; +op !=(RangeInclusive, RangeInclusive) -> bool; + +op ==(?, ?) -> bool; +op !=(?, ?) -> bool; +op >(?, ?) -> bool; +op >=(?, ?) -> bool; +op <(?, ?) -> bool; +op <=(?, ?) -> bool; + + +op &=(bool, bool); +op |=(bool, bool); + +op +=(i64, i64); +op -=(i64, i64); +op *=(i64, i64); +op /=(i64, i64); +op %=(i64, i64); +op **=(i64, i64); +op >>=(i64, i64); +op <<=(i64, i64); +op &=(i64, i64); +op |=(i64, i64); +op ^=(i64, i64); + +op +=(f64, f64); +op -=(f64, f64); +op *=(f64, f64); +op /=(f64, f64); +op %=(f64, f64); +op **=(f64, f64); + +op +=(f64, i64); +op -=(f64, i64); +op *=(f64, i64); +op /=(f64, i64); +op %=(f64, i64); +op **=(f64, i64); + +op +=(Decimal, Decimal); +op -=(Decimal, Decimal); +op *=(Decimal, Decimal); +op /=(Decimal, Decimal); +op %=(Decimal, Decimal); +op **=(Decimal, Decimal); + +op +=(Decimal, i64); +op -=(Decimal, i64); +op *=(Decimal, i64); +op /=(Decimal, i64); +op %=(Decimal, i64); +op **=(Decimal, i64); + +op +=(String, String); +op -=(String, String); +op +=(String, char); +op -=(String, char); +op +=(char, String); +op +=(char, char); + +op +=(arraArray, item: Array); +op +=(arraArray, item: ?); + +op +=(Blob, Blob); +op +=(Blob, value: i64); +op +=(Blob, char); +op +=(Blob, String); diff --git a/src/definitions/builtin.d.rhai b/src/definitions/builtin.d.rhai new file mode 100644 index 00000000..2e08fa44 --- /dev/null +++ b/src/definitions/builtin.d.rhai @@ -0,0 +1,170 @@ +module static; + +/// Display any data to the standard output. +/// +/// # Example +/// +/// ```rhai +/// let answer = 42; +/// +/// print(`The Answer is ${answer}`); +/// ``` +fn print(data: ?); + +/// Display any data to the standard output in debug format. +/// +/// # Example +/// +/// ```rhai +/// let answer = 42; +/// +/// debug(answer); +/// ``` +fn debug(data: ?); + +/// Get the type of a value. +/// +/// # Example +/// +/// ```rhai +/// let x = "hello, world!"; +/// +/// print(x.type_of()); // prints "string" +/// ``` +fn type_of(data: ?) -> String; + +/// Create a function pointer to a named function. +/// +/// If the specified name is not a valid function name, an error is raised. +/// +/// # Example +/// +/// ```rhai +/// let f = Fn("foo"); // function pointer to 'foo' +/// +/// f.call(42); // call: foo(42) +/// ``` +fn Fn(fn_name: String) -> FnPtr; + +/// Call a function pointed to by a function pointer, +/// passing following arguments to the function call. +/// +/// If an appropriate function is not found, an error is raised. +/// +/// # Example +/// +/// ```rhai +/// let f = Fn("foo"); // function pointer to 'foo' +/// +/// f.call(1, 2, 3); // call: foo(1, 2, 3) +/// ``` +fn call(fn_ptr: FnPtr, ...args: ?) -> ?; + +/// Call a function pointed to by a function pointer, binding the `this` pointer +/// to the object of the method call, and passing on following arguments to the function call. +/// +/// If an appropriate function is not found, an error is raised. +/// +/// # Example +/// +/// ```rhai +/// fn add(x) { +/// this + x +/// } +/// +/// let f = Fn("add"); // function pointer to 'add' +/// +/// let x = 41; +/// +/// let r = x.call(f, 1); // call: add(1) with 'this' = 'x' +/// +/// print(r); // prints 42 +/// ``` +fn call(obj: ?, fn_ptr: FnPtr, ...args: ?) -> ?; + +/// Curry a number of arguments into a function pointer and return it as a new function pointer. +/// +/// # Example +/// +/// ```rhai +/// fn foo(x, y, z) { +/// x + y + z +/// } +/// +/// let f = Fn("foo"); +/// +/// let g = f.curry(1, 2); // curried arguments: 1, 2 +/// +/// g.call(3); // call: foo(1, 2, 3) +/// ``` +fn curry(fn_ptr: FnPtr, ...args: ?) -> FnPtr; + +/// Return `true` if a script-defined function exists with a specified name and +/// number of parameters. +/// +/// # Example +/// +/// ```rhai +/// fn foo(x) { } +/// +/// print(is_def_fn("foo", 1)); // prints true +/// print(is_def_fn("foo", 2)); // prints false +/// print(is_def_fn("foo", 0)); // prints false +/// print(is_def_fn("bar", 1)); // prints false +/// ``` +fn is_def_fn(fn_name: String, num_params: i64) -> bool; + +/// Return `true` if a variable matching a specified name is defined. +/// +/// # Example +/// +/// ```rhai +/// let x = 42; +/// +/// print(is_def_var("x")); // prints true +/// print(is_def_var("foo")); // prints false +/// +/// { +/// let y = 1; +/// print(is_def_var("y")); // prints true +/// } +/// +/// print(is_def_var("y")); // prints false +/// ``` +fn is_def_var(var_name: String) -> bool; + +/// Return `true` if the variable is shared. +/// +/// # Example +/// +/// ```rhai +/// let x = 42; +/// +/// print(is_shared(x)); // prints false +/// +/// let f = || x; // capture 'x', making it shared +/// +/// print(is_shared(x)); // prints true +/// ``` +fn is_shared(variable: ?) -> bool; + +/// Evaluate a text script within the current scope. +/// +/// # Example +/// +/// ```rhai +/// let x = 42; +/// +/// eval("let y = x; x = 123;"); +/// +/// print(x); // prints 123 +/// print(y); // prints 42 +/// ``` +fn eval(script: String) -> ?; + +fn contains(string: String, find: String) -> bool; +fn contains(range: Range, value: i64) -> bool; +fn contains(range: RangeInclusive, value: i64) -> bool; +fn contains(map: Map, string: String) -> bool; +fn contains(blob: Blob, value: i64) -> bool; +fn contains(string: String, ch: char) -> bool; diff --git a/src/definitions.rs b/src/definitions/mod.rs similarity index 97% rename from src/definitions.rs rename to src/definitions/mod.rs index ef58a146..1b1842ce 100644 --- a/src/definitions.rs +++ b/src/definitions/mod.rs @@ -86,6 +86,9 @@ impl<'e> Definitions<'e> { fs::create_dir_all(path)?; + fs::write(path.join("__builtin__.d.rhai"), include_bytes!("builtin.d.rhai"))?; + fs::write(path.join("__builtin-operators__.d.rhai"), include_bytes!("builtin-operators.d.rhai"))?; + fs::write(path.join("__static__.d.rhai"), self.static_module())?; if self.scope.is_some() {