anchor.diff:          override __.AsArray() =
               match value with
               | List(nodes) ->
  -                nodes |> List.map(fun x->YamlNodeAdapter(x) :> SchemaNode) |> Array.ofList
  +                nodes |> Seq.map(fun x->YamlNodeAdapter(x) :> SchemaNode) |> Array.ofSeq
               | _ -> [||]
   
           override __.AsStringArrayWithoutNull() =
               match value with
               | Scalar(x) -> [|x|]
               | List(nodes) ->
  -                nodes |> Array.ofList
  -                |> Array.map(function
  +                nodes 
  +                |> Seq.map(function
                       | Scalar (x) -> x
                       | x -> failwithf "'%A' cannot be converted to string" x)
  -                |> Array.filter (fun x -> x <> "null")
  +                |> Seq.filter (fun x -> x <> "null")
  +                |> Seq.toArray
               | other -> failwithf "Value: '%A' cannot be converted to StringArray" other
   
           override __.Properties() =
               match value with
  -            | Map(pairs) -> pairs |> List.map (fun (a,b)-> (a, YamlNodeAdapter(b) :> SchemaNode)) |> Array.ofList
  +            | Map(pairs) -> pairs |> Seq.map (fun (a,b)-> (a, YamlNodeAdapter(b) :> SchemaNode)) |> Array.ofSeq
               | _ -> raise <| UnexpectedValueTypeException(value, "map")
   
           override __.TryGetProperty(prop) =
  
positive.code:                 |> Option.map (fun (_,x) -> YamlNodeAdapter(x) :> SchemaNode)
              | _ -> None
  
      let parse = parseYaml >> YamlNodeAdapter
  
  module SwaggerParser =
  
  
negative.code:     open YamlDotNet.Serialization
      open System.Collections.Generic
  
      let (|List|_|) (node: obj) =
          match node with
          | :? List<obj> as l -> Some l
          | _ -> None
  
      let (|Map|_|) (node: obj) =
          match node with
          | :? Dictionary<obj,obj> as dict ->
              dict 
              |> Seq.choose (fun p ->
                  match p.Key with
                  | :? string as key -> Some (key, p.Value)
                  | _ -> None)
              |> Some
          | _ -> None
  
      let (|Scalar|_|) (node: obj) =
          match node with
          | :? List<obj> 
          | :? Dictionary<obj,obj> ->
              None
          | scalar -> 
              let value = if isNull scalar then "" else scalar.ToString()
              Some (value)
              
      /// SchemaNode for Swagger schemes in Yaml format
      type YamlNodeAdapter(value:obj) =
          inherit SchemaNode()
  
          override __.AsBoolean() =
  