//-----------------------------------------------------------------------
 public static string Extension__BuildHumanName(this Type type)
 {
  Debug.Assert(!type.IsGenericParameter);

  var ctx
   =new tagBuildHumanNameCtx
     (type);

  var result
   =Helper__BuildHumanName
     (ref ctx,
      type);

  return result;
 }//Extension__BuildHumanName

 //-----------------------------------------------------------------------
 private struct tagBuildHumanNameCtx
 {
  public int iGenericArg;

  public readonly Type[] GenericArguments;

  public tagBuildHumanNameCtx(Type type)
  {
   this.iGenericArg=0;

   if(!type.IsGenericType)
    this.GenericArguments=null;
   else
    this.GenericArguments=type.GetGenericArguments();
  }//tagCTX
 };//struct tagBuildHumanNameCtx

 //-----------------------------------------------------------------------
 private static string Helper__BuildHumanName(ref tagBuildHumanNameCtx ctx,
                                              Type                     type)
 {
  Debug.Assert(!Object.ReferenceEquals(type,null));

  var sb
   =new System.Text.StringBuilder();

  //------------------------------------------------------- ARRAY
  if(type.IsArray)
  {
   var elementType
    =type.GetElementType();

   Debug.Assert(!Object.ReferenceEquals(elementType,null));

   sb.Append
    (Extension__BuildHumanName(elementType));

   var arrayRank
    =type.GetArrayRank();

   Debug.Assert(arrayRank>0);

   for(int i=0;i!=arrayRank;++i)
    sb.Append("[]");

   return sb.ToString();
  }//if type.IsArray

  Debug.Assert(!type.IsArray);

  //------------------------------------------------------- STD

  //------------------------- parent class OR namespace
  if(!Object.ReferenceEquals(type.DeclaringType,null))
  {
   var declaringTypeSign
    =Helper__BuildHumanName
      (ref ctx,
       type.DeclaringType);

   Debug.Assert(!string.IsNullOrEmpty(declaringTypeSign));

   sb.Append(declaringTypeSign);
   sb.Append('+');
  }
  else
  {
   for(;;)
   {
    if(Helper__BuildHumanName__SkipNms(type))
     break;

    var nms
     =type.Namespace;

    if(Object.ReferenceEquals(nms,null))
     break;

    Debug.Assert(nms.Length>0);

    if(nms.Length==0)
     break;

    sb.Append(nms);
    sb.Append('.');

    break;
   }//for[ever]
  }//else

  //------------------------- name
  if(!type.IsGenericType)
  {
   sb.Append(Helper__CheckTypeName(type.Name));
  }
  else
  {
   Debug.Assert(type.IsGenericType);

   Debug.Assert(!Object.ReferenceEquals(ctx.GenericArguments,null));
   Debug.Assert(ctx.iGenericArg<=ctx.GenericArguments.Length);

   //-------------------------
   var extractResult
    =Helper__ExtractGenericName(type);

   sb.Append(extractResult.Name);

   if(!extractResult.HasGenericParams)
   {
    //NO GENERIC PARAMETERS
   }
   else
   {
    //HAS GENERIC PARAMETERS

    sb.Append('<');
   
    var cGenericArgs
     =type.GetGenericArguments().Length;
   
    Debug.Assert(cGenericArgs>0);
    Debug.Assert(cGenericArgs<=ctx.GenericArguments.Length);
   
    Debug.Assert(ctx.iGenericArg<=cGenericArgs);
   
    bool isFirst
     =true;
   
    for(;ctx.iGenericArg!=cGenericArgs;++ctx.iGenericArg,isFirst=false)
    {
     Debug.Assert(ctx.iGenericArg<ctx.GenericArguments.Length);
   
     var a
      =ctx.GenericArguments[ctx.iGenericArg];
   
     Debug.Assert(!Object.ReferenceEquals(a,null));
   
     if(!isFirst)
      sb.Append(',');
   
     if(!a.IsGenericParameter)
     {
      if(!isFirst)
       sb.Append(' ');
   
      sb.Append
       (Extension__BuildHumanName(a));
     }//if !a.IsGenericParameter
    }//for i
   
    sb.Append('>');
   }//if extractResult.Item1
  }//else type.IsGenericType with parameters

  //-------------------------- Go home...
  return sb.ToString();
 }//Helper__BuildHumanName

 //-----------------------------------------------------------------------
 private static bool Helper__BuildHumanName__SkipNms(Type type)
 {
  Debug.Assert(!Object.ReferenceEquals(type,null));

  if(!type.IsGenericType)
   return false;

  if(!type.IsGenericTypeDefinition)
   type=type.GetGenericTypeDefinition();

  //special support for Nullable - skip namespace
  if(type==Structure_TypeCache.TypeOf__System_Nullable)
   return true;

  return false;
 }//Helper__BuildHumanName__SkipNms

 //-----------------------------------------------------------------------
 private struct tagResultOfExtractGenericName
 {
  public bool    HasGenericParams;
  public string  Name;

  public tagResultOfExtractGenericName(bool hasGenericParams,string name)
  {
   this.HasGenericParams=hasGenericParams;

   this.Name=name;
  }//tagResultOfExtractGenericName
 };//class tagResultOfExtractGenericName

 //-----------------------------------------------------------------------
 private static tagResultOfExtractGenericName Helper__ExtractGenericName(Type type)
 {
  Debug.Assert(!Object.ReferenceEquals(type,null));
  Debug.Assert(type.IsGenericType);

  //Example: "Nullable`1"
  var name
   =Helper__CheckTypeName(type.Name);

  var i
   =name.IndexOf('`');

  if(i==-1)
   return new tagResultOfExtractGenericName(false,name);

  Debug.Assert(i>0);

  var name2
   =name.Substring(0,i);

  return new tagResultOfExtractGenericName(true,Helper__CheckTypeName(name2));
 }//Helper__ExtractGenericName

 //-----------------------------------------------------------------------
 private static string Helper__CheckTypeName(string name)
 {
  Debug.Assert(!string.IsNullOrEmpty(name));

  if(Object.ReferenceEquals(name,null))
   return "##NULL_TYPE_NAME";

  if(name.Length==0)
   return "##EMPTY_TYPE_NAME";

  return name;
 }//Helper__CheckTypeName