Logo

Programming-Idioms

  • Python
  • Rust
  • Ruby

Idiom #35 First-class function : compose

Implement a function compose (A -> C) with parameters f (A -> B) and g (B -> C), which returns the composition function g ∘ f

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

We could have used a named function but a lambda is shorter
fn compose<A, B, C>(f: impl Fn(A) -> B, g: impl Fn(B) -> C) -> impl Fn(A) -> C {
    move |x| g(f(x))
}
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)))
}

Unfortunately, you'll need to implement another two variants if you care about FnMut and FnOnce. Also, for now, you need to box the returned function. In the future, this shouldn't be necessary.
def compose(f, g)
  -> x { g.(f.(x)) }
end

(defn compose [f g]
   (comp g f))
New implementation...
< > ⌨
programming-idioms.org 
def compose(f, g):
    return lambda a: g(f(a))
fn compose<A, B, C>(f: impl Fn(A) -> B, g: impl Fn(B) -> C) -> impl Fn(A) -> C {
    move |x| g(f(x))
}
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)))
}
def compose(f, g)
  -> x { g.(f.(x)) }
end

(defn compose [f g]
   (comp g f))
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);
Func<A, C> compose(Func<A, B> f, Func<B, C> g) => a => g(f(a));
auto compose(f, g) {
	return std.functional.compose!(f, g);
}
typedef R Func<T,R>(T arg);

Func<A,C> compose(B f(A x), C g(B x)) => (A x) => g(f(x))
def compose(f, g) do
  fn a ->
    g.(f.(a))
  end
end
-spec compose(fun((A) -> B), fun((B) -> C)) -> fun((A) -> C).
compose(F, G) -> fun(X) -> G(F(X)) end.
func compose(f func(A) B, g func(B) C) func(A) C {
	return func(x A) C {
		return g(f(x))
	}
}
compose :: (A -> B) -> (B -> C) -> A -> C
compose f g x = g (f x)
compose :: (A -> B) -> (B -> C) -> A -> C
compose = flip (.)
function compose(f,g){
    return function(x){
        return g(f(x));
    };
}
<A, B, C> Function<A, C> compose(Function<A, B> f, Function<B, C> g) {
    return f.andThen(g);
}
Function<Integer, Integer> addOne = i-> i + 1;
Function<Integer, String> toString = i-> i.toString();
Function<Integer, String> printIncremented = toString.compose(addOne);

public Function<A, C> compose(Function<A, B> f, Function<B, C> g) {
   return x -> g.apply(f.apply(x));
}
function compose(f,g)
   return function(x)
      return g(f(x))
   end
end
function compose($f, $g)
{
    return function ($x) use ($f, $g) {
        return $g($f($x));
    };
};
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);

(define (compose f g)
  (lambda (x) (g (f (x)))))
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