Practical generic programming for F#
TypeShape is a small, extensible F# library for practical datatype-generic programming. Borrowing from ideas used in the FsPickler implementation, it uses a combination of reflection, active patterns and F# object expressions to minimize the amount of reflection required by the user in such applications.
TypeShape permits definition of programs that act on specific algebrae of types. The library uses reflection to derive the algebraic structure of a given
System.Typeinstance and then applies a variant of the visitor pattern to provide relevant type information per shape.
TypeShape can provide significant performance improvements compared to equivalent reflection-based approaches. See the performance page for more details and benchmarks.
Please see my article and slides for a more thorough introduction to the concept.
To incorporate TypeShape in your project place the following line in your
paket.dependenciesfile:
github eiriktsarpalis/TypeShape:9.0 src/TypeShape/TypeShape.fsand in
paket.references:
File: TypeShape.fs TypeShapeTypeShape is also available on
open System open TypeShape.Corelet rec mkPrinter () : 'T -> string = let wrap(p : 'a -> string) = unbox string> p match shapeof with | Shape.Unit -> wrap(fun () -> "()") | Shape.Bool -> wrap(sprintf "%b") | Shape.Byte -> wrap(fun (b:byte) -> sprintf "%duy" b) | Shape.Int32 -> wrap(sprintf "%d") | Shape.Int64 -> wrap(fun (b:int64) -> sprintf "%dL" b) | Shape.String -> wrap(sprintf ""%s"") | Shape.FSharpOption s -> s.Element.Accept { new ITypeVisitor string> with member _.Visit () = let tp = mkPrinter() wrap(function None -> "None" | Some t -> sprintf "Some (%s)" (tp t)) }
| Shape.FSharpList s -> s.Element.Accept { new ITypeVisitor string> with member _.Visit () = let tp = mkPrinter() wrap(fun ts -> ts |> List.map tp |> String.concat "; " |> sprintf "[%s]") } | Shape.Array s when s.Rank = 1 -> s.Element.Accept { new ITypeVisitor string> with member _.Visit () = let tp = mkPrinter () wrap(fun ts -> ts |> Array.map tp |> String.concat "; " |> sprintf "[|%s|]") } | Shape.Tuple (:? ShapeTuple as shape) -> let mkElemPrinter (shape : IShapeMember) = shape.Accept { new IMemberVisitor string> with member _.Visit (shape : ShapeMember) = let fieldPrinter = mkPrinter() fieldPrinter << shape.Get } let elemPrinters : ('T -> string) [] = shape.Elements |> Array.map mkElemPrinter fun (r:'T) -> elemPrinters |> Seq.map (fun ep -> ep r) |> String.concat ", " |> sprintf "(%s)" | Shape.FSharpSet s -> s.Accept { new IFSharpSetVisitor string> with member _.Visit () = let tp = mkPrinter() wrap(fun (s:Set) -> s |> Seq.map tp |> String.concat "; " |> sprintf "set [%s]") } | _ -> failwithf "unsupported type '%O'" typeof
let p = mkPrinter () p (42, Some false, ["string"], [|1;2;3;4;5|]) // val it : string = "(42, Some (false), ["string"], [|1; 2; 3; 4; 5|])"
TypeShape can be used to define generic programs that access fields of arbitrary types: F# records, unions or POCOs. This is achieved using the
IShapeMemberabstraction:
fsharp type IShapeMember = abstract Get : 'DeclaringType -> 'Field abstract Set : 'DeclaringType -> 'Field -> 'DeclaringTypeAn F# record then is just a list of member shapes, a union is a list of lists of member shapes. Member shapes can optionally be configured to generate code at runtime for more performant
Getand
Setoperations. Member shapes come with quoted versions of the API for staged generic programming applications.
To make our pretty printer support these types, we first provide a pretty printer for members:
fsharp let mkMemberPrinter (shape : IShapeMember) = shape.Accept { new IMemberVisitor string> with member _.Visit (shape : ShapeMember) = let fieldPrinter = mkPrinter() fieldPrinter << shape.Get }Then for F# records: ```fsharp match shapeof<'T> with | Shape.FSharpRecord (:? ShapeFSharpRecord<'T> as shape) -> let fieldPrinters : (string * ('T -> string)) [] = s.Fields |> Array.map (fun f -> f.Label, mkMemberPrinter f)
fun (r:'T) -> fieldPrinters |> Seq.map (fun (label, fp) -> sprintf "%s = %s" label (fp r)) |> String.concat "; " |> sprintf "{ %s }"
Similarly, we could also add support for arbitrary F# unions: ```fsharp match shapeof with | Shape.FSharpUnion (:? ShapeFSharpUnion as shape) -> let cases : ShapeFSharpUnionCase [] = shape.UnionCases // all union cases let mkUnionCasePrinter (case : ShapeFSharpUnionCase) = let fieldPrinters = case.Fields |> Array.map mkMemberPrinter fun (u:'T) -> fieldPrinters |> Seq.map (fun fp -> fp u) |> String.concat ", " |> sprintf "%s(%s)" case.CaseInfo.Namelet casePrinters = cases |> Array.map mkUnionCasePrinter // generate printers for all union cases fun (u:'T) -> let tag : int = shape.GetTag u // get the underlying tag for the union case casePrinters.[tag] u
Similar active patterns exist for classes with settable properties and general POCOs.
TypeShape can be extended to incorporate new active patterns supporting arbitrary shapes. Here's an example illustrating how TypeShape can be extended to support ISerializable shapes.
See the project samples folder for more implementations using TypeShape:
gmaprelated functions within the
TypeShape.Genericmodule in the Nuget package.
As of TypeShape 8 it is possible to avail of an experimental higher-kinded type flavour of the api, which can be used to author fully type-safe programs for most common applications. Please see my original article on the subject for background and motivation.
To use the new approach, we first need to specify which types we would like our generic program to support:
open TypeShape.HKTtype IMyTypesBuilder = inherit IBoolBuilder inherit IInt32Builder inherit IStringBuilder
inherit IFSharpOptionBuilder inherit IFSharpListBuilder inherit ITuple2Builder
The interface
MyTypeBuilderdenotes a "higher-kinded" generic program builder which supports combinations of boolean, integer, string, optional, list and pair types.
Next, we need to define how interface implementations are to be folded:
let mkGenericProgram (builder : IMyTypesBuilder) = { new IGenericProgram with member this.Resolve () : App = match shapeof with | Fold.Bool builder r -> r | Fold.Int32 builder r -> r | Fold.String builder r -> r | Fold.Tuple2 builder this r -> r | Fold.FSharpOption builder this r -> r | Fold.FSharpList builder this r -> r | _ -> failwithf "I do not know how to fold type %O" typeof }
This piece of boilerplate composes built-in
Fold.*active patterns, which contain folding logic for the individual builders inherited by the interface. Note that the order of composition can be significant (e.g. folding with
FSharpOptionbefore
FSharpUnion).
Let's now provide a pretty-printer implementation for our interface:
// Higher-Kinded encoding type PrettyPrinter = static member Assign(_ : App, _ : 'a -> string) = ()// Implementing the interface let prettyPrinterBuilder = { new IMyTypesBuilder with member _.Bool () = HKT.pack (function false -> "false" | true -> "true") member _.Int32 () = HKT.pack (sprintf "%d") member _.String () = HKT.pack (sprintf ""%s"")
member _.Option (HKT.Unpack elemPrinter) = HKT.pack(function None -> "None" | Some a -> sprintf "Some(%s)" (elemPrinter a)) member _.Tuple2 (HKT.Unpack left) (HKT.Unpack right) = HKT.pack(fun (a,b) -> sprintf "(%s, %s)" (left a) (right b)) member _.List (HKT.Unpack elemPrinter) = HKT.pack(Seq.map elemPrinter >> String.concat "; " >> sprintf "[%s]") }
Putting it all together gives us a working pretty-printer:
let prettyPrint : 't -> string = (mkGenericProgram prettyPrinterBuilder).Resolve () |> HKT.unpackprettyPrint 42 prettyPrint (Some false) prettyPrint (Some "test", [Some 42; None; Some -1])
Please check the samples/HKT folder for real-world examples of the above.