Be concise.
Be useful.
All contributions dictatorially edited by webmasters to match personal tastes.
Please do not paste any copyright violating material.
Please try to avoid dependencies to third-party libraries and frameworks.
- JS
- Clojure
- C++
- C#
- D
- Dart
- Elixir
- Erlang
- Go
- Haskell
- Haskell
- Java
- Java
- Java
- Lua
- PHP
- Perl
- Python
- Ruby
- Rust
- Rust
- Scheme
- VB
function compose(f,g){
return function(x){
return g(f(x));
};
}(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);using lambda
typedef R Func<T,R>(T arg);
Func<A,C> compose(B f(A x), C g(B x)) => (A x) => g(f(x))Function types can be written directly on parameters, but not in the return type, so it needs a typedef to declare the types of this function.
Without the types it's just:
compose(f,g)=>(x)=>g(f(x));
Without the types it's just:
compose(f,g)=>(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))
}
}Functions are first-class citizens in Go. They are passed as arguments and as return values.
compose :: (A -> B) -> (B -> C) -> A -> C
compose = flip (.)Function composition is performed by the function ".". The parenthesis in the implementation are because the function is an operator and is usually infix.
The function flip swaps the order of the arguments to the function it is applied to, since the compose function has type signature (B -> C) -> (A -> B) -> A -> C.
The type signature (the first line) is optional and could be omitted.
The function flip swaps the order of the arguments to the function it is applied to, since the compose function has type signature (B -> C) -> (A -> B) -> A -> C.
The type signature (the first line) is optional and could be omitted.
compose :: (A -> B) -> (B -> C) -> A -> C
compose f g x = g (f x)The type signature (the first line) is optional and could be omitted.
public Function<A, C> compose(Function<A, B> f, Function<B, C> g) {
return x -> g.apply(f.apply(x));
}Functional interfaces have a built-in a instance method andThen() that composes the argument with the receiver.
<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);
function compose(f,g)
return function(x)
return g(f(x))
end
endfunction 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);
To pass a function reference to a function, you need the \& operator. To call a function reference, you need to use ->.
def compose(f, g):
return lambda a: g(f(a))We could have used a named function but a lambda is shorter
def compose(f, g)
-> x { g.(f.(x)) }
end
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.
fn compose<A, B, C>(f: impl Fn(A) -> B, g: impl Fn(B) -> C) -> impl Fn(A) -> C {
move |x| g(f(x))
}(define (compose f g)
(lambda (x) (g (f (x)))))