Write a function [closed]

Question

I honestly can't believe this challenge does not already exist.

The challenge

Write a function.

The specifics

• Your program must define some sort of callable function. This includes anything commonly known as a function, a lambda function, or a subroutine. All of these types of callables will be referred to as a "function" in this post.

  1. Input to the function is optional and not required.

  2. A return value from the function is also optional and not required but control must return to the calling program.

• The function must be assigned to some sort of variable so that it is possible to be accessed at a later time. This includes indirect assignment (in most common languages where declaring a named function automatically adds the name into the current scope) and direct assignment (assigning an anonymous function to a variable directly).

• The function does not need to be named.

• The function must be created by you - you cannot just assign a default function from the language to a variable.

• None of the standard loopholes, please.

This is code-golf, so lowest score in bytes wins.

Answer 1

x86 / x64 machine code, 1 byte

c3

Assembly:

ret

Try it online! (nasm)

¯\_(ツ)_/¯

Answer 2

Jelly, 0 bytes

Try it online!

A monadic link that returns its argument. Since it is the first function to appear in the script, it can be called using 1Ŀ.

Thanks to @lirtosiast for pointing out that a 0 byte link/function would work in Jelly.

I.e.

3,4,5 1Ŀ

Try it online!

Answer 3

Javascript, 6 bytes

f=_=>0

Includes variable assignment. Not much to see here.

Answer 4

Haskell, 3 bytes

o=9

This code defines a polymorphic function called o which takes one type parameter and one typeclass instance parameter. When this function is called, it takes the given typeclass instance, gets its fromInteger member, calls that member with the Integer value for 9, and returns the result.

Granted, what I just described is merely the behavior of the Haskell function 9, and my code merely defines a function called o which is equivalent to 9.

Now the only question is, is the 9 function "created by you," or is it "a default function from the language"?

I think that it is "created by you." My reason for saying this is that if you read the specification for Haskell, you will (I assume) find no mention of a 9 function anywhere. Instead, the specification states that you can create a number literal by stringing together one or more digits. Therefore, by writing a string of digits, I have written a function—even if I just so happen to have only used one digit.

Answer 5

Python 3, 9 bytes

def f():1

Try it online!

Answer 6

ZX Spectrum BASIC, 6 bytes

DEF FN f()=PI

Hex dump: CE 66 28 29 3D A7. CE is a 1-byte keyword for DEF FN (including the trailing space), while A7 is a 1-byte keyword for PI. Call using FN f(). Example program:

  10 PRINT FN f(): DEF FN f()=PI

Output:

3.1415927

Answer 7

R, 9 bytes

body(t)=0

Try it online!

I think this complies with the rules. The function t takes no input and outputs 0. This works because there already exists a function called t (the transposition function) and it redefines the body of the function; it would not work with say body(a)=0 (no object called a) or body(F)=0 (F is a logical, not a function). I think it complies because it is still created by me: I am not reusing what the pre-defined function does, simply its name.

I don't think I've ever seen this used by R golfers, but there may be situations where it allows us to save a few bytes on challenges where we need a helper function.

A more standard solution would have been:

R, 13 bytes

f=function()0

Try it online!

Function which takes no input and outputs 0. This is 1 byte shorter than the function which takes no input and outputs nothing, which would be

f=function(){}

If we try to define a function with no body (f=function()), R interprets this as an incomplete command (this might not be true in older versions of R).

As pointed out by OganM, we take this down to 11 bytes with

R, 11 bytes

function()0

Try it online!

which technically complies with the challenge requirement that the function be assigned to some sort of variable, since it is (ephemerally) assigned to .Last.value.

Answer 8

Perl 6, 5 bytes

$!=!*

Try it online!

Creates a Whatever lambda that returns the boolean not of its parameter, and assigns it to the variable $!.

Answer 9

C (gcc), 5 bytes

Defines a function f that takes no arguments and technically returns an undefined integer value.

f(){}

Try it online!

Answer 10

Whitespace, 7 bytes

Creates a subroutine that returns control to the caller.

Explained in context:

[N
S S N
_Create_Label][N
T   N
_Return]

Try it online!

Answer 11

[Wolfram Language (Mathematica)], 1 byte

This one is slightly questionable:

f

Defines f, which can be "called" e.g. by f[], which "returns" the expression f[]

Answer 12

Forth (gforth), 5 bytes

This is a function named f that does nothing.

: f ;

Try it Online

In the TIO code, I added a footer of see f, which prints the definition of the function.

Answer 13

Lua, 8 bytes

f=load''

Try it online!

Defines a (global) function f.

This uses Lua load function to compile given string which happens to be empty in our case (empty code is valid code) into function which does exactly what we wrote in its body: nothing.

For ones wondering, standard solution would be

function f()end

but this is longer (15 bytes).

Answer 14

POSIX sh, 6 bytes

s()(1)

Using curly braces requires one more character.

Answer 15

Java, 10 Bytes

this should match the rules of the challenge

void f(){}

Answer 16

Perl 5, 7 bytes

sub f{}

Try it online!

Answer 17

Kotlin, 8 bytes

val f={}

An empty function stored in a variable f.
Call it using f() or f.invoke().

Answer 18

shortC, 1 byte

A

Try it online!

Transpiles into this C:

 int main(int argc, char **argv){;}

Answer 19

C (gcc), 14 13 bytes

(*f)()=L"Ã";

Try it online!

This defines a function f returning int and accepting an unspecified number (and type) of parameters, the machine code of which is contained within the string literal. The unicode character Ã (stored in memory as 0xc3 0x00 0x00 0x00 on a little endian machine) corresponds to the x86 ret instruction that returns from the function. Non x86 architectures may require different opcode(s) to return.

gcc may require the -zexecstack flag to avoid a segfault.

Answer 20

Pascal, 22 bytes

procedure A;begin end;

Answer 21

Haskell, 5 bytes

f x=0

Try it online!

Answer 22

Tcl, 6 5 11 bytes

set f {_ ;}

Try it online!

Including the assignment to the variable f as part of the bytecount to comply with rules. With this change, the more conventional definition below ties the one above for bytecount:

proc f _ {}

Answer 23

XSLT, 134 bytes

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform"><xsl:template name="a"></xsl:template></xsl:stylesheet>

A template is the closest thing this language has to a function. It can definitely be called; it takes zero arguments and "returns" the empty string.

Answer 24

Binary lambda calculus, 1 byte

0100_0010

In lambda calculus: (λf. _)(λx. x)

The underscore denotes where the rest of the program should go. The function can be accessed through its De Bruijn index.

Answer 25

F# (.NET Core), 9 bytes

let f a=a

Try it online!

Answer 26

Ruby, 6 bytes

Proc called f which accepts no argument and returns nil.

f=->{}

Try it online!

Answer 27

Python 3, 10 bytes

f=lambda:0

Try it online!

Answer 28

AppleScript, 10

on a()
end

Explained, compiled, and including invocation:

on a()    -- declare event handler "a"
end a     -- end declaration

-- invoke it:
a()

Answer 29

Japt, 2 bytes

_

Called as $U ($.

_ can be replaced with @, Ï, or È.

Try it

Answer 30

SmileBASIC (>=3), 9 bytes

DEF A
END

Function is called by A.