#### Repository
https://github.com/igormuba/EthereumSolidityClasses/tree/master/class10

#### What Will I Learn?
- Multiple inheritance
- Diamond problem and how to avoid it
- Polymorphism in functions

#### Requirements

- Internet connection
- Code editor
- Browser

#### Difficulty

- Intermediate

#### Tutorial Contents

Solidity allows you to achieve polymorphism, but you need to be careful with some issues this may cause and you need to be mindful of your contract design choices

# Multiple inheritance

For this we will use three contracts, the first one is the parent that will have a variable and a function to retrieve it's variable.
The second contract is the "child", it will inherit from the parent but will override the parent's function and will implement its own version of that function calling its own variable.
Then the last contract will inherit from both the parent and the child and will call the function, that has the same name on both the parent and the child

# Parent contract
This is the base contract that will be inherited by the next two, it has it's own variable and a function that calls this variable
```
contract parent{
    uint parentNumber=1; //unique variable to identify we called this contract
    function getNumber() public view returns (uint){ 
        return parentNumber; //returns its unique variable
    }
}
```

# Child contract
This one inherits from the parent and implements its own function and variable so we can identify whether we called the child or the parent, the function from the parent gets overwritten by the new declaration on the child, so the child is parent but has its own implementation of the `getNumber()` function
```
contract kid is parent{
    uint kidNumber=2; //variable different from the parent to identify
    function getNumber() public view returns (uint){
        return kidNumber; //returns the kids variable
    }
}
```

# The contract to test
You need to inherit first from the parent, then from the child, both because else you will get an error because of the diamond inheritance problem (more on that later) and because it will help me show you one thing
```
contract test is parent, kid{ //inherits both
    function callNumber() public view returns (uint){
        return getNumber(); //calls the function that has the same name on both
    }
}
```
Now, as you can see, the contract `test` inherits from both the parent and the kid, and it calls the function that has the same name on both, so what do number will show on the result? 1, representing it called the parents variable or 2 for the child?
![image.png](https://files.steempeak.com/file/steempeak/igormuba/LsuVa1St-image.png)

It has returned the kids number, even though we have said it to inherit from the parent first!
This is because solidity prioritizes the child that is "the last on the family tree".
We can still call the function from the parent, but first I need to explain why 

# The diamond problem
![image.png](https://files.steempeak.com/file/steempeak/igormuba/8GaZOKQo-image.png)

Some programming languages do not allow you to inherit from multiple parents to avoid the diamond problem, Solidity, though, do allow you to inherit from multiple objects.

Inheriting from multiple contracts, in this case, allows you to have some cool features, but you need to be mindful of the functions naming. In case the compiler finds the same method on multiple contracts it will not be able to choose which one are you actually calling.

By saying `contract test is parent, kid` we are solving the indecision from the compiler by making it explicit that we want the kid function to override the parent one.
If you said, however, `contract test is kid, parent` it wouldn't make sense because you would tell the compiler that the functions from the parent are overriding the functions from the kid that are overriding the functions from the parent (because kid is parent).

The diamond problem by itself would be worth a whole post, but here are some useful resources on this topic

Higher level explanation of the problem:
http://www.lambdafaq.org/what-about-the-diamond-problem/

In-depth explanation with examples in c++:
https://medium.freecodecamp.org/multiple-inheritance-in-c-and-the-diamond-problem-7c12a9ddbbec

A very good example explaining how Solidity deals with the problem
https://delegatecall.com/questions/multiple-inheritance-question-9dcaa9e4-af20-4518-9a5d-033b11a0d97e

# Calling the parent function

In case you want to make a call to the function and get the number from the parent, you need to change the kid and implement this with the keyword `super`, what `super` does is it "ignores" that the function was overwritten and goes right into the parent one.

Let me show with an example, on the code below the only thing that changes is the `kid` contract

```
pragma solidity ^0.5.0;

contract parent{
    uint parentNumber=1;
    function getNumber() public view returns (uint){
        return parentNumber;
    }
}

contract kid is parent{
    uint kidNumber=2;
    function getNumber() public view returns (uint){
        return super.getNumber(); //searches for this function on the parent
    }
}

contract test is parent, kid{
    function callNumber() public view returns (uint){
        return getNumber();
    }
}
```

![image.png](https://files.steempeak.com/file/steempeak/igormuba/51KVCfSj-image.png)

As you can see, this time the parent number was called because we told the kid to search for the function on the parent contract.

# One function with many forms

Polymorphism means many forms, the same way that contracts can have many forms, functions also can have many forms. One beautiful thing on polymorphism is that you can have multiple functions with the same name if the signature from the functions is different. That means if they have different inputs. In practice, this is as if there is only one function, but this one function has many forms, hence, the word polymorphism

See the example below

```
pragma solidity ^0.5.0;

contract polymorphism {
    function manyforms(uint numberOne) public pure returns (uint){ //fist form of function manyforms
        return numberOne;
    }
    function manyforms(uint numberOne, uint numberTwo) public pure returns(uint){ //second form of function manyforms
        return numberOne+numberTwo;
    }
}

```

On the example above we have successfully implemented two functions with the exact same name, but we have had no errors raised from the Solidity compiler because their signature is different from each other, in this case, the Solidity code will choose which one to call based on the signature of the caller, if you pass to the function `manyforms()` only one number, the first one will be executed, if you pass two, there will be no ambiguity because it is obvious to the computer that you mean to call the second one that deals with two arguments

# Calling a polymorphed function

With a third function, we can test the polymorphed function `manyforms`, check the newly added function below

```
pragma solidity ^0.5.0;

contract polymorphism {
    function manyforms(uint numberOne) public pure returns (uint){
        return numberOne;
    }
    function manyforms(uint numberOne, uint numberTwo) public pure returns(uint){
        return numberOne+numberTwo;
    }
    function callOneForm() public pure returns (uint){
    //some code here
    }
}

```

Inside the `callOneForm` we can choose whether we want to send one or two arguments. For this we call the function `manyforms()` and we can either pass one or two numbers, like in
```
function callOneForm() public pure returns (uint){
    manyforms(1);
    }
```
or in
```
function callOneForm() public pure returns (uint){
    manyforms(1,3);
    }
```

Doing the first form first, the one that receives only one number and calling the `callOneForm()`
![image.png](https://files.steempeak.com/file/steempeak/igormuba/SArBegth-image.png)

And now on the second form with 1 and 3 as arguments (notice that you have to compile and deploy the contract again)

![image.png](https://files.steempeak.com/file/steempeak/igormuba/V714F5Jg-image.png)


You can keep on adding more forms, maybe you would like to add another `manyforms` function that sums multiple numbers, this allows you to design more concise contracts, with the same functionality but prepared to receive different sets of arguments.

#### Curriculum
- [(Part 9) Ethereum Solidity Assembly - Return, Memory, Hexadecimal, Pointers, And Memory Addressing(PT 9)](https://steemit.com/utopian-io/@igormuba/part-9-ethereum-solidity-assembly-return-memory-hexadecimal-pointers-and-memory-addressing-pt-9)
- [(Part 8) Ethereum Solidity - Assembly, Reducing Costs And Creation Your Low-Level Expression(PT 8)](https://steemit.com/utopian-io/@igormuba/part-8-ethereum-solidity-assembly-reducing-costs-and-creation-your-low-level-expression-pt-8)
- [(Part 7) Ethereum Solidity - Fallback, Ethereum Fractions, And Collateral Backed Contract(PT 7)](https://steemit.com/utopian-io/@igormuba/part-7-ethereum-solidity-fallback-ethereum-fractions-and-collateral-backed-contract-pt-7)
- [(Part 6) Ethereum Solidity - Custom Variable Functionalities, Libraries, Using Libraries For Security(PT 6)](https://steemit.com/utopian-io/@igormuba/part-6-ethereum-solidity-custom-varaible-functionalities-libraries-using-libraries-for-security-pt-6)
- [(Part 5) Ethereum Solidity - Custom Access Modifiers, Security Breach Alerts, Assert And Require(PT 5)](https://steemit.com/utopian-io/@igormuba/part-4-ethereum-solidity-custom-access-modifiers-security-breach-alerts-assert-and-require-pt-4)
- [(Part 4) Ethereum Solidity Development - Inheritance, Working With Multiple Contracts And Simple Mutability(PT 4)](https://steemit.com/utopian-io/@igormuba/part-4-ethereum-solidity-development-inheritance-working-with-multiple-contracts-and-simple-mutability-pt-4)
- [(Part 3) Ethereum Solidity Development - Contract Mutability, DelegateCall And Calling Functions By Address(PT 3)](https://steemit.com/utopian-io/@igormuba/part-3-ethereum-solidity-development-contract-mutability-delegatecall-and-calling-functions-by-address-pt-3)
- [(Part 2) Ethereum Solidity Development - Deploying, Security And ERC20 Compliance(PT 2)](https://steemit.com/utopian-io/@igormuba/part-2-ethereum-solidity-development-deploying-securiy-and-erc20-compliance-pt-2)
- [(Part 1) Ethereum Solidity Development - Getting Started + Lower Level Explanation (PT 1)](https://steemit.com/utopian-io/@igormuba/part-1-ethereum-solidity-development-getting-started-lower-level-explanation-pt-1)

# Beneficiaries

This post has as beneficiaries
@utopian.pay with 5%
using the SteemPeak beneficiary tool
![image.png](https://files.steempeak.com/file/steempeak/igormuba/CZTbpzrU-image.png)