What even is a "function" by our standards?

Question

On a recent question, the following was brought up by @Sp3000:

In fact, I'm almost starting to wonder what a "function" is, since it seems like every language with goto could define a "function" the same way...

What are the most basic restrictions for what can be defined as a "function", an allowed answer type, that separates it from a "snippet", which is not allowed?

Answer 1

A function is an independent routine which can perform I/O in some form.

It is a section of code, which can be directly inserted into a program with no modification, and should be able to be assigned/named/referred to in some way.

It should be able to run independent of surrounding code.

It should be able to take input/output in some form.

The function should be able to perform a successive chain of operations. Meaning these "functions" should be able to somehow be used in a program to fulfill the definition of one. A function only capable of doing a single binary operation wouldn't be valid unless, recursion or some other way for a successive operation to be performed exists

A functions call should not require calling any other functions or code besides defining the input. A function should receive the input in a format that's is compliant with the challenges rules

A function should have a way for he input to be directly passed to it (it doesn't have to take input in that way, just the functionality should be available)

---

That said, if it's blatantly obvious it's not a function, it's not a function.

---

Also as @Mego said:

Python has functions. Anything else is not a function. The further explanations in the answer are intended to be used for languages that don't have a cut-and-dry definition of a function

We know what a function is. It's futile calling what's not a function a function, it's very difficult to come up with a perfectly objective set of rules describing what a function is, but we all know what a function is, and what it is not.

If the language formally defines it to be a function/method/lambda, it's a function. this doesn't mean an esolang creator abusing their ability to define a function, is exempt from rules and other restrictions applied upon programs and functions.

---

In your question you asked if gotos could be considered functions. IIRC, they can't have I/O passed directly through them, so no.

Answer 2

A function is a piece of reusable code that will produce consistent output(s) given consistent input(s). Note that consistent doesn't necessarily mean identical; it merely means that the function won't do something unexpected (i.e. randint(1, 4) will always return a random integer n such that 1 <= n <= 4, and never an integer outside of that range, a floating point value, or the lyrics to a song).

Additionally, there must be some consistent method of providing input to the function (like function arguments, putting input on the stack, or saving input in specified registers), a consistent method of retrieving the output (like return values, modified parameters, stack contents, or register contents), and a consistent method of calling the function.

For languages that have support for functions/methods/procedures, their built-in functions are acceptable so long as they meet these requirements. Additionally, for any language (including languages without such constructs such as purely imperative languages), if there is a way to write a piece of code that adheres to the above constraints, it is acceptable.

As for writing a submission that uses a function, the result of evaluating the submission code should either result in a named function being defined, or an unnamed function being defined that can be assigned a variable reference, and can subsequently called.

Examples of acceptable submissions (not an exhaustive list):

• Macro functions (C/C++: #define ISEVEN(X) (X % 2 == 0))
• Named and unnamed lambda functions (Python: lambda x: x % 2 == 0)
• Functions with helper functions also defined (Python: f = lambda x: x == 0; lambda x: f(x % 2))

Answer 3

A function returns back to where it came from

A function is has two parts: An arbitrary length block of code which is run when the function is "called", and a "calling" statement.

After the block of code has run, the code pointer must automatically return back to the statement that made the call.

The key word is automatically. A GOTO at the end of a code block is not automatic.

Answer 4

Here is my definition of a function:

1. A function must have the ability to be called by its name, object, reference, or other handle (this prevents code snippets). The only exception to this is the main method (or equivalent) of a program.
2. A function must be able to take data as input by accepting parameters and output data by returning values. If side-effects occur, the function shouldn't exploit them; any parameters should be arguments, and any results should use your language's equivalent of return.
3. Multiple functions can be counted as one function, provided that each helper function meets the 2 previous conditions.

Lastly, as @Downgoat's answer says, if something is obviously not a function, then it shouldn't be treated as such.

---

A full program is any code that can be compiled, interpreted, or otherwise executed in a non-REPL environment without any modification. Note that some code can be classified as both functions and full programs.

Anything that is not either a function or a full program is a code snippet.

---

For an example, let's look at Java lambda expressions.

1. You can assign a lambda expression to an object, so it passes the handle test.
2. It is possible to write a lambda expression that accepts parameters and returns values.

For example:

(int a, double b)->{
    return 4;
}

Since a lambda that satisfies #2 exists, any lambda is considered a function, even those that don't accept parameters:

()->{
    System.out.println("Lambda is running");
}

3. N/A

---

I made a quick flowchart to categorize various bits of code (sorry for my lack of flowcharting skills):