Implement an Over function 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 -&gt; out

f(x) = x²
g(x,y) = x - y
-2, 2 -&gt; 0

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

f(x) = x³-x²-x-1
g(x,y) = y⁴-x³-y²-x
-1, -1 -&gt; 22

f(x) = x
g(x,y) = x / y   (Integer division)
-25, 5 -&gt; -5
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-&gt;((.f).).(.f)
(.).(.).flip(.)&lt;*&gt;flip(.)

The flipped version of ? that's invoked as g?f is a little nicer:
((.).flip(.)&lt;*&gt;).(.)

(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.