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: 
      open XsdModel
  
      let rec parseElement (ctx: ParsingContext) (elm: XmlSchemaElement)  =  
  
          let substitutionGroup = 
              ctx.getSubstitutions elm 
              |> List.filter (fun x -> x <> elm) 
              |> List.map (parseElement ctx)
  
          if ctx.isRecursive elm 
          then
            { Name = elm.QualifiedName
              Type = // empty content
                { Attributes = []
                  Contents = ComplexContent Empty 
                  IsMixed = false }
                |> ComplexType
              SubstitutionGroup = substitutionGroup
              IsAbstract = elm.IsAbstract
              IsNillable = elm.IsNillable }
          else
            { Name = elm.QualifiedName
              Type = 
                match elm.ElementSchemaType with
                | :? XmlSchemaSimpleType  as x -> SimpleType x.Datatype.TypeCode
                | :? XmlSchemaComplexType as x -> ComplexType (parseComplexType ctx x)
                | x -> failwithf "unknown ElementSchemaType: %A" x
              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
  
            IsMixed = x.IsMixed }
  
  
      and parseParticle (ctx: ParsingContext) (par: XmlSchemaParticle) =  
  
negative.code:         | [] -> 
              InferedTypeTag.Null, 
              (InferedMultiplicity.OptionalSingle, InferedType.Null)
          | items ->
              let tags = items |> List.map (fst >> getRecordTag)
              
  