• Haskell

compose :: (A -> B) -> (B -> C) -> A -> C
compose = flip (.)

• Haskell

compose :: (A -> B) -> (B -> C) -> A -> C
compose f g x = g (f x)

• Clojure

(defn compose [f g]
   (comp g f))

• C++

std::function<C (A)> compose(B (&f)(A), C (&g)(B))
{
    return [&f, &g](A a){return g(f(a));};
}

auto fn = compose(f, g);

• C#

Func<A, C> compose(Func<A, B> f, Func<B, C> g) => a => g(f(a));

• D

auto compose(f, g) {
	return std.functional.compose!(f, g);
}

• Dart

typedef R Func<T,R>(T arg);

Func<A,C> compose(B f(A x), C g(B x)) => (A x) => g(f(x))

• Elixir

def compose(f, g) do
  fn a ->
    g.(f.(a))
  end
end

• Erlang

-spec compose(fun((A) -> B), fun((B) -> C)) -> fun((A) -> C).
compose(F, G) -> fun(X) -> G(F(X)) end.

• Go

func compose(f func(A) B, g func(B) C) func(A) C {
	return func(x A) C {
		return g(f(x))
	}
}

• JS

function compose(f,g){
    return function(x){
        return g(f(x));
    };
}

• Java

Function<Integer, Integer> addOne = i-> i + 1;
Function<Integer, String> toString = i-> i.toString();
Function<Integer, String> printIncremented = toString.compose(addOne);

• Java

public Function<A, C> compose(Function<A, B> f, Function<B, C> g) {
   return x -> g.apply(f.apply(x));
}

• Java

<A, B, C> Function<A, C> compose(Function<A, B> f, Function<B, C> g) {
    return f.andThen(g);
}

• Lua

function compose(f,g)
   return function(x)
      return g(f(x))
   end
end

• PHP

function compose($f, $g)
{
    return function ($x) use ($f, $g) {
        return $g($f($x));
    };
};

• Perl

sub compose {
   my ($f, $g) = @_;
   return sub {
      return $g->($f->(shift))
   }
}

sub double { return 2*shift }
sub triple { return 3*shift }
sub aFunc = compose(\&double, \&triple);
aFunc->(7);

• Python

def compose(f, g):
    return lambda a: g(f(a))

• Ruby

def compose(f, g)
  -> x { g.(f.(x)) }
end

• Rust

fn compose<'a, A, B, C, G, F>(f: F, g: G) -> Box<Fn(A) -> C + 'a>
	where F: 'a + Fn(A) -> B, G: 'a + Fn(B) -> C
{
	Box::new(move |x| g(f(x)))
}

• Rust

fn compose<A, B, C>(f: impl Fn(A) -> B, g: impl Fn(B) -> C) -> impl Fn(A) -> C {
    move |x| g(f(x))
}

• Scheme

(define (compose f g)
  (lambda (x) (g (f (x)))))

• VB

Function compose(f As Func(Of A, B), g As Func(Of B, C)) As Func(Of A, C)
    Return Function(a) g(f(a))
End Function