FsPickler

Pickler

Namespace: MBrace.FsPickler.Combinators
Attributes:
[<RequireQualifiedAccess>]

Pickler combinator definitions

Nested types and modules

ModuleDescription
ProductInternals

Experimental support for n-way product types such as records. See product and field combinators.
SumInternals

Experimental support for n-way sum types such as unions. See sum.

Functions and values

Function or valueDescription
Pickler.alt tagReader ps
Signature: tagReader:('?123431 -> int) -> ps:Pickler<'?123431> list -> Pickler<'?123431>
Type parameters: '?123431

alt combinator: choose from list of pickler combinators using tag reader
Pickler.array(f)
Signature: f:Pickler<'T> -> Pickler<'T []>
Type parameters: 'T

array pickler combinator
Pickler.array2D(f)
Signature: f:Pickler<'T> -> Pickler<'T [,]>
Type parameters: 'T

array2D pickler combinator
Pickler.array3D(f)
Signature: f:Pickler<'T> -> Pickler<'T [,,]>
Type parameters: 'T

array3D pickler combinator
Pickler.array4D(f)
Signature: f:Pickler<'T> -> Pickler<'T [,,,]>
Type parameters: 'T

array4D pickler combinator
Pickler.auto
Signature: Pickler<'T>
Type parameters: 'T

auto generate a pickler
Pickler.bigint
Signature: Pickler<bigint>
Pickler.bool
Signature: Pickler<bool>
Pickler.byte
Signature: Pickler<byte>
Pickler.bytes
Signature: Pickler<byte []>
Pickler.case inj p
Signature: inj:'?123460 -> p:'?123461 -> Case<'?123460,'?123461>
Type parameters: '?123460, '?123461

See sum.
Pickler.char
Signature: Pickler<char>
Pickler.choice2 f g
Signature: f:Pickler<'?123397> -> g:Pickler<'?123398> -> Pickler<Choice<'?123397,'?123398>>
Type parameters: '?123397, '?123398

Choice<_,_> pickler combinator
Pickler.choice3 f g h
Signature: f:Pickler<'?123400> -> g:Pickler<'?123401> -> h:Pickler<'?123402> -> Pickler<Choice<'?123400,'?123401,'?123402>>
Type parameters: '?123400, '?123401, '?123402

Choice<_,_,_> pickler combinator
Pickler.choice4 f g h i
Signature: f:Pickler<'?123404> -> g:Pickler<'?123405> -> h:Pickler<'?123406> -> i:Pickler<'?123407> -> Pickler<Choice<'?123404,'?123405,'?123406,'?123407>>
Type parameters: '?123404, '?123405, '?123406, '?123407

Choice<_,_,_,_> pickler combinator
Pickler.dateTime
Signature: Pickler<DateTime>
Pickler.dateTimeOffset
Signature: Pickler<DateTimeOffset>
Pickler.decimal
Signature: Pickler<decimal>
Pickler.double
Signature: Pickler<double>
Pickler.field f p
Signature: f:('?123451 -> '?123452) -> p:Pickler<'?123452> -> Wrap<(Part<'?123451,'?123453,'?123454> -> Part<'?123451,('?123452 -> '?123453),('?123452 * '?123454)>)>
Type parameters: '?123451, '?123452, '?123453, '?123454

See product.
Pickler.fix(F)
Signature: F:(Pickler<'T> -> Pickler<'T>) -> Pickler<'T>
Type parameters: 'T

pickler fixpoint combinator
Pickler.fix2(F)
Signature: F:(Pickler<'T> -> Pickler<'S> -> Pickler<'T> * Pickler<'S>) -> Pickler<'T> * Pickler<'S>
Type parameters: 'T, 'S

pickler fixpoint combinator
Pickler.fix3(F)
Signature: F:(Pickler<'T> -> Pickler<'S> -> Pickler<'U> -> Pickler<'T> * Pickler<'S> * Pickler<'U>) -> Pickler<'T> * Pickler<'S> * Pickler<'U>
Type parameters: 'T, 'S, 'U

pickler fixpoint combinator
Pickler.float
Signature: Pickler<float>
Pickler.fromSerializationInfo ctor proj
Signature: ctor:(SerializationInfo -> 'T) -> proj:(SerializationInfo -> 'T -> unit) -> Pickler<'T>
Type parameters: 'T

Pickler combinator based on SerializationInfo
Pickler.func
Signature: Pickler<('T -> 'U)>
Type parameters: 'T, 'U

F# function combinator
Pickler.guid
Signature: Pickler<Guid>
Pickler.int
Signature: Pickler<int>
Pickler.int16
Signature: Pickler<int16>
Pickler.int64
Signature: Pickler<int64>
Pickler.list(f)
Signature: f:Pickler<'T> -> Pickler<'T list>
Type parameters: 'T

FSharp list pickler combinator
Pickler.map kp vp
Signature: kp:Pickler<'?123413> -> vp:Pickler<'?123414> -> Pickler<Map<'?123413,'?123414>>
Type parameters: '?123413, '?123414

FSharp map pickler combinator
Pickler.nullable(f)
Signature: f:Pickler<'T> -> Pickler<Nullable<'T>>
Type parameters: 'T

nullable pickler combinator
Pickler.obj
Signature: Pickler<obj>

the default System.Object pickler
Pickler.option(f)
Signature: f:Pickler<'T> -> Pickler<'T option>
Type parameters: 'T

option pickler combinator
Pickler.pair f g
Signature: f:Pickler<'?123381> -> g:Pickler<'?123382> -> Pickler<'?123381 * '?123382>
Type parameters: '?123381, '?123382

pair pickler combinator
Pickler.product(f)
Signature: f:'?123447 -> Wrap<(Part<'?123448,'?123447,'?123449> -> Pickler<'?123448>)>
Type parameters: '?123447, '?123448, '?123449

Starts defining a pickler for an n-ary product, such as record. Example:

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

The implementation is not currently efficient, though it may improve in the future.
Pickler.quad f g h i
Signature: f:Pickler<'?123388> -> g:Pickler<'?123389> -> h:Pickler<'?123390> -> i:Pickler<'?123391> -> Pickler<'?123388 * '?123389 * '?123390 * '?123391>
Type parameters: '?123388, '?123389, '?123390, '?123391

quad pickler combinator
Pickler.ref(f)
Signature: f:Pickler<'T> -> Pickler<Ref<'T>>
Type parameters: 'T

FSharp ref pickler combinator
Pickler.sbyte
Signature: Pickler<sbyte>
Pickler.seq(f)
Signature: f:Pickler<'?123426> -> Pickler<seq<'?123426>>
Type parameters: '?123426

sequence pickler combinator ; uses eager evaluation
Pickler.set(f)
Signature: f:Pickler<'T> -> Pickler<Set<'T>>
Type parameters: 'T

FSharp set pickler combinator
Pickler.single
Signature: Pickler<single>
Pickler.string
Signature: Pickler<string>
Pickler.sum(f)
Signature: f:('?123456 -> '?123457) -> Wrap<(Part<'?123456,'?123457,'?123458,'?123458> -> Pickler<'?123456>)>
Type parameters: '?123456, '?123457, '?123458

Starts defining a pickler for an n-ary sum type, such as a union type. For example:

type UnionT = | Case1 | Case2 of int | Case3 of string * int

let unionTPickler = 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)

Note that the implementation is not currently efficient, though it may improve in the future.
Pickler.timeSpan
Signature: Pickler<TimeSpan>
Pickler.triple f g h
Signature: f:Pickler<'?123384> -> g:Pickler<'?123385> -> h:Pickler<'?123386> -> Pickler<'?123384 * '?123385 * '?123386>
Type parameters: '?123384, '?123385, '?123386

triple pickler combinator
Pickler.uint16
Signature: Pickler<uint16>
Pickler.uint32
Signature: Pickler<uint32>
Pickler.uint64
Signature: Pickler<uint64>
Pickler.unit
Signature: Pickler<unit>
Pickler.variant(v)
Signature: v:'?123463 -> Case<(unit -> '?123463),Pickler<unit>>
Type parameters: '?123463

Useful for union cases without arguments.
Pickler.wrap recover convert p
Signature: recover:('?123428 -> '?123429) -> convert:('?123429 -> '?123428) -> p:Pickler<'?123428> -> Pickler<'?123429>
Type parameters: '?123428, '?123429

wrap combinator: defines picklers up to isomorphism
F# Project
Fork me on GitHub