// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract Function {
    // 多返回值函数
    function returnMany()
        public
        pure
        returns (
            uint,
            bool,
            uint
        )
    {
        return (1, true, 2);
    }

    // 可以命名返回值
    // 0: uint256: x 1
        // 1: bool: b true
        // 2: uint256: y 2
    function named()
        public
        pure
        returns (
            uint x,
            bool b,
            uint y
        )
    {
        return (1, true, 2);
    }

    // 返回值可以指定给其名称
    // 在这种情况下，可以省略return语句。
    function assigned()
        public
        pure
        returns (
            uint x,
            bool b,
            uint y
        )
    {
        x = 1;
        b = true;
        y = 2;
    }

    // 调用另一个函数时使用解构方式赋值
    // 返回多个值的函数。
    function destructuringAssignments()
        public
        pure
        returns (
            uint,
            bool,
            uint,
            uint,
            uint
        )
    {
        (uint i, bool b, uint j) = returnMany();

        // 值可以省略。5,就被忽略了
        (uint x, , uint y) = (4, 5, 6);

        return (i, b, j, x, y);
    }

    //不能将映射用于输入或输出 例如:function mappingInput(mapping m) public {}
    // 可以使用数组进行输入
    function arrayInput(uint[] memory _arr) public {}
}

// 函数的调用
contract XYZ {
    function plus(uint256 x, uint256 y) public pure returns (uint256) {
        return x + y;
    }

    //按顺序调用参数
    function callFunc() external pure returns (uint256) {
        return plus(1, 2);
    }

    //指明 key 值传递入参
    function callFuncWithKeyValue() external pure returns (uint256) {
        return plus({x: 1, y: 2});
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract ModifierTest {
    function plus(uint256 _x, uint256 _y) public pure returns (uint256) {
        require(_x > _y, "x>y");
        return 1 + 1;
    }

    function sub(uint256 _x, uint256 _y) public pure returns (uint256) {
        require(_x > _y, "x>y");
        return 2 - 1;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract Owner {
    modifier compare(uint256 _x, uint256 _y) {
        require(_x > _y, "x>y");
        _;
    }

    function plus(uint256 _x, uint256 _y)
        public
        pure
        compare(_x, _y)
        returns (uint256)
    {
        return _x + _y;
    }

    function sub(uint256 _x, uint256 _y)
        public
        pure
        compare(_x, _y)
        returns (uint256)
    {
        return _x - _y;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.13;

contract Owner {
    address public owner;
    modifier compare(uint256 _x, uint256 _y) {
        require(_x > _y, "x>y");
        _;
        require(owner == msg.sender,"not owner");
    }
        
    function plus(uint256 _x, uint256 _y)
        public
        compare(_x, _y)
        returns (uint256)
    {
        // 把 owner 设为调用者
        owner = msg.sender;
        return _x + _y;
    }
    // 因为用到了状态变量所以要把 pure 改为 view
    function sub(uint256 _x, uint256 _y)
        public
        view
        compare(_x, _y)
        returns (uint256)
    {
        return _x - _y;
    }
}