Logo

Programming-Idioms

  • Python
  • Go

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.

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 is generic, it accepts any type parameters T, U, V.
func composeIntFuncs(f func(int) int, g func(int) int) func(int) int {
	return func(x int) int {
		return g(f(x))
	}
}

These specific functions take and return concrete types.

It could be done with an empty interface, but that would discard static type checks (the implementations of f and g can still be type-checked, though).
compose = lambda f, g, x: \
    lambda x: g(f(x))
def compose(f, g):
	return lambda x: g(f(x))

This is the same as for non-generic composition
(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 
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))
	}
}
func composeIntFuncs(f func(int) int, g func(int) int) func(int) int {
	return func(x int) int {
		return g(f(x))
	}
}
compose = lambda f, g, x: \
    lambda x: g(f(x))
def compose(f, g):
	return lambda 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.
compose f g = g . f

function compose(f,g){
    return function(x){
        return g(f(x));
    };
}
const compose = f => g => x => 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)
  f >> g
end
def compose(f, g)
  -> x { g.(f.(x)) }
end
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)))
}
(define compose
 (lambda (f g)
   (lambda (x) (f (g x)))))
(define (compose f g) 
	(lambda x 
		(f (apply 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