# Value types

### INT / UINT

`uint` is short for `unsigned integer`, and you can choose the size from `uint8` to `uint256`

* `uint8` starts from `0` to `2 ** 8 - 1`
* `uint16` starts from `0` to `2 ** 16 - 1`\
  ...
* `uint256` starts from `0` to `2 ** 256 - 1`

```solidity
uint8 public u8 = 1;
uint256 public u256 = 456;
uint public u = 123; // uint is short hand for uint256
```

`int` is short for `integer`, and you can choose the size from `int8` to `int256`

* `int8` starts from `-2 ** 7` to `2 ** 7 - 1`
* `int16` starts from `-2 ** 15` to `2 ** 15 - 1` ...
* `int128` starts from `-2 ** 127` to `2 ** 127 - 1`
* `int256` starts from `-2 ** 255` to `2 ** 255 - 1`

```solidity
int8 public i8 = -1;
int256 public i256 = 456;
int public i = -123; // int is short hand for int256
```

#### int and uint operators:

* Comparisons: <=, <, ==, !=, >=, > (returns `bool`)
* Bit operations: &, |, ^ (bitwise exclusive hoặc), \~ (bitwise negation)
* Shifts: << (left shift), >> (right shift)
* Addition, Subtraction and Multiplication: `+`, `-`, `negative -` (as in `signed integer`), `*`, `/`, `%` (modulo), `**` (exponentiation)

For a type `integer` variable X, you can use `type(X).min` and `type(X).max` to access smallest and biggest value respectively for that type.

```solidity
// minimum and maximum of int type: 
int public minInt = type(int).min;
int public maxInt = type(int).max;

// minimum and maximum of uint type:
uint public minUint = type(uint).min;
uint public maxUint = type(uint).max;
```

### BOOL

`bool` means `Boolean` and has 2 possible values which are `true` and `false`

```solidity
bool public trueVar = true;
bool public falseVar = false;
```

#### Operators:

* `!` (logical negation)
* `&&` (logical conjunction, “and”)
* `||` (logical disjunction, “or”)
* `==` (equality)
* `!=` (inequality)

The operators `||` and `&&` apply the common short-circuiting rules. This means that in the expression `f(x) || g(y)`, if `f(x)` evaluates to `true`, `g(y)` will not be evaluated even if it may have side-effects.

### ADDRESS

* `address` is a special data type in Solidity that allows storing 20 bytes (size) of the address of an EVM account
* `address payable` similar to `address` but adds 2 more methods `transfer` and `send`

```solidity
address public exampleAddress = 0xCA35b7d915458EF540aDe6068dFe2F44E8fa733c;
address payable public examplePayableAddress = payable(0xCA35b7d915458EF540aDe6068dFe2F44E8fa733c);

function getAddressBalance() public view returns (uint) {
    // Returns the balance of the exampleAddress
    return exampleAddress.balance;
}

function sendViaTransfer() public payable {
    // This function is no longer recommended for sending Ether.
    examplePayableAddress.transfer(msg.value);
}

function sendViaSend() public payable {
    // Send returns a boolean value indicating success or failure.
    // This function is not recommended for sending Ether.
    bool sent = examplePayableAddress.send(msg.value);
    require(sent, "Failed to send Ether");
}

function sendViaCall() public payable {
    // Send Ether to the wallet
    (bool sent, bytes memory data) = examplePayableAddress.call{value: msg.value}("");
    require(sent, "Failed to send Ether");
}
```

### BYTES

In Solidity, the byte data type represents a sequence of bytes. Solidity has two types of bytes:

* Fixed-size byte arrays
* Dynamic-size byte arrays

The bytes keyword in Solidity represents a dynamic array of bytes. Essentially, it is a shorthand for `byte[]`.

```solidity
bytes1 a = 0xb5; //  [10110101]
bytes1 b = 0x56; //  [01010110]
bytes c = "abc"; //  [01100001, 01100010, 01100011]
```

### Default values

Declared variables without value assignment will have its default values.

```solidity
bool public defaultBool; // false
uint public defaultUint; // 0
int public defaultInt; // 0
address public defaultAddr; // 0x0000000000000000000000000000000000000000
bytes1 public defaultByte; // 0x00
```

### CONTRACT

`contract` is used to declare a contract in Solidity.

```solidity
contract HelloWorld {}
```

`contract` can also inherit from another contract using the keyword `is`

```solidity
contract Mercedes is Car {}
```

### ENUM

`Enums` are one way to create a user-defined type in Solidity. They are explicitly convertible to and from all integer types but implicit conversion is not allowed. The explicit conversion from integer checks at runtime that the value lies inside the range of the enum and causes a `Panic error` otherwise. `Enums` require at least one member, and its default value when declared is the first member. Enums cannot have more than 256 members.

The data representation is the same as for `enums` in C: The options are represented by subsequent unsigned integer values starting from 0.

Using `type(NameOfEnum).min` and `type(NameOfEnum).max` you can get the smallest and respectively largest value of the given enum.

```solidity
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract Enum {
    // Enum representing shipping status
    enum Status {
        Pending,
        Shipped,
        Accepted,
        Rejected,
        Canceled
    }

    // Default value is the first element listed in
    // definition of the type, in this case "Pending"
    Status public status;

    // Returns uint
    // Pending  - 0
    // Shipped  - 1
    // Accepted - 2
    // Rejected - 3
    // Canceled - 4
    function get() public view returns (Status) {
        return status;
    }

    // Update status by passing uint into input
    function set(Status _status) public {
        status = _status;
    }

    // You can update to a specific enum like this
    function cancel() public {
        status = Status.Canceled;
    }

    // delete resets the enum to its first value, 0
    function reset() public {
        delete status;
    }
}
```

### TYPE

A user-defined value type allows creating a zero cost abstraction over an elementary value type. This is similar to an alias, but with stricter type requirements.

A user-defined value type is defined using `type C is V`, where `C` is the name of the newly introduced type and `V` has to be a built-in value type (the “underlying type”)

```solidity
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.8;

// Represent a 18 decimal, 256 bit wide fixed point type using a user-defined value type.
type UFixed256x18 is uint256;
```

### FUNCTION

`function` keyword is used to declare a function in Solidity.

We can declare a `function` like below:

```solidity
contract Counter {
    uint public count;

    // Function to view count variable
    function get() public view returns (uint) {
        return count;
    }
}
```