Invalid type passed!
Received:
{type}
Expected one of:
{asideVariants.join(", ")}
: <>
{title &&
{title}
}
{children}
}
;
};
Tolk has a `bool` type with two values: `true` or `false`.
TVM does not have booleans as a separate type. Instead, `true` is represented as the bit 1 and `false` as the bit 0. In the context of TVM's signed 257-bit integers, this means that `true` corresponds to a decimal -1, while `false` corresponds to 0.
```tolk theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
fun isGreater10(v: int): bool {
return v > 10
}
```
Several operators, such as `==` or `&&` produce values of type `bool`. Many standard library functions also return `bool` values:
```tolk theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
var valid = isSignatureValid(...); // bool
var end = someSlice.isEmpty(); // bool
```
## Logical operators accept both `int` and `bool`
* Operator `!x` supports both `bool` and `int`.
* The condition of `if` and similar statements accepts both `bool` and `int`, where it treats the latter as `true` if the value is not equal to 0, and as `false` otherwise.
* Logical operators `&&` and `||` accept both `bool` and `int`. For example, `a && b` evaluates to `true` when both operands are `true` or both operands are non-zero integers.
Arithmetic operators are restricted to integers.
```tolk theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
valid && end; // ok
valid & end; // ok, bitwise & | ^ also work if both are bools
if (!end) // ok
valid + end; // error
8 & valid; // error, int & bool not allowed
```
## Logical and bitwise operators
Tolk has both bitwise `& ^ |` and logical `&& ||` operators that can be used for booleans and integers.
The main difference is that logical operators short-circuit: the right operand is evaluated only if required.
| Expression | Behavior |
| :------------------: | :--------------------------------------------: |
| `condition & f()` | `f()` is called always |
| `condition && f()` | `f()` is called only if `condition` is `true` |
| `condition \| f()` | `f()` is called always |
| `condition \|\| f()` | `f()` is called only if `condition` is `false` |
The compiler performs better instruction optimizations on booleans, saving more gas per comparison.
Bitwise operators may sometimes be used instead of logical operators to avoid generating conditional branches at runtime. For example, `(a > 0) && (a < 10)`, when replaced with bitwise `&`, consumes less gas.
## Casting to an integer
Use the `as` operator to cast the `bool` to `int`. No runtime transformations take place: at the TVM level, the `bool` type is represented as an integer with a decimal value of either -1 or 0.
```tolk theme={"theme":{"light":"github-light-default","dark":"dark-plus"},"languages":{"custom":["/resources/grammars/tolk.tmLanguage.json","/resources/grammars/tlb.tmLanguage.json","/resources/grammars/fift.tmLanguage.json","/resources/grammars/tasm.tmLanguage.json","/resources/grammars/func.tmLanguage.json"]}}
// -1 or 0 in decimal; serialized as a single bit 1 or 0
var i = boolValue as int1;
```
## Serialization
A boolean is [serialized](/languages/tolk/types/overall-serialization) as a single bit: 1 for `true` and 0 for `false`.