This is probably asked before but I don’t know how to begin searching for it.

Some context: I’m using TemporalData objects that share a number of common features but also have distinct characteristics. I use their MetaInformation to catalog these features for future reference. The output of the desired function will be used as the second argument in Rule[Metainformation, #].

I’m trying to accomplish the following: given a list of common keys and values (common:{keys_, values_}) and another list consisting of two elements namely a list of lists of distinct keys and another list of lists of their corresponding distinct values (unique:{allKeys_, allValues_}) I want to produce a list of lists of rules where all lists of rules will contain both the common and the corresponding distinctive features.

An example: Assuming f is the desired function, then

in = {
  { {"a","b","c"}, {1,2,3} },
  { {{"d"}, {"e","f"}, {"g","h","i"}}, {{4}, {5,6}, {7,8,9}} }
 };

f @@ in

is expected to produce out, where out is defined as follows:

out = {
  {"a"->1, "b"->2, "c"->3, "d"->4},
  {"a"->1, "b"->2, "c"->3, "e"->5, "f"->6},
  {"a"->1, "b"->2, "c"->3, "g"->7, "h"->8, "i"->9}
 }

(Please note that the number of elements in the lists of common and the corresponding elements in the lists of unique is expected to be random. I used the example above just for ease of exposition.)

I have developed 3 function versions that seem to do what I want but they all feel a bit clunky; also, I think they are too similar. Furthermore, only the second one is a proper function.

If there are any suggestions on the presented code or-better yet-if there are any other ideas on how to code f, that would be great!

Some f‘s

• 1.

  f[common:{keys_, values_}, unique:{allKeys_, allValues_}] := 
    h[Apply[g /* List, common], Thread[Apply[g, unique]]]
  

  and

  {out} === (f[Sequence @@ in] /. h[x__] :> 
   Outer[j /* (Thread[#, g] &), x] /. {j -> Join, g -> Rule /* Thread})
  

  evaluates to

  True
  

• 2.

  f[common:{keys_, values_}, unique:{allKeys_, allValues_}] := Outer[
    List /* Transpose /* Apply[Rule /* (Apply[Join, #, 1] &) /* Thread], 
      {common}, Transpose[unique], 1]
  

  and

  {out} == f @@ in
  

  evaluates to

  True
  

• 3.

  f[common:{keys_, values_}, unique:{allKeys_, allValues_}] := 
    Apply[Rule][Thread[g[common, unique]]]
  

  and

  out === (
    ( f @@ in /. g[x_, y_] :> ReleaseHold[
        Distribute[Hold[Join][{x}, y], List]
       ] ) // Thread /* Map[Thread]
   )
  

  evaluates to

  True