Byte count for named, recursive lambda expressions in C# answers

Question

I have been questioned about the byte count in my C# answer for the The Snail in the Well challenge. Usually C# answers only need to count the following bytes:

(a,b)=><do_something>

with the rest of the code being in the header or footer. So at first my answer was like this:

(a,b,c)=>a>b?1+f(a-b+c,b,c):1

Then Martin Ender noted that if I call a f method in my code, I should include that assignment in the code, so I changed it to

f=(a,b,c)=>a>b?1+f(a-b+c,b,c):1

Then Martin said that I should also declare the f variable and add the trailing ;, rendering my answer into something like this:

System.Func<int,int,int,int>f=null;f=(a,b,c)=>a>b?1+f(a-b+c,b,c):1;

At this point the answer is useless as there are shorter ways to solve the problem using standard, non-recursive functions.

Usually the declaration of the lambda expression goes in the header, that's why I left it there. But I understand this is a recursive function, so what should I include in the answer (and therefore in the byte count)?

Answer 1

That structure is not self-contained

All the answers we expect must be self-contained.

The formulation f=<args>=><execution> is not self-contained.

Indeed, you can write

<type> f=<args>=><execution>

But C# doesn't allow the following construct:

foo.bar(f=<args>=><execution>);

This latter construct requires that f is typed before, like this:

<type> f;
foo.bar(f=<args>=><execution>);

So, while a lambda alone is self-contained, the structure f=<lambda> is not self-contained without the type of f, and is therefore not following the global rules of PPCG.

Answer 2

If I'm not mistaken, (my search has failed me), a unnamed function literal answer is defined along the lines of

a block of code that evaluates to a callable value

So, if your submission is

<code>

You should be able to do one of the following (structures) to run your answer:

<type> <result> = (<code>).call(<params>);

<type> <name> = <code>;
<type> <result> = <name>.call(<params>);

Or, as a function answer, adding your code should (in a language-defined way) provide a callable binding which solves the problem.

In Python, f=lambda ... works because after its execution, a binding f exists which is a reusable callable binding which solves the question.

In C-like languages, <type> f() { ... } works because after its inclusion in a source file, a callable binding f exists which is a reusable solution to the question.

In Java/C# though, we've run into the issue of typing with our unnamed function. As in the related issue about typing lambdas, we allow just the literal because the question itself gives the context to infer the required type of the binding, and it's more consistent with other languages' scoring.

However, I don't think this should extend to when the function needs to be named. At that point, you are no longer submitting an answer as an unnamed function, but as a block of code that after inclusion defines a function binding.

f=<lambda> means nothing in C#. You need to provide a type to create a name binding in C#.

I think C# has an opinion on this as well:

Cannot assign lambda expression to an implicitly-typed variable

I was going to suggest the use of var, but C# disallows that, likely because of the discussed issues about typing a lambda.

My position is that if you need to name the function submission, you need to provide a proper function submission, that is: code that, when included, defines a callable name binding which can be used to solve the question.

An unnamed function expression needs to be that: an unnamed function expression that I assign to a variable (and thus take the typing responsibility).

TL;DR this shouldn't be an allowed submission format, use a proper function declaration if you need to call it.

I agree with the summary in this answer, with the extension of allowing combining any number of defined functions with one anonymous function which is the submission.

TL;DR TL;DR: Oliver's answer expresses the same sentiment and I agree with it fully.

Answer 3

If a lambda is to be called it should show what it is assigned to, so the following:

f=<args>=><someRecursiveWork>

If we view the code needing to compile this it looks like the following, note the trailing semi-colon:

System.Func<input...N, output> f = null;
f=<args>=><someRecursiveWork>;

However, we usually don't require trailing semi-colons for C# lambdas so I believe we should follow that rule here too.

---

On a side note the top comment should also be applied to if an answer uses multiple lambdas to delegate some work off:

g=<args>=><someWork>
<args>=><someWorkWithG>

Note how what would be f is not showing what it is assigned too.