# Bool

{/* Generated from types/std.Rtypes by `just docs-std`. Do not edit this file. */}

Booleans are R's `TRUE` and `FALSE`, never `NA`. R's operators already cover most of this module;
its functions exist so that a boolean step can be passed by name, as in `List.walk(flags,
Bool.true, Bool.and)`, and so that code written against Roc's names reads the same.

| Function | Summary |
| --- | --- |
| [`Bool.true`](#booltrue) | `TRUE`, as Roc spells it. |
| [`Bool.false`](#boolfalse) | `FALSE`. |
| [`Bool.and`](#booland) | Whether both are `TRUE`. |
| [`Bool.or`](#boolor) | Whether either is `TRUE`. |
| [`Bool.not`](#boolnot) | The opposite value. |
| [`Bool.is_eq`](#boolis_eq) | Whether two values are equal by `identical()`, the library's equality. |
| [`Bool.is_not_eq`](#boolis_not_eq) | Whether two values differ by `identical()`. |

## `Bool.true`

```r
#: logical
Bool.true
```

`TRUE`, as Roc spells it. It is a value, not a function.

```r
Bool.true
#> TRUE
```

[Source](https://github.com/felix-andreas/ry/blob/main/types/std.Rtypes#L1741)

## `Bool.false`

```r
#: logical
Bool.false
```

`FALSE`.

```r
Bool.false
#> FALSE
```

[Source](https://github.com/felix-andreas/ry/blob/main/types/std.Rtypes#L1749)

## `Bool.and`

### Inline

```r
Bool.and <- function(first: logical, second: logical) -> logical
```

### Comments

```r
#: fn(first: logical, second: logical) -> logical
Bool.and <- function(first, second)
```

Whether both are `TRUE`. Both arguments are evaluated, unlike with `&&`.

```r
Bool.and(TRUE, FALSE)
#> FALSE
```

[Source](https://github.com/felix-andreas/ry/blob/main/types/std.Rtypes#L1757)

## `Bool.or`

### Inline

```r
Bool.or <- function(first: logical, second: logical) -> logical
```

### Comments

```r
#: fn(first: logical, second: logical) -> logical
Bool.or <- function(first, second)
```

Whether either is `TRUE`. Both arguments are evaluated, unlike with `||`.

```r
Bool.or(TRUE, FALSE)
#> TRUE
```

[Source](https://github.com/felix-andreas/ry/blob/main/types/std.Rtypes#L1765)

## `Bool.not`

### Inline

```r
Bool.not <- function(value: logical) -> logical
```

### Comments

```r
#: fn(value: logical) -> logical
Bool.not <- function(value)
```

The opposite value.

```r
List.keep_if(list(1L, 2L, 3L), function(x) Bool.not(Num.is_even(x)))
#> list(1L, 3L)
```

[Source](https://github.com/felix-andreas/ry/blob/main/types/std.Rtypes#L1773)

## `Bool.is_eq`

### Inline

```r
Bool.is_eq <- function<T>(first: T, second: T) -> logical
```

### Comments

```r
#: <T> fn(first: T, second: T) -> logical
Bool.is_eq <- function(first, second)
```

Whether two values are equal by `identical()`, the library's equality. An integer and a double
are never identical, so `Bool.is_eq(1L, 1)` is `FALSE`, and a dictionary or set compares without
regard to order.

```r
Bool.is_eq(Set.from_list(list(1L, 2L)), Set.from_list(list(2L, 1L)))
#> TRUE
```

[Source](https://github.com/felix-andreas/ry/blob/main/types/std.Rtypes#L1783)

## `Bool.is_not_eq`

### Inline

```r
Bool.is_not_eq <- function<T>(first: T, second: T) -> logical
```

### Comments

```r
#: <T> fn(first: T, second: T) -> logical
Bool.is_not_eq <- function(first, second)
```

Whether two values differ by `identical()`.

```r
Bool.is_not_eq(list(1L), list(2L))
#> TRUE
```

[Source](https://github.com/felix-andreas/ry/blob/main/types/std.Rtypes#L1791)