Method == FunctionName + ValueTuple

[a44281071]

A method can be decomposed into two parts:

• Member name, the name of function.
• Parameters, the input parameters for function.
• return value is single/tuple.

double CalcArea(double width, double height);

As shown above, function name is 'CalcArea', and value tuple is '(double, double)'.

We can express it as a stream function:

double a = (1024,768) >> BuildSize

As shown above, we prepare a tuple value, invoke a func, finally assign a value to variable a.

Better use in streaming functions

• Invoke method like delegate(func/action).
• Almost underutilized operators.(Like << or >>)
• method return a value/ValueTuple can send as next func parameters.

// streaming functions demo 1.
double a = CreateApp >> (value, "First window") >> CreateWindow >> value.Value1 >> Window win >> MaxWindow >> RandomDoubleValue() ;

App CreateApp();
(App, Window) CreateWindow(App app, string windowTitle);
Window MaxWindow(Window win);
double RandomDoubleValue();

As shown above:

• CreateApp func return a value, type is App.
• Prepare Tuple to pass to the next func. There is a ‘value’ keyword, like 'property -> set -> value'.
• CreateWindow func need double parameters, we use 'Tuple' pass them. And func return a tuple value (App, Window).
• We just need single value of Window type.
• We don't like using this name 'value', so we use a aliases name 'win'.
• MaxWindow func need single parameter. and return a never used value Discards - C# Fundamentals.
• RandomDoubleValue is test func, just return a double value;

[huoyaoyuan]

While multiple parameters are equivalent to tuples in functional perspective, they can be different in calling convention and ABI perspective.
Thus, the conversion between different forms will need shims for transforming. This flavor of behavior fits more for F# rather than C#.

In type system of C#, parameters are also more representable when it comes to ref struct. ref struct as generic argument is still on the way. Individually tracking ref lifetime of fields are not yet supported due to complexity.

[a44281071]

It's hard to use method as parameter. Like Rx, we must use IObservable to send/return value. Can not use old code to composite a todo logic.

[huoyaoyuan]

I'd rather say "check F#" for these type of concept. Composing methods in a functional way is something that F# focuses more. C# tends to care more about implicit overhead during composing.

[colejohnson66]

Duplicate of #4599?

[HaloFour]

I think related to splatting too: #424 #1654

[CyrusNajmabadi]

I don't know what this is asking for at a language level.

[Rekkonnect]

If I understand correctly, introducing the concept of decomposing a syntactic method invocation into a delegate (with a target) and its arguments in the form of a tuple.

For example,

(Action<int, int> method, var arguments) = somekeyword this.MyMethod(1, 2);

And perhaps the other way around:

Action<int, int> method; // some value
(int, int) args; // some value
method.ComposeInvoke(args);

The above could be combined:

(_, var arguments) = somekeyword this.MyMethod(1, 2);
var otherMethod = this.OtherMethod;
otherMethod.ComposeInvoke(arguments);

And OP suggests the >> operator for forwarding the arguments into a method group, where the above example would be represented as:

(_, var arguments) = somekeyword this.MyMethod(1, 2);
this.OtherMethod >> arguments;

And my take: I like the idea, I think the primary concern is composition more than decomposition. Would like to explore the options here.

[a44281071]

This is means that: We can use a method(name) as delegate. and use a tuple as a method parameters.
We can indeed achieve this by leveraging the advantage of returning multiple values.
The other proposals are also good, but they don't seem to have much attention.

[CyrusNajmabadi]

@a44281071 delegates can already take in tuples as arguments and return them as values. I'm not sure what exactly this is asking for that would be new for the language :)

[a44281071]

Here is the relevant content.
Tuples and Methods

And we can use tuple like 'property value' or 'app parameter'.