TypeShape

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.Type

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.

Installing

To incorporate TypeShape in your project place the following line in your

paket.dependencies

github eiriktsarpalis/TypeShape:8.0 src/TypeShape/TypeShape.fs

paket.references

File: TypeShape.fs TypeShape

Example: Implementing a value printer

open System
open TypeShape.Core

let 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|])"

Records, Unions and POCOs

TypeShape can be used to define generic programs that access fields of arbitrary types: F# records, unions or POCOs. This is achieved using the

IShapeMember

fsharp
type IShapeMember =
    abstract Get : 'DeclaringType -> 'Field
    abstract Set : 'DeclaringType -> 'Field -> 'DeclaringType

Get

Set

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 }

    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.Name

    let 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.

Extensibility

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.

Additional examples

See the project samples folder for more implementations using TypeShape:

• Printer.fs Pretty printer generator for common F# types.
• Parser.fs Parser generator for common F# types using FParsec.
• Equality-Comparer.fs Equality comparer generator for common F# types.
• hashcode-staged.fs Staged generic hashcode generator.
• Gmap There are set of

  gmap

  related functions within the

  TypeShape.Generic

  module in the Nuget package.

Using the Higher-Kinded Type API (Experimental)

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.HKT

type IMyTypesBuilder =
    inherit IBoolBuilder
    inherit IInt32Builder
    inherit IStringBuilder
inherit IFSharpOptionBuilder
inherit IFSharpListBuilder
inherit ITuple2Builder

The interface

MyTypeBuilder

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.*

FSharpOption

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.unpack

prettyPrint 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.

Projects using TypeShape

• FsPickler
• FSharp.AWS.DynamoDB
• Logary
• Equinox/FsCodec
• FsConfig

Related Work

• DataType Generic Programming in F#,
• Infers