[Question]
  [
Over is a higher-order function in multiple languages such as [APL](https://aplwiki.com/) (`⍥`). 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](https://codegolf.meta.stackexchange.com/a/13706/66833), \$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](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods), **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](/questions/tagged/code-golf "show questions tagged '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]
# [Haskell](https://www.haskell.org/), 12 bytes
```
f?g=(.f).g.f
```
[Try it online!](https://tio.run/##bU7LCsIwELznK@bgIVE30KoHwbYfoi2Uvgz2ha2Sgt9uTJDqpQu7DLMzO3tNh1tR18aUURVwWQpZydJ0AY8EY2M3qqIdoRFgeDQ4e3ihxYksklLHW1RZbgm7D@DFjDWpaq0279DflTWu0IEnvgAn1xb4DL/6a@YgftGYKPTXejMJHHBcVFsVhTrZkU580uSJ2Tcle3L85HgX6H3H4hWVI1dP99XBRpl3VtZpNRjK@v4D "Haskell – 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](http://pointfree.io/) for these.)
*Test cases copied [from Unrelated String](https://codegolf.stackexchange.com/a/223888/20260).*
---
## [Haskell](https://www.haskell.org/), 10 bytes
```
(.map).(.)
```
[Try it online!](https://tio.run/##bY/LCsIwEEX3@YpZuEg0E0i0C8Hqh7QplNZqsI9gq6TgtxtTxMeisxrm3jN35pz3l2Nde3pgceqpaHLLBBXMd3FVGxvGhAzdYI7tAA5i6G8NJBIe0MIOQyeE0xxORRkGQY9BakKa3LTBW3ZgryaAC@iAZooBTRPHR417hyODBBVXmsC3fu5P5BdQS7eakIhv5wmaurA2W6PLFDqUf2FjtsFJGSdlipUc5fwWU/6w0tzDS@87Ix5p/yyqOj/1HgtrXw "Haskell – 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]
# [Factor](https://factorcode.org/), 16 bytes
```
[ bi@ rot call ]
```
[Try it online!](https://tio.run/##tVTNctMwEL77KTa3pERObeoDATpcGCaXXoCTJ8y4tpxoasuuJIM9JAcuPEofAHgCHgDegRcJn@S2acJPw4GdWN5In3a//XaTPElNpTavX87OXkwpraQRskmMqKTGt/JcyATnmi64krygokqTQlOZmKVb/LyRaY@uFTemq5WQhjS/bLhMeY/0sVly7ecul6bH3uxsSouqyD1vQK8qIzju3ETyfd@b0rcrGpIkxqikkUew9251HsWUNTUF9ITm1ldVTcdw17@BPN1Cgh1IfOtZs@BGCtBm1zR3jmNctg@jIwRRPGtS7gLXqoJv4J8LmtDR7a2589ZW0gwVu0qXnHiblHXBSci6Mdrri7JsGUKwkEK4@tISxf6A8mE7Qgnt1087dPZtQIthO@4cFJG6e8AsHCMRO6Vj8Loh0Av2AKkz0b8jeoRddGKPzfeP9m1t@LwpuCKz18LRX/P/gXjYImn3DzejMfihiOBkW8UK9Xe0wnNCb@A/xAo9rKTMSQORA/txyNU1ot2eBw6zJ/5nhgawlgUHszvc7ijQ/fjwhdlsnc32X3KxYOwEOKUwvNP7iRu@CB2Pf6neO3DsJpAZEzGThi8wE5l4K/Q9s2AnEV2MLB8WeetNjF/RM1KVIfzNFDTHxjthlixLTKJNkl5QLpQ25INl2ijVEU/S5eYn "Factor – 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](https://factorcode.org/), 10 bytes
```
map-reduce
```
[Try it online!](https://tio.run/##S0tMLskv@h8a7OnnbqWQm1iSoVBQlFpSUllQlJlXolCcWliampecWqxgzVWtYKhgpFCrEK1QXKgQC6S0FWL/5yYW6BalppQmp/7X@w8A "Factor – Try It Online")
Built-in.
[Answer]
# [J](http://jsoftware.com/), 12 bytes
```
2 :'(u v)~v'
```
[Try it online!](https://tio.run/##y/qvpKegrpCmYGuloK6jYKBgBcS6egrOQT5u/40UrNQ1ShXKNOvK1P9r/jdR0E5TVDDnMlHQBdEA "J – 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](http://jsoftware.com/), 1 byte
```
&
```
[Try it online!](https://tio.run/##y/qvpKegrpCmYGuloK6jYKBgBcS6egrOQT5u/9X@a/43UdBOU1Qw5zJR0AXRAA "J – Try It Online")
J's built-in conjunctions can be assigned to a variable, unlike in Dyalog APL.
[Answer]
# JavaScript (ES6), 23 bytes
```
(f,g,x,y)=>g(f(x),f(y))
```
[Try it online!](https://tio.run/##dU5BDsIwDLvzihyTKgVtsGN33D@msVagaUVsQs3rS7pdQIKDFdmxLd/7V78Mz9tjtXO8jrlzGT0HTizk2oAeE7FHIcpDnJc4jccpBuwwgWshGVMzYGIQ2jhYEAarYk10@J04q6kEy1FUnwVizGV/F5cy2GxaWRX86fyecNonNAyNrn4D "JavaScript (Node.js) – Try It Online")
[Answer]
# [Rust](https://www.rust-lang.org/), 21 bytes
```
|f,g,x,y|g(f(x),f(y))
```
[Try it online!](https://tio.run/##VYzNCsIwEITveYp4y8oGSrwZ6qtIAtlS0IXmB1qMzx5TKogwDMzHzMSSciOWTzezgpd8hCzpSqy65osBfeuOR8Af@Etjq4QTrrjVSZFaAUltAM2K/S0txcUwysqVz/xlxctOHPrqtLfCpRRivofl1PfHAHsHDWoDOIAV7/YB "Rust – 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]
# [Haskell](https://www.haskell.org/), ~~17~~ ~~16~~ 15 bytes
```
(f!k)x=k(f x).f
```
[Try it online!](https://tio.run/##bU7LCsIwELznK6bgIVFTSLUHwfRHtIFiWw19ia2yBf@9Jkj10oVdhtmZnb1lfVXU9TTxMqgE6YqXIBGW09ANtmgHEDT6Z4OTwhstjtKhMKR0i@sld4Tba6iUsU7zQDDWZLZ1lrzD/WGdf4UO3EQCXPp2IGL41V8z5/EzYZRJtKbNKBDjsKh2KpmQ2UkykSSpxOwbzV56fvS8D1TfsXjF5sjty38Vu6jpAw "Haskell – Try It Online")
*-1 thanks to Wheat Wizard repatterning the use of infix*
[Answer]
# [APL (Dyalog Classic)](https://www.dyalog.com/), 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!](https://tio.run/##SyzI0U2pTMzJT9dNzkksLs5M/v8/7VHbhOpHvbuASP9R71YgOrQCSNT@/6@dpqhgomAOAA "APL (Dyalog Classic) – Try It Online")
[Answer]
# [Racket](https://racket-lang.org/), 26 bytes
```
(λ(f g x y)(g(f x)(f y)))
```
[Try it online!](https://tio.run/##ZYtLCoQwEET3OUWBm66FCz8XEqcNg6ISRJKzeYe5UuyRwVkIRVEF74WuH3XLxdTNHuE6Tl46vGfFsmvI8jlkgEdEonibkVaJZKZz8mVgDCQSUkI0rpvBDe9Z06oif5i5fzCh5dNJl2NGWVmYTw "Racket – 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]
# [R](https://www.r-project.org/), 29 bytes
```
function(f,g,a,b)g(f(a),f(b))
```
[Try it online!](https://tio.run/##bY1BCgIxDEX3nqIgAwkkaKvd2asMbcUWNzMw6NCevjYDiojb/Pdeljavt0VdWLX0nK6P@zxBokyBImZIEJASRMQNg@Q@UMEyGspfB6pYuFJwbCg6g2qvjrt/2om7yoX1r17HM8tcZZaQ7iHWUjLmnfLgu@eHw@C3X7YzVhC27QU "R – 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]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 10 bytes
```
#2@@#/@#3&
```
[Try it online!](https://tio.run/##JYy9CoMwFIV3nyJwIUvvpeRahw4tLt0tHUsDQRQD1YLEKcRXT5M4Hc53fmbjpmE2zvYmjrcI3LZwbqGWsVvt4t5A9zGhj9xfvVl2X3nQLFEAQRZPjBwCVv6xfYe1mywKhtORNXgtEeia0oqAVF6yvlBBnFk5UUjqqCb73H7ODosr7w2KJoQqxD8 "Wolfram Language (Mathematica) – Try It Online")
Input `[f, g, {x, y}]`.
[Answer]
## 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](https://en.wikipedia.org/wiki/Combinatory_logic#Completeness_of_the_S-K_basis), this time arriving at the same answer as @Bubbler.
[Answer]
# [tinylisp](https://github.com/dloscutoff/Esolangs/tree/master/tinylisp), 23 bytes
```
(q((f g x y)(g(f x)(f y
```
[Try it online!](https://tio.run/##FYoxDoAgEAR7XrHlrZ1@hDdgiISEoKIF9/rzbCaTzLy1a6vPZSYZUW6RAwUTSimukw41aWfKaHUfaShDkIh/9br4O0kiYcVG@wA "tinylisp – 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]
# [Python 2](https://docs.python.org/2/), 25 bytes
\$ a \$ and \$ b \$ are inputted as a tuple (called \$ x \$).
```
lambda f,g,x:g(*map(f,x))
```
[Try it online!](https://tio.run/##ZY3NCoMwEITveYo5JmGX1rReBK8@RS@R1h/wJ5RIk6e3qSAohVnY3ZmPcdF382TWqnysgx3rp0VDLYWilXq0TjYUlFo/XT@8kBUimWgJ0hJqwrx4p1Cin9zipaK/RcC9@8mjkgdOJaTc2L0xFAhaG7GfFNODo2BDSLqKU@7GvzAHzk5A1PrOmx03W2QETmPMET93XH4dOSGJ8y8 "Python 2 – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 bytes
```
Ñ€ç/
```
[Try it online!](https://tio.run/##ATMAzP9qZWxsef804bi2VSpAwrVfLwoswrXhuosyKjRSwqRVXy//w5HigqzDpy////8tMSwgLTE "Jelly – 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](https://github.com/DennisMitchell/jelly), 4 bytes
```
ÑçÑ}
```
[Try it online!](https://tio.run/##y0rNyan8b/Jwx7ZQLYdDW@P1uXQObX24q9tIyyTo0JLQeP3/hyceXn54Yu3///91DYEIAA "Jelly – 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]
# [Scala](http://www.scala-lang.org/), 16 bytes
```
_ map _ reduce _
```
[Try it online!](https://tio.run/##K05OzEn8n5@UlZpcouCbmJmnkFpRkpqXUqzgWFBQzVWWmKOQZqURnFoY7ZlXEqsDJGztgISOBogAYk0wF0La/o9XyE0sUIhXKEpNKU1OVYj/X1CUmVeSk6eRBjJCw1jHVFNHN14nXjteU5Or9j8A "Scala – 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]
# [Proton](https://github.com/alexander-liao/proton), 21 bytes
```
(f,g,a)=>g(*map(f,a))
```
[Try it online!](https://tio.run/##Pc0xDoQgEAXQnlP8EshQ4G6LFzFbUCixEAgxRk7PDhptJn8yL/NzSXuKLR1zgWtyoUBeuTFIvfnMq1eqLXA44UYeWuMDc4fhCgZWBAbyJFTVVe3H76M6ry8XIpc17rL38XcEwmQswdgfF/0B "Proton – Try It Online")
Time to bring out this garbage again :D
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 7 bytes
```
n!aa!a!
```
[Run and debug it](https://staxlang.xyz/#c=%7B%22Code%3A%22d%0An%21aa%21a%21%0A%7DY%0A%22Testcases%22d%0A%7B-%7D+2N+%7BJ%7D+2+y%21P%0A%7BH%2B%7D+5+%7B%3At%7D+9+y%21P&i=)
A full program which can be executed as a block as well.
accepts the arguments as `g x f y`.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 23 bytes
```
->f,g,x,y{g[f[x],f[y]]}
```
[Try it online!](https://tio.run/##KypNqvyfYftf1y5NJ12nQqeyOj06LboiVictujI2tvZ/gUJGtK5dRXWFlpZRrQ6QBVRRoVtZq2Oko2sU@x8A "Ruby – Try It Online")
Or:
# [Ruby](https://www.ruby-lang.org/), 23 bytes
```
->f,g,*x{g[*x.map(&f)]}
```
[Try it online!](https://tio.run/##KypNqvyfYftf1y5NJ11Hq6I6PVqrQi83sUBDLU0ztvZ/gUJGtK5dRXWFlpZRrQ6QpVNZXaFbWatjpKNrFPsfAA "Ruby – Try It Online")
[Answer]
# [C (clang)](http://clang.llvm.org/), ~~54~~ \$\cdots\$ ~~37~~ 36 bytes
```
o(f(),g(),a,b){return g(f(a),f(b));}
```
[Try it online!](https://tio.run/##lVJLjtNAEN3nFG8iRWo73ZrYkMVgGhaIU5BZtL9jTegM7QC2Ii/YcCDgBFxg7jAHwVS37cQZDUKTqO1UV716r@olEclW6aLrdixnHi/oKB57B5PtPxuNgm6Vx3MWe17UdqXeo/pkWO3hgKGkho86QjuzybTMc1bz5iwv0Iz5IkmZ4ogn@RgXEiu8dbmYQ2Fh86@gRtDdTcm0RdjAQCKIkO8MmI1LisOIXq@hIyyXpWuNpXT9NAddSAdpR0ZzbLzbNiuSi6ne0M6D5UmzrQrOR/bpS2MNTzrBtDgcN9D4kroMoMZveogDud8jqEzP2x/v9T4tvzze56VT5go@qlIzb3aYgT7JjTI@PbPkNjMfrmkvh/mmfh9u6qt3dNZzjmn8Yt5GDudMpeodI2u5s5BDhByhdyrIqGDVh3eGLnI2z61oifr3D07/EydS9m4PcIg3WKRYVBtN3BU/aqukzK6puWvXU5PHvPeDY81xNVBb2uDlk7z33@lNLM6rHvQsQutqT0laRWDPhDQM/zHsT0EDi9oCjkM3D99@CZtqbGrs9hw1ZcoHt@3uaJb1RItYP63lbO2X/dot9L/EbfcnybeqqDrx9S8 "C (clang) – Try It Online")
*Saved 8 bytes thanks to [dingledooper](https://codegolf.stackexchange.com/users/88546/dingledooper)!!!*  
*Saved 2 bytes thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/ceilingcat)!!!*  
*Saved a byte thanks to [jdt](https://codegolf.stackexchange.com/users/41374/jdt)!!!*
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), ~~8~~ 3 bytes
```
M$R
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=M%24R&inputs=&header=%CE%BB2%7C-%3B%20%0A2%202N%22%0A%CE%BB%C2%B2%3B&footer=)
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]
# 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]
# [Red](http://www.red-lang.org), 24 bytes
```
func[f g x y][g f x f y]
```
[Try it online!](https://tio.run/##K0pN@R@UmhIdy5Vfllpk9T@tNC85Ok0hXaFCoTI2Ol0hDchIAzL//wcA "Red – 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:
[![enter image description here](https://i.stack.imgur.com/HDHRu.png)](https://i.stack.imgur.com/HDHRu.png)
# TIO compatible version, 28 bytes
```
func[f g x y][do[g f x f y]]
```
[Try it online!](https://tio.run/##ZY69DoMwDIT3PMWNFIkBWpY8RtcoA8UJygIl/Ch5@tRBrURbyZbsu@8se0PpbkhpMe3Gy2S3sVcWAwKiVjSpAZZny5tOyyxxAEGrgBJBCxu@pBJXVCgO88JT4K4zFT9YPhszeHuDHMlkwSLikdHC0emqFuLp3bgifwi5zJAdEWo0f/qyPVbf9Suq5se1IXdEVXO9nbPvCJLc7shwtkWbXg "Red – Try It Online")
[Answer]
# [Husk](https://github.com/barbuz/Husk), ~~5~~ 4 bytes
```
₂₁⁰₁
```
[Try it online!](https://tio.run/##yygtzv7//1FT06OmxkeNG4Dk/0fTFnJp//9v@N8IAA "Husk – 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]
# [Coconut](http://coconut-lang.org/), 11 bytes
Takes input as `Ꙫ(g)(f, [a, b])`.
```
g->g<*..map
```
[Try it online!](https://tio.run/##S85Pzs8rLfn/auYqBVuFmP/punbpNlp6ermJBf@LC4FCFQq6dgoVWlpGXAVFmXklGkCFGrqaGsWFOgrRRjoKukaxmpr/AQ "Coconut – Try It Online")
`<*..` is the *multi-arg backward function composition*, which makes this function equivalent to
```
g->*args->g(*map(*args))
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 5 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?") ([SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set"))
Full program version of [rak1507's implementation](https://codegolf.stackexchange.com/a/223885/43319).
```
⎕/⎕¨⎕
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKO94P@jvqn6QHxoBZAAifxXAIMCLhMFcy5FLm0A "APL (Dyalog Unicode) – Try It Online")
[Answer]
# [Julia](http://julialang.org/), ~~17~~ 16 bytes
```
F(!,+,a,b)=!a+!b
```
[Try it online!](https://tio.run/##XY9BasMwEEX3PsWYbCQ8irBi0yQ0pZvmGAFFkWw1tlRimcon6wF6MNcOhTqF2Qzvf3j/vW@szOM4HkmKGUo800Mqs/Q8JoZECgeIJ5FUJOJwf9iQvHa1/4QjMVghEyhoMkXdTLu@JZa9VOpCLDr6LDDfT2AFb32jbxB8sNoFML1TwXoH5uZbqEP46PacK3/RlW/MugtSXXVUtXSVXivfcsm3m7J44rttWeR/MiJCBo8@Je7uOr/mGzbZs8gWpeFUsBkMM3jckk@3aC9Ww/cX/B9eYknHHw "Julia 1.0 – Try It Online")
**Previous answer, 17 bytes**
```
g*f*x=g(f.(x)...)
```
[Try it online!](https://tio.run/##XY9BbsMgEEX3PsVI3UDCgHCMmkRN1U2vEckigEltqGKs4pP1AD2Ya0ddON3N6M3XvH8dWl/LPE1uYzf55IjlJFPOOZ3sPMAJ8rksHMlsvC84Fm99E79guSdYMihpUVgSFtoPHfH46vSFeBboS8nkcQZP8D605gYpJm9CAjsEnXwMYG@xgyalz/4ohI4X42JreZ9q/WGyburgDNexE7XY71T1LA57VcmVzDbDFh6EFDvcdf7MdzjbY8ZVaDxXuIBxAQ9dJEO5Cq/@wM83/OutGCo6/QI "Julia 1.0 – Try It Online")
[Answer]
# [Attache](https://github.com/ConorOBrien-Foxx/Attache), 10 bytes
```
${z|x|>&y}
```
[Try it online!](https://tio.run/##XYyxCsIwFEX3fMUjFBeTSqsuhbqIxUkE3R5PKDVUQVppoyTWfntMURAd7nLuuTfXOi9OymVJ6oLu8TTPxcj2bqPUscXgei1KYjvdnKtyX2e3qtDnukJDkKSwuueXtWoU8qDjMAbjw3tOjG29r/eq1cu8VS2Ogi7DMAz/f9KFEWCpF4AMABCQm0PMBXAjLSePZSwgJiDx7afSO9LIaPDsYSYHZAf0XkQCZPQzGcTsUtcNmomlz@9cwNxbjMi9AA "Attache – 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](https://github.com/ConorOBrien-Foxx/Attache) (builtin), 3 bytes
```
`#:
```
[Try it online!](https://tio.run/##XYzLCsIwFET3@YpLLKKYVFrtplA3YnElgu4uVyw1qCCttFESfPx6TVEQXczmzJnJtM7yg2rSOGm2nbhZKLWr0Tuf8z2xla6OxX5dppci18eyQEMQJzC7Zqe5qhRy78ZhAMaFPzgxtnS@XqtaT7Na1dj1br3/j2Ri4D6B7jPto@/7lh4CkAEAAnKzCbkAbqTl5LAMBYQEJL79SDpHGhm0nt2MZYtsi96LQIAMfiatmJ7KskIztPT5jQREzmJEzQs "Attache – Try It Online")
Simple quote-operator. Called as `(`#:)[g, f][a, b]`.
[Answer]
# [Stacked](https://github.com/ConorOBrien-Foxx/stacked), 11 bytes
```
[@:g"!...g]
```
[Try it online!](https://tio.run/##TY7BCsIwEETv@xWjF5NDAkk95SA99SdKLUVLDyKGNgWD5NvjNoJ62J0d5g3sEobLbbzm3NZu2u@01lOXa9cQCSF6CyvxwhOOx@KMVFwsPkIhSQJzBr35gRWDH1yxKpgN/BYjjiWvSh7/uAQpiVo3j36GXwMOUCde28mPNXisocN98JTf "Stacked – 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]
# [C (gcc)](https://gcc.gnu.org/), 30 bytes
```
#define o(f,g,a,b)g(f(a),f(b))
```
[Try it online!](https://tio.run/##PYzNCsIwEITveYqlIuzqetBr8WE2v@RgqmkLgdJnj0kFL8POzLdjbsGYWk/W@ZgcTOg5sLCmgB6F2KMmqjEtMH9WyQ77WWjLbllzgnIp4656JtYenXBX/SfkqhtxIC@JCZA2Bd1lNz8n/K1y@@Y7P2hU8M6t9YDD2Q7coJbt9Qs "C (gcc) – Try It Online")
[Answer]
# Standard ML, 24 bytes
```
fn(f,g,a,b)=>g(f a)(f b)
```
---
### [Concurr pre-release](https://codeberg.org/Wezl/Concurr/commit/22c5242bfe500ba531b6f3808ec60af1f0e74386), 50 bytes
```
$lambda\f:lambda\g:lambda\a:lambda\b::g(:f a)$:f b
```
Wow that's horrible.
]