def compose(f, g):
def wrapped(*args, **kwargs):
return g(f(*args, **kwargs))
return wrapped
def g(function):
@wraps(function) # __name__
def wrapped(*args, **kwargs):
return function(*args, **kwargs)
return wrapped
@g
def f():
...
compose = f
compose()
def compose(f, *functions):
def wrap(value, *wrappers):
if not wrappers:
return value
w, *wrappers = wrappers
return wrap(w(value), *wrappers)
def wrapped(*args, **kwargs):
arg = f(*args, **kwargs)
return wrap(arg, *functions)
return wrapped
function = compose(f, g)
value = function(123)
def compose(f, g):
return lambda a: g(f(a))
(defn compose [f g]
(comp g f))
template <typename A, typename B>
auto compose(A a, B b) {
return [=] (auto x) {
return b(a(x));
};
}
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));
};
}
public Function<A, C> compose(Function<A, B> f, Function<B, C> g) {
return x -> g.apply(f.apply(x));
}
Function<Integer, Integer> addOne = i-> i + 1;
Function<Integer, String> toString = i-> i.toString();
Function<Integer, String> printIncremented = toString.compose(addOne);
<A, B, C> Function<A, C> compose(Function<A, B> f, Function<B, C> g) {
return f.andThen(g);
}
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);
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 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
