range of ranges into one range?

[Jonathan Marler via Digitalmars-d-learn]

I'm using the phobos "chain" function to iterate over a set of 
string arrays.  However, one of the variables is actually an 
array of structs that each contain a string array.  So I use 
"map" to get a range of string arrays, but "chain" expects each 
variable to be a string array, not a range of string arrays.  The 
solution I came up with was to find a way to convert a range of 
ranges into one range.  I couldn't find this transformation in 
phobos.  Does anyone know if it already exists?  It's actually 
similar to chain itself but chains a range of ranges, not a tuple 
of ranges.  I implemented something that works below, but would 
love to use something that already exists in phobos.

import std.stdio, std.range, std.algorithm;

struct MyStrings
{
     string[] strings;
}

void main()
{
     auto normalStringArray1 = ["a", "b", "c"];
     auto normalStringArray2 = ["d", "e", "f"];
     auto myStringArrays = [
         MyStrings(["g", "h", "i"]),
         MyStrings(["j", "k", "l"]),
     ];

     foreach(str; chain(
         normalStringArray1,
         normalStringArray2,
         splice(map!(a => a.strings)(myStringArrays))))
     {
         writeln(str);
     }
}

auto splice(Range)(Range inputRange)
{
     static struct SplicedRanges(K)
     {
         static assert(K.init.empty);

         Range inputRange;
         K current;
         this(Range inputRange)
         {
             this.inputRange = inputRange;
             if(!this.inputRange.empty)
             {
                 current = this.inputRange.front;
                 if(current.empty)
                 {
                     setCurrentToNext();
                 }
             }
         }

         private void setCurrentToNext()
         {
             while(!inputRange.empty)
             {
                 inputRange.popFront;
                 if(inputRange.empty)
                 {
                     break;
                 }
                 current = inputRange.front;
                 if(!current.empty)
                 {
                     break;
                 }
             }
         }

         @property bool empty()
         {
             return current.empty;
         }
         @property auto front()
         {
             return current.front;
         }
         void popFront()
         {
             if(!current.empty)
             {
                 current.popFront;
                 if(!current.empty)
                 {
                     return;
                 }
             }
             setCurrentToNext();
         }
     }

     return SplicedRanges!(typeof(inputRange.front))(inputRange);
}