# Modifiers

Although we have already covered [functions](https://cs4998.cornellblockchain.org/introduction/hello-world/functions), there is one aspect of functions that we have yet to explore. 

To see the current problem with our understanding of functions, consider the *visibility* of functions; by specifying the visibility of a function, we can restrict actors from accessing a function. However, this becomes an issue if we want to allow *some* actors to call a function, while denying permission to others. With our understanding of visibility, we know that this is not possible. Therefore, are we doomed?

It seems as if we could implement permissioned functions if we could *modify* the logic of our function. And indeed, this is what modifiers allow us to do! Below is the general syntax for modifiers:

```solidity
modifier modifierName(P) {
    // Insert logic here
}
```

where `P` are the parameters that the modifier takes in. To see how modifiers are used, assume we have the following contract:

```solidity
contract Bank {

    address owner;
    
    function withdraw() public {
        // Withdraw logic goes here
    }

}
```

As the name intends, `Bank` holds a large sum of money and `withdraw` is a function is which we *only want the owner* to be able to call. For this guarantee to hold true, lets create a modifier `onlyOwner` that, when assigned to a function, only allows for the owner (i.e. deployer) of a contract to be able to call.

{% code lineNumbers="true" %}

```solidity
modifier onlyOwner() {
    require(msg.sender == owner, "You are not the owner!");
    _;
}
```

{% endcode %}

To understand the logic of `onlyOwner`, it is best to examine the modifier line-by-line:

* Line 2: we are *requiring* that the current message sender is the owner of the contract. If this invariant does not hold, the transaction will fail
* Line 3: the underscore implies that we are reverting control back to the function itself

The following code utilizes `onlyOwner`:

{% code lineNumbers="true" %}

```solidity
contract Bank {

    address owner;
    
    modifier onlyOwner() {
        require(msg.sender == owner, "You are not the owner!");
        _;
    }
    
    function withdraw() public onlyOwner {
        // Withdraw logic goes here
    }

}
```

{% endcode %}

In the function header of `withdraw`, we are calling `onlyOwner`; `withdraw` will execute if the owner of `Bank` is the one calling the function.

Although the `_` symbol inside modifiers might imply that we are reverting control back to the calling function for the rest of the execution context, this is actually not the case! Consider the following code:

{% code lineNumbers="true" %}

```solidity
contract Restroom {

    bool isOccupied;
    
    modifier lock() {
        require(!isOccupied, "Bathroom is already occupied!");
        isOccupied = true;
        _;
        isOccupied = false;
    }
    
    function useRestroom() public lock {
        // Logic goes here
    }

}
```

{% endcode %}

The contract represents a restroom where only one person is allowed at a time. Assuming that *anyone can call `useRestroom` at any time*, the `lock` modifier allows us to adhere to this invariant. Examining the modifier line-by-line:

* Line 6: we are checking if the restroom is occupied; if so, our function will revert
* Line 7: we are "locking" the restroom
* Line 8: we delegate control back to `useRestroom`
* Line 9: after `useRestroom` is finished executing, control is delegated back to `lock`, where it "unlocks" the restroom