Calling functions with explicit arguments

[PaulRBerg]

@andreivladbrg, would you be open to refactoring all of our function calls to use explicit arguments, e.g. like this?

foo({ x: 1, y: 2})

See my tweet for more details on this.

[andreivladbrg]

Don't know what to say yet.

One thing I can say for now, there would be so much repetitive code and I don't find yet to be worth it. Especially when you call an internal function with the same name, you expect to have the same arguments.

[PaulRBerg]

I don't think it is accurate to refer to "explicit arguments" as "repetitive code". They add clarity and provide context - they do not repeat anything that is already written.

The advantage of explicit arguments is that it lessens the cognitive load on the reader of the smart contract. The reader doesn't have to remember what arguments were defined, where. Crucially, an external reader of the contract might not be as familiar with the function declarations as you are, since you wrote the functions.

Especially when you call an internal function with the same name, you expect to have the same arguments.

Could you give an example for this?

Again, the reason you can "expect" the arguments to be the same is that you are familiar with the function declarations.

[andreivladbrg]

I am going to give two examples, one for when I am against using it and one for when I am in favor of using it.

Against

This case is what I mean by "repetitive code". Same function name with the same arguments, one is external one is internal

function create(
        address sender,
        address recipient,
        uint256 depositAmount,
        IERC20 token,
        uint64 startTime,
        uint64 cliffTime,
        uint64 stopTime,
        bool cancelable
    ) external returns (uint256 streamId) {
        // Checks, Effects and Interactions: create the stream.
        streamId = _create({
            sender: sender,
            recipient: recipient,
            depositAmount: depositAmount,
            token: token,
            startTime: startTime,
            cliffTime: cliffTime,
            stopTime: stopTime,
            cancelable: cancelable
        });
}

Pro

function _checkSegmentCounts(
        uint256 amountCount,
        uint256 exponentCount,
        uint256 milestoneCount
    ) internal view returns (uint256 segmentCount) {}

function _create(
        address sender,
        address recipient,
        uint256 depositAmount,
        IERC20 token,
        uint64 startTime,
        uint256[] memory segmentAmounts,
        SD59x18[] memory segmentExponents,
        uint64[] memory segmentMilestones,
        bool cancelable
    ) internal returns (uint256 streamId) {
        // Checks: segment counts match.
        uint256 segmentCount = _checkSegmentCounts({
            amountCount: segmentAmounts.length,
            exponentCount: segmentExponents.length,
            milestoneCount: segmentMilestones.length
        });
 }

[PaulRBerg]

Thanks @andreivladbrg for sharing these examples. I agree that we should not use explicit arguments everywhere. But in certain cases, such as the one you offered as an example (_checkSegmentsCounts), it'd be worth it.

[PaulRBerg]

Locking, since this was implemented in #184.