Implement an Over function

Question

Over is a higher-order function in multiple languages such as APL (⍥). It takes 2 functions and 2 values as arguments, applies the first function to both values, then applies the second to their result. For example, using ⍥ to represent Over:

1 ²⍥+ 2

We would first calculate ² of each argument: 1² = 1 and 2² = 4. We then apply + to these, yielding 5.

You are to take as input:

• A black box function, \$f\$, which takes an integer as input and returns an integer
• A black box function, \$g\$, which takes 2 integers as input and returns a single integer
• 2 integers, \$a\$ and \$b\$.

You should then return the result of \$g(f(a), f(b))\$.

If you have a builtin specifically for this (e.g. APL's ⍥, Husk's ¤ etc.), consider including a non-builtin answer as well. It might even get you an upvote :)

You may input and output in the most convenient format for your language, and in any convenient method, including taking \$a\$ and \$b\$ as a pair/list/tuple [a, b]

For the sake of simplicity, you can assume that the black-box function will always input and output integers within your language's integer domain, and that \$a\$, \$b\$ and the output will be with your language's integer domain.

This is code-golf, so the shortest code in bytes wins

Test cases

f
g
a, b -> out

f(x) = x²
g(x,y) = x - y
-2, 2 -> 0

f(x) = φ(x)     (Euler totient function)
g(x,y) = 2x + y
5, 9 -> 14

f(x) = x³-x²-x-1
g(x,y) = y⁴-x³-y²-x
-1, -1 -> 22

f(x) = x
g(x,y) = x / y   (Integer division)
-25, 5 -> -5

Answer 1

Haskell, 12 bytes

f?g=(.f).g.f

Try it online!

Haskell was made for this.

Let's unpack it:

(f?g) x y =
(((.f).g.f) x) y =
(.f)(g (f x)) y =
((g (f x)).f) y =
g (f x) (f y)

If you're wondering what happens if we make this further pointfree in f and g, we can express (?) as:

\f->((.f).).(.f)
(.).(.).flip(.)<*>flip(.)

The flipped version of ? that's invoked as g?f is a little nicer:

((.).flip(.)<*>).(.)

(I used pointfree.io for these.)

Test cases copied from Unrelated String.

---

Haskell, 10 bytes

(.map).(.)

Try it online!

If the input [x,y] is a two-element list, and the binary function g accepts its two arguments as such a list. The main function takes is arguments as g then `f.

Answer 2

Factor, 16 bytes

[ bi@ rot call ]

Try it online!

Explanation:

It's a quotation (anonymous function) that takes a quotation with stack effect ( x x -- x ), two integers, and a quotation with stack effect ( x -- x ) on the data stack as input. It takes them in that order, as that allows for what I believe is the shortest code. Assuming the data stack looks like [ + ] 1 2 [ sq ] when this quotation is called...

• bi@ Apply a quotation to two objects.

  Stack: [ + ] 1 4

• rot Move the object third from the top to the top.

  Stack: 1 4 [ + ]

• call Call a quotation.

  Stack: 5

Factor, 10 bytes

map-reduce

Try it online!

Built-in.

Answer 3

J, 12 bytes

2 :'(u v)~v'

Try it online!

Non-built-in solution. This is an explicit conjunction that takes two functions on two sides and evaluates to a train that acts like "u over v", but with flipped arguments.

x ((u v)~v) y
x (u v)~ v y
(v y) (u v) x
(v y) u v x

J, 1 byte

&

Try it online!

J's built-in conjunctions can be assigned to a variable, unlike in Dyalog APL.

Answer 4

JavaScript (ES6), 23 bytes

(f,g,x,y)=>g(f(x),f(y))

Try it online!

Answer 5

Rust, 21 bytes

|f,g,x,y|g(f(x),f(y))

Try it online!

An anonymous function that has the signature

fn(fn(i32)->i32,fn(i32,i32)->i32,i32,i32)->i32

Don't you love it when the function signature is twice as long as the function itself?

Answer 6

Haskell, 17 16 15 bytes

(f!k)x=k(f x).f

Try it online!

-1 thanks to Wheat Wizard repatterning the use of infix

Answer 7

APL (Dyalog Classic), 9 bytes

{⍺⍺/⍵⍵¨⍵}

{⍺⍺/⍵⍵¨⍵}
 ⍺⍺          left operand (function argument)
   /         reduce
    ⍵⍵       right operand
      ¨      each
       ⍵     right argument

APL has a builtin for this, ⍥, but here's a non builtin solution as an operator taking an array of arguments.

Alternative 'proper' definition: {(⍵⍵⍺)⍺⍺⍵⍵⍵}, or more readably as {(⍵⍵ ⍺) ⍺⍺ ⍵⍵ ⍵}

Try it online!

Answer 8

Racket, 26 bytes

(λ(f g x y)(g(f x)(f y)))

Try it online!

λ is 2 bytes, BTW.

Pretty self-explanatory, but:

(λ(f g x y)(g(f x)(f y)))  Anonymous function submission
(λ                      )  Lambda;
  (f g x y)                accept functions f, g and arguments x, y and return
           (g          )   g(
             (f x)           f(x),
                  (f y)            f(y))

Answer 9

R, 29 bytes

function(f,g,a,b)g(f(a),f(b))

Try it online!

No surprises here. In a future version of R, function will be replaceable with \ (which is supposed to look like a lambda).

Answer 10

Wolfram Language (Mathematica), 10 bytes

#2@@#/@#3&

Try it online!

Input [f, g, {x, y}].

Answer 11

SKI-calculus, 71 bytes

S(S(KS)(S(K(S(KS)))(S(K(S(K(S(KS)))))(S(K(S(K(S(KK)))))(S(KS)K)))))(KK)

Edit: Another go at hand-translating the lambda calculus expression into SKI using the rules in Wikipedia, this time arriving at the same answer as @Bubbler.

Answer 12

tinylisp, 23 bytes

(q((f g x y)(g(f x)(f y

Try it online!

Ungolfed

(lambda (f g x y)     ; a lambda function taking four arguments
  (g (f x) (f y)))    ; apply f to x, f to y, and g to the results

Answer 13

Python 2, 25 bytes

\$ a \$ and \$ b \$ are inputted as a tuple (called \$ x \$).

lambda f,g,x:g(*map(f,x))

Try it online!

Answer 14

Jelly, 4 bytes

Ñ€ç/

Try it online!

Takes f on the first line, g on the second line, and the code is on the third line (this is standard for Jelly). Also, takes the arguments together as a list

 €    For each of the arguments
Ñ     Apply the next link (wraps around to `f`)
   /  Reduce by (for a pair, applies dyad to the first and second element of the list)
  ç   Apply the last link (`g`)

Also works:

Jelly, 4 bytes

ÑçÑ}

Try it online!

Ñ     Apply `f` (to the left argument, since it's called as a monad)
 çÑ}  2-2 chain - given dyads x, y, computes x(a, y(a, b)) if the chain's current value is a and the right argument is b
 ç    Apply `g` to the current value (f(left)) and
  Ñ}  A dyad formed from a monad by ignoring the left argument

Basically, Ñ} is (l, r) -> f(r), so this ends up evaluating as λ x y -> g(f(x), (λ a b -> f(b))(x, y)) which simplifies to λ x y -> g(f(x), f(y)) as required.

(These chaining rules are absolutely beautiful. Thank you Dennis for Jelly :P)

Answer 15

Excel (Insider Beta), 29 bytes

=LAMBDA(f,g,a,b,g(f(a),f(b)))

LAMBDA is only available through Excel Insider Beta. The functions have to be defined as names to work. In my case, I defined a name q that is equal to the above and then used the formula =q(LAMBDA(x,x^2),LAMBDA(x,y,x+y),1,2) in a cell. This could also be done by defining the names a=LAMBDA(x,x^2) and b=LAMBDA(x,y,x+y) and then use the formula q(a,b,1,5).

Answer 16

Scala, 16 bytes

_ map _ reduce _

Try it online!

Takes ([a,b],f,g). There’s more ways to do this but I’m on mobile so I’ll add them later

Answer 17

Proton, 21 bytes

(f,g,a)=>g(*map(f,a))

Try it online!

Time to bring out this garbage again :D

Answer 18

Stax, 7 bytes

n!aa!a!

Run and debug it

A full program which can be executed as a block as well.

accepts the arguments as g x f y.

Answer 19

Ruby, 23 bytes

->f,g,x,y{g[f[x],f[y]]}

Try it online!

Or:

Ruby, 23 bytes

->f,g,*x{g[*x.map(&f)]}

Try it online!

Answer 20

C (clang), ^{54 \$\cdots\$ 37} 36 bytes

o(f(),g(),a,b){return g(f(a),f(b));}

Try it online!

Saved 8 bytes thanks to dingledooper!!!
Saved 2 bytes thanks to ceilingcat!!!
Saved a byte thanks to jdt!!!

Answer 21

Vyxal, 8 3 bytes

M$R

Try it Online!

Takes [g, [a, b], f]. If reduction was reversible, then this would be 2 bytes.

Explained

M$R
M   # map f over [a, b]
 $R # reduce that by g

Answer 22

Red, 24 bytes

func[f g x y][g f x f y]

Try it online!

This version doesn't work in TIO (Red is not up-to date), that's why I provide a screenshot from my Red GUI console:

TIO compatible version, 28 bytes

func[f g x y][do[g f x f y]]

Try it online!

Answer 23

Husk, 5 4 bytes

₂₁⁰₁

Try it online!

Black-box functions are supplied as sequential lines in the code (in the footer in the TIO link), input values are given as program arguments.

₂₁⁰₁     # 2 argument function: second argument is implicit
   ₁     # perform function ₁ using second argument
 ₁⁰      # perform function ₁ using first argument
₂        # perform function ₂ using the last 2 values as arguments

Answer 24

Coconut, 11 bytes

Takes input as Ꙫ(g)(f, [a, b]).

g->g<*..map

Try it online!

<*.. is the multi-arg backward function composition, which makes this function equivalent to

g->*args->g(*map(*args))

Answer 25

APL (Dyalog Unicode), 5 bytes (SBCS)

Full program version of rak1507's implementation.

⎕/⎕¨⎕

Try it online!

Answer 26

Julia, 17 16 bytes

F(!,+,a,b)=!a+!b

Try it online!

Previous answer, 17 bytes

g*f*x=g(f.(x)...)

Try it online!

Answer 27

Attache, 10 bytes

${z|x|>&y}

Try it online!

Takes input as F[f, g, [a, b]], where F is the above function.

This is two separate pipes: The vectorizing pipe |, and the regular pipe |>. z|x pipes each element of z into the unary function x, i.e., Map[x, z]. Then, this array is piped to &y, which passes each element of the array as a separate parameter.

Alternatives

${&y!x=>z}, 10 bytes. Same input as above.

{_2@@Map[_]}, 12 bytes. Takes parameters f and g, returns a function which takes a tuple [a, b] as input.

Attache (builtin), 3 bytes

`#:

Try it online!

Simple quote-operator. Called as (`#:)[g, f][a, b].

Answer 28

Stacked, 11 bytes

[@:g"!...g]

Try it online!

Simple anonymous function. Takes input on stack as (a b) f g.

Works by storing g as a temporary function variable. Then, applies the " transformation on function f, which makes it apply on each element its called on. ! calls this function f" on the tuple (a b). Then, we simply put these two elements on the stack and call g.

Answer 29

C (gcc), 30 bytes

#define o(f,g,a,b)g(f(a),f(b))

Try it online!

Answer 30

Standard ML, 24 bytes

fn(f,g,a,b)=>g(f a)(f b)

---

Concurr pre-release, 50 bytes

$lambda\f:lambda\g:lambda\a:lambda\b::g(:f a)$:f b

Wow that's horrible.