# Types

At the heart of the Dahlia compiler is the type checker that checks for various constraints that make programs hardware realizable.

## Booleans

Boolean constants and the result of comparisons are typed as `boolean`

.

```
let x = true // x is boolean
let z = x >= y // y is boolean
```

## Sized Integers

Bitwidth optimizations are important for building fast hardware. Dahlia allows programs to specify an exact bit width specification for all constants and variables.

A bare `let`

-binding automatically infers bit widths for constants. The
inference is conservative and finds the minimum number bits needed to store
the constant:

```
let x = 1; // x is bit<1>
```

If the program needs to store a constant with a larger bitwidth (for use in a future computation), simply add an explicit type annotation:

```
let x: bit<10> = 1;
```

## Floats & Doubles

Dahlia provides a simple float type:

```
let f = 1.0; // f is float
let f: double = 2.0;
```

**Note**: Automatic inferences always infers the type `float`

for floating
point literals.

Fixed point floating numbers are **not yet implemented**.

## Binary Operations

Binary operations over `booleans`

and `floats`

are straightforward.

```
let a = true || false // a is boolean
let b = 1 || 2 // Error! Only booleans expressions can be used with boolean operators
let f = 1.0 + 2.0 // f is float
```

Binary operations over sized integers are more subtle. They automatically infer the largest bitwidth between the operands and uses that for the result:

```
let x: bit<10> = 10;
let y: bit<32> = 20;
let z = x + y; // z is bit<32>
```