# Basic Types

## Bool – logical values

**Bool **is a logical data type that can be either `True`

or `False`

.

## Int – fixed-precision integers

**Int **can contain integers, both negative and positive whole numbers (e.g. `-50`

, `50`

) up to a certain size which is limited by a fixed amount of memory, hence the term fixed-precision. GHC can hold values in the range of `(-2^63)`

to `(2^63 - 1)`

for **Int **types - going outside those ranges will yield unexpected results.

## Integer – arbitrary-precision integers

**Integer **is the same as Int except it does not have a limit to the values it can hold. Performance-wise, it is better to use Int if we know our values will not go out of range, as most computers have built-in hardware for dealing with fixed-precision integers.

## Float – single-precision floating-point numbers

**Float **can contain decimal numbers (e.g. `-1.5`

, `6.23`

, `50.0`

) up to a certain precision which is limited by a fixed amount of memory. The term floating-point comes from this memory limitation, which limits the number of digits (precision) that can come after the decimal point based on the size of the number.

## Double – double-precision floating-point numbers

**Double **is the same type as float, containing decimal numbers but with double the memory assigned for storage for increased precision.

## Char – single character

**Char **is a type for characters – it can hold any Unicode character including control characters such as `'\n'`

(a new line character) or `'\t'`

(tab stop character). **Char** type values** **must be enclosed in single quotes `''`

.

## String – strings of characters

**Strings **simply hold a string of characters – they are in fact a type `[Char]`

(a list of **Char **type values) in Haskell. Strings must be enclosed in double-quotes `""`

, e.g. `"Haskell is great"`

.

Last updated