Multiple functions without leading/trailing mandatory parts?

Question

Are we allowed to have multiple functions without the verbose Func-parts which are calling each other as code-golf submission?

For example, in Java 8+ this is an allowed answer based on the current meta:

n->doSomethingWithInput

// Which is short for this (Integer parameter & String return-type):
Function<Integer,String>f=n->doSomethingWithInput;

But what if we call one method inside another (1):

n->f(n)+doSomethingMore
f=n->doSomethingWithInput

Are we allowed to post this above, or should we post this instead (2):

n->f.apply(n)+doSomethingMore
Function<Integer,String>f=n->doSomethingWithInput;

Or shorter using a regular method instead of lambda (3):

n->f(n)+doSomethingMore
void f(int n){return doSomethingWithInput;}

Or should it be this instead perhaps (4):

n->f.g(n)+doSomethingMore
F f=n->doSomethingWithInput;

// Where F is an interface like this:
interface F{String g(int n);}

Or should it be this instead (thanks @MartinEnder) (5):

f=n->g(n)+doSomethingMore
g=n->doSomethingWithInput

---

Personally I'd say (1) should be allowed, or perhaps (4). (For now I've used (3) in some recent Java 8 answer.)
My vote goes to (5), because you clearly see there are two methods (f and g), and function f is calling g).

Answer 1

This answer assumes C#, I do not believe (explained below) that this can be answered in a way that applies to numerous languages.

As we have discovered, this is not an easy question to answer... This answer is based on my miserable commentary from another question about C# and Lambdas. The reason I do all this talking to start with is because we have half a dozen questions about statically typed languages, and they have achieved almost nothing, so I'm stating (and assuming) some general (language specific) rules that we could use before trying to answer this questions which should be answerable by understanding the general rules about the language (though we can add more specific rules if we wanted). I shall probably write a meta question up about these 'general rules' in due course.

Your code should be self-contained and well defined

We can define 'well defined' on a per language basis. If we want enforcable rules, we have to do this, because it is well recognise that we don't require code that compiles on it's own, so we need per-language rules to decide what is or is not well defined. For example, taking C# as an example (widly applicable to Java): we define 'well defined' code as code which compiles under one of the trivially identifiable and applicable situations below:

As a complete program

That is, something you can stuff in a file, called csc mycode.cs on it and get csc mycode.exe out.

As a member of a class

Example E

Stuff your code into the boilerplate below. You may not define your own boilerplate in your answer, that would be silly.

/*usings here perhaps?*/

class LONGCLASSNAMETHATWONTCLASH
{
    /*submission here*/

    /*calling code (in a method or w/e)*/
}

As a locally defined function

Example F

More C&Ping...

class ANOTHERLONGCLASSNAMETHATWONTCLASH
{
    void LONGMETHODNAMETHATWONTCLASH()
    {
        /*submission code*/

        /* calling code */
    }
}

As an anonymous well-typed method

Example H

And from Martin's prompting, maybe we can even stretch to not requiring you to put brackets around your well typed lambdas:

// taken to be in a method
var result = (/*submission here*/)(/*arguments*/);

Now to answer the question at hand...

.... Assuming all of the above (which we have no consensus on at this time), we have to find a way to fit 2 named function definitions into one of these boilerplates above. This makes everything very simple, your best option is member functions (or local functions (C# 7)):

typename f(typename n)=>g(n)+doSomethingMore;
typename g(typename n)=>doSomethingWithInput;

I'm not sure what the shortest Java code would be under similar rules.

If we agreed to add a surprise semi-colon in the (example) boilerplates, we could often spare ourselves a byte, but would invalidate many answers also. Alternatively, we could be generous and allow either with or without a semi-colon (they should't change the meaning ,but C# can be picky about these things (and given the small space or allowed boilerplate, you could argue it doesn't matter)).

Counter Discussion

Indeed, one could argue that writing one method has a much lower overhead than writing two (and this is what the question is saying). That could be a separate decision, but until we have general rules for languages, it is just going to add to the confusion and misery that is ruling (in particular) on statically typed languages (that is, if you are of a similar miserable school of thought to that I am).

Some sort of delimiter would absolutely be necessary (i.e. you can't just say it is two functions, the code needs to make this clear, and the code that does so must be included in the byte count).

Answer 2

Your code needs to compile

Some minor tweaks:

n->doSomethingWithInput

This actually isn't allowed. You are in a manifestly-typed language. You have to declare the type of the input. So, this looks like: (int n)->doSomethingWithInput

// Which is short for this (Integer parameter & String return-type):
Function<Integer,String>f=n->doSomethingWithInput;

It isn't shorthand, the two statements mean different things. The former is a literal function. The latter is an assignment of a function into a variable.

As for the rest of your examples, none of them are valid Java code, so none of them are acceptable.

Some valid submissions:

(int n)->n   
// Function literal.  If you paste this anywhere that wants a function literal, it'll work.


Function<Integer,Integer>f=n->n; 
// Assigning function to a variable.  If you use this variable, it'll just work

Function<Integer,Integer>f=n->n
Function<Integer,Integer>g=n->f(n);
// Two functions, and the second uses the first.
// You'll need to indicate which variable to use in the post


F f=n->doSomethingWithInput;
Function<Integer, String> n->f.g(n)+doSomethingMore
interface F{String g(int n);}
// Because Java only allow 1 interface/class per file, I think we allow them to be inline. 
// I may be wrong, and I can't find a meta post on it

Some invalid submissions:

Function<Integer,Integer>f=n->n
n->f(n)
// This code doesn't compile, no matter where you put it.  
// You can't put it where a function literal is required, 
// You can't put it where statements are required

The above example basically covers all of your examples. If you are able to copy/paste it, and have it compile, it's valid. (Excepting for inline classes/interfaces)