139 lines
3.7 KiB
Markdown
139 lines
3.7 KiB
Markdown
In Operator
|
|
===========
|
|
|
|
{{#include ../links.md}}
|
|
|
|
```admonish question.side.wide "Trivia"
|
|
|
|
The `in` operator is simply syntactic sugar for a call to the `contains` function.
|
|
|
|
Similarly, `!in` is a call to `!contains`.
|
|
```
|
|
|
|
The `in` operator is used to check for _containment_ – i.e. whether a particular collection
|
|
data type _contains_ a particular item.
|
|
|
|
Similarly, `!in` is used to check for non-existence – i.e. it is `true` if a particular
|
|
collection data type does _not_ contain a particular item.
|
|
|
|
```rust
|
|
42 in array;
|
|
|
|
array.contains(42); // <- the above is equivalent to this
|
|
|
|
123 !in array;
|
|
|
|
!array.contains(123); // <- the above is equivalent to this
|
|
```
|
|
|
|
|
|
Built-in Support for Standard Data Types
|
|
----------------------------------------
|
|
|
|
| Data type | Check for |
|
|
| :-------------: | :---------------------------------: |
|
|
| Numeric [range] | integer number |
|
|
| [Array] | contained item |
|
|
| [Object map] | property name |
|
|
| [String] | [sub-string][string] or [character] |
|
|
|
|
|
|
Examples
|
|
--------
|
|
|
|
```rust
|
|
let array = [1, "abc", 42, ()];
|
|
|
|
42 in array == true; // check array for item
|
|
|
|
let map = #{
|
|
foo: 42,
|
|
bar: true,
|
|
baz: "hello"
|
|
};
|
|
|
|
"foo" in map == true; // check object map for property name
|
|
|
|
'w' in "hello, world!" == true; // check string for character
|
|
|
|
'w' !in "hello, world!" == false;
|
|
|
|
"wor" in "hello, world" == true; // check string for sub-string
|
|
|
|
42 in -100..100 == true; // check range for number
|
|
```
|
|
|
|
|
|
Array Items Comparison
|
|
----------------------
|
|
|
|
The default implementation of the `in` operator for [arrays] uses the `==` operator (if defined)
|
|
to compare items.
|
|
|
|
~~~admonish warning.small "`==` defaults to `false`"
|
|
|
|
For a [custom type], `==` defaults to `false` when comparing it with a value of of the same type.
|
|
|
|
See the section on [_Logic Operators_](logic.md) for more details.
|
|
~~~
|
|
|
|
```rust
|
|
let ts = new_ts(); // assume 'new_ts' returns a custom type
|
|
|
|
let array = [1, 2, 3, ts, 42, 999];
|
|
// ^^ custom type
|
|
|
|
42 in array == true; // 42 cannot be compared with 'ts'
|
|
// so it defaults to 'false'
|
|
// because == operator is not defined
|
|
```
|
|
|
|
|
|
Custom Implementation of `contains`
|
|
-----------------------------------
|
|
|
|
The `in` and `!in` operators map directly to a call to a function `contains` with the two operands switched.
|
|
|
|
```rust
|
|
// This expression...
|
|
item in container
|
|
|
|
// maps to this...
|
|
contains(container, item)
|
|
|
|
// or...
|
|
container.contains(item)
|
|
```
|
|
|
|
Support for the `in` and `!in` operators can be easily extended to other types by registering a
|
|
custom binary function named `contains` with the correct parameter types.
|
|
|
|
Since `!in` maps to `!(... in ...)`, `contains` is enough to support both operators.
|
|
|
|
```rust
|
|
let mut engine = Engine::new();
|
|
|
|
engine.register_type::<TestStruct>()
|
|
.register_fn("new_ts", || TestStruct::new())
|
|
.register_fn("contains", |ts: &mut TestStruct, item: i64| -> bool {
|
|
// Remember the parameters are switched from the 'in' expression
|
|
ts.contains(item)
|
|
});
|
|
|
|
// Now the 'in' operator can be used for 'TestStruct' and integer
|
|
|
|
engine.run(
|
|
r#"
|
|
let ts = new_ts();
|
|
|
|
if 42 in ts { // this calls 'ts.contains(42)'
|
|
print("I got 42!");
|
|
} else if 123 !in ts { // this calls '!ts.contains(123)'
|
|
print("I ain't got 123!");
|
|
}
|
|
|
|
let err = "hello" in ts; // <- runtime error: 'contains' not found
|
|
// for 'TestStruct' and string
|
|
"#)?;
|
|
```
|