The docs state that a plain `address` cannot be sent Ether. But even though `send` and `transfer` members are not available for plain `address`, the `call` is. And `call` can be invoked upon a plain `address` type to send Ether to the address.
For instance, the `someone` (`address` type) can be sent Ether by invoking `sendSomeone()` method in the following `Dummy` contract:
```
contract Dummy {
address someone = 0xAb8...cb2;
function balanceOf(address addr) public view returns (uint) {
return addr.balance;
}
function sendToSomeone() public payable returns (bool) {
(bool sent, ) = someone.call{value: msg.value}("");
return sent;
}
}
```
At this point of the documentation a new Solidity learner will not understand this line without further explanation:
if (!payable(msg.sender).send(amount)) {
It should explain how msg.sender is of type "address" and not "address payable" so it cannot send or receive Ether. Therefore it must be explicitly converted to payable.
I'm learning Solidity by reading these docs and found this statement confusing. I'm fairly certain that the correct description here is that the *callee* changes get reverted, but the caller is able to react to the failures.
I tested this with the following snippet in Remix, which resulted in a successful transaction when deployed:
```
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.7;
contract A {
uint public value;
function a(uint newValue, bool shouldRevert) external {
value = newValue;
if (shouldRevert) {
revert();
}
}
}
contract B {
function b() external {
A a = new A();
try a.a(50, false) {
assert(a.value() == 50);
} catch {
assert(false);
}
a = new A();
try a.a(50, true) {
assert(false);
} catch {
assert(a.value() == 0);
}
}
}
```
Added the specificity that bytes1[] and bytes differ because of padding only in memory data location. Added extra sentence that they are similar when used in storage data location.
