# Bool¶

## Description¶

The `Bool` type corresponds to a boolean value (True or False).

## Declaration¶

The syntax to declare a boolean value is as follows: (everything between [] is optional)

Syntax

Description

Return

Bool[()]

Create a Bool

Bool

True

Create a Bool assigned with `true`

Bool

False

Create a Bool assigned with `false`

Bool

Bool(value: Boolean)

Create a Bool assigned with a Scala Boolean(true, false)

Bool

```val myBool_1 = Bool          // Create a Bool
myBool_1 := False            // := is the assignment operator

val myBool_2 = False         // Equivalent to the code above

val myBool_3 = Bool(5 > 12)  // Use a Scala Boolean to create a Bool
```

## Operators¶

The following operators are available for the `Bool` type:

### Logic¶

Operator

Description

Return type

!x

Logical NOT

Bool

x && y
x & y

Logical AND

Bool

x || y
x | y

Logical OR

Bool

x ^ y

Logical XOR

Bool

x.set[()]

Set x to True

x.clear[()]

Set x to False

x.setWhen(cond)

Set x when cond is True

Bool

x.clearWhen(cond)

Clear x when cond is True

Bool

```val a, b, c = Bool
val res = (!a & b) ^ c   // ((NOT a) AND b) XOR c

val d = False
when(cond) {
d.set()    // equivalent to d := True
}

val e = False
e.setWhen(cond) // equivalent to when(cond) { d := True }
```

### Edge detection¶

Operator

Description

Return type

x.edge[()]

Return True when x changes state

Bool

x.edge(initAt: Bool)

Same as x.edge but with a reset value

Bool

x.rise[()]

Return True when x was low at the last cycle and is now high

Bool

x.rise(initAt: Bool)

Same as x.rise but with a reset value

Bool

x.fall[()]

Return True when x was high at the last cycle and is now low

Bool

x.fall(initAt: Bool)

Same as x.fall but with a reset value

Bool

x.edges[()]

Return a bundle (rise, fall, toggle)

BoolEdges

x.edges(initAt: Bool)

Same as x.edges but with a reset value

BoolEdges

```when(myBool_1.rise(False)) {
// do something when a rising edge is detected
}

val edgeBundle = myBool_2.edges(False)
when(edgeBundle.rise) {
// do something when a rising edge is detected
}
when(edgeBundle.fall) {
// do something when a falling edge is detected
}
when(edgeBundle.toggle) {
// do something at each edge
}
```

### Comparison¶

Operator

Description

Return type

x === y

Equality

Bool

x =/= y

Inequality

Bool

```when(myBool) { // Equivalent to when(myBool === True)
// do something when myBool is True
}

when(!myBool) { // Equivalent to when(myBool === False)
// do something when myBool is False
}
```

### Type cast¶

Operator

Description

Return

x.asBits

Binary cast to Bits

Bits(w(x) bits)

x.asUInt

Binary cast to UInt

UInt(w(x) bits)

x.asSInt

Binary cast to SInt

SInt(w(x) bits)

x.asUInt(bitCount)

Binary cast to UInt and resize

UInt(bitCount bits)

x.asBits(bitCount)

Binary cast to Bits and resize

Bits(bitCount bits)

```// Add the carry to an SInt value
val carry = Bool
val res = mySInt + carry.asSInt
```

### Misc¶

Operator

Description

Return

x ## y

Concatenate, x->high, y->low

Bits(w(x) + w(y) bits)

```val a, b, c = Bool

// Concatenation of three Bool into a Bits
val myBits = a ## b ## c
```