anchor.diff:          types
           |> Seq.iter(fun x -> writer.WriteLine( sprintf "* [%s](%s)" x.name (x.name + ".md") ))
   
  -    namespaces
  -    |> Seq.iter renderNameSpace
  +        if children.IsEmpty |> not then
  +            renderHeadline writer 2 "Namespaces"
  +            writer.WriteLine()
  +
  +            children
  +            |> Seq.iter(fun child -> 
  +                let (Tree(name, children)) = child
  +                writer.WriteLine( sprintf "* [%s.%s](%s/ReadMe.md)" fullName name name )
  +                renderTree fullPath child)
  +
  +    nsTrees
  +    |> Seq.iter (renderTree [])
   
       
   let generateAssemblyFileDoc outputFolder assemblyFile  = 
  
positive.code: 
          // render summary file
          use writer =  new StreamWriter(Path.Combine(folder, "ReadMe.md")) 
          renderHeadline writer 1 ns
          writer.WriteLine()
  
          renderHeadline writer 2 "Types"
  
negative.code: /// Summary page per namespace listing all types
  /// (with readme.md from source folder at top if available)    
  let generateAssemblyDoc outputFolder (assembly:DAssembly) = 
      let namespaceTypesMap =
          assembly.assembly.GetTypes()
          |> Seq.filter (fun t -> t.IsPublic)
          |> Seq.map (createDType assembly)
          |> Seq.groupBy(fun x -> x.nameSpace )
          |> dict
      
      let rec createTrees (namespaces:list<list<string>>) = [
          for top in namespaces |> Seq.groupBy(fun x -> Seq.head x) do
              let name = top |> fst
              let children = 
                  snd top 
                  |> Seq.map(function | [] -> [] | h::t -> t)
                  |> Seq.filter(fun x -> x.IsEmpty |> not)
                  |> List.ofSeq
              yield if children.Length = 0 then Tree(name,[]) else Tree(name, createTrees children)
      ]
  
      let nsTrees = 
          namespaceTypesMap
          |> Seq.map(fun x -> x.Key.Split( [|'.'|], StringSplitOptions.RemoveEmptyEntries) |> List.ofArray)
          |> Seq.sortBy(fun x ->x.Length)
          |> List.ofSeq
          |> createTrees
  
      let rec renderTree (path:string list) (tree:Tree) =
          let (Tree(name, children)) = tree
  
          let fullPath = [ yield! path; yield name ]
  
          let subFolder = Path.Combine(fullPath |> Array.ofList)
          let folder = Path.Combine(outputFolder, subFolder)
  
          if Directory.Exists folder then 
              Directory.Delete(folder, true)
  
          Directory.CreateDirectory(folder) |> ignore
  
          let fullName = String.Join(".", fullPath)
          let types = namespaceTypesMap.[fullName]
  
          // render individual type files
          types
  