anchor.diff:              | None -> None
   
   
  -type Struct = { name : string; fields : list<Type * string>; isUnion : bool }
  +type Struct = { name : string; fields : list<Type * string>; isUnion : bool; alias : Option<string> }
  +
  +
  +
   [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
   module Struct =
       let tryRead (defines : Map<string, string>) (e : XElement) =
           let isUnion = attrib e "category" = Some "union"
           match attrib e "name" with
               | Some name ->
  -                
  -                let fields = 
  -                    e.Descendants (xname "member")
  -                        |> Seq.map (fun m ->
  -                            m.Elements(xname "comment").Remove()
  -
  -                            let name = m.Element(xname "name").Value
  -                            let t = 
  -                                let v = m.Value.Trim()
  -                                let id = v.LastIndexOf(name)
  -                                if id < 0 then v
  -                                else v.Substring(0, id).Trim() + v.Substring(id + name.Length)
  -
  -                            Type.parseTypeAndName defines t name
  -                           )
  -                        |> Seq.toList
  -
  -                Some { name = name; fields = fields; isUnion = isUnion }
  +                match attrib e "alias" with
  +                    | Some alias -> 
  +                        Some { name = name; fields = []; isUnion = isUnion; alias = Some alias }
  +                    | None -> 
  +                        let fields = 
  +                            e.Descendants (xname "member")
  +                                |> Seq.map (fun m ->
  +                                    m.Elements(xname "comment").Remove()
  +
  +                                    let name = m.Element(xname "name").Value
  +                                    let t = 
  +                                        let v = m.Value.Trim()
  +                                        let id = v.LastIndexOf(name)
  +                                        if id < 0 then v
  +                                        else v.Substring(0, id).Trim() + v.Substring(id + name.Length)
  +
  +                                    Type.parseTypeAndName defines t name
  +                                   )
  +                                |> Seq.toList
  +
  +                        Some { name = name; fields = fields; isUnion = isUnion; alias = None }
   
               | None -> None
   
  
positive.code: [<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  module Command =
      let tryRead (defines : Map<string, string>) (e : XElement) : Option<Command> =
          let proto = e.Element(xname "proto")
          let (returnType,name) = Type.readXmlTypeAndName defines proto
  
          let parameters =
              e.Elements(xname "param")
                  |> Seq.map (Type.readXmlTypeAndName defines)
                  |> Seq.toList
  
  
          Some { returnType = returnType; name = name; parameters = parameters }
  
  type Extension =
      {
          name            : string
  
negative.code:     let aliases (defines : Map<string, string>) (vk : XElement) =
          vk.Descendants(xname "types")
              |> Seq.collect (fun tc -> tc.Descendants (xname "type"))
              |> Seq.filter (fun t -> attrib t "category" = Some "basetype" )
              |> Seq.choose (Alias.tryRead defines)
              |> Seq.toList
  
  