# Primitive Values & Types

What are we working with?

Although this course is primarily focused on developing smart contracts, it is crucial to understand the values that we will be working with; after all, code is just a collection of expressions that all add up to something meaningful.

Being a statically-typed programming language, Solidity requires us to declare the types of each value we utilize in our smart contracts. This section will therefore focus on the primitive types that Solidity offers.

### Primer on Integer Sizes

Before discussing any types, it is important to discuss the concept of integer sizes (or to be mathematically correct, the *magnitude* of integers)

Languages like Python make it seem as if we are able to store arbitrarily large integers with no limitations. However, developers who use languages such as Rust or C will know that this is not the case. Integer types in most programming languages are restricted to a certain *range*; this is due to the fact that we are unable to store infinitely large integers (as this would imply that we have infinitely large memory).

What defines the range of integer types? Recall that all integers can be written in binary form. Listed below are integers (represented in decimal format) and their associated binary representation:

The binary representation of the integers above consist of bits (i.e. 0s or 1s). It is bits that are used to define the range of integer types. As an example, consider a 32-bit integer; the 32-bit part refers the fact that the integer can only store integers whose binary representation consists of *at most 32 bits.*

From a mathematical perspective, a `n`

-bit integer means that any integer `x`

within the range `0 <= n <= 2**n - 1`

can be stored.

#### What About *Signed* Integers?

*Signed*Integers?

Signed integers are represented in binary via the two's complement formula. Although we won't get into how to compute the binary representation of a signed integer, note that a `n`

-bit signed integer means that any integer `x`

within the range `-2**(n-1) <= x <= 2**(n-1) - 1 `

can be stored

### Integers (Signed and Unsigned)

In Solidity, the two *general* integer types available to us are `uint`

(unsigned integer) and `int`

(signed integer). Both `uint`

and `int`

are of size 256-bits. However, these are not the only integer types that we are restricted to; in fact, we can utilize any signed/unsigned integer type of size `n`

where `n`

is a multiple of 8. The following is a list of valid integer types in Solidity:

#### Integer Operations

Assuming `a`

, `b`

are integers and `c`

is a non-zero integer, listed below are the operations that we can perform on integers in Solidity

### Booleans

Solidity provides us with the boolean values `true`

and `false`

.

### Address

Since addresses are commonly used within smart contracts, Solidity provides us with an address type. An example of the address type is as follows:

Last updated