[Question]
  [
Write a function or program that takes two words as input and outputs variants of the popular English tongue-twister "How much wood would a woodchuck chuck if a woodchuck could chuck wood?".
The output will use the first word four times
* How much `wood` would a `wood`chuck chuck if a `wood`chuck could chuck `wood`?
and the second word four times
* How much wood would a wood`chuck` `chuck` if a wood`chuck` could `chuck` wood?
with the rest of the output being the same for any inputs.
* `How much`wood`would a`woodchuckchuck`if a`woodchuck`could`chuckwood`?`
The input and output can be in any format that your language reasonably recognizes as dealing with strings of text. The output must be exactly in the indicated format, including capitalization, spaces and lack thereof, and the ending question mark. An optional trailing newline is acceptable.
Ideally your code will handle input containing any printable ASCII characters. However, it is permitted to restrict the input to reasonable subsets of printable ASCII; just indicate this in your answer. Handling larger character sets is of course fine.
Example input-output pairs:
```
"wood", "chuck"
"How much wood would a woodchuck chuck if a woodchuck could chuck wood?"
"ground", "hog"
"How much ground would a groundhog hog if a groundhog could hog ground?"
"bar", "keep"
"How much bar would a barkeep keep if a barkeep could keep bar?"
"money", "belt"
"How much money would a moneybelt belt if a moneybelt could belt money?"
"rain", "fall"
"How much rain would a rainfall fall if a rainfall could fall rain?"
"hair", "cut"
"How much hair would a haircut cut if a haircut could cut hair?"
"green", "house"
"How much green would a greenhouse house if a greenhouse could house green?"
"jabber", "wock"
"How much jabber would a jabberwock wock if a jabberwock could wock jabber?"
"pine", "apple"
"How much pine would a pineapple apple if a pineapple could apple pine?"
"Rob", "Lowe"
"How much Rob would a RobLowe Lowe if a RobLowe could Lowe Rob?"
"code", "golf"
"How much code would a codegolf golf if a codegolf could golf code?"
"fish", ""
"How much fish would a fish  if a fish could  fish?"
"", "fish"
"How much  would a fish fish if a fish could fish ?"
"", ""
"How much  would a   if a  could  ?"
"  ", "     "
"How much    would a               if a         could         ?"
"would a", "how much"
"How much would a would a would ahow much how much if a would ahow much could how much would a?"
```
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so fewest bytes wins. Answers are welcome in all languages, even if some other language can do it in fewer bytes.
(Inspired by [this meme](https://www.facebook.com/movieweb/photos/a.10150200043617199/10157150855317199), which uses one input pair better than this rigid pattern does....)
  
[Answer]
# [Python 3](https://docs.python.org/3/), ~~70~~ 67 bytes
```
"How much {0} would a {0}{1} {1} if a {0}{1} could {1} {0}?".format
```
[Try it online!](https://tio.run/##RU7NCsIwDL77FCGnTYpMvAni1XeoO4x2tUXXjK5lyNiz1zUKHsL3R5JvfEdL/pTN5Z7xRjMMSVlYmhVmSi8NXeHLcYUyzvy14piTZr3iwVAYupg32DaDnsB5kBJnIo0CUNmkntgKiUUxeYS@9yjQUpp6dn4v2fs2wbY97wDG4HysTLXn03WdPw "Python 3 – Try It Online")
I mean, if the shoe fits..
*Thanks to **manatwork** for catching a typo*
*Thanks to **Remco Haszing** for the excellent -3 bytes idea*
I am running off of the assumption that this would still be a valid submission (because man, it's too cool not to try). If OP could clarify whether this is acceptable (because I haven't *written* a function, per se), that would be appreciated.
Update: Blessing received, all is good :)
---
**Previous version:**
```
lambda a,b:f"How much {a} would a {a+b} {b} if a {a+b} could {b} {a}?"
```
[Answer]
# T-SQL, 82 bytes
```
SELECT'How much '+w+' would a '+w+c+' '+c+' if a '+w+c+' could '+c+' '+w+'?'FROM t
```
Input is taken from pre-existing table \$t\$ with columns \$w\$ and \$c\$, [per our IO rules](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods/5341#5341).
One byte longer, but for some reason slightly more pleasing:
```
SELECT REPLACE(REPLACE('How much 1 would a 12 2 if a 12 could 2 1?',1,w),2,c)FROM t
```
This version works on a subset of inputs that *don't* include the numeral `2` in the first word \$w\$.
Because I'm in SQL, I can pre-load all examples into the table, and run them all at once:
[![enter image description here](https://i.stack.imgur.com/G31Jp.png)](https://i.stack.imgur.com/G31Jp.png)
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 50 bytes
```
echo How much $2 {would,$1\ if}\ a\ $2$1 could $@?
```
[Try it online!](https://tio.run/##S0oszvj/PzU5I1/BI79cIbc0OUNBxUihujy/NCdFR8UwRiEzrTZGITEGKKpiqJAMElZQcbD///9/ckZpcvb/8vz8FAA "Bash – Try It Online")
-5 bytes due to help from comments below.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), ~~33~~ ~~31~~ ~~30~~ 29 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
-1 thanks to [recursive](https://codegolf.stackexchange.com/users/527/recursive)!
```
¢èO∩sP↑å♥|1╧ì}ò♂xb■δå«█Γ╨╦►Q²
```
[Run and debug it at staxlang.xyz!](https://staxlang.xyz/#p=9b8a4fef73501886037c31cf8d7d950b7862feeb86aedbe2d0cb1051fd&i=wood%0Achuck%0A%0Acode%0Agolf%0A%0A%22%22+%22fish%22%0A%0A%22fish%22+%22%22%0A%0A%22%22+%22%22%0A%0A%22++%22+%22+++++%22%0A%0Awould+a%0Ahow+much&a=1&m=1)
Push each component to the stack in reverse order, then join all with spaces.
### Unpacked (35 bytes) and explanation:
```
X'?+;`IM'`x;+Y`~^$`,y`75\`x`Q)("`LJ
X                                      Set register X to the first word
                                       "wood"
 '?+                                   Append a question mark, popping from the input stack
                                       "wood?"
    ;                                  Peek from input stack and push to main stack
                                       "chuck" "wood?"
     `IM'`                             Literal "could"
                                       "could" "chuck" "wood?"
          x;+Y                         Peek register x. Peek input. Concatenate. Set register Y.
                                       "woodchuck" "could" "chuck" "wood?"
              et cetera, ad nauseam
                                  LJ   Listify the stack and join with spaces
                                       Implicit print
```
Everything between `` is compressed string literal. That comma is vital. The last time I read from the input stack, I must pop rather than peek to avoid an extra "chuck" on the end of my output.
You'll notice that I put both inputs on the same line for a few test cases, and that they're in reverse order. This is necessary in order to take empty strings or strings of spaces as input.
### ~~27~~ 26 bytes with restrictions on input
```
å▓Zf╢7)╪♪²p╞8ó╪l▼]<¡REïSèΣ
```
[Run and debug it at staxlang.xyz!](https://staxlang.xyz/#p=86b25a66b63729d80dfd70c638a2d86c1f5d3cad52458b538ae4&i=wood%0Achuck%0A%0Acode%0Agolf%0A%0A%22%22+%22fish%22%0A%0A%22fish%22+%22%22%0A%0A%22%22+%22%22%0A%0A%22++%22+%22+++++%22%0A%0Awould+a%0Ahow+much&a=1&m=1)
Just like [@dzaima's SOGL](https://codegolf.stackexchange.com/a/190327/73884), this will fail if the first input contains the lowercase letter 'y'. Pushes the string "How much b would a by y if a by could y b?", then makes a pair of replacements.
[Answer]
# JavaScript, 70 bytes
Boring!
```
a=>b=>`How much ${a} would a ${a+b} ${b} if a ${a+b} could ${b} ${a}?`
```
[Try it online!](https://tio.run/##RYo7DoAgEESvQogFxOgN0NZjuC7gD12jIoXx7PhpbOZl3swAB2y49suezaRNtCqCKhpV1BUFNnnsWHLCxQJ5pxm8JW2uB0/09hf47Z9@/2UdkeaNnMkdtcIKHog0l4Jj53HkUsYb)
Mildly less boring!
```
a=>"How much 0 would a 01 1 if a 01 could 1 0?".replace(/\d/g,x=>a[x])
```
[Try it online!](https://tio.run/##JchBDoIwEADAr2z21CYI7QOKV/@AHDbbFtDKErCW39dEb5N50IcO3pftfVnFhxpdJdfjTQq8Ms9goEhOHgiMBQtL/It/acFcsd3DloiD6u6@m5rT9TSco64s6yEptEkmFdWARcRjgzxnfuKodf0C)
[Answer]
# [SOGL](https://github.com/dzaima/SOGLOnline), ~~32~~ 30 [bytes](https://github.com/dzaima/SOGL/blob/master/chartable.md)
```
^.](9V;⅜‛°@Ε¬tπs%.½Ω‘⁽ b,ŗ y,ŗ
```
[Try it here!](https://dzaima.github.io/SOGLOnline/?code=JTVFLiU1RCUyODlWJTNCJXUyMTVDJXUyMDFCJUIwQCV1MDM5NSVBQ3QldTAzQzBzJTI1LiVCRCV1MDNBOSV1MjAxOCV1MjA3RCUyMGIlMkMldTAxNTclMjB5JTJDJXUwMTU3,inputs=d29vZCUwQWNodWNr,v=0.12)
The first input can't contain the letter `y`, which seems to leave a reasonable subset of ASCII (and unicode) left.
`½ouiīZģ9Ο|ΧyΚ⅞ō÷Jeq(‚7‘` is a compressed string of `"how much b would a by y if a by could y b?"` (characters chosen so the required words are all in the top 512 words of the dictionary which compress better), then `b` is replaced with the 1st input and `y` with the 2nd.
[Answer]
# ZX Spectrum Basic, 87 bytes
Just for completeness, straightforward implementation:
```
INPUT a$,b$: PRINT "How much ";a$;" would a ";a$;b$;"  ";b$;" if a ";a$;b$;" could ";b$;" ";a$;"?"
```
Using the `IF` keyword (1 byte) golfes it down by 3 bytes, but breaks the "same capitalization" condition:
```
INPUT a$,b$: PRINT "How much ";a$;" would a ";a$;b$;"  ";b$;" IF a ";a$;b$;" could ";b$;" ";a$;"?"
```
[Answer]
# [R](https://www.r-project.org/), ~~90~~ ~~77~~ 76 bytes
-13 thanks to Sumner18  
-1 thanks to Giuseppe 
```
function(x,y,`[`=gsub)2[y,1[x,"How much 1 would a 12 2 if a 12 could 2 1?"]]
```
[Try it online!](https://tio.run/##Nc2xDoIwEIDh3ae4dIKkDjBrXB2cXAmJbblCtfYI2BSeHluL292X/3LTpuF03LR36mPIFQtf@aN5nPvZy7JuVl41C2dXCvD2aoAKAnnbgYCqhhqMzpP6YQ3VhbXtpgsWiDrGmRq8erHyEEWKKcILccz7mxyuUSTaT5ZJGBdBC2szDMKkG@X3oJ8QUzGQnzHTU0iJKQr0fzQahxHEONo9upOMcKOw74q6VPRkNSu3Lw "R – Try It Online")
[Answer]
# [Kotlin](https://kotlinlang.org), 59 bytes
```
{i,j->"How much $i would a $i$j $j if a $i$j could $j $i?"}
```
[Try it online!](https://tio.run/##VY7NCsIwEITP9imG4iGBWvQqWhERxGu9iYcYrV2bJqWmLVL67LH@grCwM98yw2bGKtKuFgqNMSeZVjKbgsW2JH0J8N4co@gjMXctBddR5G9Mg7ySKYbURyt1gujl8Ip@KPka@bo8KS38ziWVRi5IMzHFsizFffaujThabyDCxJRrIdMWRU@t0uz3FCMb3gpFlvnw@X58CPBPJgfO0Xmdc7E912dszfHmdpRjZUz2AA "Kotlin – Try It Online")
[Answer]
# [PHP](https://php.net/), 72 bytes
```
[,$a,$b]=$argv;echo"How much $a would a $a$b $b if a $a$b could $b $a?";
```
[Try it online!](https://tio.run/##K8go@G9jXwAko3VUEnVUkmJtVRKL0susU5Mz8pU88ssVckuTMxRUEhXK80tzUhQSgUyVJAUgykyDcZLBMiDRRHsl6////5fn56f8T84oTc4GAA "PHP – Try It Online")
Or:
# [PHP](https://php.net/), 72 bytes
```
How much <?=![,$a,$b]=$argv,"$a would a $a$b $b if a $a$b could $b $a?";
```
[Try it online!](https://tio.run/##K8go@P/fI79cIbc0OUPBxt5WMVpHJVFHJSnWViWxKL1MR0klUaE8vzQnRSFRQSVRJUkBiDLTYJxksAxINNFeyfr////l@fkp/5MzSpOzAQ "PHP – Try It Online")
Input from command line, output to `STDOUT`.
[Answer]
# [JavaScript (V8)](https://v8.dev/), 72 bytes
```
(a,b)=>['How much',a,'would a',c=a+b,b,'if a',c,'could',b,a+'?'].join` `
```
[Try it online!](https://tio.run/##bc7BDoIwDAbgu0@xWyFUziYGvfoOxISuOhkiNcDg8WfH0dBb/@9P044Wmnj03/m4nKKrYkZo8@pSw01W8wncAhLCKqF/GALkigqLFsG7bUXgRKARFXCFe9mJHxrTRJZhkv5Z9vLKXKYXRFvAbeA35Pn58Oct@TF5mPfU@UkfgT3SeNMdMkbR6CSMPw "JavaScript (V8) – Try It Online")
The variable assignment actually saves 0 bytes, but I figured I'd keep it in just to make this *slightly* unique.
[Answer]
# [Rust](https://www.rust-lang.org/), 75 bytes
```
|a,b|print!("How much {} would a {0}{} {1} if a {0}{1} could {1} {0}?",a,b)
```
[Try it online!](https://tio.run/##fY29DsIgFIX3PsXpnSBhqLMxrr5GpcU2UjAVwkB5doRqHHun8/Pl3NW/XVYGSz8bxhEblNOjg8Ilb724b691Nq5ldLMBi5cTYkKwXg/oEbtUXDwlzOpni5Z7W1UJriTKCs/nfVkxCtYOJEBy8vJJ/JvvT7RpGf9z0g5j5R5WqwOsIgc1UIFqUKkm5Q8 "Rust – Try It Online")
Using [this trick](https://codegolf.stackexchange.com/a/188625/85842), which let's you skip the formatting index once per item to format.
Also using `print!()`, because it's one byte shorter than building a string with `format!()` and returning it.
[Answer]
# Applesoft BASIC, ~~77~~ 76 bytes
```
1INPUTA$,B$:?"How much "A$" would a "A$B$" "B$" if a "A$B$" could "B$" "A$"?
```
The above may not look like proper BASIC, but Applesoft allows for a few shortcuts when using the `PRINT` statement:
* Use of `?` in place of `PRINT` when entering the statement
* Concatenation characters (either `;` or `+`) may be omitted
* If the statement ends in a quoted string, the final quote may be omitted *Thanks, [Mark](https://codegolf.stackexchange.com/users/19365/mark)!*
The line number is required, or the `INPUT` statement will cause an `?ILLEGAL DIRECT ERROR`
[Answer]
# [33](https://github.com/TheOnlyMrCat/33), 78 bytes
```
"How much "p1btpt" would a "ptpz2btp" "ptbtp" if a "ptpbtp" could "ptbtp" "ptp
```
[Try it online!](https://tio.run/##Mzb@/1/JI79cIbc0OUNBqcAwqaSgREmhPL80J0UhEShQUlBlBBRTAjHBdGYaVBzMSwYrhMmBhP///1@en5/yPzmjNDkbAA "33 – Try It Online")
Takes the input as command-line arguments.
## Bonus: 91 bytes
```
"How much "p1bztp" would a "p1bztp2bztp" "p2bztp" if a "p1bztp2bztp" could "p2bztp" "p1bztp
```
[Try it online!](https://tio.run/##Mzb@/1/JI79cIbc0OUNBqcAwqaqkQEmhPL80J0UhESZgBBFVgjEy0zDkksE6lBBKwZL///@H0GBhAA "33 – Try It Online")
Gives output resembling itself when given inputs `1bztp` and `2bztp`
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~37~~ ~~35~~ ~~31~~ 30 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
“Howƒ×1€Þ a ÿ0€¬ a ÿƒˆ01?“T$ú‡
```
[Try it online](https://tio.run/##yy9OTMpM/f//UcMcj/zyY5MOTzd81LTm8DyFRIXD@w2AzENrwMxjk063GRjaA5WFqBze9ahh4f//0Url@fkpSjpKyRmlydlKsQA) or [verify all test cases](https://tio.run/##NY6xTsMwEIZf5eQ5Q/MEWRmYEFvUwXYujambixKMla1i6IyysCAk9j4BCxKWuvAWeZFwrtOb/u/Tf7qjQSqDy8sY3goB82kCUSzz8eOO/GUK7/n8eg6fICH8bDj@nq/xMv2dNnnBtccxD9/z8WvJlrIUnqgSmdCN03uxzaAUSvYs9ohd4gO1OLJRaJ@T6aVpWdTS2iQaaeKOdmth1yPGRkNuwKSepFIYS55uhzrTIgvZdXYtPZBicU9@ZU1VbOzI1knUZmhYJIgvRL5BCgAcIU5iT85WIK/feDg4zQvbfw).
Or alternatively:
```
…a ÿªðì₁“Howƒ×2€Þ65€¬6ƒˆ52?“r‡
```
[Try it online](https://tio.run/##yy9OTMpM/f//UcOyRIXD@w@tOrzh8JpHTY2PGuZ45Jcfm3R4utGjpjWH55mZAqlDa8yOTTrdZmpkD5QuetSw8P//aKXy/PwUJR2l5IzS5GylWAA) or [verify all test cases](https://tio.run/##LY6hbsMwEIZfxTIOqtTSkIGCodGowHacxKubi5K6VlhW0AcIKZkmjQxMAXuDSbVUsrfwi2T2NSb3f//9d2foGFdyPvUpJf4yEpr2T7Mfvhhxv7dv9@Mmf37zw/sW7H1015U/T@5jsw7lNm3u499lvUpDu/XD55zMWUYtQE4TKioj9nSXZLRswdTRqqBEg7M20F7KBvEAteyDwaU@otEyVQcumNbIFVNxQJjjsk/KGteZTqLzyjiXMWJhudmoWgZmTaMfkRfggZ/BPlBAHvsl6AK5UF0VGHU8HXHRWAkJisSHaMHonDD8hCUHI0J69w8).
-5 bytes thanks to *@Grimy*.
Takes a list of two items, `wood` as first value and `chuck` as second.
**Explanation:**
```
“Howƒ×1€Þ a ÿ0€¬ a ÿƒˆ01?“
        # Push dictionary string "How much1 would a ÿ0 if a ÿ could01?",
        # where the `ÿ` are automatically filled with the (implicit) input-list,
        # implicitly joined together to a single string
        #  i.e. ["wood","chuck"] → "How much1 would a woodchuck0 if a woodchuck could01?"
T       # Push 10
 $      # Push the input-list and 1
  ù     # Pad the strings in the input-list with this 1 amount of leading spaces
        #  ["wood","chuck"] → [" wood"," chuck"]
   ‡    # Transliterate the 10 ([1,0]) to these strings in the sentence
        #  → "How much wood would a woodchuck chuck if a woodchuck could chuck wood?"
        # (after which the result is output implicitly)
…a ÿ    # Push dictionary string "a ÿ",
        # where the `ÿ` are automatically filled with the (implicit) input-list,
        # implicitly joined together to a single string
        #  i.e. ["wood","chuck"] → "a woodchuck"
    ª   # Append this to the (implicit) input-list: ["wood","chuck","a woodchuck"]
     ðì # Prepend a space before each string: [" wood"," chuck"," a woodchuck"]
₁       # Push builtin 256
“Howƒ×2€Þ65€¬6ƒˆ52?“
        # Push dictionary string "How much2 would65 if6 could52?"
r       # Reverse the values on the stack
 ‡      # Transliterate [2,5,6] to [" wood"," chuck"," a woodchuck"] in the string
        #  → "How much wood would a woodchuck chuck if a woodchuck could chuck wood?"
        # (after which the result is output implicitly)
```
[See this 05AB1E tip of mine (section *How to use the dictionary?*)](https://codegolf.stackexchange.com/a/166851/52210) to understand why `“Howƒ×1€Þ a ÿ0€¬ a ÿƒˆ01?“` is `"How much1 would a ÿ0 if a ÿ could01?"` and `“Howƒ×2€Þ65€¬6ƒˆ52?“` is `"How much2 would65 if6 could52?"`.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 65 bytes
```
param($a,$b)"How much $a would a $a$b $b if a $a$b could $b $a`?"
```
[Try it online!](https://tio.run/##NcxBCsMgEAXQfU4xhKHTQvEGpdseoxMTUaoYTAcXoWe32liYxfz34a8xL2mzi/cFzW0vKycOZ@QrTpfxETME0RaQIUfxM3B9cYJ6zvyD/jVN@Xkfy2cYTmiAcowzAWkr@kUHWXapkbw7GLfZCj1RhyNJUEpR26nzVL4 "PowerShell – Try It Online")
The only thing of note is that you have to escape the question mark because those can be valid parts of a PowerShell identifier 
[Answer]
# VBA, 107 bytes
```
Function q(a,b)
b=b&" "
c="ould "
q="How much "&a&" w"&c&"a "&a&b&b&"if a "&a&b&"c"&c&b&a&"?"
End Function
```
Should run as VBScript too, I used two shortcuts: "ould " is repeating and "chuck" never appears without an additional space.
[Answer]
# [C#](https://visualstudio.microsoft.com/), 165 148 133 bytes
```
class P{static void Main(string[]a){System.Console.Write("How much {0} would a {0}{1} {1} if a {0}{1} could {1} {0}?\n",a[0],a[1]);}}
```
Thanks to [Andrew Baumher](https://codegolf.stackexchange.com/users/77057/andrew-baumher) for telling me about interpolated strings!! 
  
EDIT: Full class now added  
EDIT: Thanks to [Kenneth K.](https://codegolf.stackexchange.com/users/3505/kenneth-k) for giving me a few tips for shortening it  
EDIT: Thanks to Andrew again for telling me that using interpolated string is actually longer in this scenario.
[Answer]
# [Haskell](https://www.haskell.org/), 76 bytes
```
a?b=a++" "++b
a!b="How much"?a?"would a"?a++b?b?"if a"?a++b?"could"?b?a++"?"
```
[Try it online!](https://tio.run/##Pcw9DoAgFAPg3VNg48YZyFsd3DzBA0GN/BiVcHzExa3tl3Tj@7De18qkFUsJASl1x71WGFMRIZsNxISSsl8Et9ycNGF3f4P5EG39Hgg18B7VmZ/5uaY4NF4seqzJO9QX "Haskell – Try It Online")
First try, so I hope I didn't break any rules.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 39 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ŒPKŒP“µkþ¿µ‘ị“þ>Æƈ)taJṖ;ạʂ\4S%dñl»Ỵ¤ż”?
```
A full program accepting a list of two strings.
**[Try it online!](https://tio.run/##AWAAn/9qZWxsef//xZJQS8WSUOKAnMK1a8O@wr/CteKAmOG7i@KAnMO@PsOGxogpdGFK4bmWO@G6ocqCXDRTJWTDsWzCu@G7tMKkxbzigJ0/////Wydncm91bmQnLCAnaG9nJ10 "Jelly – Try It Online")**
...Or (also a full program accepting a list of two strings)
```
⁽4ṀDBịs€2ṭ€€⁶“þ>Æƈ)taJṖ;ạʂ\4S%dñl»Ỵ¤ż”?
```
**[Try it online!](https://tio.run/##y0rNyan8//9R416ThzsbXJwe7u4uftS0xujhzrVACoQatz1qmHN4n93htmMdmiWJXg93TrN@uGvhqaYYk2DVlMMbcw7tfrh7y6ElR/c8aphr/////2j19KL80rwUdR0F9Yz8dPVYAA "Jelly – Try It Online")**
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 68 bytes
```
StringRiffle@{How,much,#,would,a,c=#<>#2,#2,if,a,c,could,#2,#<>"?"}&
```
[Try it online!](https://tio.run/##HcwxC8MgFATgPT/jCZleKWROrGPH0o6hg33RKom1BMVB/O3WFG657@CcDEY5GSzJqqf6CLv9vO9W602JfPUJXSSDDJOP24ISaWIjZwO2WH10pP9y0MjhAqWvt/YRZnbiWgj27M8idxmS9wsgkIm0QsEmL7k3WJX6QulK/QE "Wolfram Language (Mathematica) – Try It Online")
[Answer]
# [Python 3](https://docs.python.org/3/), 80 bytes
```
lambda n:'How much {0} would a {0}{1} {1} if a {0}{1} could {1} {0}?'.format(*n)
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZ6tenp@foq6jnpxRmpytzpVmG/M/JzE3KSVRIc9KPSO/XCG3NDlDodqgVqE8vzQnRSERxK42rFUA4cw0BD8ZLA2WMai1V9dLyy/KTSzR0MrT/F9QlJlXopGmkaep@R8A "Python 3 – Try It Online")
when in rome, use str format.
**Edited** using squid's trick.
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), ~~66~~ 65 bytes
```
x=>y=>$"How much {x} would a {x+y} {y} if a {x+y} could {y} {x}?"
```
[Try it online!](https://tio.run/##Sy7WTS7O/O9WmpdsU1xSlJmXrqOAwoHQdnZptv8rbO0qbe1UlDzyyxVyS5MzFKorahXK80tzUhQSgWztylqFaiDOTINzk8GSIEGgUnul/9ZcAUDTSjTSNJTK8/NTlDQ1lJIzSpOzlTQ1kaSC8pNAMj755akgif8A "C# (Visual C# Interactive Compiler) – Try It Online")
same as everyone else, except C#. 
-1 byte by using currying strat a=>b=>c instead of (a,b)=>c
[Answer]
# [R](https://www.r-project.org/), 95 bytes
```
function(a,b)cat("How much ",a," would a ",a,b," ",b," if a ",a,b," could ",b," ",a,"?",sep='')
```
[Try it online!](https://tio.run/##TYtBCoAgEEWvIrMZhbmCtO0aOiVK5UQlHt9EWrT58N7//2rBtlAyP0myduQNu0fDLFUdhaMCcgSqStkX5Qb5zjAyhZ/iMYGv7qcJ6F5Pi2ha0FhFFiTkWHjr5gU "R – Try It Online")
[Answer]
# [C (clang)](http://clang.llvm.org/), 78 bytes
```
#define f(a,b)"How much "#a" would a "#a#b" "#b" if a "#a#b" could "#b" "#a"?"
```
[Try it online!](https://tio.run/##RYkxDsIwDEV3TmE5SyKFE3Rg5Rquk7SR3BhBowyoZw8tSGX5T/89vrJQmXo3IaZcIiRLfnR41wZL5RnQEELTKgHoOGbEHfvk9Bf87fhrhDfsuaywUC7WwfsCj7q@bLJzFFHf9CnBueHUrCH6SSUdcusf "C (clang) – Try It Online")
Using stringification
---
# [C (gcc)](https://gcc.gnu.org/), 85 bytes
```
f(a,b){printf("How much %s would a %s%s %s if a %s%s could %s %s?",a,a,b,b,a,b,b,a);}
```
[Try it online!](https://tio.run/##NUxLCoMwEN17imGgkEB6Ahfd9hpxYjQwOqKGLMSzp9PQ8obH@wyPnhNRrdF4N9hr29N6RoNvKbBkmuFxQJHMAbxKNXop/g21pqUvdF4xKH5s@7vqGCw@rcbC1YHuziOzoAMssnNA23ew5fMw2KQ@kIQRHU7C8Rvd9QM "C (gcc) – Try It Online")
Thanks to @ErikF suggestion to use gcc, btw I've seen that clang accepts f(\*a,\*b){ // which is 2 Bytes expensive anyway 
Saved 2 thanks to @ceilingcat.
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), ~~56~~ 59 bytes
```
{∊'How much '⍺' would a '⍺⍵' '⍵' if a '⍺⍵' could '⍵' '⍺'?'}
```
[Try it online!](https://tio.run/##TdAxagMxEAXQPqdQN5WrHCBFGhsCBjsXkLTSSrG8I9YWwhhXBhMMa5LC50iVxmWOootsZpQE0ozm6QsNjIxh0uxkwHYc9@X1DFPMYp20E1CGG4iMKTRCVpXhE7ih6u3/O10fwV9@gwc4jLac3spwKZfrbF7Ox6@P@3J6Jy0Xj1Sfp7PlCBmxAQvaJb2CO1CyJ62MiYQ1dmZHVCZsib30HcnKEEhOen6qE0dtbwxnDtPGkF@kUobjjPXb6DtDkjEGjheoSE@YGRobzloMlmT9xpGo41GM2lEVdAghqPvdSJ33syr4Bg "APL (Dyalog Unicode) – Try It Online")
Pretty straightforward dfn. Saves a byte by cutting `∊` if we're allowed to return an array of strings instead of a single string.
3 bytes added because I'd forgotten to add the question mark.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~41~~ 37 bytes
```
⁾be,y“Ø[gœıJ9°m.OṚuHlh3Ƥ⁾$ɲ0øḲʂṇHẎṆȥ»
```
[Try it online!](https://tio.run/##AVcAqP9qZWxsef//4oG@YmUseeKAnMOYW2fFk8SxSjnCsG0uT@G5mnVIbGgzxqTigb4kybIww7jhuLLKguG5h0jhuo7huYbIpcK7////Indvb2QiLCJjaHVjayI "Jelly – Try It Online")
A full program taking a pair of strings as its argument and printing the processed string. A monadic link could be formed by adding a `F` to the end (thanks to @JonathanAllan for pointing this out).
I’ve now switched to using "b" and "e" as placeholders, inspired by [@dzaima’s SOGL answer](https://codegolf.stackexchange.com/a/190327/42248) so be sure to upvote that one too! This does mean that the first word can’t include the letter e.
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-S`](https://codegolf.meta.stackexchange.com/a/14339/), ~~44~~ 39 bytes
```
[`How Û2`U`Ùd a`N=¬V`if a`N`Öd`VU+'?]
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVM&code=W2BIb3cg2zJgVWDZAmQgYWBOPaxWYGlmIGFgTmDWAmRgVlUrJz9d&input=Indvb2QiCiJjaHVjayI)
[Answer]
# [Forth (gforth)](http://www.complang.tuwien.ac.at/forth/gforth/Docs-html/), 116 bytes
```
: x 2over type ; : y 2dup type ; : f ." How much "x ."  would a "x y ."  "y ."  if a "x y ."  could "y ."  "x ." ?";
```
[Try it online!](https://tio.run/##TZDBDoMgDIbve4o/XHbaDh71sOteQxGGUQdBmPL0DgpGE0L7fYW0qdTWqcdHprDvNTZU@icsXDACDWoEVL03J0s8Gd56xey5AtsSYtV@6tEmDCRYDoO8Sk6vSin/fLEmNjW4M4h5cNfmh1pMy086hzkMt3GmeMXT3BYWZ9E9Q0y48nxkMEl2rSU3CmGKmvVXBJKdmFyRxCXPcJAcFnWtUp6lyW1pBaRVWU8s7X8 "Forth (gforth) – Try It Online")
### Code Explanation
```
\ x = output the first word
: x               \ start a new word definition
  2over type      \ copy the "first" word to the top of the stack and print it
;                 \ end word definition
\ y = output the second word
: y               \ start a new word definition
  2dup type       \ copy the "second" word to the top of the stack and print it
;                 \ end word definition
  
: f               \ start a new word definition
  ." How much "x  \ print "How much " followed by the first word   
  ."  would a "x  \ print " would a " followed by the first word
  y ."  if a "x   \ print the second word followed by " if a " and then the first word
  y ."  could "y  \ print the second word, then " could " then the second word again
  ."  "x ." ?"    \ print a space followed by the first word, followed by "?"
;                 \ end word definition
```
[Answer]
# [Lua](https://www.lua.org), 82 bytes
```
a,b=...print((('How much x would a xy y if a xy could y x?'):gsub('.',{x=a,y=b})))
```
[Try it online!](https://tio.run/##JchBCoAgEADAr@xNBfEBgXTtG2qUkmVUiy7R2zeo2zAZHbPT3hpj9iNtl5RSDKXCiiFCg1owj@CgERCk6Vf4kqD1QnXziV4KI/TdrNNk/aOUYuZaysghYlhe "Lua – Try It Online")
Full program, take input as arguments.
Nothing special here. Hope that there's shorter version, but no obvious ways to shorten this at first glance.
]