anchor.diff:  
       and XsdComplexType = 
           { Attributes: (XmlQualifiedName * XmlTypeCode * IsOptional) list
  -          Contents: XsdContent 
  -          IsMixed: bool }
  +          Contents: XsdContent }
   
       and XsdContent = SimpleContent of XmlTypeCode | ComplexContent of XsdParticle
   
  
positive.code:         | [] -> 
              InferedTypeTag.Null, 
              (InferedMultiplicity.OptionalSingle, InferedType.Null)
  //        | [ (elm, mul) ] ->
  //            InferedTypeTag.Record(Some elm.Name.Name), 
  //            (mul, inferElementType elm)
          | items ->
              let tags = items |> List.map (fst >> getRecordTag)
              
  
negative.code: 
      open XsdModel
  
      let rec parseElement (ctx: ParsingContext) elm = 
          let substitutionGroup = 
              ctx.getSubstitutions elm 
              |> List.filter (fun x -> x <> elm) 
              |> List.map (parseElement ctx)
          let elementType =
              if ctx.isRecursive elm
              then // empty content
                  ComplexType { Attributes = []; Contents = ComplexContent Empty }
              else 
                  match elm.ElementSchemaType with
                  | :? XmlSchemaSimpleType  as x -> SimpleType x.Datatype.TypeCode
                  | :? XmlSchemaComplexType as x -> ComplexType (parseComplexType ctx x)
                  | x -> failwithf "unknown ElementSchemaType: %A" x
          { Name = elm.QualifiedName
            Type = elementType
            SubstitutionGroup = substitutionGroup
            IsAbstract = elm.IsAbstract
            IsNillable = elm.IsNillable }
          
  
      and parseComplexType (ctx: ParsingContext) (x: XmlSchemaComplexType) =  
          { Attributes = 
              x.AttributeUses.Values 
              |> ofType<XmlSchemaAttribute>
              |> Seq.filter (fun a -> a.Use <> XmlSchemaUse.Prohibited)
              |> Seq.map (fun a -> 
                  a.QualifiedName,
                  a.AttributeSchemaType.Datatype.TypeCode, 
                  a.Use <> XmlSchemaUse.Required)
              |> List.ofSeq
            Contents = 
              match x.ContentType with
              | XmlSchemaContentType.TextOnly -> SimpleContent x.Datatype.TypeCode
              | XmlSchemaContentType.Mixed 
              | XmlSchemaContentType.Empty 
              | XmlSchemaContentType.ElementOnly -> 
                  x.ContentTypeParticle |> parseParticle ctx |> ComplexContent
              | _ -> failwithf "Unknown content type: %A." x.ContentType }
  
  
      and parseParticle (ctx: ParsingContext) (par: XmlSchemaParticle) =  
  