9 people like it.

Union-Friendly Generic Binary Serializer

Implements binary serialization. The encoding supports all records, unions, numeric types, strings, rank-1 arrays, maps, sets, lists and dictionaries. Strings are interned for efficiency. The encoding also uses binary compression (GZIP).

  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: 
101: 
102: 
103: 
104: 
105: 
106: 
107: 
108: 
109: 
110: 
111: 
112: 
113: 
114: 
115: 
116: 
117: 
118: 
119: 
120: 
121: 
122: 
123: 
124: 
125: 
126: 
127: 
128: 
129: 
130: 
131: 
132: 
133: 
134: 
135: 
136: 
137: 
138: 
139: 
140: 
141: 
142: 
143: 
144: 
145: 
146: 
147: 
148: 
149: 
150: 
151: 
152: 
153: 
154: 
155: 
156: 
157: 
158: 
159: 
160: 
161: 
162: 
163: 
164: 
165: 
166: 
167: 
168: 
169: 
170: 
171: 
172: 
173: 
174: 
175: 
176: 
177: 
178: 
179: 
180: 
181: 
182: 
183: 
184: 
185: 
186: 
187: 
188: 
189: 
190: 
191: 
192: 
193: 
194: 
195: 
196: 
197: 
198: 
199: 
200: 
201: 
202: 
203: 
204: 
205: 
206: 
207: 
208: 
209: 
210: 
211: 
212: 
213: 
214: 
215: 
216: 
217: 
218: 
219: 
220: 
221: 
222: 
223: 
224: 
225: 
226: 
227: 
228: 
229: 
230: 
231: 
232: 
233: 
234: 
235: 
236: 
237: 
238: 
239: 
240: 
241: 
242: 
243: 
244: 
245: 
246: 
247: 
248: 
249: 
250: 
251: 
252: 
253: 
254: 
255: 
256: 
257: 
258: 
259: 
260: 
261: 
262: 
263: 
264: 
265: 
266: 
267: 
268: 
269: 
270: 
271: 
272: 
273: 
274: 
275: 
276: 
277: 
278: 
279: 
280: 
281: 
282: 
283: 
284: 
285: 
286: 
287: 
288: 
289: 
290: 
291: 
292: 
293: 
294: 
295: 
296: 
297: 
298: 
299: 
300: 
301: 
302: 
303: 
304: 
305: 
306: 
307: 
308: 
309: 
310: 
311: 
312: 
313: 
314: 
315: 
316: 
317: 
318: 
319: 
320: 
321: 
322: 
323: 
324: 
325: 
326: 
327: 
328: 
329: 
330: 
331: 
332: 
333: 
334: 
335: 
336: 
337: 
338: 
339: 
340: 
341: 
342: 
343: 
344: 
345: 
346: 
347: 
348: 
349: 
350: 
351: 
352: 
353: 
354: 
355: 
356: 
357: 
358: 
359: 
360: 
361: 
362: 
363: 
364: 
365: 
366: 
367: 
368: 

module Serialization.Binary

exception EncodingError

exception NoEncoding of System.Type with
    override this.ToString() =
        sprintf "Failed to derive a binary encoding for type: %O" this.Data0

type E = (string -> int) -> System.IO.BinaryWriter -> obj -> unit
type D = (int -> string) -> System.IO.BinaryReader -> obj
type S = D * E

type Dictionary<'T1,'T2> = System.Collections.Generic.Dictionary<'T1,'T2>

let inline Basic<'T> (rd: System.IO.BinaryReader -> 'T) 
                     (wr: System.IO.BinaryWriter -> 'T -> unit) : S =
    let dec dS r = rd r :> obj
    let enc eS w (x: obj) = wr w (x :?> 'T)
    (dec, enc)

let inline Add<'T> (rd: System.IO.BinaryReader -> 'T)
                   (wr: System.IO.BinaryWriter -> 'T -> unit)
                   (d: Dictionary<_,_>) =
    d.[typeof<'T>] <- Basic rd wr

let Serializers =
    let d = Dictionary()
    Add (fun r -> r.ReadChar()) (fun w -> w.Write) d
    Add (fun r -> r.ReadByte()) (fun w -> w.Write) d
    Add (fun r -> r.ReadSByte()) (fun w -> w.Write) d
    Add (fun r -> r.ReadInt16()) (fun w -> w.Write) d
    Add (fun r -> r.ReadInt32()) (fun w -> w.Write) d
    Add (fun r -> r.ReadInt64()) (fun w -> w.Write) d
    Add (fun r -> r.ReadUInt16()) (fun w -> w.Write) d
    Add (fun r -> r.ReadUInt32()) (fun w -> w.Write) d
    Add (fun r -> r.ReadUInt64()) (fun w -> w.Write) d
    Add (fun r -> r.ReadSingle()) (fun w -> w.Write) d
    Add (fun r -> r.ReadDouble()) (fun w -> w.Write) d
    Add (fun r -> r.ReadDecimal()) (fun w -> w.Write) d
    Add (fun r -> r.ReadBoolean()) (fun w -> w.Write) d
    d.[typeof<string>] <-
        let decString : D = fun dS r -> dS (r.ReadInt32()) :> obj
        let encString : E = fun eS w x -> w.Write (eS (string x))
        (decString, encString)
    d

type FST = Reflection.FSharpType
type FSV = Reflection.FSharpValue

let TupleEncoder dE (t: System.Type) : E =
    let e = Array.map dE (FST.GetTupleElements t)
    let r = FSV.PreComputeTupleReader t
    fun eS w o -> Array.iter2 (fun e x -> e eS w x) e (r o)

let TupleDecoder dD (t: System.Type) : D =
    let e = Array.map dD (FST.GetTupleElements t)
    let c = FSV.PreComputeTupleConstructor t
    fun dS r -> c (Array.map (fun e -> e dS r) e)

let ArrayEncoder (dE: System.Type -> E) (t: System.Type) : E =
    let e = dE (t.GetElementType())
    fun eS w o ->
        let o = o :?> System.Array
        w.Write o.Length
        for x in o do
            e eS w x

let ArrayDecoder (dD: System.Type -> D) (t: System.Type) : D =
    let eT = t.GetElementType()
    let e  = dD eT
    fun dS r ->
        let k = r.ReadInt32()
        let res = System.Array.CreateInstance(eT, k)
        for i in 0 .. k - 1 do
            res.SetValue(e dS r, i)
        res :> obj

let Flags =
    System.Reflection.BindingFlags.Public
    ||| System.Reflection.BindingFlags.NonPublic

let UnionEncoder dE (t: System.Type) : E =
    let tR = FSV.PreComputeUnionTagReader(t, Flags)
    let cs =
        FST.GetUnionCases(t, Flags)
        |> Array.map (fun c ->
            let r = FSV.PreComputeUnionReader(c, Flags)
            let fs =
                c.GetFields()
                |> Array.map (fun f -> dE f.PropertyType)
            (r, fs))
    fun wS w o ->
        let tag = tR o
        w.Write (byte tag)
        let (r, fs) = cs.[tag]
        Array.iter2 (fun e x -> e wS w x) fs (r o)

let UnionDecoder dD (t: System.Type) : D =
    let cs =
        FST.GetUnionCases(t, Flags)
        |> Array.map (fun c ->
            let mk = FSV.PreComputeUnionConstructor(c, Flags)
            let fs =
                c.GetFields()
                |> Array.map (fun f -> dD f.PropertyType)
            (mk, fs))
    let k = cs.Length
    fun dS r ->
        let tag = int (r.ReadByte())
        let (mk, fs) = cs.[tag]
        fs
        |> Array.map (fun f -> f dS r)
        |> mk

let RecordEncoder dE (t: System.Type) : E =
    let fs =
        FST.GetRecordFields(t, Flags)
        |> Array.map (fun f ->
            let r = FSV.PreComputeRecordFieldReader f
            (fun eS w o -> dE f.PropertyType eS w (r o)))
    fun eS w o -> Array.iter (fun f -> f eS w o) fs

let RecordDecoder dD (t: System.Type) : D =
    let mk = FSV.PreComputeRecordConstructor(t, Flags)
    let fs =
        FST.GetRecordFields(t, Flags)
        |> Array.map (fun f -> dD f.PropertyType)
    fun dS r ->
        fs
        |> Array.map (fun dec -> dec dS r)
        |> mk

type IDictionaryProcessor =
    abstract member ToSequence : obj -> seq<obj*obj>
    abstract member FromSequence : seq<obj*obj> -> obj

type ISequenceProcessor =
    abstract member ToSequence : obj -> seq<obj>
    abstract member FromSequence : seq<obj> -> obj

type DictionaryProcessor<'T1,'T2 when 'T1 : comparison>() =
    interface IDictionaryProcessor with
        member this.ToSequence (map: obj) =
            (map :?> Dictionary<'T1,'T2>)
            |> Seq.map (fun (KeyValue (k, v)) -> (box k, box v))
        member this.FromSequence (seq: seq<obj*obj>) =
            let d = Dictionary()
            for (k, v) in seq do
                d.[k :?> 'T1] <- v :?> 'T2
            box d

type MapProcessor<'T1,'T2 when 'T1 : comparison>() =
    interface IDictionaryProcessor with
        member this.ToSequence (map: obj) =
            (map :?> Map<'T1,'T2>)
            |> Seq.map (fun (KeyValue (k, v)) -> (box k, box v))
        member this.FromSequence (seq: seq<obj*obj>) =
            seq
            |> Seq.map (fun (k, v) -> (k :?> 'T1, v :?> 'T2))
            |> Map.ofSeq
            |> box

type ListProcessor<'T>() =
    interface ISequenceProcessor with
        member this.ToSequence (x: obj) = Seq.map box (x :?> list<'T>)
        member this.FromSequence (s: seq<obj>) = box [for x in s -> x :?> 'T]

type SetProcessor<'T when 'T : comparison>() =
    interface ISequenceProcessor with
        member this.ToSequence (x: obj) = Seq.map box (x :?> Set<'T>)
        member this.FromSequence (s: seq<obj>) =
            s
            |> Seq.map (fun x -> x :?> 'T)
            |> Set.ofSeq
            |> box

let DictionaryDecoder (dP: IDictionaryProcessor) dD kT vT : D =
    let kD = dD kT
    let vD = dD vT
    fun dS r ->
        let k = r.ReadInt32()
        Array.init k (fun _ ->
            let key = kD dS r
            let value = vD dS r
            (key, value))
        |> dP.FromSequence

let DictionaryEncoder (dP: IDictionaryProcessor) dE kT vT : E =
    let kE = dE kT
    let vE = dE vT
    fun eS w x ->
        let s = dP.ToSequence x
        w.Write (Seq.length s)
        for (k, v) in s do
            kE eS w k
            vE eS w v

let SequenceDecoder (sP: ISequenceProcessor) dD eT : D =
    let eD = dD eT
    fun dS r ->
        let k = r.ReadInt32()
        Array.init k (fun _ -> eD dS r)
        |> sP.FromSequence

let SequenceEncoder (sP: ISequenceProcessor) dE eT : E =
    let eE = dE eT
    fun dS w x ->
        let s = sP.ToSequence x
        w.Write (Seq.length s)
        for e in s do
            eE dS w e

let inline GetEncoding scalar array tuple union record dict seq
                       (cache: Dictionary<_,_>) =
    let recurse t =
        lock cache <| fun () ->
            cache.[t] <-
                Choice1Of2 (fun i v ->
                    match cache.TryGetValue t with
                    | true, Choice1Of2 f -> f i v
                    | _ -> raise (NoEncoding t))
    let rec get (t: System.Type) =
        let derive dD =
            try
                let r =
                    if t.IsGenericType then
                        let d = t.GetGenericTypeDefinition()
                        let a = t.GetGenericArguments()
                        if d = typedefof<Map<_,_>> then
                            let dP =
                                typedefof<MapProcessor<_,_>>
                                    .MakeGenericType(a)
                                |> System.Activator.CreateInstance
                                |> unbox : IDictionaryProcessor
                            Some (dict dP dD a.[0] a.[1])
                        elif d = typedefof<Dictionary<_,_>> then
                            let dP =
                                typedefof<DictionaryProcessor<_,_>>
                                    .MakeGenericType(a)
                                |> System.Activator.CreateInstance
                                |> unbox : IDictionaryProcessor
                            Some (dict dP dD a.[0] a.[1])
                        elif d = typedefof<list<_>> then
                            let sP =
                                typedefof<ListProcessor<_>>
                                    .MakeGenericType(a)
                                |> System.Activator.CreateInstance
                                |> unbox : ISequenceProcessor
                            Some (seq sP dD a.[0])
                        elif d = typedefof<Set<_>> then
                            let sP =
                                typedefof<SetProcessor<_>>
                                    .MakeGenericType(a)
                                |> System.Activator.CreateInstance
                                |> unbox : ISequenceProcessor
                            Some (seq sP dD a.[0])
                        else
                            None
                    else
                        None
                if r.IsSome then (Choice1Of2 r.Value) else
                    if t.IsArray && t.GetArrayRank() = 1 then
                        Choice1Of2 (array dD t)
                    elif FST.IsTuple t then
                        Choice1Of2 (tuple dD t)
                    elif FST.IsUnion (t, Flags) then
                        recurse t
                        Choice1Of2 (union dD t)
                    elif FST.IsRecord (t, Flags) then
                        recurse t
                        Choice1Of2 (record dD t)
                    else
                        Choice2Of2 t
            with NoEncoding t ->
                Choice2Of2 t
        if t = null then Choice2Of2 t else
            match Serializers.TryGetValue t with
            | true, x ->
                Choice1Of2 (scalar x)
            | _ ->
                let d =
                    match cache.TryGetValue t with
                    | true, d -> Some d
                    | _ -> None
                match d with
                | Some d -> d
                | None ->
                    let dD t =
                        match get t with
                        | Choice1Of2 d -> d
                        | Choice2Of2 d -> raise (NoEncoding t)
                    let d = derive dD
                    cache.[t] <- d
                    d
    get

[<Sealed>]
type Encoding(t: System.Type, d: D, e: E) =

    member this.Decode stream =
        let mode = System.IO.Compression.CompressionMode.Decompress
        use reader =
            new System.IO.BinaryReader(
                new System.IO.Compression.GZipStream(stream, mode))
        try
            if reader.ReadString() <> t.AssemblyQualifiedName then
                raise EncodingError
            let dS = Dictionary()
            for i in 0 .. reader.ReadInt32() - 1 do
                let s = reader.ReadString()
                dS.[i] <- s
            d (fun x -> dS.[x]) reader
        with _ ->
            raise EncodingError

    member this.Encode stream (value: obj) =
        let mode   = System.IO.Compression.CompressionMode.Compress
        use memory = new System.IO.MemoryStream()
        use actual = new System.IO.Compression.GZipStream(stream, mode)
        use wM     = new System.IO.BinaryWriter(memory)
        use wA     = new System.IO.BinaryWriter(actual)
        try
            let eS = Dictionary()
            let encS x =
                match eS.TryGetValue x with
                | true, y -> y
                | _ ->
                    let y = eS.Count
                    eS.[x] <- y
                    y
            e encS wM value
            wA.Write t.AssemblyQualifiedName
            wA.Write eS.Count
            for v in eS.Keys do
                wA.Write v
            memory.WriteTo actual
        with _ ->
            raise EncodingError

    member this.Type = t

[<Sealed>]
type EncodingProvider() =

    let Decoders = Dictionary()
    let Encoders = Dictionary()

    let GetDecoder (t: System.Type) =
        GetEncoding fst ArrayDecoder TupleDecoder
            UnionDecoder RecordDecoder
            DictionaryDecoder SequenceDecoder
            Decoders t

    let GetEncoder (t: System.Type) =
        GetEncoding snd ArrayEncoder TupleEncoder
            UnionEncoder RecordEncoder
            DictionaryEncoder SequenceEncoder
            Encoders t

    member this.DeriveEncoding t =
        match GetEncoder t, GetDecoder t with
        | Choice1Of2 e, Choice1Of2 d ->
            Encoding (t, d, e)
        | Choice2Of2 t, _ | _, Choice2Of2 t ->
            raise (NoEncoding t)

    static member Create() =
        EncodingProvider()
namespace Serialization
module Binary

from Serialization
exception EncodingError

Full name: Serialization.Binary.EncodingError
exception NoEncoding of System.Type

Full name: Serialization.Binary.NoEncoding
namespace System
type Type =
  inherit MemberInfo
  member Assembly : Assembly
  member AssemblyQualifiedName : string
  member Attributes : TypeAttributes
  member BaseType : Type
  member ContainsGenericParameters : bool
  member DeclaringMethod : MethodBase
  member DeclaringType : Type
  member Equals : o:obj -> bool + 1 overload
  member FindInterfaces : filter:TypeFilter * filterCriteria:obj -> Type[]
  member FindMembers : memberType:MemberTypes * bindingAttr:BindingFlags * filter:MemberFilter * filterCriteria:obj -> MemberInfo[]
  ...

Full name: System.Type
val this : NoEncoding
override NoEncoding.ToString : unit -> string

Full name: Serialization.Binary.NoEncoding.ToString
val sprintf : format:Printf.StringFormat<'T> -> 'T

Full name: Microsoft.FSharp.Core.ExtraTopLevelOperators.sprintf
NoEncoding.Data0: System.Type
type E = (string -> int) -> System.IO.BinaryWriter -> obj -> unit

Full name: Serialization.Binary.E
Multiple items
val string : value:'T -> string

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

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

Full name: Microsoft.FSharp.Core.string
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<_>
namespace System.IO
Multiple items
type BinaryWriter =
  new : output:Stream -> BinaryWriter + 1 overload
  member BaseStream : Stream
  member Close : unit -> unit
  member Dispose : unit -> unit
  member Flush : unit -> unit
  member Seek : offset:int * origin:SeekOrigin -> int64
  member Write : value:bool -> unit + 17 overloads
  static val Null : BinaryWriter

Full name: System.IO.BinaryWriter

--------------------
System.IO.BinaryWriter(output: System.IO.Stream) : unit
System.IO.BinaryWriter(output: System.IO.Stream, encoding: System.Text.Encoding) : unit
type obj = System.Object

Full name: Microsoft.FSharp.Core.obj
type unit = Unit

Full name: Microsoft.FSharp.Core.unit
type D = (int -> string) -> System.IO.BinaryReader -> obj

Full name: Serialization.Binary.D
Multiple items
type BinaryReader =
  new : input:Stream -> BinaryReader + 1 overload
  member BaseStream : Stream
  member Close : unit -> unit
  member Dispose : unit -> unit
  member PeekChar : unit -> int
  member Read : unit -> int + 2 overloads
  member ReadBoolean : unit -> bool
  member ReadByte : unit -> byte
  member ReadBytes : count:int -> byte[]
  member ReadChar : unit -> char
  ...

Full name: System.IO.BinaryReader

--------------------
System.IO.BinaryReader(input: System.IO.Stream) : unit
System.IO.BinaryReader(input: System.IO.Stream, encoding: System.Text.Encoding) : unit
type S = D * E

Full name: Serialization.Binary.S
type Dictionary<'T1,'T2> = System.Collections.Generic.Dictionary<'T1,'T2>

Full name: Serialization.Binary.Dictionary<_,_>
namespace System.Collections
namespace System.Collections.Generic
Multiple items
type Dictionary<'TKey,'TValue> =
  new : unit -> Dictionary<'TKey, 'TValue> + 5 overloads
  member Add : key:'TKey * value:'TValue -> unit
  member Clear : unit -> unit
  member Comparer : IEqualityComparer<'TKey>
  member ContainsKey : key:'TKey -> bool
  member ContainsValue : value:'TValue -> bool
  member Count : int
  member GetEnumerator : unit -> Enumerator<'TKey, 'TValue>
  member GetObjectData : info:SerializationInfo * context:StreamingContext -> unit
  member Item : 'TKey -> 'TValue with get, set
  ...
  nested type Enumerator
  nested type KeyCollection
  nested type ValueCollection

Full name: System.Collections.Generic.Dictionary<_,_>

--------------------
System.Collections.Generic.Dictionary() : unit
System.Collections.Generic.Dictionary(capacity: int) : unit
System.Collections.Generic.Dictionary(comparer: System.Collections.Generic.IEqualityComparer<'TKey>) : unit
System.Collections.Generic.Dictionary(dictionary: System.Collections.Generic.IDictionary<'TKey,'TValue>) : unit
System.Collections.Generic.Dictionary(capacity: int, comparer: System.Collections.Generic.IEqualityComparer<'TKey>) : unit
System.Collections.Generic.Dictionary(dictionary: System.Collections.Generic.IDictionary<'TKey,'TValue>, comparer: System.Collections.Generic.IEqualityComparer<'TKey>) : unit
val Basic : rd:(System.IO.BinaryReader -> 'T) -> wr:(System.IO.BinaryWriter -> 'T -> unit) -> S

Full name: Serialization.Binary.Basic
val rd : (System.IO.BinaryReader -> 'T)
val wr : (System.IO.BinaryWriter -> 'T -> unit)
val dec : ('a -> System.IO.BinaryReader -> obj)
val dS : 'a
val r : System.IO.BinaryReader
val enc : ('a -> System.IO.BinaryWriter -> obj -> unit)
val eS : 'a
val w : System.IO.BinaryWriter
val x : obj
val Add : rd:(System.IO.BinaryReader -> 'T) -> wr:(System.IO.BinaryWriter -> 'T -> unit) -> d:Dictionary<System.Type,S> -> unit

Full name: Serialization.Binary.Add
val d : Dictionary<System.Type,S>
val typeof<'T> : System.Type

Full name: Microsoft.FSharp.Core.Operators.typeof
val Serializers : System.Collections.Generic.Dictionary<System.Type,S>

Full name: Serialization.Binary.Serializers
val d : System.Collections.Generic.Dictionary<System.Type,S>
System.IO.BinaryReader.ReadChar() : char
System.IO.BinaryWriter.Write(value: string) : unit
   (+0 other overloads)
System.IO.BinaryWriter.Write(value: float32) : unit
   (+0 other overloads)
System.IO.BinaryWriter.Write(value: uint64) : unit
   (+0 other overloads)
System.IO.BinaryWriter.Write(value: int64) : unit
   (+0 other overloads)
System.IO.BinaryWriter.Write(value: uint32) : unit
   (+0 other overloads)
System.IO.BinaryWriter.Write(value: int) : unit
   (+0 other overloads)
System.IO.BinaryWriter.Write(value: uint16) : unit
   (+0 other overloads)
System.IO.BinaryWriter.Write(value: int16) : unit
   (+0 other overloads)
System.IO.BinaryWriter.Write(value: decimal) : unit
   (+0 other overloads)
System.IO.BinaryWriter.Write(value: float) : unit
   (+0 other overloads)
System.IO.BinaryReader.ReadByte() : byte
System.IO.BinaryReader.ReadSByte() : sbyte
System.IO.BinaryReader.ReadInt16() : int16
System.IO.BinaryReader.ReadInt32() : int
System.IO.BinaryReader.ReadInt64() : int64
System.IO.BinaryReader.ReadUInt16() : uint16
System.IO.BinaryReader.ReadUInt32() : uint32
System.IO.BinaryReader.ReadUInt64() : uint64
System.IO.BinaryReader.ReadSingle() : float32
System.IO.BinaryReader.ReadDouble() : float
System.IO.BinaryReader.ReadDecimal() : decimal
System.IO.BinaryReader.ReadBoolean() : bool
val decString : D
val dS : (int -> string)
val encString : E
val eS : (string -> int)
type FST = Reflection.FSharpType

Full name: Serialization.Binary.FST
namespace Microsoft.FSharp.Reflection
type FSharpType =
  static member GetExceptionFields : exceptionType:Type * ?bindingFlags:BindingFlags -> PropertyInfo []
  static member GetFunctionElements : functionType:Type -> Type * Type
  static member GetRecordFields : recordType:Type * ?bindingFlags:BindingFlags -> PropertyInfo []
  static member GetTupleElements : tupleType:Type -> Type []
  static member GetUnionCases : unionType:Type * ?bindingFlags:BindingFlags -> UnionCaseInfo []
  static member IsExceptionRepresentation : exceptionType:Type * ?bindingFlags:BindingFlags -> bool
  static member IsFunction : typ:Type -> bool
  static member IsModule : typ:Type -> bool
  static member IsRecord : typ:Type * ?bindingFlags:BindingFlags -> bool
  static member IsTuple : typ:Type -> bool
  ...

Full name: Microsoft.FSharp.Reflection.FSharpType
type FSV = Reflection.FSharpValue

Full name: Serialization.Binary.FSV
type FSharpValue =
  static member GetExceptionFields : exn:obj * ?bindingFlags:BindingFlags -> obj []
  static member GetRecordField : record:obj * info:PropertyInfo -> obj
  static member GetRecordFields : record:obj * ?bindingFlags:BindingFlags -> obj []
  static member GetTupleField : tuple:obj * index:int -> obj
  static member GetTupleFields : tuple:obj -> obj []
  static member GetUnionFields : value:obj * unionType:Type * ?bindingFlags:BindingFlags -> UnionCaseInfo * obj []
  static member MakeFunction : functionType:Type * implementation:(obj -> obj) -> obj
  static member MakeRecord : recordType:Type * values:obj [] * ?bindingFlags:BindingFlags -> obj
  static member MakeTuple : tupleElements:obj [] * tupleType:Type -> obj
  static member MakeUnion : unionCase:UnionCaseInfo * args:obj [] * ?bindingFlags:BindingFlags -> obj
  ...

Full name: Microsoft.FSharp.Reflection.FSharpValue
val TupleEncoder : dE:(System.Type -> (string -> int) -> System.IO.BinaryWriter -> obj -> unit) -> t:System.Type -> E

Full name: Serialization.Binary.TupleEncoder
val dE : (System.Type -> (string -> int) -> System.IO.BinaryWriter -> obj -> unit)
val t : System.Type
val e : ((string -> int) -> System.IO.BinaryWriter -> obj -> unit) []
module Array

from Microsoft.FSharp.Collections
val map : mapping:('T -> 'U) -> array:'T [] -> 'U []

Full name: Microsoft.FSharp.Collections.Array.map
static member Reflection.FSharpType.GetTupleElements : tupleType:System.Type -> System.Type []
val r : (obj -> obj [])
static member Reflection.FSharpValue.PreComputeTupleReader : tupleType:System.Type -> (obj -> obj [])
val o : obj
val iter2 : action:('T1 -> 'T2 -> unit) -> array1:'T1 [] -> array2:'T2 [] -> unit

Full name: Microsoft.FSharp.Collections.Array.iter2
val e : ((string -> int) -> System.IO.BinaryWriter -> obj -> unit)
val TupleDecoder : dD:(System.Type -> (int -> string) -> System.IO.BinaryReader -> obj) -> t:System.Type -> D

Full name: Serialization.Binary.TupleDecoder
val dD : (System.Type -> (int -> string) -> System.IO.BinaryReader -> obj)
val e : ((int -> string) -> System.IO.BinaryReader -> obj) []
val c : (obj [] -> obj)
static member Reflection.FSharpValue.PreComputeTupleConstructor : tupleType:System.Type -> (obj [] -> obj)
val e : ((int -> string) -> System.IO.BinaryReader -> obj)
val ArrayEncoder : dE:(System.Type -> E) -> t:System.Type -> E

Full name: Serialization.Binary.ArrayEncoder
val dE : (System.Type -> E)
System.Type.GetElementType() : System.Type
val o : System.Array
type Array =
  member Clone : unit -> obj
  member CopyTo : array:Array * index:int -> unit + 1 overload
  member GetEnumerator : unit -> IEnumerator
  member GetLength : dimension:int -> int
  member GetLongLength : dimension:int -> int64
  member GetLowerBound : dimension:int -> int
  member GetUpperBound : dimension:int -> int
  member GetValue : [<ParamArray>] indices:int[] -> obj + 7 overloads
  member Initialize : unit -> unit
  member IsFixedSize : bool
  ...

Full name: System.Array
property System.Array.Length: int
val ArrayDecoder : dD:(System.Type -> D) -> t:System.Type -> D

Full name: Serialization.Binary.ArrayDecoder
val dD : (System.Type -> D)
val eT : System.Type
val k : int
val res : System.Array
System.Array.CreateInstance(elementType: System.Type, [<System.ParamArray>] lengths: int64 []) : System.Array
System.Array.CreateInstance(elementType: System.Type, [<System.ParamArray>] lengths: int []) : System.Array
System.Array.CreateInstance(elementType: System.Type, length: int) : System.Array
System.Array.CreateInstance(elementType: System.Type, lengths: int [], lowerBounds: int []) : System.Array
System.Array.CreateInstance(elementType: System.Type, length1: int, length2: int) : System.Array
System.Array.CreateInstance(elementType: System.Type, length1: int, length2: int, length3: int) : System.Array
val i : int32
System.Array.SetValue(value: obj, [<System.ParamArray>] indices: int64 []) : unit
System.Array.SetValue(value: obj, index: int64) : unit
System.Array.SetValue(value: obj, [<System.ParamArray>] indices: int []) : unit
System.Array.SetValue(value: obj, index: int) : unit
System.Array.SetValue(value: obj, index1: int64, index2: int64) : unit
System.Array.SetValue(value: obj, index1: int, index2: int) : unit
System.Array.SetValue(value: obj, index1: int64, index2: int64, index3: int64) : unit
System.Array.SetValue(value: obj, index1: int, index2: int, index3: int) : unit
val Flags : System.Reflection.BindingFlags

Full name: Serialization.Binary.Flags
namespace System.Reflection
type BindingFlags =
  | Default = 0
  | IgnoreCase = 1
  | DeclaredOnly = 2
  | Instance = 4
  | Static = 8
  | Public = 16
  | NonPublic = 32
  | FlattenHierarchy = 64
  | InvokeMethod = 256
  | CreateInstance = 512
  ...

Full name: System.Reflection.BindingFlags
field System.Reflection.BindingFlags.Public = 16
field System.Reflection.BindingFlags.NonPublic = 32
val UnionEncoder : dE:(System.Type -> (string -> int) -> System.IO.BinaryWriter -> obj -> unit) -> t:System.Type -> E

Full name: Serialization.Binary.UnionEncoder
val tR : (obj -> int)
static member Reflection.FSharpValue.PreComputeUnionTagReader : unionType:System.Type * ?bindingFlags:System.Reflection.BindingFlags -> (obj -> int)
val cs : ((obj -> obj []) * ((string -> int) -> System.IO.BinaryWriter -> obj -> unit) []) []
static member Reflection.FSharpType.GetUnionCases : unionType:System.Type * ?bindingFlags:System.Reflection.BindingFlags -> Reflection.UnionCaseInfo []
val c : Reflection.UnionCaseInfo
static member Reflection.FSharpValue.PreComputeUnionReader : unionCase:Reflection.UnionCaseInfo * ?bindingFlags:System.Reflection.BindingFlags -> (obj -> obj [])
val fs : ((string -> int) -> System.IO.BinaryWriter -> obj -> unit) []
member Reflection.UnionCaseInfo.GetFields : unit -> System.Reflection.PropertyInfo []
val f : System.Reflection.PropertyInfo
property System.Reflection.PropertyInfo.PropertyType: System.Type
val wS : (string -> int)
val tag : int
Multiple items
val byte : value:'T -> byte (requires member op_Explicit)

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

--------------------
type byte = System.Byte

Full name: Microsoft.FSharp.Core.byte
val UnionDecoder : dD:(System.Type -> (int -> string) -> System.IO.BinaryReader -> obj) -> t:System.Type -> D

Full name: Serialization.Binary.UnionDecoder
val cs : ((obj [] -> obj) * ((int -> string) -> System.IO.BinaryReader -> obj) []) []
val mk : (obj [] -> obj)
static member Reflection.FSharpValue.PreComputeUnionConstructor : unionCase:Reflection.UnionCaseInfo * ?bindingFlags:System.Reflection.BindingFlags -> (obj [] -> obj)
val fs : ((int -> string) -> System.IO.BinaryReader -> obj) []
val f : ((int -> string) -> System.IO.BinaryReader -> obj)
val RecordEncoder : dE:(System.Type -> (string -> int) -> System.IO.BinaryWriter -> obj -> unit) -> t:System.Type -> E

Full name: Serialization.Binary.RecordEncoder
static member Reflection.FSharpType.GetRecordFields : recordType:System.Type * ?bindingFlags:System.Reflection.BindingFlags -> System.Reflection.PropertyInfo []
val r : (obj -> obj)
static member Reflection.FSharpValue.PreComputeRecordFieldReader : info:System.Reflection.PropertyInfo -> (obj -> obj)
val iter : action:('T -> unit) -> array:'T [] -> unit

Full name: Microsoft.FSharp.Collections.Array.iter
val f : ((string -> int) -> System.IO.BinaryWriter -> obj -> unit)
val RecordDecoder : dD:(System.Type -> (int -> string) -> System.IO.BinaryReader -> obj) -> t:System.Type -> D

Full name: Serialization.Binary.RecordDecoder
static member Reflection.FSharpValue.PreComputeRecordConstructor : recordType:System.Type * ?bindingFlags:System.Reflection.BindingFlags -> (obj [] -> obj)
val dec : ((int -> string) -> System.IO.BinaryReader -> obj)
type IDictionaryProcessor =
  interface
    abstract member FromSequence : seq<obj * obj> -> obj
    abstract member ToSequence : obj -> seq<obj * obj>
  end

Full name: Serialization.Binary.IDictionaryProcessor
abstract member IDictionaryProcessor.ToSequence : obj -> seq<obj * obj>

Full name: Serialization.Binary.IDictionaryProcessor.ToSequence
Multiple items
val seq : sequence:seq<'T> -> seq<'T>

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

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

Full name: Microsoft.FSharp.Collections.seq<_>
abstract member IDictionaryProcessor.FromSequence : seq<obj * obj> -> obj

Full name: Serialization.Binary.IDictionaryProcessor.FromSequence
type ISequenceProcessor =
  interface
    abstract member FromSequence : seq<obj> -> obj
    abstract member ToSequence : obj -> seq<obj>
  end

Full name: Serialization.Binary.ISequenceProcessor
abstract member ISequenceProcessor.ToSequence : obj -> seq<obj>

Full name: Serialization.Binary.ISequenceProcessor.ToSequence
abstract member ISequenceProcessor.FromSequence : seq<obj> -> obj

Full name: Serialization.Binary.ISequenceProcessor.FromSequence
Multiple items
type DictionaryProcessor<'T1,'T2 (requires comparison)> =
  interface IDictionaryProcessor
  new : unit -> DictionaryProcessor<'T1,'T2>

Full name: Serialization.Binary.DictionaryProcessor<_,_>

--------------------
new : unit -> DictionaryProcessor<'T1,'T2>
val this : DictionaryProcessor<'T1,'T2> (requires comparison)
override DictionaryProcessor.ToSequence : map:obj -> seq<obj * obj>

Full name: Serialization.Binary.DictionaryProcessor`2.ToSequence
val map : obj
module Seq

from Microsoft.FSharp.Collections
val map : mapping:('T -> 'U) -> source:seq<'T> -> seq<'U>

Full name: Microsoft.FSharp.Collections.Seq.map
active recognizer KeyValue: System.Collections.Generic.KeyValuePair<'Key,'Value> -> 'Key * 'Value

Full name: Microsoft.FSharp.Core.Operators.( |KeyValue| )
val k : 'T1 (requires comparison)
val v : 'T2
val box : value:'T -> obj

Full name: Microsoft.FSharp.Core.Operators.box
override DictionaryProcessor.FromSequence : seq:seq<obj * obj> -> obj

Full name: Serialization.Binary.DictionaryProcessor`2.FromSequence
Multiple items
val seq : seq<obj * obj>

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

Full name: Microsoft.FSharp.Collections.seq<_>
val d : System.Collections.Generic.Dictionary<'T1,'T2> (requires comparison)
val k : obj
val v : obj
Multiple items
type MapProcessor<'T1,'T2 (requires comparison)> =
  interface IDictionaryProcessor
  new : unit -> MapProcessor<'T1,'T2>

Full name: Serialization.Binary.MapProcessor<_,_>

--------------------
new : unit -> MapProcessor<'T1,'T2>
val this : MapProcessor<'T1,'T2> (requires comparison)
override MapProcessor.ToSequence : map:obj -> seq<obj * obj>

Full name: Serialization.Binary.MapProcessor`2.ToSequence
Multiple items
module Map

from Microsoft.FSharp.Collections

--------------------
type Map<'Key,'Value (requires comparison)> =
  interface IEnumerable
  interface IComparable
  interface IEnumerable<KeyValuePair<'Key,'Value>>
  interface ICollection<KeyValuePair<'Key,'Value>>
  interface IDictionary<'Key,'Value>
  new : elements:seq<'Key * 'Value> -> Map<'Key,'Value>
  member Add : key:'Key * value:'Value -> Map<'Key,'Value>
  member ContainsKey : key:'Key -> bool
  override Equals : obj -> bool
  member Remove : key:'Key -> Map<'Key,'Value>
  ...

Full name: Microsoft.FSharp.Collections.Map<_,_>

--------------------
new : elements:seq<'Key * 'Value> -> Map<'Key,'Value>
override MapProcessor.FromSequence : seq:seq<obj * obj> -> obj

Full name: Serialization.Binary.MapProcessor`2.FromSequence
val ofSeq : elements:seq<'Key * 'T> -> Map<'Key,'T> (requires comparison)

Full name: Microsoft.FSharp.Collections.Map.ofSeq
Multiple items
type ListProcessor<'T> =
  interface ISequenceProcessor
  new : unit -> ListProcessor<'T>

Full name: Serialization.Binary.ListProcessor<_>

--------------------
new : unit -> ListProcessor<'T>
val this : ListProcessor<'T>
override ListProcessor.ToSequence : x:obj -> seq<obj>

Full name: Serialization.Binary.ListProcessor`1.ToSequence
type 'T list = List<'T>

Full name: Microsoft.FSharp.Collections.list<_>
override ListProcessor.FromSequence : s:seq<obj> -> obj

Full name: Serialization.Binary.ListProcessor`1.FromSequence
val s : seq<obj>
Multiple items
type SetProcessor<'T (requires comparison)> =
  interface ISequenceProcessor
  new : unit -> SetProcessor<'T>

Full name: Serialization.Binary.SetProcessor<_>

--------------------
new : unit -> SetProcessor<'T>
val this : SetProcessor<'T> (requires comparison)
override SetProcessor.ToSequence : x:obj -> seq<obj>

Full name: Serialization.Binary.SetProcessor`1.ToSequence
Multiple items
module Set

from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> =
  interface IComparable
  interface IEnumerable
  interface IEnumerable<'T>
  interface ICollection<'T>
  new : elements:seq<'T> -> Set<'T>
  member Add : value:'T -> Set<'T>
  member Contains : value:'T -> bool
  override Equals : obj -> bool
  member IsProperSubsetOf : otherSet:Set<'T> -> bool
  member IsProperSupersetOf : otherSet:Set<'T> -> bool
  ...

Full name: Microsoft.FSharp.Collections.Set<_>

--------------------
new : elements:seq<'T> -> Set<'T>
override SetProcessor.FromSequence : s:seq<obj> -> obj

Full name: Serialization.Binary.SetProcessor`1.FromSequence
val ofSeq : elements:seq<'T> -> Set<'T> (requires comparison)

Full name: Microsoft.FSharp.Collections.Set.ofSeq
val DictionaryDecoder : dP:IDictionaryProcessor -> dD:('a -> (int -> string) -> System.IO.BinaryReader -> obj) -> kT:'a -> vT:'a -> D

Full name: Serialization.Binary.DictionaryDecoder
val dP : IDictionaryProcessor
val dD : ('a -> (int -> string) -> System.IO.BinaryReader -> obj)
val kT : 'a
val vT : 'a
val kD : ((int -> string) -> System.IO.BinaryReader -> obj)
val vD : ((int -> string) -> System.IO.BinaryReader -> obj)
val init : count:int -> initializer:(int -> 'T) -> 'T []

Full name: Microsoft.FSharp.Collections.Array.init
val key : obj
val value : obj
abstract member IDictionaryProcessor.FromSequence : seq<obj * obj> -> obj
val DictionaryEncoder : dP:IDictionaryProcessor -> dE:('a -> (string -> int) -> System.IO.BinaryWriter -> obj -> unit) -> kT:'a -> vT:'a -> E

Full name: Serialization.Binary.DictionaryEncoder
val dE : ('a -> (string -> int) -> System.IO.BinaryWriter -> obj -> unit)
val kE : ((string -> int) -> System.IO.BinaryWriter -> obj -> unit)
val vE : ((string -> int) -> System.IO.BinaryWriter -> obj -> unit)
val s : seq<obj * obj>
abstract member IDictionaryProcessor.ToSequence : obj -> seq<obj * obj>
val length : source:seq<'T> -> int

Full name: Microsoft.FSharp.Collections.Seq.length
val SequenceDecoder : sP:ISequenceProcessor -> dD:('a -> (int -> string) -> System.IO.BinaryReader -> obj) -> eT:'a -> D

Full name: Serialization.Binary.SequenceDecoder
val sP : ISequenceProcessor
val eT : 'a
val eD : ((int -> string) -> System.IO.BinaryReader -> obj)
abstract member ISequenceProcessor.FromSequence : seq<obj> -> obj
val SequenceEncoder : sP:ISequenceProcessor -> dE:('a -> (string -> int) -> System.IO.BinaryWriter -> obj -> unit) -> eT:'a -> E

Full name: Serialization.Binary.SequenceEncoder
val eE : ((string -> int) -> System.IO.BinaryWriter -> obj -> unit)
val dS : (string -> int)
abstract member ISequenceProcessor.ToSequence : obj -> seq<obj>
val e : obj
val GetEncoding : scalar:(S -> 'a -> 'b -> 'c) -> array:(('d -> 'a -> 'b -> 'c) -> System.Type -> 'a -> 'b -> 'c) -> tuple:(('d -> 'a -> 'b -> 'c) -> System.Type -> 'a -> 'b -> 'c) -> union:(('d -> 'a -> 'b -> 'c) -> System.Type -> 'a -> 'b -> 'c) -> record:(('d -> 'a -> 'b -> 'c) -> System.Type -> 'a -> 'b -> 'c) -> dict:(IDictionaryProcessor -> ('d -> 'a -> 'b -> 'c) -> System.Type -> System.Type -> 'a -> 'b -> 'c) -> seq:(ISequenceProcessor -> ('d -> 'a -> 'b -> 'c) -> System.Type -> 'a -> 'b -> 'c) -> cache:Dictionary<System.Type,Choice<('a -> 'b -> 'c),System.Type>> -> (System.Type -> Choice<('a -> 'b -> 'c),System.Type>) (requires 'd :> System.Type)

Full name: Serialization.Binary.GetEncoding
val scalar : (S -> 'a -> 'b -> 'c)
Multiple items
val array : ((#System.Type -> 'a -> 'b -> 'c) -> System.Type -> 'a -> 'b -> 'c)

--------------------
type 'T array = 'T []

Full name: Microsoft.FSharp.Core.array<_>
val tuple : ((#System.Type -> 'a -> 'b -> 'c) -> System.Type -> 'a -> 'b -> 'c)
val union : ((#System.Type -> 'a -> 'b -> 'c) -> System.Type -> 'a -> 'b -> 'c)
val record : ((#System.Type -> 'a -> 'b -> 'c) -> System.Type -> 'a -> 'b -> 'c)
val dict : (IDictionaryProcessor -> (#System.Type -> 'a -> 'b -> 'c) -> System.Type -> System.Type -> 'a -> 'b -> 'c)
Multiple items
val seq : (ISequenceProcessor -> (#System.Type -> 'a -> 'b -> 'c) -> System.Type -> 'a -> 'b -> 'c)

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

Full name: Microsoft.FSharp.Collections.seq<_>
val cache : Dictionary<System.Type,Choice<('a -> 'b -> 'c),System.Type>>
val recurse : (System.Type -> unit)
val lock : lockObject:'Lock -> action:(unit -> 'T) -> 'T (requires reference type)

Full name: Microsoft.FSharp.Core.Operators.lock
union case Choice.Choice1Of2: 'T1 -> Choice<'T1,'T2>
val i : 'a
val v : 'b
System.Collections.Generic.Dictionary.TryGetValue(key: System.Type, value: byref<Choice<('a -> 'b -> 'c),System.Type>>) : bool
val f : ('a -> 'b -> 'c)
val raise : exn:System.Exception -> 'T

Full name: Microsoft.FSharp.Core.Operators.raise
val get : (System.Type -> Choice<('a -> 'b -> 'c),System.Type>)
val derive : ((#System.Type -> 'a -> 'b -> 'c) -> Choice<('a -> 'b -> 'c),System.Type>)
val dD : (#System.Type -> 'a -> 'b -> 'c)
val r : ('a -> 'b -> 'c) option
property System.Type.IsGenericType: bool
val d : System.Type
System.Type.GetGenericTypeDefinition() : System.Type
val a : System.Type []
System.Type.GetGenericArguments() : System.Type []
val typedefof<'T> : System.Type

Full name: Microsoft.FSharp.Core.Operators.typedefof
type Activator =
  static member CreateComInstanceFrom : assemblyName:string * typeName:string -> ObjectHandle + 1 overload
  static member CreateInstance<'T> : unit -> 'T + 15 overloads
  static member CreateInstanceFrom : assemblyFile:string * typeName:string -> ObjectHandle + 6 overloads
  static member GetObject : type:Type * url:string -> obj + 1 overload

Full name: System.Activator
System.Activator.CreateInstance<'T>() : 'T
   (+0 other overloads)
System.Activator.CreateInstance(activationContext: System.ActivationContext) : System.Runtime.Remoting.ObjectHandle
   (+0 other overloads)
System.Activator.CreateInstance(type: System.Type) : obj
   (+0 other overloads)
System.Activator.CreateInstance(activationContext: System.ActivationContext, activationCustomData: string []) : System.Runtime.Remoting.ObjectHandle
   (+0 other overloads)
System.Activator.CreateInstance(type: System.Type, nonPublic: bool) : obj
   (+0 other overloads)
System.Activator.CreateInstance(assemblyName: string, typeName: string) : System.Runtime.Remoting.ObjectHandle
   (+0 other overloads)
System.Activator.CreateInstance(type: System.Type, [<System.ParamArray>] args: obj []) : obj
   (+0 other overloads)
System.Activator.CreateInstance(domain: System.AppDomain, assemblyName: string, typeName: string) : System.Runtime.Remoting.ObjectHandle
   (+0 other overloads)
System.Activator.CreateInstance(assemblyName: string, typeName: string, activationAttributes: obj []) : System.Runtime.Remoting.ObjectHandle
   (+0 other overloads)
System.Activator.CreateInstance(type: System.Type, args: obj [], activationAttributes: obj []) : obj
   (+0 other overloads)
val unbox : value:obj -> 'T

Full name: Microsoft.FSharp.Core.Operators.unbox
union case Option.Some: Value: 'T -> Option<'T>
union case Option.None: Option<'T>
property Option.IsSome: bool
property Option.Value: 'a -> 'b -> 'c
property System.Type.IsArray: bool
System.Type.GetArrayRank() : int
static member Reflection.FSharpType.IsTuple : typ:System.Type -> bool
static member Reflection.FSharpType.IsUnion : typ:System.Type * ?bindingFlags:System.Reflection.BindingFlags -> bool
static member Reflection.FSharpType.IsRecord : typ:System.Type * ?bindingFlags:System.Reflection.BindingFlags -> bool
union case Choice.Choice2Of2: 'T2 -> Choice<'T1,'T2>
System.Collections.Generic.Dictionary.TryGetValue(key: System.Type, value: byref<S>) : bool
val x : S
val d : Choice<('a -> 'b -> 'c),System.Type> option
val d : Choice<('a -> 'b -> 'c),System.Type>
val dD : (System.Type -> 'a -> 'b -> 'c)
val d : ('a -> 'b -> 'c)
Multiple items
type SealedAttribute =
  inherit Attribute
  new : unit -> SealedAttribute
  new : value:bool -> SealedAttribute
  member Value : bool

Full name: Microsoft.FSharp.Core.SealedAttribute

--------------------
new : unit -> SealedAttribute
new : value:bool -> SealedAttribute
Multiple items
type Encoding =
  new : t:Type * d:D * e:E -> Encoding
  member Decode : stream:Stream -> obj
  member Encode : stream:Stream -> value:obj -> unit
  member Type : Type

Full name: Serialization.Binary.Encoding

--------------------
new : t:System.Type * d:D * e:E -> Encoding
val d : D
val e : E
val this : Encoding
member Encoding.Decode : stream:System.IO.Stream -> obj

Full name: Serialization.Binary.Encoding.Decode
val stream : System.IO.Stream
val mode : System.IO.Compression.CompressionMode
namespace System.IO.Compression
type CompressionMode =
  | Decompress = 0
  | Compress = 1

Full name: System.IO.Compression.CompressionMode
field System.IO.Compression.CompressionMode.Decompress = 0
val reader : System.IO.BinaryReader
Multiple items
type GZipStream =
  inherit Stream
  new : stream:Stream * mode:CompressionMode -> GZipStream + 1 overload
  member BaseStream : Stream
  member BeginRead : array:byte[] * offset:int * count:int * asyncCallback:AsyncCallback * asyncState:obj -> IAsyncResult
  member BeginWrite : array:byte[] * offset:int * count:int * asyncCallback:AsyncCallback * asyncState:obj -> IAsyncResult
  member CanRead : bool
  member CanSeek : bool
  member CanWrite : bool
  member EndRead : asyncResult:IAsyncResult -> int
  member EndWrite : asyncResult:IAsyncResult -> unit
  member Flush : unit -> unit
  ...

Full name: System.IO.Compression.GZipStream

--------------------
System.IO.Compression.GZipStream(stream: System.IO.Stream, mode: System.IO.Compression.CompressionMode) : unit
System.IO.Compression.GZipStream(stream: System.IO.Stream, mode: System.IO.Compression.CompressionMode, leaveOpen: bool) : unit
System.IO.BinaryReader.ReadString() : string
property System.Type.AssemblyQualifiedName: string
val dS : System.Collections.Generic.Dictionary<int32,string>
val s : string
val x : int
member Encoding.Encode : stream:System.IO.Stream -> value:obj -> unit

Full name: Serialization.Binary.Encoding.Encode
field System.IO.Compression.CompressionMode.Compress = 1
val memory : System.IO.MemoryStream
Multiple items
type MemoryStream =
  inherit Stream
  new : unit -> MemoryStream + 6 overloads
  member CanRead : bool
  member CanSeek : bool
  member CanWrite : bool
  member Capacity : int with get, set
  member Flush : unit -> unit
  member GetBuffer : unit -> byte[]
  member Length : int64
  member Position : int64 with get, set
  member Read : buffer:byte[] * offset:int * count:int -> int
  ...

Full name: System.IO.MemoryStream

--------------------
System.IO.MemoryStream() : unit
System.IO.MemoryStream(capacity: int) : unit
System.IO.MemoryStream(buffer: byte []) : unit
System.IO.MemoryStream(buffer: byte [], writable: bool) : unit
System.IO.MemoryStream(buffer: byte [], index: int, count: int) : unit
System.IO.MemoryStream(buffer: byte [], index: int, count: int, writable: bool) : unit
System.IO.MemoryStream(buffer: byte [], index: int, count: int, writable: bool, publiclyVisible: bool) : unit
val actual : System.IO.Compression.GZipStream
val wM : System.IO.BinaryWriter
val wA : System.IO.BinaryWriter
val eS : System.Collections.Generic.Dictionary<string,int>
val encS : (string -> int)
val x : string
System.Collections.Generic.Dictionary.TryGetValue(key: string, value: byref<int>) : bool
val y : int
property System.Collections.Generic.Dictionary.Count: int
val v : string
property System.Collections.Generic.Dictionary.Keys: System.Collections.Generic.Dictionary`2.KeyCollection<string,int>
System.IO.MemoryStream.WriteTo(stream: System.IO.Stream) : unit
member Encoding.Type : System.Type

Full name: Serialization.Binary.Encoding.Type
Multiple items
type EncodingProvider =
  new : unit -> EncodingProvider
  member DeriveEncoding : t:Type -> Encoding
  static member Create : unit -> EncodingProvider

Full name: Serialization.Binary.EncodingProvider

--------------------
new : unit -> EncodingProvider
val Decoders : System.Collections.Generic.Dictionary<System.Type,Choice<((int -> string) -> System.IO.BinaryReader -> obj),System.Type>>
val Encoders : System.Collections.Generic.Dictionary<System.Type,Choice<((string -> int) -> System.IO.BinaryWriter -> obj -> unit),System.Type>>
val GetDecoder : (System.Type -> Choice<((int -> string) -> System.IO.BinaryReader -> obj),System.Type>)
val fst : tuple:('T1 * 'T2) -> 'T1

Full name: Microsoft.FSharp.Core.Operators.fst
val GetEncoder : (System.Type -> Choice<((string -> int) -> System.IO.BinaryWriter -> obj -> unit),System.Type>)
val snd : tuple:('T1 * 'T2) -> 'T2

Full name: Microsoft.FSharp.Core.Operators.snd
val this : EncodingProvider
member EncodingProvider.DeriveEncoding : t:System.Type -> Encoding

Full name: Serialization.Binary.EncodingProvider.DeriveEncoding
val d : ((int -> string) -> System.IO.BinaryReader -> obj)
static member EncodingProvider.Create : unit -> EncodingProvider

Full name: Serialization.Binary.EncodingProvider.Create
Raw view Test code New version

More information

Link:http://fssnip.net/6u
Posted:13 years ago
Author:Anton Tayanovskyy
Tags: serialization

This web site is created using F# and Suave web server. It is hosted on Azure and the source code is on GitHub. Contributions are welcome!

The first version of fssnip.net has been created by @tomaspetricek back in 2010. This web site is a new, open-source and contribution-friendly version.