Logo

Programming-Idioms

This language bar is your friend. Select your favorite languages!
  • Rust

Idiom #36 First-class function : generic composition

Implement a function compose which returns composition function g ∘ f for any functions f and g having exactly 1 parameter.

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.
(comp g f)

Function composition is already a function in Clojure's core API. It has no restriction on numbers of parameters.
New implementation...
< > ⌨
programming-idioms.org 
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)))
}
(comp g f)
template<typename Pred1, typename Pred2>
auto compose(Pred1 f, Pred2 g){
  return [f,g](auto x){ return g(f(x)); };	
}
Func<T1, T3> compose<T1, T2, T3>(Func<T1, T2> f, Func<T2, T3> g) => x => g(f(x));
auto _compose(T)(T function(T) f, T function(T) g)
{
    auto lambda = (T x) { return g(f(x));  };
    return lambda;
}
compose(f, g) => (x) => g(f(x));
-spec compose(fun((X) -> Y), fun((Y) -> Z)) -> fun((X) -> Z).
compose(F, G) -> fun(X) -> G(F(X)) end.
func composeIntFuncs(f func(int) int, g func(int) int) func(int) int {
	return func(x int) int {
		return g(f(x))
	}
}
func compose[T, U, V any](f func(T) U, g func(U) V) func(T) V {
	return func(x T) V {
		return g(f(x))
	}
}
compose f g = g . f

const compose = f => g => x => g(f(x));
function compose(f,g){
    return function(x){
        return g(f(x));
    };
}
    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
        Objects.requireNonNull(before);
        return (V v) -> apply(before.apply(v));
    }

(defun compose (f g)
  (lambda (x) (g (f 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 {
      my $x = shift;
      return $g->($f->($x));
   }
}
def compose(f, g):
	return lambda x: g(f(x))
compose = lambda f, g, x: \
    lambda x: g(f(x))
def compose(f, g)
  f >> g
end
def compose(f, g)
  -> x { g.(f.(x)) }
end
(define (compose f g) 
	(lambda x 
		(f (apply g x))))
(define compose
 (lambda (f g)
   (lambda (x) (f (g x)))))
Function Compose(Of T1, T2, T3)(f As Func(Of T1, T2), g As Func(Of T2, T3)) As Func(Of T1, T3)
    Return Function(x) g(f(x))
End Function