GS2 → K, 2 bytes

•+

This prints a tacit, monadic function. The source code uses the CP437 encoding.

Test run

$ xxd -c 2 -g 1 sum-func.gs2
00000000: 07 2b  .+
$ printf 42 | gs2 sum-func.gs2
42+
$ kona
K Console - Enter \ for help

  (42+) 69
111
  f : 42+
42+
  f 69
111

How it works

GS2

• GS2 automatically reads from STDIN and pushes the input on the stack.

• • indicates that the next byte is a singleton string literal.

• Before exiting, GS2 prints all stack items.

K

Left argument currying is automatic in K.

Here, n+ turns the dyadic function + into a monadic function by setting its left argument to n.

ShapeScript → J, 4 bytes

"&+"

This prints a tacit, monadic verb. Try it online: ShapeScript, J

Test run

$ cat sum-func.shape; echo
"&+"
$ printf 42 | shapescript sum-func.shape; echo
42&+
$ j64-804/jconsole.sh 
   42&+ 69
111
   f =: 42&+
   f 69
111

How it works

ShapeScript

• ShapeScript automatically reads from STDIN and pushes the input on the stack.

• "&+" pushes that string on the stack.

• Before exiting, ShapeScript prints all stack items.

J

& performs argument currying.

Here, n&+ turns the dyadic verb + into a monadic verb by setting its left argument to n.

GolfScript → CJam, 4 bytes

{+}+

This prints a code block (anonymous function). Try it online: GolfScript, CJam

Test run

$ cat sum-func.gs; echo
{+}+
$ printf 42 | golfscript sum-func.gs
{42 +}
$ cjam
> 69 {42 +} ~
111
> {42 +}:F; 69F    
111

How it works

GolfScript

• GolfScript automatically reads from STDIN and pushes the input on the stack.

• {+} pushes that block on the stack.

• + performs concatenation, which happily concatenates a string and a block.

• Before exiting, GolfScript prints all stack items.

CJam

{n +} is a code block that, when executed, first pushes 42 on the stack, then executes +, which pops two integers from the stack and pushes their sum.

R to Julia, 19 bytes

cat("x->x+",scan())

This reads an integer from STDIN using scan() and writes an unnamed Julia function to STDOUT using cat(). The Julia function is simply x->x+n, where n comes from the R program.

BrainF*** to JavaScript ES6, 57 bytes

----[-->+++<]>--.[-->+<]>+.+.--[->++<]>.[--->+<]>+++.[,.]

(Assumes that the input is composed of numeric characters)

Say 1337 is your input. Then, this would compile to:

x=>x+1337

O to K, 5 bytes

i'++o

Thanks to @kirbyfan64sos

Seriously to Python, 15 bytes

,"lambda n:n+"+

Expects input to be in string form, i.e. "3"

Explanation:

,: read value from input
"lambda n:n+": push this literal string
+: concatenate top two values on stack

><> to Python, 25 + 3 = 28 bytes

"v+x:x adbmal
o/?(3l
;>~n

Takes input via the -v flag, e.g.

py -3 fish.py add.fish -v 27

and outputs a Python lambda, e.g. lambda x:x+27.

For a bonus, here's an STDIN input version for 30 bytes:

i:0(?v
x+"r~/"lambda x:
o;!?l<

Mouse to Ruby, 19 bytes

?N:"->x{x+"N.!"}"$

Ungolfed:

? N:       ~ Read an integer from STDIN, store in N
"->x{x+"   ~ Write that string to STOUT
N. !       ~ Write N
"}"$       ~ Close bracket, end of program

This creates an unnamed Ruby function of the form ->x{x+n} where n comes from Mouse.

Rotor to K, 2 bytes

'+

Might as well jump in on the K bandwagon.

Mathematica to C#, 20 bytes

"x=>x+"<>ToString@#&

Outputs a C# Func<int, int> of form

x=>x+n

rs -> K, 2 bytes

/+

Live demo.

Pyth -> K, 4 bytes

+z\+

K is really easy to abuse here...

Live demo.

Pyth to APL, 7 5 bytes

+z"--

The Pyth code simply concatenates the input (z) with the string "--". This creates an unnamed monadic train in APL with the form n--, where n comes from Pyth. When calling it in APL, (n--)x for some argument x computes n--x = n-(-x) = n+x.

Try: Pyth, APL

Saved 2 bytes thanks to Dennis!

POSIX shell to Haskell, 19 bytes

read n;echo "($n+)"

Anonymous functions being allowed, Haskell is a good output choice with the operator sections.

Microscript II to Javascript ES6, 9 bytes

"x=>x+"pF

Python to CJam, 18 bytes

lambda n:"{%f+}"%n

The Python does a basic string format. %f is the code for a float, and since I wouldn't lose any bytes for handling floats, I went ahead and did so.

The CJam is much the same as the Golfscript->CJam answer. It looks something like this:

{7.4+}

or:

{23+}

It's a block that takes the top value off the stack, pushes the special number, then adds them.

PHP → JavaScript (ES6), 20 24 bytes

Reading from STDIN is always expensive in PHP. It looks a bit strange:

x=>x+<?fgets(STDIN);

It prints x=>x+ and waits for user input to complete the string, terminates with the complete anonymous JavaScript function, e.g. x=>x+2.

First version (24 bytes)

<?='x=>x+'.fgets(STDIN);

Haskell to Mathematica, 14 bytes

(++"+#&").show

GNU sed to C, 46 bytes

sed -r 's/^([0-9]+)$/f(int x){return x+\1;}/'

Retina to Pip, 4 bytes

Uses one file for each of these lines + 1 penalty byte; or, put both lines in a single file and use the -s flag.

$
+_

Matches the end of the input with $ and puts +_ there. This results in something of the form 3+_, which is an anonymous function in Pip.

Bash → C/C++/C#/Java, 33 bytes

and maybe others

echo "int f(int a){return a+$1;}"

Chaîne to JavaScript ES6, 7 bytes

Again, assumes numeric input.

x=>x+{i
~~~~~~~
x=>x+   ; write that text
     {  ; command sequence
      i ; read input and push to stack
        ; implicit: take top entry on stack and pushes it to writing string
        ; implicit: close }
        ; implicit: print string

JavaScript to Lambda Calculus, 21 bytes

(This uses the linked document as a basis.)

x=>`λa(${x}(add a))`

Say input is 5. Then this becomes:

"λa(5(add a))"

Tiny Lisp to Ceylon, 68

(d u(q((n)(c(q(Integer x))(c(q =>)(c(c(q x)(c(q +)(c n())))()))))))

Tiny Lisp doesn't have real input and output – it just has expression evaluation. This code above creates a function and binds it to u. You can then call u with the argument n like this: (u 7), which will evaluate to this Tiny Lisp value:

((Integer x) => (x + 7))

This is a valid Ceylon expression, for an anonymous function which adds 7 to an arbitrary integer.

Ceylon to Tiny lisp, 76

shared void run(){print("(q((x)(s ``process.readLine()else""``(s 0 x))))");}

This produces (after reading a line of input) output like (q((x)(s 5(s 0 x)))), which evaluates in Tiny Lisp to ((x) (s 5 (s 0 x))), a function which takes an argument x, subtracts it from 0, and subtracts the result from 5. _{(Yeah, this is how one adds in Tiny Lisp, there is only a subtraction function build in. Of course, one could define an addition function first, but this would be longer.)}

You can use it like this as an anonymous function:

((q((x)(s 5(s 0 x)))) 7)

(This will evaluate to 12.)

Or you can give it a name:

(d p5 (q((x)(s 5(s 0 x)))))
(p5 7)

^{Corrections and Golfing Hints from DLosc, the author of Tiny Lisp.}

Powershell to EmacsLisp, 37 bytes

function p($a){"(defun p(x)(+ $a x)"}

EmacsLisp to Powershell, 44 bytes

(defun p(x)(format"function p($a){%s+$a}"x))

Javascript ES6 to ಠ_ಠ, 34 bytes

_=>`ಠ${[...'_1+'].join`ಠ
ಠ`}ಠ`

You can try the ಠ_ಠ interpreter here.The ಠ_ಠ program takes input and adds one to it.

Vitsy to K, 5 Bytes

\o/ K will be being used very soon if it can do this.

N'+'Z

or maybe...

N'+'O

If the input is taken as a string (only for 0-9 input)...

i'+'Z

All of these, for input 2, will output:

2+

C# to Mathematica, 10 bytes

n=>n+"+#&"

Outputs a Mathematica Function of form

n+#&