anchor.diff:  
                       // Add fields and properties to type
                       ty.AddMembers <|
  -                        (members |> Array.collect (fun (f,p) -> [|f :> MemberInfo; p:> MemberInfo|]) |> List.ofArray)
  +                        (members |> List.collect (fun (f,p) -> [f :> MemberInfo; p:> MemberInfo]))
  +
  +                    // Add default constructor
  +                    ty.AddMember <| ProvidedConstructor([], invokeCode = fun _ -> <@@ () @@>)
  +                    // Add full-init constructor
  +                    let ctorParams =
  +                        members |> List.map(fun (f,p) -> 
  +                            let paramName = niceCamelName p.Name
  +                            ProvidedParameter(paramName, f.FieldType) )
  +                    ty.AddMember <| ProvidedConstructor(ctorParams, invokeCode = fun args ->
  +                        let (this,args) = 
  +                            match args with
  +                            | x::xs -> (x,xs)
  +                            | _ -> failwith "Wrong constructor arguments"
  +                        List.zip args members
  +                        |> List.map (fun (arg,(f, p)) ->
  +                             Expr.FieldSetUnchecked(this, f, arg))
  +                        |> List.rev
  +                        |> List.fold (fun a b -> 
  +                            Expr.Sequential(a, b)) (<@@ () @@>)
  +                        )
   
                       // Override `.ToString()`
                       let toStr = 
  
positive.code:                             invokeCode = fun args ->
                                  let this = args.[0]
                                  let (pNames, pValues) =
                                      members
                                      |> Array.map (fun (pField, pProp) ->
                                          let pValObj = Expr.FieldGet(this, pField)
                                          pProp.Name, Expr.Coerce(pValObj, typeof<obj>)
  
negative.code:                                             then
                                                  let elements =
                                                      seq {
                                                          for x in (v :?> Collections.IEnumerable) do
                                                              yield formatValue x
                                                      } |> Seq.toArray
                                                  String.Format("[{0}]", String.Join("; ", elements))
  