Composing fill in the blanks Let us say that we have a particular set of functions on strings.  These functions are kind of like fill in the blanks or madlibs, except that they only take one input and use that to fill in all of their blanks.  For example we might have a function that looks like

I went to the ____ store and bought ____ today.


If we applied this function to the string cheese the result would be:

I went to the cheese store and bought cheese today.


We can represent these functions as a non-empty list of strings, where the blanks are simply the gaps in between strings.  For example our function above would be:

["I went to the ", " store and bought ", " today."]


With this representation there is only one representation for every function of this sort and only one function for each representation.

A really neat thing is that the set of such functions is closed under composition.  That is to say composition of two of our functions is always another one of these functions.  For example if I compose our function above with

["blue ", ""]


(the function that prepends blue to the input)
We get the function:

["I went to the blue ", " store and bought blue ", " today."]


These can get a little more complex though.  For example if we compose the first function with

["big ", " and ", ""]


The result is 

["I went to the big ", " and ", " store and bought big ", "and", " today."]


Task

Your task is to take two functions as described as non-empty lists of strings and output their composition as a non-empty list of strings.

For the purpose of this challenge a list can be any ordered container that permits
duplicates and a string may be a native string type, a list of characters or a list of integers.

This is code-golf answers will be scored in bytes with fewer bytes being better.

Test cases

["","xy"] ["ab",""] -&gt; ["ab","xy"]
["x","y","z"] ["a","b"] -&gt; ["xa","bya","bz"]
["xy"] ["ab"] -&gt; ["xy"]
["","",""] ["a",""] -&gt; ["a","a",""]
["x",""] ["","",""] -&gt; ["x","",""]
["x","y","z"] ["a","b","c"] -&gt; ["xa","b","cya","b","cz"]
["x","x","x"] ["a"] -&gt; ["xaxax"]
["w","x","y","z"] ["ab","cd","e"] -&gt; ["wab","cd","exab","cd","eyab","cd","ez"]
Jelly, 6 bytes

j0j@ṣ0


A dyadic Link accepting the first function representation on the right and the second function representation on the left which yields the resulting function representation. Each function representation is a list of lists of characters (Jelly has no other strings).

Try it online! (the full-program arguments are given in Python notation; strings become lists. The footer shows a Python representation of the Link's output.)

Here is a test-suite which reformats the Link's output like the inputs.

How?

Takes advantage of Jelly's mixed type lists to allow the entire domain of representations (any list of lists of characters) by using the integer zero as a place-holder:

j0j@ṣ0 - Link: b, a        e.g.    b = [['a','b'],['c','d'],['e']]
       -                   ...and  a = [['w'],['x'],['y'],['z']]
                             (i.e. test-case ["w","x","y","z"] ["ab","cd","e"])
j0     - join b with zeros         ['a','b',0,'c','d',0,'e']    
  j@   - join a with that          ['w','a','b',0,'c','d',0,'e','x','a','b',0,'c','d',0,'e','y','a','b',0,'c','d',0,'e','z']
    ṣ0 - split at zeros            [['w','a','b'],['c','d'],['e','x','a','b'],['c','d'],['e','y','a','b'],['c','d'],['e','z']
                             (i.e.: ["wab","cd","exab","cd","eyab","cd","ez"])




If we needed to deal with any of Jelly's mixed lists (including those of any depth or shape) we could use this eight byter: j,©⁹jœṣ® which uses the paired arguments as the place-holder.