FsPickler


An Introduction to FsPickler

The following provides an overview of the basic functionalities offered by the library.

The core serialization API

The basic API is accessible through instances of type FsPicklerSerializer that can be initialized as follows:

1: 
2: 
3: 
4: 
5: 
6: 
#r "FsPickler.dll"

open MBrace.FsPickler

let binarySerializer = FsPickler.CreateBinarySerializer()
let xmlSerializer = FsPickler.CreateXmlSerializer(indent = true)

Json serialization formats can be accessed by referencing the FsPickler.Json project. If evaluating from F# interactive, make sure to add an explicit reference to Json.Net.

1: 
2: 
3: 
4: 
5: 
6: 
7: 
#r "Newtonsoft.Json.dll"
#r "FsPickler.Json.dll"

open MBrace.FsPickler.Json

let jsonSerializer = FsPickler.CreateJsonSerializer(indent = false)
let bsonSerializer = FsPickler.CreateBsonSerializer()

A simple serialization/deserialization roundtrip can be performed as follows:

1: 
2: 
xmlSerializer.Serialize(stream, [0. .. 0.1 .. 1.])
xmlSerializer.Deserialize<float list>(stream)

FsPickler instances can be used to produce binary pickles, that is byte arrays containing the serialized values:

1: 
2: 
let pickle = binarySerializer.Pickle <@ 1 + 1 @>
binarySerializer.UnPickle<Quotations.Expr<int>> pickle

Text-based serialization

The Xml and Json serializers are instances of type FsPicklerTextSerializer that offers functionality for text-based serialization:

1: 
2: 
3: 
4: 
5: 
xmlSerializer.Serialize(textWriter, [ Some 1 ; Some 2 ; None ])
xmlSerializer.Deserialize<int option list>(textReader)

let text = jsonSerializer.PickleToString (fun x -> x + 1)
jsonSerializer.UnPickleOfString<int -> int> text

Sequence serialization

FsPickler offers support for on-demand sequence serialization/deserialization:

1: 
2: 
3: 
4: 
5: 
let seq = Seq.initInfinite string |> Seq.take 100

let length = binarySerializer.SerializeSequence(stream, seq) // returns the length of serialized elements
let seq' = binarySerializer.DeserializeSequence<int>(stream) // lazy deserialization IEnumerable
Seq.toArray seq' // evaluation forces full deserialization

Picklers and Pickler combinators

A pickler is essentially the type

1: 
2: 
3: 
4: 
5: 
type Pickler<'T> =
    {
        Write : WriteState -> 'T -> unit
        Read  : ReadState  -> 'T
    }

which defines the serialization/deserialization rules for a given type. Picklers are strongly typed and perform serialization without reflection or intermediate boxings.

There are two kinds of picklers:

  • Primitive or atomic picklers that are self-contained definitions for simple values like primitives, strings or timespans.

  • Composite picklers which are derived from composition of simpler types. They are generated using pickler combinators, functions taking a collection of picklers as inputs yielding a composite result.

FsPickler is essentially an automated pickler generation framework: picklers are generated at runtime and on demand using a combination of reflection and dynamic IL generation. Picklers are cached for future use, hence the cost of generation has a constant price.

Moreover, the library provides an experimental combinator module that allows direct manipulation of picklers in a more functional style:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
open MBrace.FsPickler.Combinators

// atomic picklers
let int = Pickler.int
let string = Pickler.string
let dateTime = Pickler.dateTime

// composite picklers
let p1 = Pickler.pair int dateTime
let p2 = Pickler.option string
let p3 = Pickler.list p2
let p4 = Pickler.array2D p1
let p5 = Pickler.auto<int * string option list>

// pickler-based serialization
let t1 = Binary.pickle int 42
let t2 = Json.pickle p3 [ Some "" ; None ; Some "message" ]

Json.unpickle p3 t2

The module includes all primitive combinators as described in Andrew Kennedy's Pickler Combinators likewrap and alt. Fixpoint combinators for declaring recursive picklers are also available:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
type Peano = Zero | Succ of Peano

let pp : Pickler<Peano> =
    Pickler.fix(fun peano ->
        peano
        |> Pickler.option
        |> Pickler.wrap (function None -> Zero | Some p -> Succ p)
                        (function Zero -> None | Succ p -> Some p))
                        
Succ (Succ Zero) |> Binary.pickle pp |> Binary.unpickle pp

When it comes to generic types, picklers can be created through user-defined combinators:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
type Tree<'T> = Leaf | Node of 'T * Tree<'T> list

let mkTree (ep : Pickler<'T>) =
    Pickler.fix(fun tree ->
        tree
        |> Pickler.list
        |> Pickler.pair ep
        |> Pickler.option
        |> Pickler.wrap (function None -> Leaf | Some (t,c) -> Node(t,c))
                        (function Leaf -> None | Node (t,c) -> Some(t,c)))
                        
Node(2,[]) |> Xml.pickle (mkTree Pickler.int)

or it could be done using automatic resolution of type parameters:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
let tree<'T> =
    Pickler.fix(fun tree ->
        tree
        |> Pickler.list
        |> Pickler.pair Pickler.auto<'T>
        |> Pickler.option
        |> Pickler.wrap (function None -> Leaf | Some (t,c) -> Node(t,c))
                        (function Leaf -> None | Node (t,c) -> Some(t,c)))


Node([1],[Leaf ; Leaf]) |> Json.pickle tree

SerializationInfo Picklers

It is possible to define picklers that serialise objects using SerializationInfo. For example, consider the record:

1: 
type Name = { FirstName : string ; MiddleName : string option ; Surname : string }

We can define a SerializationInfo based pickler using the following combinator:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
let nameP =
    Pickler.fromSerializationInfo
                (fun si -> 
                    { FirstName = si.Get "First Name"
                      MiddleName = si.TryGet "Middle Name"
                      Surname = si.Get "Last Name" })
                (fun si p -> 
                    si.Add("First Name", p.FirstName)
                    si.Add("Last Name", p.Surname)
                    match p.MiddleName with Some mn -> si.Add("Middle Name", mn) | None -> ())

Experimental N-way Sum and Product Combinators

N-way sum and product combinators provide an alternative pretty syntax for defining picklers over arbitrary discriminated unions and records. Unfortunately at the moment the performance of resulting picklers is sub-optimal, this might improve in the future.

The types involved in the examples are not fit for human consumption, but thankfully F# infers them automatically. The implementation is total and purely functional, see this gist for some Coq code used to model these combinators.

Records / Product Types

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
type Person =
    {
        Address : string
        Age : int
        Name : string
    }

let makePerson name age address =
    {
        Address = address
        Age = age
        Name = name
    }

let personPickler =
    Pickler.product makePerson
    ^+ Pickler.field (fun p -> p.Name) Pickler.string
    ^+ Pickler.field (fun p -> p.Age) Pickler.int
    ^. Pickler.field (fun p -> p.Address) Pickler.string

Unions / Sum Types

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
type U =
| Case1
| Case2 of int
| Case3 of string * int

let uPickler =
    Pickler.sum (fun x k1 k2 k3 ->
        match x with
        | Case1 -> k1 ()
        | Case2 x -> k2 x
        | Case3 (x, y) -> k3 (x, y))
    ^+ Pickler.variant Case1
    ^+ Pickler.case Case2 Pickler.int
    ^. Pickler.case Case3 (Pickler.pair Pickler.string Pickler.int)

Generating custom picklers in type definitions

FsPickler can be instructed to use custom pickler definitions for given types using the following design pattern:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
[<CustomPickler>]
type CustomClass<'T, 'S> (x : 'T, y : 'S) =

    member __.X = x
    member __.Y = y

    static member CreatePickler (resolver : IPicklerResolver) =
        let xp = resolver.Resolve<'T> ()
        let yp = resolver.Resolve<'S> ()

        let writer (ws : WriteState) (c : CustomClass<'T,'S>) =
            xp.Write ws "X" c.X
            yp.Write ws "Y" c.Y

        let reader (rs : ReadState) =
            let x = xp.Read rs "X"
            let y = yp.Read rs "Y"
            new CustomClass<_,_>(x,y)

        Pickler.FromPrimitives(reader, writer)

This tells FsPickler to generate a pickler for the given type using that particular factory method. It should be noted that the Read/Write operations are not commutative, hence care should be taken so that ordering is matched. The IPicklerResolver argument provides a handle to the pickler generator and can be used recursively:

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
[<CustomPickler>]
type RecursiveClass(?nested : RecursiveClass) =

    member __.Value = nested

    static member CreatePickler (resolver : IPicklerResolver) =
        let self = resolver.Resolve<RecursiveClass> ()
        self
        |> Pickler.option 
        |> Pickler.wrap (fun x -> RecursiveClass(?nested = x)) (fun rc -> rc.Value)

// a pickler will be generated based on the above definition
let p = FsPickler.GeneratePickler<RecursiveClass> ()

RecursiveClass(RecursiveClass()) |> Json.pickle p |> Json.unpickle p

Runtime pickler registration

As of FsPickler 1.2.5 it is possible to register custom pickler definitions at runtime. Consider a type declaration that has not been made serializable:

1: 
2: 
3: 
[<AutoSerializable(false)>]
type NonSerializable(value : int) =
    member __.Value = value

It is now possible to declare and register a pickler factory at a separate location

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
let mkPickler (resolver : IPicklerResolver) =
    let intP = resolver.Resolve<int> ()

    let writer (w : WriteState) (ns : NonSerializable) =
        intP.Write w "value" ns.Value

    let reader (r : ReadState) =
        let v = intP.Read r "value" in new NonSerializable(v)

    Pickler.FromPrimitives(reader, writer) 

FsPickler.RegisterPicklerFactory mkPickler

When resolving a pickler of this type in the future, the user-supplied implementation will be used:

1: 
2: 
3: 
let pickler = FsPickler.GeneratePickler<NonSerializable> ()

pickler.PicklerInfo // PicklerInfo.UserDefined

Note that factory registrations need to be performed before FsPickler uses their types at all in the current AppDomain:

1: 
2: 
3: 
System.InvalidOperationException: A pickler for type 'FSI_0004+NonSerializable' has already been generated.
   at <StartupCode$FsPickler>.$FsPickler.RegisterPicklerFactory@54.Invoke(Unit unitVar0) in c:\Users\eirik\Development\nessos\FsPickler\src\FsPickler\FsPickler\FsPickler.fs:line 60
   at <StartupCode$FsPickler>.$PicklerCache.f@1-2(PicklerCache c, FSharpFunc`2 f, Unit unitVar0) in c:\Users\eirik\Development\nessos\FsPickler\src\FsPickler\PicklerGeneration\PicklerCache.fs:line 73

If all that needs to be done is declare to FsPickler the intention of treating a type as serializable, we can avoid the hassle of defining a full-blown custom pickler as follows:

1: 
FsPickler.DeclareSerializable<NonSerializable> ()

Additional tools

This section describes some of the additional tools offered by the library:

Object Cloning

FsPickler 1.2 adds support for fast cloning of serializable objects. This is done in a node-per-node basis, without the need for serialization formats and intermediate buffers.

1: 
let clonedValue = FsPickler.Clone [Choice1Of2 "foo" ; Choice2Of2 ['b';'a';'r']]

Structural Hashcodes

FsPickler offers experimental support for structural, non-cryptographic, hashcode generation:

1: 
2: 
3: 
4: 
5: 
6: 
7: 
8: 
let hash = FsPickler.ComputeHash [1 .. 100000]

//val it : HashResult =
//  {Algorithm = "MurMur3";
//   Length = 400008L;
//   Hash =
//    [|52uy; 70uy; 141uy; 214uy; 3uy; 231uy; 11uy; 100uy; 94uy; 250uy; 231uy;
//      97uy; 188uy; 215uy; 70uy; 0uy|];}

This will generate a 128-bit structural hashcode based on the MurMurHash algorithm. Implementation is memory efficient, since the hashing algorithm is integrated with the underlying stream implementation. It is possible for users to define their own hashing algorithms by inheriting the special HashStream class.

Hashing functionality offered by FsPickler is an ideal replacement to .GetHashCode() for large objects or complex object graphs, but it is not recommended for small values or primitives.

If a hashcode is not required, the size of an object alone can be computed as follows:

1: 
2: 
3: 
FsPickler.ComputeSize [1 .. 1000000]

//val it : int64 = 4000008L

Typed Serialization

It is possible to create typed picklings of objects:

1: 
let typedPickle = jsonSerializer.PickleTyped [1 .. 1000]

this will produce a serialization annotated with the type of the original object. They can then be easily deserialized like so:

1: 
let value = jsonSerializer.UnPickleTyped typedPickle

Object Sifting

FsPickler 1.2 comes with a 'sifting' functionality which allows serialization/cloning while omitting specified instances from an object graph. For example, consider the object graph

1: 
2: 
3: 
let small = [|1..10|]
let large = [|1..100000000|]
let graph = Some [small; large; small; large]

The size of the object becomes evident when running

1: 
2: 
3: 
FsPickler.ComputeSize graph

//val it : int64 = 400000203L

Supposing we knew that the size of the graph was being bloated by large arrays, we can use FsPickler to optimize serialization by sifting away occurences from the object graph.

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
let sifter : obj -> bool = function :? (int []) as ts -> ts.Length > 100 | _ -> false
let siftedGraph, siftedValues = FsPickler.Sift(graph, sifter)

//val siftedValues : (int64 * obj) [] =
//  [|(4L,
//     [|1; 2; 3; 4; 5; 6; 7; 8; 9; 10; 11; 12; 13; 14; 15; 16; 17; 18; 19; 20;
//       21; 22; 23; 24; 25; 26; 27; 28; 29; 30; 31; 32; 33; 34; 35; 36; 37; 38;
//       39; 40; 41; 42; 43; 44; 45; 46; 47; 48; 49; 50; 51; 52; 53; 54; 55; 56;
//       57; 58; 59; 60; 61; 62; 63; 64; 65; 66; 67; 68; 69; 70; 71; 72; 73; 74;
//       75; 76; 77; 78; 79; 80; 81; 82; 83; 84; 85; 86; 87; 88; 89; 90; 91; 92;
//       93; 94; 95; 96; 97; 98; 99; 100; ...|])|]
//
//val siftedGraph : Sifted<int [] list option> =
//  Sift: Some
//  [[|1; 2; 3; 4; 5; 6; 7; 8; 9; 10|]; null; [|1; 2; 3; 4; 5; 6; 7; 8; 9; 10|];
//   null]

This will return a sifted clone of the original object as well as a collection of all objects that were sifted from the original input. The sifted copy encapsulated in a wrapper type so that it cannot be consumed while in its partial state. The original input graph will not be mutated in any way. We can verify that the size of the sifted object has been reduced:

1: 
2: 
3: 
FsPickler.ComputeSize siftedGraph

//val it : int64 = 270L

Sifted objects can be put back together by calling

1: 
let reconstructed = FsPickler.UnSift(siftedGraph, siftedValues)

Object Graph Visitors

FsPickler is capable of efficiently traversing arbitrary object graphs (as long as they are serializable) by exploiting its pickler infrastructure. This can be done by calling the method:

1: 
FsPickler.VisitObject

which takes as input a serializable object graph and a so-called object visitor:

1: 
2: 
3: 
4: 
type IObjectVisitor =
  interface
    abstract member Visit : Pickler<'T> * 'T -> bool
  end

A few applications of this are provided by the core library:

1: 
2: 
3: 
4: 
5: 
6: 
let types = FsPickler.GatherTypesInObjectGraph [box 42 ; box (Some (42, "42"))]

//val types : Type [] =
//  [|Microsoft.FSharp.Collections.FSharpList`1[System.Object]; System.Int32;
//    Microsoft.FSharp.Core.FSharpOption`1[System.Tuple`2[System.Int32,System.String]];
//    System.Tuple`2[System.Int32,System.String]; System.String|]

Disabling Subtype Resolution

For security reasons, it might often be desirable to disable subtype resolution when serializing classes:

1: 
serializer.DisableSubtypeResolution <- true

This essentially disables the serialization of any object whose declaring type is specified on the serialization itself. Attempting to serialize or deserialize any such object will result in an exception.

Note that enabling this option prevents serialization of the following types:

  • System.Object or any abstract class (excluding F# DUs).
  • Any delegate instance or F# function.
  • Any ISerializable class.

As a further precaution, it is also possible to disable implicit assembly loading when deserializing objects:

1: 
serializer.DisableAssemblyLoading <- true

Defining Custom Pickle Formats

It is possible to create user-defined pickle formats for FsPickler. One simply needs to implement the interface

1: 
2: 
3: 
4: 
5: 
6: 
7: 
type IPickleFormatProvider =
  interface
    abstract member Name : string
    abstract DefaultEncoding : Encoding
    abstract member CreateReader : Stream * Encoding * leaveOpen:bool -> IPickleFormatReader
    abstract member CreateWriter : Stream * Encoding * leaveOpen:bool -> IPickleFormatWriter
  end

which can then be bolted on a class that inherits either of the FsPicklerSerializer or FsPicklerTextSerializer.

val stream : System.IO.Stream

Full name: Tutorial.stream
module Unchecked

from Microsoft.FSharp.Core.Operators
val defaultof<'T> : 'T

Full name: Microsoft.FSharp.Core.Operators.Unchecked.defaultof
namespace System
namespace System.IO
type Stream =
  inherit MarshalByRefObject
  member BeginRead : buffer:byte[] * offset:int * count:int * callback:AsyncCallback * state:obj -> IAsyncResult
  member BeginWrite : buffer:byte[] * offset:int * count:int * callback:AsyncCallback * state:obj -> IAsyncResult
  member CanRead : bool
  member CanSeek : bool
  member CanTimeout : bool
  member CanWrite : bool
  member Close : unit -> unit
  member CopyTo : destination:Stream -> unit + 1 overload
  member Dispose : unit -> unit
  member EndRead : asyncResult:IAsyncResult -> int
  ...

Full name: System.IO.Stream
val serializer : MBrace.FsPickler.FsPicklerSerializer

Full name: Tutorial.serializer
namespace MBrace
namespace MBrace.FsPickler
Multiple items
type FsPicklerSerializer =
  new : formatProvider:IPickleFormatProvider * ?typeConverter:ITypeNameConverter -> FsPicklerSerializer
  member ComputeHash : value:'T * ?hashFactory:IHashStreamFactory -> HashResult
  member ComputeSize : value:'T * ?pickler:Pickler<'T> -> int64
  member CreateObjectSizeCounter : ?encoding:Encoding * ?resetInterval:int64 -> ObjectSizeCounter
  member Deserialize : stream:Stream * ?pickler:Pickler<'T> * ?streamingContext:StreamingContext * ?encoding:Encoding * ?leaveOpen:bool -> 'T
  member DeserializeSequence : stream:Stream * ?pickler:Pickler<'T> * ?streamingContext:StreamingContext * ?encoding:Encoding * ?leaveOpen:bool -> seq<'T>
  member DeserializeSequenceUntyped : stream:Stream * pickler:Pickler * ?streamingContext:StreamingContext * ?encoding:Encoding * ?leaveOpen:bool -> IEnumerable
  member DeserializeSifted : stream:Stream * sifted:(int64 * obj) [] * ?pickler:Pickler<'T> * ?streamingContext:StreamingContext * ?encoding:Encoding * ?leaveOpen:bool -> 'T
  member DeserializeUntyped : stream:Stream * pickler:Pickler * ?streamingContext:StreamingContext * ?encoding:Encoding * ?leaveOpen:bool -> obj
  member Pickle : value:'T * ?pickler:Pickler<'T> * ?streamingContext:StreamingContext * ?encoding:Encoding -> byte []
  ...

Full name: MBrace.FsPickler.FsPicklerSerializer

--------------------
new : formatProvider:MBrace.FsPickler.IPickleFormatProvider * ?typeConverter:MBrace.FsPickler.ITypeNameConverter -> MBrace.FsPickler.FsPicklerSerializer
val textWriter : System.IO.TextWriter

Full name: Tutorial.textWriter
type TextWriter =
  inherit MarshalByRefObject
  member Close : unit -> unit
  member Dispose : unit -> unit
  member Encoding : Encoding
  member Flush : unit -> unit
  member FormatProvider : IFormatProvider
  member NewLine : string with get, set
  member Write : value:char -> unit + 16 overloads
  member WriteLine : unit -> unit + 17 overloads
  static val Null : TextWriter
  static member Synchronized : writer:TextWriter -> TextWriter

Full name: System.IO.TextWriter
val textReader : System.IO.TextReader

Full name: Tutorial.textReader
type TextReader =
  inherit MarshalByRefObject
  member Close : unit -> unit
  member Dispose : unit -> unit
  member Peek : unit -> int
  member Read : unit -> int + 1 overload
  member ReadBlock : buffer:char[] * index:int * count:int -> int
  member ReadLine : unit -> string
  member ReadToEnd : unit -> string
  static val Null : TextReader
  static member Synchronized : reader:TextReader -> TextReader

Full name: System.IO.TextReader
val binarySerializer : BinarySerializer

Full name: Tutorial.binarySerializer
type FsPickler =
  private new : unit -> FsPickler
  static member Clone : value:'T * ?pickler:Pickler<'T> * ?streamingContext:StreamingContext -> 'T
  static member ComputeHash : value:'T * ?hashFactory:IHashStreamFactory -> HashResult
  static member ComputeSize : value:'T * ?pickler:Pickler<'T> -> int64
  static member CreateBinarySerializer : ?forceLittleEndian:bool * ?typeConverter:ITypeNameConverter -> BinarySerializer
  static member CreateObjectSizeCounter : ?encoding:Encoding * ?resetInterval:int64 -> ObjectSizeCounter
  static member CreateXmlSerializer : ?typeConverter:ITypeNameConverter * ?indent:bool -> XmlSerializer
  static member DeclareSerializable : unit -> unit
  static member DeclareSerializable : predicate:(Type -> bool) -> unit
  static member DeclareSerializable : t:Type -> unit
  ...

Full name: MBrace.FsPickler.FsPickler
static member FsPickler.CreateBinarySerializer : ?forceLittleEndian:bool * ?typeConverter:ITypeNameConverter -> BinarySerializer
val xmlSerializer : XmlSerializer

Full name: Tutorial.xmlSerializer
static member FsPickler.CreateXmlSerializer : ?typeConverter:ITypeNameConverter * ?indent:bool -> XmlSerializer
namespace MBrace.FsPickler.Json
val jsonSerializer : JsonSerializer

Full name: Tutorial.jsonSerializer
type FsPickler =
  static member CreateBsonSerializer : ?typeConverter:ITypeNameConverter -> BsonSerializer
  static member CreateJsonSerializer : ?indent:bool * ?omitHeader:bool * ?typeConverter:ITypeNameConverter -> JsonSerializer

Full name: MBrace.FsPickler.Json.FsPickler
static member FsPickler.CreateJsonSerializer : ?indent:bool * ?omitHeader:bool * ?typeConverter:ITypeNameConverter -> JsonSerializer
val bsonSerializer : BsonSerializer

Full name: Tutorial.bsonSerializer
static member FsPickler.CreateBsonSerializer : ?typeConverter:ITypeNameConverter -> BsonSerializer
member FsPicklerTextSerializer.Serialize : writer:System.IO.TextWriter * value:'T * ?pickler:Pickler<'T> * ?streamingContext:System.Runtime.Serialization.StreamingContext * ?leaveOpen:bool -> unit
member FsPicklerSerializer.Serialize : stream:System.IO.Stream * value:'T * ?pickler:Pickler<'T> * ?streamingContext:System.Runtime.Serialization.StreamingContext * ?encoding:System.Text.Encoding * ?leaveOpen:bool -> unit
member FsPicklerTextSerializer.Deserialize : reader:System.IO.TextReader * ?pickler:Pickler<'T> * ?streamingContext:System.Runtime.Serialization.StreamingContext * ?leaveOpen:bool -> 'T
member FsPicklerSerializer.Deserialize : stream:System.IO.Stream * ?pickler:Pickler<'T> * ?streamingContext:System.Runtime.Serialization.StreamingContext * ?encoding:System.Text.Encoding * ?leaveOpen:bool -> 'T
Multiple items
val float : value:'T -> float (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.float

--------------------
type float = System.Double

Full name: Microsoft.FSharp.Core.float

--------------------
type float<'Measure> = float

Full name: Microsoft.FSharp.Core.float<_>
type 'T list = List<'T>

Full name: Microsoft.FSharp.Collections.list<_>
val pickle : byte []

Full name: Tutorial.pickle
member FsPicklerSerializer.Pickle : value:'T * ?pickler:Pickler<'T> * ?streamingContext:System.Runtime.Serialization.StreamingContext * ?encoding:System.Text.Encoding -> byte []
member FsPicklerSerializer.UnPickle : data:byte [] * ?pickler:Pickler<'T> * ?streamingContext:System.Runtime.Serialization.StreamingContext * ?encoding:System.Text.Encoding -> 'T
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr =
  override Equals : obj:obj -> bool
  member GetFreeVars : unit -> seq<Var>
  member Substitute : substitution:(Var -> Expr option) -> Expr
  member ToString : full:bool -> string
  member CustomAttributes : Expr list
  member Type : Type
  static member AddressOf : target:Expr -> Expr
  static member AddressSet : target:Expr * value:Expr -> Expr
  static member Application : functionExpr:Expr * argument:Expr -> Expr
  static member Applications : functionExpr:Expr * arguments:Expr list list -> Expr
  ...

Full name: Microsoft.FSharp.Quotations.Expr

--------------------
type Expr<'T> =
  inherit Expr
  member Raw : Expr

Full name: Microsoft.FSharp.Quotations.Expr<_>
Multiple items
val int : value:'T -> int (requires member op_Explicit)

Full name: Microsoft.FSharp.Core.Operators.int

--------------------
type int = int32

Full name: Microsoft.FSharp.Core.int

--------------------
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>
union case Option.Some: Value: 'T -> Option<'T>
union case Option.None: Option<'T>
type 'T option = Option<'T>

Full name: Microsoft.FSharp.Core.option<_>
val text : string

Full name: Tutorial.text
member FsPicklerTextSerializer.PickleToString : value:'T * ?pickler:Pickler<'T> * ?streamingContext:System.Runtime.Serialization.StreamingContext -> string
val x : int
member FsPicklerTextSerializer.UnPickleOfString : pickle:string * ?pickler:Pickler<'T> * ?streamingContext:System.Runtime.Serialization.StreamingContext -> 'T
Multiple items
val seq : seq<string>

Full name: Tutorial.seq

--------------------
type seq<'T> = System.Collections.Generic.IEnumerable<'T>

Full name: Microsoft.FSharp.Collections.seq<_>
module Seq

from Microsoft.FSharp.Collections
val initInfinite : initializer:(int -> 'T) -> seq<'T>

Full name: Microsoft.FSharp.Collections.Seq.initInfinite
Multiple items
val string : value:'T -> string

Full name: Microsoft.FSharp.Core.Operators.string

--------------------
type string = System.String

Full name: Microsoft.FSharp.Core.string
val take : count:int -> source:seq<'T> -> seq<'T>

Full name: Microsoft.FSharp.Collections.Seq.take
val length : int

Full name: Tutorial.length
member FsPicklerSerializer.SerializeSequence : stream:System.IO.Stream * sequence:seq<'T> * ?pickler:Pickler<'T> * ?streamingContext:System.Runtime.Serialization.StreamingContext * ?encoding:System.Text.Encoding * ?leaveOpen:bool -> int
val seq' : seq<int>

Full name: Tutorial.seq'
member FsPicklerSerializer.DeserializeSequence : stream:System.IO.Stream * ?pickler:Pickler<'T> * ?streamingContext:System.Runtime.Serialization.StreamingContext * ?encoding:System.Text.Encoding * ?leaveOpen:bool -> seq<'T>
val toArray : source:seq<'T> -> 'T []

Full name: Microsoft.FSharp.Collections.Seq.toArray
Multiple items
type Pickler =
  private new : Type -> Pickler
  abstract member private Cast : unit -> Pickler<'S>
  abstract member private Unpack : IPicklerUnpacker<'U> -> 'U
  abstract member private UntypedAccept : state:VisitState -> value:obj -> unit
  abstract member private UntypedClone : state:CloneState -> value:obj -> obj
  abstract member private UntypedRead : state:ReadState -> tag:string -> obj
  abstract member private UntypedWrite : state:WriteState -> tag:string -> value:obj -> unit
  abstract member ImplementationType : Type
  abstract member IsCacheByRef : bool
  abstract member IsCloneableOnly : bool
  ...

Full name: MBrace.FsPickler.Pickler

--------------------
type Pickler<'T> =
  {Write: WriteState -> 'T -> unit;
   Read: ReadState -> 'T;}

Full name: Tutorial.Pickler<_>
Pickler.Write: WriteState -> 'T -> unit
type WriteState =
  private new : formatter:IPickleFormatWriter * resolver:IPicklerResolver * reflectionCache:ReflectionCache * isHashComputation:bool * disableSubtypeResolution:bool * ?streamingContext:StreamingContext * ?sifter:IObjectSifter -> WriteState
  member private GetObjectId : obj:obj * firstTime:byref<bool> -> int64
  member private Reset : unit -> unit
  member private CyclicObjectSet : HashSet<int64>
  member DisableSubtypeResolution : bool
  member private Formatter : IPickleFormatWriter
  member IsHashComputation : bool
  member private ObjectCount : int64
  member private ObjectStack : Stack<int64>
  member private PicklerResolver : IPicklerResolver
  ...

Full name: MBrace.FsPickler.WriteState
type unit = Unit

Full name: Microsoft.FSharp.Core.unit
Pickler.Read: ReadState -> 'T
type ReadState =
  private new : formatter:IPickleFormatReader * resolver:IPicklerResolver * reflectionCache:ReflectionCache * disableSubtypeResolution:bool * disableAssemblyLoading:bool * ?streamingContext:StreamingContext * ?sifted:(int64 * obj) [] -> ReadState
  member private EarlyRegisterArray : array:Array -> unit
  member private NextObjectId : unit -> int64
  member private Reset : unit -> unit
  member DisableAssemblyLoading : bool
  member DisableSubtypeResolution : bool
  member private Formatter : IPickleFormatReader
  member private IsUnSifting : bool
  member private ObjectCache : Dictionary<int64,obj>
  member private ObjectCount : int64
  ...

Full name: MBrace.FsPickler.ReadState
namespace MBrace.FsPickler.Combinators
Multiple items
val int : Pickler<int>

Full name: Tutorial.int

--------------------
type int = int32

Full name: Microsoft.FSharp.Core.int

--------------------
type int<'Measure> = int

Full name: Microsoft.FSharp.Core.int<_>
Multiple items
module Pickler

from MBrace.FsPickler.Combinators

--------------------
type Pickler =
  private new : Type -> Pickler
  abstract member private Cast : unit -> Pickler<'S>
  abstract member private Unpack : IPicklerUnpacker<'U> -> 'U
  abstract member private UntypedAccept : state:VisitState -> value:obj -> unit
  abstract member private UntypedClone : state:CloneState -> value:obj -> obj
  abstract member private UntypedRead : state:ReadState -> tag:string -> obj
  abstract member private UntypedWrite : state:WriteState -> tag:string -> value:obj -> unit
  abstract member ImplementationType : Type
  abstract member IsCacheByRef : bool
  abstract member IsCloneableOnly : bool
  ...

Full name: MBrace.FsPickler.Pickler

--------------------
type Pickler<'T> =
  inherit Pickler
  private new : unit -> Pickler<'T>
  abstract member Accept : state:VisitState -> value:'T -> unit
  abstract member Clone : state:CloneState -> value:'T -> 'T
  abstract member Read : state:ReadState -> tag:string -> 'T
  abstract member Write : state:WriteState -> tag:string -> value:'T -> unit
  override private Unpack : IPicklerUnpacker<'R> -> 'R
  override private UntypedAccept : state:VisitState -> value:obj -> unit
  override private UntypedClone : state:CloneState -> obj -> obj
  override private UntypedRead : state:ReadState -> tag:string -> obj
  ...

Full name: MBrace.FsPickler.Pickler<_>
val int : Pickler<int>

Full name: MBrace.FsPickler.Combinators.Pickler.int
Multiple items
val string : Pickler<string>

Full name: Tutorial.string

--------------------
type string = System.String

Full name: Microsoft.FSharp.Core.string
val string : Pickler<string>

Full name: MBrace.FsPickler.Combinators.Pickler.string
val dateTime : Pickler<System.DateTime>

Full name: Tutorial.dateTime
val dateTime : Pickler<System.DateTime>

Full name: MBrace.FsPickler.Combinators.Pickler.dateTime
val p1 : Pickler<int * System.DateTime>

Full name: Tutorial.p1
val pair : f:Pickler<'a> -> g:Pickler<'b> -> Pickler<'a * 'b>

Full name: MBrace.FsPickler.Combinators.Pickler.pair
val p2 : Pickler<string option>

Full name: Tutorial.p2
val option : f:Pickler<'T> -> Pickler<'T option>

Full name: MBrace.FsPickler.Combinators.Pickler.option
val p3 : Pickler<string option list>

Full name: Tutorial.p3
val list : f:Pickler<'T> -> Pickler<'T list>

Full name: MBrace.FsPickler.Combinators.Pickler.list
val p4 : Pickler<(int * System.DateTime) [,]>

Full name: Tutorial.p4
val array2D : f:Pickler<'T> -> Pickler<'T [,]>

Full name: MBrace.FsPickler.Combinators.Pickler.array2D
val p5 : Pickler<int * string option list>

Full name: Tutorial.p5
val auto<'T> : Pickler<'T>

Full name: MBrace.FsPickler.Combinators.Pickler.auto
val t1 : byte []

Full name: Tutorial.t1
module Binary

from MBrace.FsPickler.Combinators
val pickle : pickler:Pickler<'T> -> value:'T -> byte []

Full name: MBrace.FsPickler.Combinators.Binary.pickle
val t2 : string

Full name: Tutorial.t2
Multiple items
module Json

from MBrace.FsPickler.Combinators

--------------------
namespace MBrace.FsPickler.Json
val pickle : pickler:Pickler<'T> -> value:'T -> string

Full name: MBrace.FsPickler.Combinators.Json.pickle
val unpickle : pickler:Pickler<'T> -> pickle:string -> 'T

Full name: MBrace.FsPickler.Combinators.Json.unpickle
type Peano =
  | Zero
  | Succ of Peano

Full name: Tutorial.Peano
union case Peano.Zero: Peano
union case Peano.Succ: Peano -> Peano
val pp : Pickler<Peano>

Full name: Tutorial.pp
val fix : F:(Pickler<'T> -> Pickler<'T>) -> Pickler<'T>

Full name: MBrace.FsPickler.Combinators.Pickler.fix
val peano : Pickler<Peano>
val wrap : recover:('a -> 'b) -> convert:('b -> 'a) -> p:Pickler<'a> -> Pickler<'b>

Full name: MBrace.FsPickler.Combinators.Pickler.wrap
val p : Peano
val unpickle : pickler:Pickler<'T> -> pickle:byte [] -> 'T

Full name: MBrace.FsPickler.Combinators.Binary.unpickle
type Tree<'T> =
  | Leaf
  | Node of 'T * Tree<'T> list

Full name: Tutorial.Tree<_>
union case Tree.Leaf: Tree<'T>
union case Tree.Node: 'T * Tree<'T> list -> Tree<'T>
val mkTree : ep:Pickler<'T> -> Pickler<Tree<'T>>

Full name: Tutorial.mkTree
val ep : Pickler<'T>
val tree : Pickler<Tree<'T>>
val t : 'T
val c : Tree<'T> list
module Xml

from MBrace.FsPickler.Combinators
val pickle : pickler:Pickler<'T> -> value:'T -> string

Full name: MBrace.FsPickler.Combinators.Xml.pickle
val tree<'T> : Pickler<Tree<'T>>

Full name: Tutorial.tree
type Name =
  {FirstName: string;
   MiddleName: string option;
   Surname: string;}

Full name: Tutorial.Name
Name.FirstName: string
Name.MiddleName: string option
Name.Surname: string
val nameP : Pickler<Name>

Full name: Tutorial.nameP
val fromSerializationInfo : ctor:(System.Runtime.Serialization.SerializationInfo -> 'T) -> proj:(System.Runtime.Serialization.SerializationInfo -> 'T -> unit) -> Pickler<'T>

Full name: MBrace.FsPickler.Combinators.Pickler.fromSerializationInfo
val si : System.Runtime.Serialization.SerializationInfo
member System.Runtime.Serialization.SerializationInfo.Get : name:string -> 'T
member System.Runtime.Serialization.SerializationInfo.TryGet : name:string -> 'T option
val p : Name
member System.Runtime.Serialization.SerializationInfo.Add : name:string * value:'T -> unit
val mn : string
type Person =
  {Address: string;
   Age: int;
   Name: string;}

Full name: Tutorial.Person
Person.Address: string
Person.Age: int
Multiple items
Person.Name: string

--------------------
type Name =
  {FirstName: string;
   MiddleName: string option;
   Surname: string;}

Full name: Tutorial.Name
val makePerson : name:string -> age:int -> address:string -> Person

Full name: Tutorial.makePerson
val name : string
val age : int
val address : string
val personPickler : Pickler<Person>

Full name: Tutorial.personPickler
val product : f:'a -> Pickler.ProductInternals.Wrap<(Pickler.ProductInternals.Part<'b,'a,'c> -> Pickler<'b>)>

Full name: MBrace.FsPickler.Combinators.Pickler.product
val field : f:('a -> 'b) -> p:Pickler<'b> -> Pickler.ProductInternals.Wrap<(Pickler.ProductInternals.Part<'a,'c,'d> -> Pickler.ProductInternals.Part<'a,('b -> 'c),('b * 'd)>)>

Full name: MBrace.FsPickler.Combinators.Pickler.field
val p : Person
Person.Name: string
type U =
  | Case1
  | Case2 of int
  | Case3 of string * int

Full name: Tutorial.U
union case U.Case1: U
union case U.Case2: int -> U
union case U.Case3: string * int -> U
val uPickler : Pickler<U>

Full name: Tutorial.uPickler
val sum : f:('a -> 'b) -> Pickler.SumInternals.Wrap<(Pickler.SumInternals.Part<'a,'b,'c,'c> -> Pickler<'a>)>

Full name: MBrace.FsPickler.Combinators.Pickler.sum
val x : U
val k1 : (unit -> Choice<unit,Choice<int,(string * int)>>)
val k2 : (int -> Choice<unit,Choice<int,(string * int)>>)
val k3 : (string * int -> Choice<unit,Choice<int,(string * int)>>)
val x : string
val y : int
val variant : v:'a -> Pickler.SumInternals.Case<(unit -> 'a),Pickler<unit>>

Full name: MBrace.FsPickler.Combinators.Pickler.variant
val case : inj:'a -> p:'b -> Pickler.SumInternals.Case<'a,'b>

Full name: MBrace.FsPickler.Combinators.Pickler.case
Multiple items
type CustomPicklerAttribute =
  inherit Attribute
  new : unit -> CustomPicklerAttribute

Full name: MBrace.FsPickler.CustomPicklerAttribute

--------------------
new : unit -> CustomPicklerAttribute
Multiple items
type CustomClass<'T,'S> =
  new : x:'T * y:'S -> CustomClass<'T,'S>
  member X : 'T
  member Y : 'S
  static member CreatePickler : resolver:IPicklerResolver -> Pickler<CustomClass<'T,'S>>

Full name: Tutorial.CustomClass<_,_>

--------------------
new : x:'T * y:'S -> CustomClass<'T,'S>
val x : 'T
val y : 'S
member CustomClass.X : 'T

Full name: Tutorial.CustomClass`2.X
val __ : CustomClass<'T,'S>
member CustomClass.Y : 'S

Full name: Tutorial.CustomClass`2.Y
static member CustomClass.CreatePickler : resolver:IPicklerResolver -> Pickler<CustomClass<'T,'S>>

Full name: Tutorial.CustomClass`2.CreatePickler
val resolver : IPicklerResolver
type IPicklerResolver =
  interface
    abstract member IsSerializable : unit -> bool
    abstract member IsSerializable : Type -> bool
    abstract member Resolve : unit -> Pickler<'T>
    abstract member Resolve : Type -> Pickler
  end

Full name: MBrace.FsPickler.IPicklerResolver
val xp : Pickler<'T>
abstract member IPicklerResolver.Resolve : unit -> Pickler<'T>
abstract member IPicklerResolver.Resolve : System.Type -> Pickler
val yp : Pickler<'S>
val writer : (WriteState -> CustomClass<'T,'S> -> unit)
val ws : WriteState
val c : CustomClass<'T,'S>
abstract member Pickler.Write : state:WriteState -> tag:string -> value:'T -> unit
property CustomClass.X: 'T
property CustomClass.Y: 'S
val reader : (ReadState -> CustomClass<'T,'S>)
val rs : ReadState
abstract member Pickler.Read : state:ReadState -> tag:string -> 'T
static member Pickler.FromPrimitives : reader:(ReadState -> 'T) * writer:(WriteState -> 'T -> unit) * ?cloner:(CloneState -> 'T -> 'T) * ?accepter:(VisitState -> 'T -> unit) * ?cacheByRef:bool * ?useWithSubtypes:bool -> Pickler<'T>
Multiple items
type RecursiveClass =
  new : ?nested:RecursiveClass -> RecursiveClass
  member Value : RecursiveClass option
  static member CreatePickler : resolver:IPicklerResolver -> Pickler<RecursiveClass>

Full name: Tutorial.RecursiveClass

--------------------
new : ?nested:RecursiveClass -> RecursiveClass
val nested : RecursiveClass option
member RecursiveClass.Value : RecursiveClass option

Full name: Tutorial.RecursiveClass.Value
static member RecursiveClass.CreatePickler : resolver:IPicklerResolver -> Pickler<RecursiveClass>

Full name: Tutorial.RecursiveClass.CreatePickler
val self : Pickler<RecursiveClass>
val x : RecursiveClass option
val rc : RecursiveClass
property RecursiveClass.Value: RecursiveClass option
val p : Pickler<RecursiveClass>

Full name: Tutorial.p
static member FsPickler.GeneratePickler : unit -> Pickler<'T>
static member FsPickler.GeneratePickler : t:System.Type -> Pickler
Multiple items
type AutoSerializableAttribute =
  inherit Attribute
  new : value:bool -> AutoSerializableAttribute
  member Value : bool

Full name: Microsoft.FSharp.Core.AutoSerializableAttribute

--------------------
new : value:bool -> AutoSerializableAttribute
Multiple items
type NonSerializable =
  new : value:int -> NonSerializable
  member Value : int

Full name: Tutorial.NonSerializable

--------------------
new : value:int -> NonSerializable
val value : int
member NonSerializable.Value : int

Full name: Tutorial.NonSerializable.Value
val mkPickler : resolver:IPicklerResolver -> Pickler<NonSerializable>

Full name: Tutorial.mkPickler
val intP : Pickler<int>
val writer : (WriteState -> NonSerializable -> unit)
val w : WriteState
val ns : NonSerializable
property NonSerializable.Value: int
val reader : (ReadState -> NonSerializable)
val r : ReadState
val v : int
static member FsPickler.RegisterPicklerFactory : factory:(IPicklerResolver -> Pickler<'T>) -> unit
val pickler : Pickler<NonSerializable>

Full name: Tutorial.pickler
property Pickler.PicklerInfo: PicklerInfo
static member FsPickler.DeclareSerializable : unit -> unit
static member FsPickler.DeclareSerializable : predicate:(System.Type -> bool) -> unit
static member FsPickler.DeclareSerializable : t:System.Type -> unit
val clonedValue : Choice<string,char list> list

Full name: Tutorial.clonedValue
static member FsPickler.Clone : value:'T * ?pickler:Pickler<'T> * ?streamingContext:System.Runtime.Serialization.StreamingContext -> 'T
union case Choice.Choice1Of2: 'T1 -> Choice<'T1,'T2>
union case Choice.Choice2Of2: 'T2 -> Choice<'T1,'T2>
val hash : Hashing.HashResult

Full name: Tutorial.hash
static member FsPickler.ComputeHash : value:'T * ?hashFactory:Hashing.IHashStreamFactory -> Hashing.HashResult
static member FsPickler.ComputeSize : value:'T * ?pickler:Pickler<'T> -> int64
val typedPickle : Pickle<int list>

Full name: Tutorial.typedPickle
member FsPicklerSerializer.PickleTyped : value:'T * ?streamingContext:System.Runtime.Serialization.StreamingContext * ?encoding:System.Text.Encoding -> Pickle<'T>
val value : int list

Full name: Tutorial.value
member FsPicklerSerializer.UnPickleTyped : pickle:Pickle<'T> * ?streamingContext:System.Runtime.Serialization.StreamingContext * ?encoding:System.Text.Encoding -> 'T
val small : int []

Full name: Tutorial.small
val large : int []

Full name: Tutorial.large
val graph : int [] list option

Full name: Tutorial.graph
val sifter : _arg1:obj -> bool

Full name: Tutorial.sifter
type obj = System.Object

Full name: Microsoft.FSharp.Core.obj
type bool = System.Boolean

Full name: Microsoft.FSharp.Core.bool
val ts : int []
property System.Array.Length: int
val siftedGraph : Sifted<int [] list option>

Full name: Tutorial.siftedGraph
val siftedValues : (int64 * obj) []

Full name: Tutorial.siftedValues
static member FsPickler.Sift : value:'T * sifter:(obj -> bool) * ?pickler:Pickler<'T> * ?streamingContext:System.Runtime.Serialization.StreamingContext -> Sifted<'T> * (int64 * obj) []
static member FsPickler.Sift : value:'T * sifter:IObjectSifter * ?pickler:Pickler<'T> * ?streamingContext:System.Runtime.Serialization.StreamingContext -> Sifted<'T> * (int64 * obj) []
val reconstructed : int [] list option

Full name: Tutorial.reconstructed
static member FsPickler.UnSift : sifted:Sifted<'T> * values:(int64 * obj) [] * ?pickler:Pickler<'T> * ?streamingContext:System.Runtime.Serialization.StreamingContext -> 'T
static member FsPickler.VisitObject : visitor:IObjectVisitor * graph:'T * ?pickler:Pickler<'T> * ?streamingContext:System.Runtime.Serialization.StreamingContext * ?visitOrder:VisitOrder -> unit
type IObjectVisitor =
  interface
    abstract member Visit : Pickler<'T> * 'T -> bool
  end

Full name: Tutorial.IObjectVisitor
abstract member IObjectVisitor.Visit : Pickler<'T> * 'T -> bool

Full name: Tutorial.IObjectVisitor.Visit
namespace System.Text
val types : System.Type []

Full name: Tutorial.types
static member FsPickler.GatherTypesInObjectGraph : graph:obj -> System.Type []
val box : value:'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box
val serializer : FsPicklerSerializer

Full name: Tutorial.serializer
property FsPicklerSerializer.DisableSubtypeResolution: bool
property FsPicklerSerializer.DisableAssemblyLoading: bool
type IPickleFormatProvider =
  interface
    abstract member CreateReader : Stream * Encoding * leaveOpen:bool -> IPickleFormatReader
    abstract member CreateWriter : Stream * Encoding * leaveOpen:bool -> IPickleFormatWriter
    abstract member DefaultEncoding : Encoding
    abstract member Name : string
  end

Full name: Tutorial.IPickleFormatProvider
Multiple items
abstract member IPickleFormatProvider.Name : string

Full name: Tutorial.IPickleFormatProvider.Name

--------------------
type Name =
  {FirstName: string;
   MiddleName: string option;
   Surname: string;}

Full name: Tutorial.Name
abstract member IPickleFormatProvider.DefaultEncoding : Encoding

Full name: Tutorial.IPickleFormatProvider.DefaultEncoding
type Encoding =
  member BodyName : string
  member Clone : unit -> obj
  member CodePage : int
  member DecoderFallback : DecoderFallback with get, set
  member EncoderFallback : EncoderFallback with get, set
  member EncodingName : string
  member Equals : value:obj -> bool
  member GetByteCount : chars:char[] -> int + 3 overloads
  member GetBytes : chars:char[] -> byte[] + 5 overloads
  member GetCharCount : bytes:byte[] -> int + 2 overloads
  ...

Full name: System.Text.Encoding
abstract member IPickleFormatProvider.CreateReader : Stream * Encoding * leaveOpen:bool -> IPickleFormatReader

Full name: Tutorial.IPickleFormatProvider.CreateReader
type IPickleFormatReader =
  interface
    inherit IDisposable
    abstract member BeginReadObject : tag:string -> ObjectFlags
    abstract member BeginReadRoot : tag:string -> unit
    abstract member EndReadObject : unit -> unit
    abstract member EndReadRoot : unit -> unit
    abstract member ReadBigInteger : tag:string -> bigint
    abstract member ReadBoolean : tag:string -> bool
    abstract member ReadByte : tag:string -> byte
    abstract member ReadBytes : tag:string -> byte []
    abstract member ReadCachedObjectId : unit -> int64
    ...
  end

Full name: MBrace.FsPickler.IPickleFormatReader
abstract member IPickleFormatProvider.CreateWriter : Stream * Encoding * leaveOpen:bool -> IPickleFormatWriter

Full name: Tutorial.IPickleFormatProvider.CreateWriter
type IPickleFormatWriter =
  interface
    inherit IDisposable
    abstract member BeginWriteObject : tag:string -> objectFlags:ObjectFlags -> unit
    abstract member BeginWriteRoot : tag:string -> unit
    abstract member EndWriteObject : unit -> unit
    abstract member EndWriteRoot : unit -> unit
    abstract member Flush : unit -> unit
    abstract member WriteBigInteger : tag:string -> value:bigint -> unit
    abstract member WriteBoolean : tag:string -> value:bool -> unit
    abstract member WriteByte : tag:string -> value:byte -> unit
    abstract member WriteBytes : tag:string -> value:byte [] -> unit
    ...
  end

Full name: MBrace.FsPickler.IPickleFormatWriter
Fork me on GitHub