Short notation for function types

[chriseth]

Function types require quite a lot of keystrokes. The obvious shorthand is
(uint) -> (uint), but our function types are more complicated than javascript's - we also need to specify internal / external, constant, payable (view, pure). Is there a good notation for these?

We could distinguish internal and external by -> and => and then something like this:

(uint) [pure,payable]=> (uint)

[pipermerriam]

This seems like it adds complication without a lot of real value.

• Pros:
  • Fewer keystrokes
  • Function definitions get shorter
• Cons:
  • Anything that parses source code has to now account for this notation and the old.
  • Mental overhead. People have to understand that there are two ways to define functions.

[chriseth]

I think the mental overhead is actually reduced:

library ArrayUtils {
  // internal functions can be used in internal library functions because
  // they will be part of the same code context
  function map(uint[] memory self, function (uint) returns (uint) f)
    returns (uint[] memory r)
  {
    r = new uint[](self.length);
    for (uint i = 0; i < self.length; i++) {
      r[i] = f(self[i]);
    }
  }

vs.

library ArrayUtils {
  // internal functions can be used in internal library functions because
  // they will be part of the same code context
  function map(uint[] memory self, (uint) -> (uint) f)
    returns (uint[] memory r)
  {
    r = new uint[](self.length);
    for (uint i = 0; i < self.length; i++) {
      r[i] = f(self[i]);
    }
  }

and this is only a simple example, one of the more complex being

contract C {
  function f3() internal returns (function() returns (function () returns (function () returns (uint))));

vs

contract C {
  function f3() internal returns (() -> (() -> (() -> (uint))));

Note that this is ONLY about function types, not about function declarations.

[pipermerriam]

I completely misunderstood the intent of this. Disregard my injections. I'm
+1 on this notation.

On Mon, Nov 21, 2016, 11:18 AM chriseth notifications@github.com wrote:

I think the mental overhead is actually reduced:

library ArrayUtils {
// internal functions can be used in internal library functions because
// they will be part of the same code context
function map(uint[] memory self, function (uint) returns (uint) f)
returns (uint[] memory r)
{
r = new uint;
for (uint i = 0; i < self.length; i++) {
r[i] = f(self[i]);
}
}

vs.

library ArrayUtils {
// internal functions can be used in internal library functions because
// they will be part of the same code context
function map(uint[] memory self, (uint) -> (uint) f)
returns (uint[] memory r)
{
r = new uint;
for (uint i = 0; i < self.length; i++) {
r[i] = f(self[i]);
}
}

and this is only a simple example.

Note that this is ONLY about function types, not about function
declarations.

—
You are receiving this because you commented.
Reply to this email directly, view it on GitHub
#1349 (comment),
or mute the thread
https://github.com/notifications/unsubscribe-auth/AAyTguvifVaB-sL6qsrF3Ihi92qYosG5ks5rAeCPgaJpZM4Ktl_v
.