Express HttpClient as extension method (#140)

* Bump fsharp-analyzers from 0.25.0 to 0.26.0

Bumps [fsharp-analyzers](https://github.com/ionide/FSharp.Analyzers.SDK) from 0.25.0 to 0.26.0.
- [Release notes](https://github.com/ionide/FSharp.Analyzers.SDK/releases)
- [Changelog](https://github.com/ionide/FSharp.Analyzers.SDK/blob/main/CHANGELOG.md)
- [Commits](https://github.com/ionide/FSharp.Analyzers.SDK/compare/v0.25.0...v0.26.0)

---
updated-dependencies:
- dependency-name: fsharp-analyzers
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

---------

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Smaug123 <3138005+Smaug123@users.noreply.github.com>

.config/dotnet-tools.json

@@ -3,16 +3,16 @@
   "isRoot": true,
   "tools": {
     "fantomas": {
-      "version": "6.3.0-alpha-007",
+      "version": "6.3.4",
       "commands": [
         "fantomas"
       ]
     },
     "fsharp-analyzers": {
-      "version": "0.24.0",
+      "version": "0.26.0",
       "commands": [
         "fsharp-analyzers"
       ]
     }
   }
-}
+}

.editorconfig

@@ -2,7 +2,6 @@ root=true
 
 [*]
 charset=utf-8
-end_of_line=crlf
 trim_trailing_whitespace=true
 insert_final_newline=true
 indent_style=space

.gitattributes

@@ -1,5 +1,5 @@
-* eol=auto
-*.sh text eol=lf
-*.yaml text
-*.nix text eol=lf
-hooks/pre-push text eol=lf
+* eol=auto
+*.sh text eol=lf
+*.yaml text
+*.nix text eol=lf
+hooks/pre-push text eol=lf

.github/workflows/dotnet.yaml

@@ -28,7 +28,7 @@ jobs:
       with:
         fetch-depth: 0 # so that NerdBank.GitVersioning has access to history
     - name: Install Nix
-      uses: cachix/install-nix-action@v25
+      uses: cachix/install-nix-action@V27
       with:
         extra_nix_config: |
           access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -49,7 +49,7 @@ jobs:
         with:
           fetch-depth: 0 # so that NerdBank.GitVersioning has access to history
       - name: Install Nix
-        uses: cachix/install-nix-action@v25
+        uses: cachix/install-nix-action@V27
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -58,7 +58,7 @@ jobs:
       - name: Build project
         run: nix develop --command dotnet build ./WoofWare.Myriad.Plugins/WoofWare.Myriad.Plugins.fsproj
       - name: Run analyzers
-        run: nix run .#fsharp-analyzers -- --project ./WoofWare.Myriad.Plugins/WoofWare.Myriad.Plugins.fsproj --analyzers-path ./.analyzerpackages/g-research.fsharp.analyzers/0.8.0/ --verbosity detailed --report ./analysis.sarif --treat-as-error GRA-STRING-001 GRA-STRING-002 GRA-STRING-003 GRA-UNIONCASE-001 GRA-INTERPOLATED-001 GRA-TYPE-ANNOTATE-001 GRA-VIRTUALCALL-001 GRA-IMMUTABLECOLLECTIONEQUALITY-001 GRA-JSONOPTS-001 GRA-LOGARGFUNCFULLAPP-001 GRA-DISPBEFOREASYNC-001 --exclude-analyzers PartialAppAnalyzer
+        run: nix run .#fsharp-analyzers -- --project ./WoofWare.Myriad.Plugins/WoofWare.Myriad.Plugins.fsproj --analyzers-path ./.analyzerpackages/g-research.fsharp.analyzers/*/ --verbosity detailed --report ./analysis.sarif --treat-as-error GRA-STRING-001 GRA-STRING-002 GRA-STRING-003 GRA-UNIONCASE-001 GRA-INTERPOLATED-001 GRA-TYPE-ANNOTATE-001 GRA-VIRTUALCALL-001 GRA-IMMUTABLECOLLECTIONEQUALITY-001 GRA-JSONOPTS-001 GRA-LOGARGFUNCFULLAPP-001 GRA-DISPBEFOREASYNC-001 --exclude-analyzers PartialAppAnalyzer
 
   build-nix:
     runs-on: ubuntu-latest
@@ -66,7 +66,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Install Nix
-        uses: cachix/install-nix-action@v25
+        uses: cachix/install-nix-action@V27
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -79,7 +79,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Install Nix
-        uses: cachix/install-nix-action@v25
+        uses: cachix/install-nix-action@V27
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -92,7 +92,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Install Nix
-        uses: cachix/install-nix-action@v25
+        uses: cachix/install-nix-action@V27
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -105,7 +105,7 @@ jobs:
     steps:
       - uses: actions/checkout@master
       - name: Install Nix
-        uses: cachix/install-nix-action@v25
+        uses: cachix/install-nix-action@V27
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -118,7 +118,7 @@ jobs:
     steps:
       - uses: actions/checkout@master
       - name: Install Nix
-        uses: cachix/install-nix-action@v25
+        uses: cachix/install-nix-action@V27
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -132,7 +132,7 @@ jobs:
       with:
         fetch-depth: 0 # so that NerdBank.GitVersioning has access to history
     - name: Install Nix
-      uses: cachix/install-nix-action@v25
+      uses: cachix/install-nix-action@V27
       with:
         extra_nix_config: |
           access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -188,7 +188,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Install Nix
-        uses: cachix/install-nix-action@v25
+        uses: cachix/install-nix-action@V27
         with:
           extra_nix_config: |
             access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
@@ -206,3 +206,25 @@ jobs:
           path: packed-attribute
       - name: Publish to NuGet (attribute)
         run: nix develop --command dotnet nuget push "packed-attribute/WoofWare.Myriad.Plugins.Attributes.*.nupkg" --api-key ${{ secrets.NUGET_API_KEY }} --source https://api.nuget.org/v3/index.json --skip-duplicate
+
+  github-release-plugin:
+    runs-on: ubuntu-latest
+    if: ${{ !github.event.repository.fork && github.ref == 'refs/heads/main' }}
+    needs: [all-required-checks-complete]
+    environment: main-deploy
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+      - name: Download NuGet artifact (plugin)
+        uses: actions/download-artifact@v4
+        with:
+          name: nuget-package-plugin
+      - name: Download NuGet artifact (attribute)
+        uses: actions/download-artifact@v4
+        with:
+          name: nuget-package-attribute
+      - name: Tag and release plugin
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: sh .github/workflows/tag.sh

.github/workflows/tag.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+
+find . -maxdepth 1 -type f -name '*.nupkg' -exec sh -c 'tag=$(basename "$1" .nupkg); git tag "$tag"; git push origin "$tag"' shell {} \;
+
+export TAG
+TAG=$(find . -maxdepth 1 -type f -name 'WoofWare.Myriad.Plugins.*.nupkg' -exec sh -c 'basename "$1" .nupkg' shell {} \; | grep -v Attributes)
+
+case "$TAG" in
+  *"
+"*)
+    echo "Error: TAG contains a newline; multiple plugins found."
+    exit 1
+    ;;
+esac
+
+# target_commitish empty indicates the repo default branch
+curl -L -X POST -H "Accept: application/vnd.github+json" -H "Authorization: Bearer $GITHUB_TOKEN" -H "X-GitHub-Api-Version: 2022-11-28" https://api.github.com/repos/Smaug123/WoofWare.Myriad/releases -d '{"tag_name":"'"$TAG"'","target_commitish":"","name":"'"$TAG"'","draft":false,"prerelease":false,"generate_release_notes":false}'

CHANGELOG.md

@@ -1,6 +1,18 @@
 Notable changes are recorded here.
 
-# WoofWare.Myriad.Plugins 1.4 -> 2.0
+# WoofWare.Myriad.Plugins 2.1.20, WoofWare.Myriad.Plugins.Attributes 3.0.1
+
+We now bundle copies of the RestEase attributes in `WoofWare.Myriad.Plugins.Attributes`, in case you don't want to take a dependency on RestEase.
+
+# WoofWare.Myriad.Plugins 2.1.15
+
+The `GenerateMock` generator now permits a limited amount of inheritance in the record we're mocking out (specifically, `IDisposable`).
+
+# WoofWare.Myriad.Plugins 2.1.8
+
+No change to the packages, but this is when we started creating and tagging GitHub releases, which are a better source of truth than this file.
+
+# WoofWare.Myriad.Plugins 2.0
 
 This transition split the attributes (e.g. `[<JsonParseAttribute>]`) into their own assembly, WoofWare.Myriad.Plugins.Attributes.
 The new assembly has minimal dependencies, so you may safely use it from your own code.

ConsumePlugin/Catamorphism.fs

@@ -0,0 +1,22 @@
+namespace ConsumePlugin
+
+open WoofWare.Myriad.Plugins
+
+type Const<'a> =
+    | Verbatim of 'a
+    | String of string
+
+type PairOpKind =
+    | NormalSeq
+    | ThenDoSeq
+
+[<CreateCatamorphism "TreeCata">]
+type Tree<'a, 'b> =
+    | Const of Const<'a> * 'b
+    | Pair of Tree<'a, 'b> * Tree<'a, 'b> * PairOpKind
+    | Sequential of Tree<'a, 'b> list
+    | Builder of Tree<'a, 'b> * TreeBuilder<'b, 'a>
+
+and TreeBuilder<'b, 'a> =
+    | Child of TreeBuilder<'b, 'a>
+    | Parent of Tree<'a, 'b>

ConsumePlugin/ConsumePlugin.fsproj

@@ -39,6 +39,18 @@
     <Compile Include="GeneratedSerde.fs">
       <MyriadFile>SerializationAndDeserialization.fs</MyriadFile>
     </Compile>
+    <Compile Include="Catamorphism.fs" />
+    <Compile Include="GeneratedCatamorphism.fs">
+      <MyriadFile>Catamorphism.fs</MyriadFile>
+    </Compile>
+    <Compile Include="FSharpForFunAndProfitCata.fs" />
+    <Compile Include="GeneratedFileSystem.fs">
+      <MyriadFile>FSharpForFunAndProfitCata.fs</MyriadFile>
+    </Compile>
+    <Compile Include="List.fs" />
+    <Compile Include="ListCata.fs">
+      <MyriadFile>List.fs</MyriadFile>
+    </Compile>
   </ItemGroup>
 
   <ItemGroup>

ConsumePlugin/FSharpForFunAndProfitCata.fs

@@ -0,0 +1,52 @@
+namespace ConsumePlugin
+
+open WoofWare.Myriad.Plugins
+
+type File =
+    {
+        Name : string
+        FileSize : int
+    }
+
+type Directory =
+    {
+        Name : string
+        DirSize : int
+        Contents : FileSystemItem list
+    }
+
+and [<CreateCatamorphism "FileSystemCata">] FileSystemItem =
+    | Directory of Directory
+    | File of File
+
+type Book =
+    {
+        title : string
+        price : decimal
+    }
+
+type ChocolateType =
+    | Dark
+    | Milk
+    | SeventyPercent
+
+type Chocolate =
+    {
+        chocType : ChocolateType
+        price : decimal
+    }
+
+    override this.ToString () = this.chocType.ToString ()
+
+type WrappingPaperStyle =
+    | HappyBirthday
+    | HappyHolidays
+    | SolidColor
+
+[<CreateCatamorphism "GiftCata">]
+type Gift =
+    | Book of Book
+    | Chocolate of Chocolate
+    | Wrapped of Gift * WrappingPaperStyle
+    | Boxed of Gift
+    | WithACard of Gift * message : string

ConsumePlugin/GeneratedCatamorphism.fs

@@ -0,0 +1,138 @@
+//------------------------------------------------------------------------------
+//        This code was generated by myriad.
+//        Changes to this file will be lost when the code is regenerated.
+//------------------------------------------------------------------------------
+
+
+
+
+
+namespace ConsumePlugin
+
+open WoofWare.Myriad.Plugins
+
+/// Description of how to combine cases during a fold
+type TreeBuilderCataCase<'b, 'a, 'TreeBuilder, 'Tree> =
+    /// How to operate on the Child case
+    abstract Child : 'TreeBuilder -> 'TreeBuilder
+    /// How to operate on the Parent case
+    abstract Parent : 'Tree -> 'TreeBuilder
+
+/// Description of how to combine cases during a fold
+type TreeCataCase<'a, 'b, 'TreeBuilder, 'Tree> =
+    /// How to operate on the Const case
+    abstract Const : Const<'a> -> 'b -> 'Tree
+    /// How to operate on the Pair case
+    abstract Pair : 'Tree -> 'Tree -> PairOpKind -> 'Tree
+    /// How to operate on the Sequential case
+    abstract Sequential : 'Tree list -> 'Tree
+    /// How to operate on the Builder case
+    abstract Builder : 'Tree -> 'TreeBuilder -> 'Tree
+
+/// Specifies how to perform a fold (catamorphism) over the type Tree and its friends.
+type TreeCata<'b, 'a, 'TreeBuilder, 'Tree> =
+    {
+        /// How to perform a fold (catamorphism) over the type TreeBuilder
+        TreeBuilder : TreeBuilderCataCase<'b, 'a, 'TreeBuilder, 'Tree>
+        /// How to perform a fold (catamorphism) over the type Tree
+        Tree : TreeCataCase<'a, 'b, 'TreeBuilder, 'Tree>
+    }
+
+/// Methods to perform a catamorphism over the type Tree
+[<RequireQualifiedAccess>]
+module TreeCata =
+    [<RequireQualifiedAccess>]
+    type private Instruction<'b, 'a> =
+        | Process__TreeBuilder of TreeBuilder<'b, 'a>
+        | Process__Tree of Tree<'a, 'b>
+        | TreeBuilder_Child
+        | TreeBuilder_Parent
+        | Tree_Pair of PairOpKind
+        | Tree_Sequential of int
+        | Tree_Builder
+
+    let private loop (cata : TreeCata<'b, 'a, 'TreeBuilder, 'Tree>) (instructions : ResizeArray<Instruction<'b, 'a>>) =
+        let treeStack = ResizeArray<'Tree> ()
+        let treeBuilderStack = ResizeArray<'TreeBuilder> ()
+
+        while instructions.Count > 0 do
+            let currentInstruction = instructions.[instructions.Count - 1]
+            instructions.RemoveAt (instructions.Count - 1)
+
+            match currentInstruction with
+            | Instruction.Process__TreeBuilder x ->
+                match x with
+                | TreeBuilder.Child (arg0_0) ->
+                    instructions.Add Instruction.TreeBuilder_Child
+                    instructions.Add (Instruction.Process__TreeBuilder arg0_0)
+                | TreeBuilder.Parent (arg0_0) ->
+                    instructions.Add Instruction.TreeBuilder_Parent
+                    instructions.Add (Instruction.Process__Tree arg0_0)
+            | Instruction.Process__Tree x ->
+                match x with
+                | Tree.Const (arg0_0, arg1_0) -> cata.Tree.Const arg0_0 arg1_0 |> treeStack.Add
+                | Tree.Pair (arg0_0, arg1_0, arg2_0) ->
+                    instructions.Add (Instruction.Tree_Pair (arg2_0))
+                    instructions.Add (Instruction.Process__Tree arg0_0)
+                    instructions.Add (Instruction.Process__Tree arg1_0)
+                | Tree.Sequential (arg0_0) ->
+                    instructions.Add (Instruction.Tree_Sequential ((List.length arg0_0)))
+
+                    for elt in arg0_0 do
+                        instructions.Add (Instruction.Process__Tree elt)
+                | Tree.Builder (arg0_0, arg1_0) ->
+                    instructions.Add Instruction.Tree_Builder
+                    instructions.Add (Instruction.Process__Tree arg0_0)
+                    instructions.Add (Instruction.Process__TreeBuilder arg1_0)
+            | Instruction.TreeBuilder_Child ->
+                let arg0_0 = treeBuilderStack.[treeBuilderStack.Count - 1]
+                treeBuilderStack.RemoveAt (treeBuilderStack.Count - 1)
+                cata.TreeBuilder.Child arg0_0 |> treeBuilderStack.Add
+            | Instruction.TreeBuilder_Parent ->
+                let arg0_0 = treeStack.[treeStack.Count - 1]
+                treeStack.RemoveAt (treeStack.Count - 1)
+                cata.TreeBuilder.Parent arg0_0 |> treeBuilderStack.Add
+            | Instruction.Tree_Pair (arg2_0) ->
+                let arg0_0 = treeStack.[treeStack.Count - 1]
+                treeStack.RemoveAt (treeStack.Count - 1)
+                let arg1_0 = treeStack.[treeStack.Count - 1]
+                treeStack.RemoveAt (treeStack.Count - 1)
+                cata.Tree.Pair arg0_0 arg1_0 arg2_0 |> treeStack.Add
+            | Instruction.Tree_Sequential (arg0_0) ->
+                let arg0_0_len = arg0_0
+
+                let arg0_0 =
+                    seq {
+                        for i = treeStack.Count - 1 downto treeStack.Count - arg0_0 do
+                            yield treeStack.[i]
+                    }
+                    |> Seq.toList
+
+                treeStack.RemoveRange (treeStack.Count - arg0_0_len, arg0_0_len)
+                cata.Tree.Sequential arg0_0 |> treeStack.Add
+            | Instruction.Tree_Builder ->
+                let arg0_0 = treeStack.[treeStack.Count - 1]
+                treeStack.RemoveAt (treeStack.Count - 1)
+                let arg1_0 = treeBuilderStack.[treeBuilderStack.Count - 1]
+                treeBuilderStack.RemoveAt (treeBuilderStack.Count - 1)
+                cata.Tree.Builder arg0_0 arg1_0 |> treeStack.Add
+
+        treeBuilderStack, treeStack
+
+    /// Execute the catamorphism.
+    let runTreeBuilder
+        (cata : TreeCata<'b, 'a, 'TreeBuilderRet, 'TreeRet>)
+        (x : TreeBuilder<'b, 'a>)
+        : 'TreeBuilderRet
+        =
+        let instructions = ResizeArray ()
+        instructions.Add (Instruction.Process__TreeBuilder x)
+        let treeBuilderRetStack, treeRetStack = loop cata instructions
+        Seq.exactlyOne treeBuilderRetStack
+
+    /// Execute the catamorphism.
+    let runTree (cata : TreeCata<'b, 'a, 'TreeBuilderRet, 'TreeRet>) (x : Tree<'a, 'b>) : 'TreeRet =
+        let instructions = ResizeArray ()
+        instructions.Add (Instruction.Process__Tree x)
+        let treeBuilderRetStack, treeRetStack = loop cata instructions
+        Seq.exactlyOne treeRetStack

ConsumePlugin/GeneratedFileSystem.fs

@@ -0,0 +1,152 @@
+//------------------------------------------------------------------------------
+//        This code was generated by myriad.
+//        Changes to this file will be lost when the code is regenerated.
+//------------------------------------------------------------------------------
+
+
+
+
+
+namespace ConsumePlugin
+
+open WoofWare.Myriad.Plugins
+
+/// Description of how to combine cases during a fold
+type FileSystemItemCataCase<'FileSystemItem> =
+    /// How to operate on the Directory case
+    abstract Directory : name : string -> dirSize : int -> contents : 'FileSystemItem list -> 'FileSystemItem
+    /// How to operate on the File case
+    abstract File : File -> 'FileSystemItem
+
+/// Specifies how to perform a fold (catamorphism) over the type FileSystemItem and its friends.
+type FileSystemCata<'FileSystemItem> =
+    {
+        /// How to perform a fold (catamorphism) over the type FileSystemItem
+        FileSystemItem : FileSystemItemCataCase<'FileSystemItem>
+    }
+
+/// Methods to perform a catamorphism over the type FileSystemItem
+[<RequireQualifiedAccess>]
+module FileSystemItemCata =
+    [<RequireQualifiedAccess>]
+    type private Instruction =
+        | Process__FileSystemItem of FileSystemItem
+        | FileSystemItem_Directory of string * int * int
+
+    let private loop (cata : FileSystemCata<'FileSystemItem>) (instructions : ResizeArray<Instruction>) =
+        let fileSystemItemStack = ResizeArray<'FileSystemItem> ()
+
+        while instructions.Count > 0 do
+            let currentInstruction = instructions.[instructions.Count - 1]
+            instructions.RemoveAt (instructions.Count - 1)
+
+            match currentInstruction with
+            | Instruction.Process__FileSystemItem x ->
+                match x with
+                | FileSystemItem.Directory ({
+                                                Name = name
+                                                DirSize = dirSize
+                                                Contents = contents
+                                            }) ->
+                    instructions.Add (Instruction.FileSystemItem_Directory (name, dirSize, (List.length contents)))
+
+                    for elt in contents do
+                        instructions.Add (Instruction.Process__FileSystemItem elt)
+                | FileSystemItem.File (arg0_0) -> cata.FileSystemItem.File arg0_0 |> fileSystemItemStack.Add
+            | Instruction.FileSystemItem_Directory (name, dirSize, contents) ->
+                let contents_len = contents
+
+                let contents =
+                    seq {
+                        for i = fileSystemItemStack.Count - 1 downto fileSystemItemStack.Count - contents do
+                            yield fileSystemItemStack.[i]
+                    }
+                    |> Seq.toList
+
+                fileSystemItemStack.RemoveRange (fileSystemItemStack.Count - contents_len, contents_len)
+                cata.FileSystemItem.Directory name dirSize contents |> fileSystemItemStack.Add
+
+        fileSystemItemStack
+
+    /// Execute the catamorphism.
+    let runFileSystemItem (cata : FileSystemCata<'FileSystemItemRet>) (x : FileSystemItem) : 'FileSystemItemRet =
+        let instructions = ResizeArray ()
+        instructions.Add (Instruction.Process__FileSystemItem x)
+        let fileSystemItemRetStack = loop cata instructions
+        Seq.exactlyOne fileSystemItemRetStack
+namespace ConsumePlugin
+
+open WoofWare.Myriad.Plugins
+
+/// Description of how to combine cases during a fold
+type GiftCataCase<'Gift> =
+    /// How to operate on the Book case
+    abstract Book : Book -> 'Gift
+    /// How to operate on the Chocolate case
+    abstract Chocolate : Chocolate -> 'Gift
+    /// How to operate on the Wrapped case
+    abstract Wrapped : 'Gift -> WrappingPaperStyle -> 'Gift
+    /// How to operate on the Boxed case
+    abstract Boxed : 'Gift -> 'Gift
+    /// How to operate on the WithACard case
+    abstract WithACard : 'Gift -> message : string -> 'Gift
+
+/// Specifies how to perform a fold (catamorphism) over the type Gift and its friends.
+type GiftCata<'Gift> =
+    {
+        /// How to perform a fold (catamorphism) over the type Gift
+        Gift : GiftCataCase<'Gift>
+    }
+
+/// Methods to perform a catamorphism over the type Gift
+[<RequireQualifiedAccess>]
+module GiftCata =
+    [<RequireQualifiedAccess>]
+    type private Instruction =
+        | Process__Gift of Gift
+        | Gift_Wrapped of WrappingPaperStyle
+        | Gift_Boxed
+        | Gift_WithACard of string
+
+    let private loop (cata : GiftCata<'Gift>) (instructions : ResizeArray<Instruction>) =
+        let giftStack = ResizeArray<'Gift> ()
+
+        while instructions.Count > 0 do
+            let currentInstruction = instructions.[instructions.Count - 1]
+            instructions.RemoveAt (instructions.Count - 1)
+
+            match currentInstruction with
+            | Instruction.Process__Gift x ->
+                match x with
+                | Gift.Book (arg0_0) -> cata.Gift.Book arg0_0 |> giftStack.Add
+                | Gift.Chocolate (arg0_0) -> cata.Gift.Chocolate arg0_0 |> giftStack.Add
+                | Gift.Wrapped (arg0_0, arg1_0) ->
+                    instructions.Add (Instruction.Gift_Wrapped (arg1_0))
+                    instructions.Add (Instruction.Process__Gift arg0_0)
+                | Gift.Boxed (arg0_0) ->
+                    instructions.Add Instruction.Gift_Boxed
+                    instructions.Add (Instruction.Process__Gift arg0_0)
+                | Gift.WithACard (arg0_0, message) ->
+                    instructions.Add (Instruction.Gift_WithACard (message))
+                    instructions.Add (Instruction.Process__Gift arg0_0)
+            | Instruction.Gift_Wrapped (arg1_0) ->
+                let arg0_0 = giftStack.[giftStack.Count - 1]
+                giftStack.RemoveAt (giftStack.Count - 1)
+                cata.Gift.Wrapped arg0_0 arg1_0 |> giftStack.Add
+            | Instruction.Gift_Boxed ->
+                let arg0_0 = giftStack.[giftStack.Count - 1]
+                giftStack.RemoveAt (giftStack.Count - 1)
+                cata.Gift.Boxed arg0_0 |> giftStack.Add
+            | Instruction.Gift_WithACard (message) ->
+                let arg0_0 = giftStack.[giftStack.Count - 1]
+                giftStack.RemoveAt (giftStack.Count - 1)
+                cata.Gift.WithACard arg0_0 message |> giftStack.Add
+
+        giftStack
+
+    /// Execute the catamorphism.
+    let runGift (cata : GiftCata<'GiftRet>) (x : Gift) : 'GiftRet =
+        let instructions = ResizeArray ()
+        instructions.Add (Instruction.Process__Gift x)
+        let giftRetStack = loop cata instructions
+        Seq.exactlyOne giftRetStack

ConsumePlugin/GeneratedJson.fs

@@ -129,24 +129,230 @@ module ToGetExtensionMethodJsonParseExtension =
 
         /// Parse from a JSON node.
         static member jsonParse (node : System.Text.Json.Nodes.JsonNode) : ToGetExtensionMethod =
-            let Sailor =
-                (match node.["sailor"] with
+            let Whiskey = System.Numerics.BigInteger.Parse (node.["whiskey"].ToJsonString ())
+
+            let Victor =
+                (match node.["victor"] with
                  | null ->
                      raise (
                          System.Collections.Generic.KeyNotFoundException (
-                             sprintf "Required key '%s' not found on JSON object" ("sailor")
+                             sprintf "Required key '%s' not found on JSON object" ("victor")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Char> ()
+
+            let Uniform =
+                (match node.["uniform"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("uniform")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Decimal> ()
+
+            let Tango =
+                (match node.["tango"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("tango")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.SByte> ()
+
+            let Quebec =
+                (match node.["quebec"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("quebec")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Byte> ()
+
+            let Papa =
+                (match node.["papa"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("papa")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Byte> ()
+
+            let Oscar =
+                (match node.["oscar"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("oscar")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.SByte> ()
+
+            let November =
+                (match node.["november"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("november")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.UInt16> ()
+
+            let Mike =
+                (match node.["mike"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("mike")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Int16> ()
+
+            let Lima =
+                (match node.["lima"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("lima")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.UInt32> ()
+
+            let Kilo =
+                (match node.["kilo"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("kilo")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Int32> ()
+
+            let Juliette =
+                (match node.["juliette"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("juliette")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.UInt32> ()
+
+            let India =
+                (match node.["india"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("india")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<int> ()
+
+            let Hotel =
+                (match node.["hotel"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("hotel")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.UInt64> ()
+
+            let Golf =
+                (match node.["golf"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("golf")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Int64> ()
+
+            let Foxtrot =
+                (match node.["foxtrot"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("foxtrot")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Double> ()
+
+            let Echo =
+                (match node.["echo"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("echo")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Single> ()
+
+            let Delta =
+                (match node.["delta"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("delta")
+                         )
+                     )
+                 | v -> v)
+                    .AsValue()
+                    .GetValue<System.Single> ()
+
+            let Charlie =
+                (match node.["charlie"] with
+                 | null ->
+                     raise (
+                         System.Collections.Generic.KeyNotFoundException (
+                             sprintf "Required key '%s' not found on JSON object" ("charlie")
                          )
                      )
                  | v -> v)
                     .AsValue()
                     .GetValue<float> ()
 
-            let Soldier =
-                (match node.["soldier"] with
+            let Bravo =
+                (match node.["bravo"] with
                  | null ->
                      raise (
                          System.Collections.Generic.KeyNotFoundException (
-                             sprintf "Required key '%s' not found on JSON object" ("soldier")
+                             sprintf "Required key '%s' not found on JSON object" ("bravo")
                          )
                      )
                  | v -> v)
@@ -154,24 +360,12 @@ module ToGetExtensionMethodJsonParseExtension =
                     .GetValue<string> ()
                 |> System.Uri
 
-            let Tailor =
-                (match node.["tailor"] with
+            let Alpha =
+                (match node.["alpha"] with
                  | null ->
                      raise (
                          System.Collections.Generic.KeyNotFoundException (
-                             sprintf "Required key '%s' not found on JSON object" ("tailor")
-                         )
-                     )
-                 | v -> v)
-                    .AsValue()
-                    .GetValue<int> ()
-
-            let Tinker =
-                (match node.["tinker"] with
-                 | null ->
-                     raise (
-                         System.Collections.Generic.KeyNotFoundException (
-                             sprintf "Required key '%s' not found on JSON object" ("tinker")
+                             sprintf "Required key '%s' not found on JSON object" ("alpha")
                          )
                      )
                  | v -> v)
@@ -179,8 +373,25 @@ module ToGetExtensionMethodJsonParseExtension =
                     .GetValue<string> ()
 
             {
-                Tinker = Tinker
-                Tailor = Tailor
-                Soldier = Soldier
-                Sailor = Sailor
+                Alpha = Alpha
+                Bravo = Bravo
+                Charlie = Charlie
+                Delta = Delta
+                Echo = Echo
+                Foxtrot = Foxtrot
+                Golf = Golf
+                Hotel = Hotel
+                India = India
+                Juliette = Juliette
+                Kilo = Kilo
+                Lima = Lima
+                Mike = Mike
+                November = November
+                Oscar = Oscar
+                Papa = Papa
+                Quebec = Quebec
+                Tango = Tango
+                Uniform = Uniform
+                Victor = Victor
+                Whiskey = Whiskey
             }

ConsumePlugin/GeneratedMock.fs

@@ -5,6 +5,7 @@
 
 namespace SomeNamespace
 
+open System
 open WoofWare.Myriad.Plugins
 
 /// Mock record type for an interface
@@ -25,10 +26,11 @@ type internal PublicTypeMock =
 
     interface IPublicType with
         member this.Mem1 (arg_0_0, arg_0_1) = this.Mem1 (arg_0_0, arg_0_1)
-        member this.Mem2 (arg_0_0) = this.Mem2 (arg_0_0)
+        member this.Mem2 arg_0_0 = this.Mem2 (arg_0_0)
         member this.Mem3 (arg_0_0, arg_0_1) = this.Mem3 (arg_0_0, arg_0_1)
 namespace SomeNamespace
 
+open System
 open WoofWare.Myriad.Plugins
 
 /// Mock record type for an interface
@@ -49,10 +51,11 @@ type public PublicTypeInternalFalseMock =
 
     interface IPublicTypeInternalFalse with
         member this.Mem1 (arg_0_0, arg_0_1) = this.Mem1 (arg_0_0, arg_0_1)
-        member this.Mem2 (arg_0_0) = this.Mem2 (arg_0_0)
+        member this.Mem2 arg_0_0 = this.Mem2 (arg_0_0)
         member this.Mem3 (arg_0_0, arg_0_1) = this.Mem3 (arg_0_0, arg_0_1)
 namespace SomeNamespace
 
+open System
 open WoofWare.Myriad.Plugins
 
 /// Mock record type for an interface
@@ -71,9 +74,10 @@ type internal InternalTypeMock =
 
     interface InternalType with
         member this.Mem1 (arg_0_0, arg_0_1) = this.Mem1 (arg_0_0, arg_0_1)
-        member this.Mem2 (arg_0_0) = this.Mem2 (arg_0_0)
+        member this.Mem2 arg_0_0 = this.Mem2 (arg_0_0)
 namespace SomeNamespace
 
+open System
 open WoofWare.Myriad.Plugins
 
 /// Mock record type for an interface
@@ -92,9 +96,10 @@ type private PrivateTypeMock =
 
     interface PrivateType with
         member this.Mem1 (arg_0_0, arg_0_1) = this.Mem1 (arg_0_0, arg_0_1)
-        member this.Mem2 (arg_0_0) = this.Mem2 (arg_0_0)
+        member this.Mem2 arg_0_0 = this.Mem2 (arg_0_0)
 namespace SomeNamespace
 
+open System
 open WoofWare.Myriad.Plugins
 
 /// Mock record type for an interface
@@ -113,9 +118,10 @@ type private PrivateTypeInternalFalseMock =
 
     interface PrivateTypeInternalFalse with
         member this.Mem1 (arg_0_0, arg_0_1) = this.Mem1 (arg_0_0, arg_0_1)
-        member this.Mem2 (arg_0_0) = this.Mem2 (arg_0_0)
+        member this.Mem2 arg_0_0 = this.Mem2 (arg_0_0)
 namespace SomeNamespace
 
+open System
 open WoofWare.Myriad.Plugins
 
 /// Mock record type for an interface
@@ -131,9 +137,10 @@ type internal VeryPublicTypeMock<'a, 'b> =
         }
 
     interface VeryPublicType<'a, 'b> with
-        member this.Mem1 (arg_0_0) = this.Mem1 (arg_0_0)
+        member this.Mem1 arg_0_0 = this.Mem1 (arg_0_0)
 namespace SomeNamespace
 
+open System
 open WoofWare.Myriad.Plugins
 
 /// Mock record type for an interface
@@ -159,9 +166,9 @@ type internal CurriedMock<'a> =
         }
 
     interface Curried<'a> with
-        member this.Mem1 (arg_0_0) (arg_1_0) = this.Mem1 (arg_0_0) (arg_1_0)
-        member this.Mem2 (arg_0_0, arg_0_1) (arg_1_0) = this.Mem2 (arg_0_0, arg_0_1) (arg_1_0)
-        member this.Mem3 ((arg_0_0, arg_0_1)) (arg_1_0) = this.Mem3 (arg_0_0, arg_0_1) (arg_1_0)
+        member this.Mem1 arg_0_0 arg_1_0 = this.Mem1 (arg_0_0) (arg_1_0)
+        member this.Mem2 (arg_0_0, arg_0_1) arg_1_0 = this.Mem2 (arg_0_0, arg_0_1) (arg_1_0)
+        member this.Mem3 ((arg_0_0, arg_0_1)) arg_1_0 = this.Mem3 (arg_0_0, arg_0_1) (arg_1_0)
 
         member this.Mem4 ((arg_0_0, arg_0_1)) ((arg_1_0, arg_1_1)) =
             this.Mem4 (arg_0_0, arg_0_1) (arg_1_0, arg_1_1)
@@ -171,3 +178,31 @@ type internal CurriedMock<'a> =
 
         member this.Mem6 (arg_0_0, arg_0_1) (arg_1_0, arg_1_1) =
             this.Mem6 (arg_0_0, arg_0_1) (arg_1_0, arg_1_1)
+namespace SomeNamespace
+
+open System
+open WoofWare.Myriad.Plugins
+
+/// Mock record type for an interface
+type internal TypeWithInterfaceMock =
+    {
+        /// Implementation of IDisposable.Dispose
+        Dispose : unit -> unit
+        Mem1 : string option -> string[] Async
+        Mem2 : unit -> string[] Async
+    }
+
+    /// An implementation where every method throws.
+    static member Empty : TypeWithInterfaceMock =
+        {
+            Dispose = (fun _ -> ())
+            Mem1 = (fun x -> raise (System.NotImplementedException "Unimplemented mock function"))
+            Mem2 = (fun x -> raise (System.NotImplementedException "Unimplemented mock function"))
+        }
+
+    interface TypeWithInterface with
+        member this.Mem1 arg_0_0 = this.Mem1 (arg_0_0)
+        member this.Mem2 () = this.Mem2 (())
+
+    interface System.IDisposable with
+        member this.Dispose () : unit = this.Dispose ()

ConsumePlugin/GeneratedRestClient.fs

@@ -87,6 +87,40 @@ module PureGymApi =
                 }
                 |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
 
+            member _.GetGymAttendance' (gymId : int, ct : CancellationToken option) =
+                async {
+                    let! ct = Async.CancellationToken
+
+                    let uri =
+                        System.Uri (
+                            (match client.BaseAddress with
+                             | null -> System.Uri "https://whatnot.com"
+                             | v -> v),
+                            System.Uri (
+                                "v1/gyms/{gym_id}/attendance"
+                                    .Replace ("{gym_id}", gymId.ToString () |> System.Web.HttpUtility.UrlEncode),
+                                System.UriKind.Relative
+                            )
+                        )
+
+                    let httpMessage =
+                        new System.Net.Http.HttpRequestMessage (
+                            Method = System.Net.Http.HttpMethod.Get,
+                            RequestUri = uri
+                        )
+
+                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
+                    let response = response.EnsureSuccessStatusCode ()
+                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
+
+                    let! jsonNode =
+                        System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
+                        |> Async.AwaitTask
+
+                    return GymAttendance.jsonParse jsonNode
+                }
+                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
+
             member _.GetMember (ct : CancellationToken option) =
                 async {
                     let! ct = Async.CancellationToken
@@ -288,7 +322,52 @@ module PureGymApi =
                              | v -> v),
                             System.Uri (
                                 ("/v2/gymSessions/member"
-                                 + "?fromDate="
+                                 + (if "/v2/gymSessions/member".IndexOf (char 63) >= 0 then
+                                        "&"
+                                    else
+                                        "?")
+                                 + "fromDate="
+                                 + ((fromDate.ToString "yyyy-MM-dd") |> System.Web.HttpUtility.UrlEncode)
+                                 + "&toDate="
+                                 + ((toDate.ToString "yyyy-MM-dd") |> System.Web.HttpUtility.UrlEncode)),
+                                System.UriKind.Relative
+                            )
+                        )
+
+                    let httpMessage =
+                        new System.Net.Http.HttpRequestMessage (
+                            Method = System.Net.Http.HttpMethod.Get,
+                            RequestUri = uri
+                        )
+
+                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
+                    let response = response.EnsureSuccessStatusCode ()
+                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
+
+                    let! jsonNode =
+                        System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
+                        |> Async.AwaitTask
+
+                    return Sessions.jsonParse jsonNode
+                }
+                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
+
+            member _.GetSessionsWithQuery (fromDate : DateOnly, toDate : DateOnly, ct : CancellationToken option) =
+                async {
+                    let! ct = Async.CancellationToken
+
+                    let uri =
+                        System.Uri (
+                            (match client.BaseAddress with
+                             | null -> System.Uri "https://whatnot.com"
+                             | v -> v),
+                            System.Uri (
+                                ("/v2/gymSessions/member?foo=1"
+                                 + (if "/v2/gymSessions/member?foo=1".IndexOf (char 63) >= 0 then
+                                        "&"
+                                    else
+                                        "?")
+                                 + "fromDate="
                                  + ((fromDate.ToString "yyyy-MM-dd") |> System.Web.HttpUtility.UrlEncode)
                                  + "&toDate="
                                  + ((toDate.ToString "yyyy-MM-dd") |> System.Web.HttpUtility.UrlEncode)),
@@ -1140,6 +1219,69 @@ module ApiWithHeaders =
             member _.SomeHeader : string = someHeader ()
             member _.SomeOtherHeader : int = someOtherHeader ()
 
+            member this.GetPathParam (parameter : string, ct : CancellationToken option) =
+                async {
+                    let! ct = Async.CancellationToken
+
+                    let uri =
+                        System.Uri (
+                            (match client.BaseAddress with
+                             | null ->
+                                 raise (
+                                     System.ArgumentNullException (
+                                         nameof (client.BaseAddress),
+                                         "No base address was supplied on the type, and no BaseAddress was on the HttpClient."
+                                     )
+                                 )
+                             | v -> v),
+                            System.Uri (
+                                "endpoint/{param}"
+                                    .Replace ("{param}", parameter.ToString () |> System.Web.HttpUtility.UrlEncode),
+                                System.UriKind.Relative
+                            )
+                        )
+
+                    let httpMessage =
+                        new System.Net.Http.HttpRequestMessage (
+                            Method = System.Net.Http.HttpMethod.Get,
+                            RequestUri = uri
+                        )
+
+                    do httpMessage.Headers.Add ("X-Foo", this.SomeHeader.ToString ())
+                    do httpMessage.Headers.Add ("Authorization", this.SomeOtherHeader.ToString ())
+                    do httpMessage.Headers.Add ("Header-Name", "Header-Value")
+                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
+                    let response = response.EnsureSuccessStatusCode ()
+                    let! responseString = response.Content.ReadAsStringAsync ct |> Async.AwaitTask
+                    return responseString
+                }
+                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
+        }
+namespace PureGym
+
+open System
+open System.Threading
+open System.Threading.Tasks
+open System.IO
+open System.Net
+open System.Net.Http
+open RestEase
+
+/// Module for constructing a REST client.
+[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
+[<RequireQualifiedAccess>]
+module ApiWithHeaders2 =
+    /// Create a REST client. The input functions will be re-evaluated on every HTTP request to obtain the required values for the corresponding header properties.
+    let make
+        (someHeader : unit -> string)
+        (someOtherHeader : unit -> int)
+        (client : System.Net.Http.HttpClient)
+        : IApiWithHeaders2
+        =
+        { new IApiWithHeaders2 with
+            member _.SomeHeader : string = someHeader ()
+            member _.SomeOtherHeader : int = someOtherHeader ()
+
             member this.GetPathParam (parameter : string, ct : CancellationToken option) =
                 async {
                     let! ct = Async.CancellationToken

ConsumePlugin/GeneratedSerde.fs

@@ -210,7 +210,7 @@ module InnerTypeWithBothJsonParseExtension =
 
                     let value =
                         (kvp.Value).AsArray ()
-                        |> Seq.map (fun elt -> elt.AsValue().GetValue<char> ())
+                        |> Seq.map (fun elt -> elt.AsValue().GetValue<System.Char> ())
                         |> List.ofSeq
 
                     key, value

ConsumePlugin/GeneratedVault.fs

@@ -543,3 +543,201 @@ module VaultClient =
                 }
                 |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
         }
+namespace ConsumePlugin
+
+open System
+open System.Collections.Generic
+open System.Text.Json.Serialization
+open System.Threading
+open System.Threading.Tasks
+open RestEase
+
+/// Module for constructing a REST client.
+[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
+[<RequireQualifiedAccess>]
+module VaultClientNonExtensionMethod =
+    /// Create a REST client.
+    let make (client : System.Net.Http.HttpClient) : IVaultClientNonExtensionMethod =
+        { new IVaultClientNonExtensionMethod with
+            member _.GetSecret
+                (jwt : JwtVaultResponse, path : string, mountPoint : string, ct : CancellationToken option)
+                =
+                async {
+                    let! ct = Async.CancellationToken
+
+                    let uri =
+                        System.Uri (
+                            (match client.BaseAddress with
+                             | null ->
+                                 raise (
+                                     System.ArgumentNullException (
+                                         nameof (client.BaseAddress),
+                                         "No base address was supplied on the type, and no BaseAddress was on the HttpClient."
+                                     )
+                                 )
+                             | v -> v),
+                            System.Uri (
+                                "v1/{mountPoint}/{path}"
+                                    .Replace("{path}", path.ToString () |> System.Web.HttpUtility.UrlEncode)
+                                    .Replace (
+                                        "{mountPoint}",
+                                        mountPoint.ToString () |> System.Web.HttpUtility.UrlEncode
+                                    ),
+                                System.UriKind.Relative
+                            )
+                        )
+
+                    let httpMessage =
+                        new System.Net.Http.HttpRequestMessage (
+                            Method = System.Net.Http.HttpMethod.Get,
+                            RequestUri = uri
+                        )
+
+                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
+                    let response = response.EnsureSuccessStatusCode ()
+                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
+
+                    let! jsonNode =
+                        System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
+                        |> Async.AwaitTask
+
+                    return JwtSecretResponse.jsonParse jsonNode
+                }
+                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
+
+            member _.GetJwt (role : string, jwt : string, ct : CancellationToken option) =
+                async {
+                    let! ct = Async.CancellationToken
+
+                    let uri =
+                        System.Uri (
+                            (match client.BaseAddress with
+                             | null ->
+                                 raise (
+                                     System.ArgumentNullException (
+                                         nameof (client.BaseAddress),
+                                         "No base address was supplied on the type, and no BaseAddress was on the HttpClient."
+                                     )
+                                 )
+                             | v -> v),
+                            System.Uri ("v1/auth/jwt/login", System.UriKind.Relative)
+                        )
+
+                    let httpMessage =
+                        new System.Net.Http.HttpRequestMessage (
+                            Method = System.Net.Http.HttpMethod.Get,
+                            RequestUri = uri
+                        )
+
+                    let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
+                    let response = response.EnsureSuccessStatusCode ()
+                    let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
+
+                    let! jsonNode =
+                        System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
+                        |> Async.AwaitTask
+
+                    return JwtVaultResponse.jsonParse jsonNode
+                }
+                |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
+        }
+namespace ConsumePlugin
+
+open System
+open System.Collections.Generic
+open System.Text.Json.Serialization
+open System.Threading
+open System.Threading.Tasks
+open RestEase
+
+/// Extension methods for constructing a REST client.
+[<AutoOpen>]
+module VaultClientExtensionMethodHttpClientExtension =
+    /// Extension methods for HTTP clients
+    type VaultClientExtensionMethod with
+
+        /// Create a REST client.
+        static member make (client : System.Net.Http.HttpClient) : IVaultClientExtensionMethod =
+            { new IVaultClientExtensionMethod with
+                member _.GetSecret
+                    (jwt : JwtVaultResponse, path : string, mountPoint : string, ct : CancellationToken option)
+                    =
+                    async {
+                        let! ct = Async.CancellationToken
+
+                        let uri =
+                            System.Uri (
+                                (match client.BaseAddress with
+                                 | null ->
+                                     raise (
+                                         System.ArgumentNullException (
+                                             nameof (client.BaseAddress),
+                                             "No base address was supplied on the type, and no BaseAddress was on the HttpClient."
+                                         )
+                                     )
+                                 | v -> v),
+                                System.Uri (
+                                    "v1/{mountPoint}/{path}"
+                                        .Replace("{path}", path.ToString () |> System.Web.HttpUtility.UrlEncode)
+                                        .Replace (
+                                            "{mountPoint}",
+                                            mountPoint.ToString () |> System.Web.HttpUtility.UrlEncode
+                                        ),
+                                    System.UriKind.Relative
+                                )
+                            )
+
+                        let httpMessage =
+                            new System.Net.Http.HttpRequestMessage (
+                                Method = System.Net.Http.HttpMethod.Get,
+                                RequestUri = uri
+                            )
+
+                        let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
+                        let response = response.EnsureSuccessStatusCode ()
+                        let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
+
+                        let! jsonNode =
+                            System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
+                            |> Async.AwaitTask
+
+                        return JwtSecretResponse.jsonParse jsonNode
+                    }
+                    |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
+
+                member _.GetJwt (role : string, jwt : string, ct : CancellationToken option) =
+                    async {
+                        let! ct = Async.CancellationToken
+
+                        let uri =
+                            System.Uri (
+                                (match client.BaseAddress with
+                                 | null ->
+                                     raise (
+                                         System.ArgumentNullException (
+                                             nameof (client.BaseAddress),
+                                             "No base address was supplied on the type, and no BaseAddress was on the HttpClient."
+                                         )
+                                     )
+                                 | v -> v),
+                                System.Uri ("v1/auth/jwt/login", System.UriKind.Relative)
+                            )
+
+                        let httpMessage =
+                            new System.Net.Http.HttpRequestMessage (
+                                Method = System.Net.Http.HttpMethod.Get,
+                                RequestUri = uri
+                            )
+
+                        let! response = client.SendAsync (httpMessage, ct) |> Async.AwaitTask
+                        let response = response.EnsureSuccessStatusCode ()
+                        let! responseStream = response.Content.ReadAsStreamAsync ct |> Async.AwaitTask
+
+                        let! jsonNode =
+                            System.Text.Json.Nodes.JsonNode.ParseAsync (responseStream, cancellationToken = ct)
+                            |> Async.AwaitTask
+
+                        return JwtVaultResponse.jsonParse jsonNode
+                    }
+                    |> (fun a -> Async.StartAsTask (a, ?cancellationToken = ct))
+            }

ConsumePlugin/JsonRecord.fs

@@ -32,10 +32,27 @@ type JsonRecordType =
 [<WoofWare.Myriad.Plugins.JsonParse true>]
 type ToGetExtensionMethod =
     {
-        Tinker : string
-        Tailor : int
-        Soldier : System.Uri
-        Sailor : float
+        Alpha : string
+        Bravo : System.Uri
+        Charlie : float
+        Delta : float32
+        Echo : single
+        Foxtrot : double
+        Golf : int64
+        Hotel : uint64
+        India : int
+        Juliette : uint
+        Kilo : int32
+        Lima : uint32
+        Mike : int16
+        November : uint16
+        Oscar : int8
+        Papa : uint8
+        Quebec : byte
+        Tango : sbyte
+        Uniform : decimal
+        Victor : char
+        Whiskey : bigint
     }
 
 [<RequireQualifiedAccess>]

ConsumePlugin/List.fs

@@ -0,0 +1,19 @@
+namespace ConsumePlugin
+
+open WoofWare.Myriad.Plugins
+
+[<CreateCatamorphism "MyListCata">]
+type MyList<'a> =
+    | Nil
+    | Cons of ConsCase<'a>
+
+and ConsCase<'a> =
+    {
+        Head : 'a
+        Tail : MyList<'a>
+    }
+
+[<CreateCatamorphism "MyList2Cata">]
+type MyList2<'a> =
+    | Nil
+    | Cons of 'a * MyList2<'a>

ConsumePlugin/ListCata.fs

@@ -0,0 +1,118 @@
+//------------------------------------------------------------------------------
+//        This code was generated by myriad.
+//        Changes to this file will be lost when the code is regenerated.
+//------------------------------------------------------------------------------
+
+
+
+
+
+namespace ConsumePlugin
+
+open WoofWare.Myriad.Plugins
+
+/// Description of how to combine cases during a fold
+type MyListCataCase<'a, 'MyList> =
+    /// How to operate on the Nil case
+    abstract Nil : 'MyList
+    /// How to operate on the Cons case
+    abstract Cons : head : 'a -> tail : 'MyList -> 'MyList
+
+/// Specifies how to perform a fold (catamorphism) over the type MyList and its friends.
+type MyListCata<'a, 'MyList> =
+    {
+        /// How to perform a fold (catamorphism) over the type MyList
+        MyList : MyListCataCase<'a, 'MyList>
+    }
+
+/// Methods to perform a catamorphism over the type MyList
+[<RequireQualifiedAccess>]
+module MyListCata =
+    [<RequireQualifiedAccess>]
+    type private Instruction<'a> =
+        | Process__MyList of MyList<'a>
+        | MyList_Cons of 'a
+
+    let private loop (cata : MyListCata<'a, 'MyList>) (instructions : ResizeArray<Instruction<'a>>) =
+        let myListStack = ResizeArray<'MyList> ()
+
+        while instructions.Count > 0 do
+            let currentInstruction = instructions.[instructions.Count - 1]
+            instructions.RemoveAt (instructions.Count - 1)
+
+            match currentInstruction with
+            | Instruction.Process__MyList x ->
+                match x with
+                | MyList.Nil -> cata.MyList.Nil |> myListStack.Add
+                | MyList.Cons ({
+                                   Head = head
+                                   Tail = tail
+                               }) ->
+                    instructions.Add (Instruction.MyList_Cons (head))
+                    instructions.Add (Instruction.Process__MyList tail)
+            | Instruction.MyList_Cons (head) ->
+                let tail = myListStack.[myListStack.Count - 1]
+                myListStack.RemoveAt (myListStack.Count - 1)
+                cata.MyList.Cons head tail |> myListStack.Add
+
+        myListStack
+
+    /// Execute the catamorphism.
+    let runMyList (cata : MyListCata<'a, 'MyListRet>) (x : MyList<'a>) : 'MyListRet =
+        let instructions = ResizeArray ()
+        instructions.Add (Instruction.Process__MyList x)
+        let myListRetStack = loop cata instructions
+        Seq.exactlyOne myListRetStack
+namespace ConsumePlugin
+
+open WoofWare.Myriad.Plugins
+
+/// Description of how to combine cases during a fold
+type MyList2CataCase<'a, 'MyList2> =
+    /// How to operate on the Nil case
+    abstract Nil : 'MyList2
+    /// How to operate on the Cons case
+    abstract Cons : 'a -> 'MyList2 -> 'MyList2
+
+/// Specifies how to perform a fold (catamorphism) over the type MyList2 and its friends.
+type MyList2Cata<'a, 'MyList2> =
+    {
+        /// How to perform a fold (catamorphism) over the type MyList2
+        MyList2 : MyList2CataCase<'a, 'MyList2>
+    }
+
+/// Methods to perform a catamorphism over the type MyList2
+[<RequireQualifiedAccess>]
+module MyList2Cata =
+    [<RequireQualifiedAccess>]
+    type private Instruction<'a> =
+        | Process__MyList2 of MyList2<'a>
+        | MyList2_Cons of 'a
+
+    let private loop (cata : MyList2Cata<'a, 'MyList2>) (instructions : ResizeArray<Instruction<'a>>) =
+        let myList2Stack = ResizeArray<'MyList2> ()
+
+        while instructions.Count > 0 do
+            let currentInstruction = instructions.[instructions.Count - 1]
+            instructions.RemoveAt (instructions.Count - 1)
+
+            match currentInstruction with
+            | Instruction.Process__MyList2 x ->
+                match x with
+                | MyList2.Nil -> cata.MyList2.Nil |> myList2Stack.Add
+                | MyList2.Cons (arg0_0, arg1_0) ->
+                    instructions.Add (Instruction.MyList2_Cons (arg0_0))
+                    instructions.Add (Instruction.Process__MyList2 arg1_0)
+            | Instruction.MyList2_Cons (arg0_0) ->
+                let arg1_0 = myList2Stack.[myList2Stack.Count - 1]
+                myList2Stack.RemoveAt (myList2Stack.Count - 1)
+                cata.MyList2.Cons arg0_0 arg1_0 |> myList2Stack.Add
+
+        myList2Stack
+
+    /// Execute the catamorphism.
+    let runMyList2 (cata : MyList2Cata<'a, 'MyList2Ret>) (x : MyList2<'a>) : 'MyList2Ret =
+        let instructions = ResizeArray ()
+        instructions.Add (Instruction.Process__MyList2 x)
+        let myList2RetStack = loop cata instructions
+        Seq.exactlyOne myList2RetStack

ConsumePlugin/MockExample.fs

@@ -1,5 +1,6 @@
 namespace SomeNamespace
 
+open System
 open WoofWare.Myriad.Plugins
 
 [<GenerateMock>]
@@ -41,3 +42,9 @@ type Curried<'a> =
     abstract Mem4 : (int * string) -> ('a * int) -> string
     abstract Mem5 : x : int * string -> ('a * int) -> string
     abstract Mem6 : int * string -> y : 'a * int -> string
+
+[<GenerateMock>]
+type TypeWithInterface =
+    inherit IDisposable
+    abstract Mem1 : string option -> string[] Async
+    abstract Mem2 : unit -> string[] Async

ConsumePlugin/RestApiExample.fs

@@ -17,6 +17,9 @@ type IPureGymApi =
     [<Get "v1/gyms/{gym_id}/attendance">]
     abstract GetGymAttendance : [<Path "gym_id">] gymId : int * ?ct : CancellationToken -> Task<GymAttendance>
 
+    [<Get "v1/gyms/{gym_id}/attendance">]
+    abstract GetGymAttendance' : [<Path("gym_id")>] gymId : int * ?ct : CancellationToken -> Task<GymAttendance>
+
     [<RestEase.GetAttribute "v1/member">]
     abstract GetMember : ?ct : CancellationToken -> Member Task
 
@@ -38,6 +41,10 @@ type IPureGymApi =
     abstract GetSessions :
         [<Query>] fromDate : DateOnly * [<Query>] toDate : DateOnly * ?ct : CancellationToken -> Task<Sessions>
 
+    [<Get "/v2/gymSessions/member?foo=1">]
+    abstract GetSessionsWithQuery :
+        [<Query>] fromDate : DateOnly * [<Query>] toDate : DateOnly * ?ct : CancellationToken -> Task<Sessions>
+
     // An example from RestEase's own docs
     [<Post "users/new">]
     abstract CreateUserString : [<Body>] user : string * ?ct : CancellationToken -> Task<string>
@@ -120,7 +127,8 @@ type internal IApiWithoutBaseAddress =
 [<WoofWare.Myriad.Plugins.HttpClient>]
 [<BasePath "foo">]
 type IApiWithBasePath =
-    [<Get "endpoint/{param}">]
+    // Example where we use the bundled attributes rather than RestEase's
+    [<WoofWare.Myriad.Plugins.RestEase.Get "endpoint/{param}">]
     abstract GetPathParam : [<Path "param">] parameter : string * ?cancellationToken : CancellationToken -> Task<string>
 
 [<WoofWare.Myriad.Plugins.HttpClient>]
@@ -141,3 +149,16 @@ type IApiWithHeaders =
 
     [<Get "endpoint/{param}">]
     abstract GetPathParam : [<Path "param">] parameter : string * ?ct : CancellationToken -> Task<string>
+
+[<WoofWare.Myriad.Plugins.HttpClient>]
+[<WoofWare.Myriad.Plugins.RestEase.Header("Header-Name", "Header-Value")>]
+type IApiWithHeaders2 =
+    [<WoofWare.Myriad.Plugins.RestEase.Header "X-Foo">]
+    abstract SomeHeader : string
+
+    [<WoofWare.Myriad.Plugins.RestEase.Header "Authorization">]
+    abstract SomeOtherHeader : int
+
+    [<Get "endpoint/{param}">]
+    abstract GetPathParam :
+        [<WoofWare.Myriad.Plugins.RestEase.Path "param">] parameter : string * ?ct : CancellationToken -> Task<string>

ConsumePlugin/Vault.fs

@@ -76,3 +76,33 @@ type IVaultClient =
 
     [<Get "v1/auth/jwt/login">]
     abstract GetJwt : role : string * jwt : string * ?ct : CancellationToken -> Task<JwtVaultResponse>
+
+[<WoofWare.Myriad.Plugins.HttpClient false>]
+type IVaultClientNonExtensionMethod =
+    [<Get "v1/{mountPoint}/{path}">]
+    abstract GetSecret :
+        jwt : JwtVaultResponse *
+        [<Path "path">] path : string *
+        [<Path "mountPoint">] mountPoint : string *
+        ?ct : CancellationToken ->
+            Task<JwtSecretResponse>
+
+    [<Get "v1/auth/jwt/login">]
+    abstract GetJwt : role : string * jwt : string * ?ct : CancellationToken -> Task<JwtVaultResponse>
+
+[<WoofWare.Myriad.Plugins.HttpClient(true)>]
+type IVaultClientExtensionMethod =
+    [<Get "v1/{mountPoint}/{path}">]
+    abstract GetSecret :
+        jwt : JwtVaultResponse *
+        [<Path "path">] path : string *
+        [<Path "mountPoint">] mountPoint : string *
+        ?ct : CancellationToken ->
+            Task<JwtSecretResponse>
+
+    [<Get "v1/auth/jwt/login">]
+    abstract GetJwt : role : string * jwt : string * ?ct : CancellationToken -> Task<JwtVaultResponse>
+
+[<RequireQualifiedAccess>]
+type VaultClientExtensionMethod =
+    static member thisClashes = 99

README.md

@@ -23,6 +23,7 @@ Currently implemented:
 * `RemoveOptions` (to strip `option` modifiers from a type).
 * `HttpClient` (to stamp out a [RestEase](https://github.com/canton7/RestEase)-style HTTP client).
 * `GenerateMock` (to stamp out a record type corresponding to an interface).
+* `CreateCatamorphism` (to stamp out a non-stack-overflowing [catamorphism](https://fsharpforfunandprofit.com/posts/recursive-types-and-folds/) for a discriminated union).
 
 ## `JsonParse`
 
@@ -326,6 +327,82 @@ thereby allowing the programmer to use F#'s record-update syntax.
 
 * You may supply an `isInternal : bool` argument to the attribute. By default, we make the resulting record type at most internal (never public), since this is intended only to be used in tests; but you can instead make it public with `[<GenerateMock false>]`.
 
+## `CreateCatamorphism`
+
+Takes a collection of mutually recursive discriminated unions:
+
+```fsharp
+[<CreateCatamorphism "MyCata">]
+type Expr =
+    | Const of Const
+    | Pair of Expr * Expr * PairOpKind
+    | Sequential of Expr list
+    | Builder of Expr * ExprBuilder
+
+and ExprBuilder =
+    | Child of ExprBuilder
+    | Parent of Expr
+```
+
+and stamps out a type like this:
+```fsharp
+type ExprCata<'Expr, 'ExprBuilder> =
+    abstract Const : Const -> 'Expr
+    abstract Pair : 'Expr -> 'Expr -> PairOpKind -> 'Expr
+    abstract Sequential : 'Expr list -> 'Expr
+    abstract Builder : 'Expr -> 'ExprBuilder -> 'Expr
+
+type ExprBuilderCata<'Expr, 'ExprBuilder> =
+    abstract Child : 'ExprBuilder -> 'ExprBuilder
+    abstract Parent : 'Expr -> 'ExprBuilder
+
+type MyCata<'Expr, 'ExprBuilder> =
+    {
+        Expr : ExprCata<'Expr, 'ExprBuilder>
+        ExprBuilder : ExprBuilderCata<'Expr, 'ExprBuilder>
+    }
+
+[<RequireQualifiedAccess>]
+module ExprCata =
+    let runExpr (cata : MyCata<'ExprRet, 'ExprBuilderRet>) (x : Expr) : 'ExprRet =
+        failwith "this is implemented"
+
+    let runExprBuilder (cata : MyCata<'ExprRet, 'ExprBuilderRet>) (x : ExprBuilder) : 'ExprBuilderRet =
+        failwith "this is implemented"
+```
+
+### What's the point?
+Recursing over a tree is not easy to get right, especially if you want to avoid stack overflows.
+Instead of writing the recursion many times, it's better to do it once,
+and then each time you only plug in what you want to do.
+
+### Features
+
+* Mutually recursive DUs are supported (as in the example above).
+  Every DU in a recursive `type Foo... and Bar...` knot will be given an appropriate cata, as long as any one of those DUs has the `[<CreateCatamorphism>]` attribute.
+* There is *limited* support for records and for lists.
+* There is *extremely brittle* support for generics in the DUs you are cata'ing over.
+  It is based on the names of the generic parameters, so you must ensure that generic parameters with the same name have the same meaning across the various cases in your recursive knot of DUs.
+  (If you overstep the bounds of what this generator can do, you will get compile-time errors, e.g. with generics being constrained to each other's values.)
+  See the [List tests](./WoofWare.Myriad.Plugins.Test/TestCataGenerator/TestMyList2.fs) for an example, where we re-implement `FSharpList<'a>`.
+
+### Limitations
+
+**I am not at all convinced of the correctness of this generator**, and I know it is very incomplete (in the sense that there are many possible DUs you could write for which the generator will bail out).
+I *strongly* recommend implementing the identity catamorphism for your type and using property-based tests ([as I do](./WoofWare.Myriad.Plugins.Test/TestCataGenerator/TestDirectory.fs)) to assert that the correct thing happens.
+Feel free to raise GitHub issues with code I can copy-paste to reproduce a case where the wrong thing happens (though I can't promise to look at them).
+
+* This is a particularly half-baked generator which has so far seen no real-world use.
+  It likely has a bunch of [80/20](https://en.wikipedia.org/wiki/Pareto_principle) low-hanging fruit remaining, but it also likely has impossible problems to solve which I don't know about yet.
+* Only a very few kinds of DU field are currently implemented.
+  For example, this generator can't see through an interface (e.g. the kind of interface one would use to implement the [crate pattern](https://www.patrickstevens.co.uk/posts/2021-10-19-crates/) to represent a [GADT](https://en.wikipedia.org/wiki/Generalized_algebraic_data_type)),
+  so the generated cata will simply grant you access to the interface (rather than attempting to descend into it to discover recursive references).
+  You can't nest lists deeply. All sorts of other cases are unaddressed.
+* This generator does not try to solve the "exponential diamond dependency" problem.
+  If you have a case of the form `type Expr = | Branch of Expr * Expr`, the cata will walk into both `Expr`s separately.
+  If the `Expr`s happen to be equal, the cata will nevertheless traverse them individually (that is, it will traverse the same `Expr` twice).
+  Your type may represent a [DAG](https://en.wikipedia.org/wiki/Directed_acyclic_graph), but we will always effectively expand it into a tree of paths and operate on each of the exponentially-many paths.
+
 # Detailed examples
 
 See the tests.

WoofWare.Myriad.Plugins.Attributes/Attributes.fs

@@ -60,5 +60,22 @@ type JsonParseAttribute (isExtensionMethod : bool) =
 /// generator should apply during build.
 /// This generator is intended to replicate much of the functionality of RestEase,
 /// i.e. to stamp out HTTP REST clients from interfaces defining the API.
-type HttpClientAttribute () =
+///
+/// If you supply isExtensionMethod = true, you will get extension methods.
+/// These can only be consumed from F#, but the benefit is that they don't use up the module name
+/// (since by default we create a module called "{TypeName}").
+type HttpClientAttribute (isExtensionMethod : bool) =
+    inherit Attribute ()
+    /// The default value of `isExtensionMethod`, the optional argument to the HttpClientAttribute constructor.
+    static member DefaultIsExtensionMethod = false
+
+    /// Shorthand for the "isExtensionMethod = false" constructor; see documentation there for details.
+    new () = HttpClientAttribute HttpClientAttribute.DefaultIsExtensionMethod
+
+/// Attribute indicating a DU type to which the "create catamorphism" Myriad
+/// generator should apply during build.
+/// Supply the `typeName` for the name of the record type we will generate, which contains
+/// all the catas required; for example, "MyThing" would generate:
+/// type MyThing<'a, 'b> = { Du1 : Du1Cata<'a, 'b> ; Du2 : Du2Cata<'a, 'b> }.
+type CreateCatamorphismAttribute (typeName : string) =
     inherit Attribute ()

WoofWare.Myriad.Plugins.Attributes/RestEase.fs

@@ -0,0 +1,63 @@
+namespace WoofWare.Myriad.Plugins
+
+open System
+
+/// Module containing duplicates of the supported RestEase attributes, in case you don't want
+/// to take a dependency on RestEase.
+[<RequireQualifiedAccess>]
+module RestEase =
+    /// Indicates that a method represents an HTTP Get query to the specified endpoint.
+    type GetAttribute (path : string) =
+        inherit Attribute ()
+
+    /// Indicates that a method represents an HTTP Post query to the specified endpoint.
+    type PostAttribute (path : string) =
+        inherit Attribute ()
+
+    /// Indicates that a method represents an HTTP Delete query to the specified endpoint.
+    type DeleteAttribute (path : string) =
+        inherit Attribute ()
+
+    /// Indicates that a method represents an HTTP Head query to the specified endpoint.
+    type HeadAttribute (path : string) =
+        inherit Attribute ()
+
+    /// Indicates that a method represents an HTTP Options query to the specified endpoint.
+    type OptionsAttribute (path : string) =
+        inherit Attribute ()
+
+    /// Indicates that a method represents an HTTP Put query to the specified endpoint.
+    type PutAttribute (path : string) =
+        inherit Attribute ()
+
+    /// Indicates that a method represents an HTTP Patch query to the specified endpoint.
+    type PatchAttribute (path : string) =
+        inherit Attribute ()
+
+    /// Indicates that a method represents an HTTP Trace query to the specified endpoint.
+    type TraceAttribute (path : string) =
+        inherit Attribute ()
+
+    /// Indicates that this argument to a method is interpolated into the HTTP request at runtime
+    /// by setting a query parameter (with the given name) to the value of the annotated argument.
+    type QueryAttribute (paramName : string) =
+        inherit Attribute ()
+
+    /// Indicates that this interface represents a REST client which accesses an API whose paths are
+    /// all relative to the given address.
+    type BaseAddressAttribute (addr : string) =
+        inherit Attribute ()
+
+    /// Indicates that this interface member causes the interface to set a header with the given name,
+    /// whose value is obtained whenever required by a fresh call to the interface member.
+    type HeaderAttribute (header : string, value : string option) =
+        inherit Attribute ()
+        new (header : string) = HeaderAttribute (header, None)
+        new (header : string, value : string) = HeaderAttribute (header, Some value)
+
+    /// Indicates that this argument to a method is interpolated into the request path at runtime
+    /// by writing it into the templated string that specifies the HTTP query e.g. in the `[<Get "/foo/{template}">]`.
+    type PathAttribute (path : string option) =
+        inherit Attribute ()
+        new (path : string) = PathAttribute (Some path)
+        new () = PathAttribute None

WoofWare.Myriad.Plugins.Attributes/SurfaceBaseline.txt

@@ -1,10 +1,15 @@
+WoofWare.Myriad.Plugins.CreateCatamorphismAttribute inherit System.Attribute
+WoofWare.Myriad.Plugins.CreateCatamorphismAttribute..ctor [constructor]: string
 WoofWare.Myriad.Plugins.GenerateMockAttribute inherit System.Attribute
 WoofWare.Myriad.Plugins.GenerateMockAttribute..ctor [constructor]: bool
 WoofWare.Myriad.Plugins.GenerateMockAttribute..ctor [constructor]: unit
 WoofWare.Myriad.Plugins.GenerateMockAttribute.DefaultIsInternal [static property]: [read-only] bool
 WoofWare.Myriad.Plugins.GenerateMockAttribute.get_DefaultIsInternal [static method]: unit -> bool
 WoofWare.Myriad.Plugins.HttpClientAttribute inherit System.Attribute
+WoofWare.Myriad.Plugins.HttpClientAttribute..ctor [constructor]: bool
 WoofWare.Myriad.Plugins.HttpClientAttribute..ctor [constructor]: unit
+WoofWare.Myriad.Plugins.HttpClientAttribute.DefaultIsExtensionMethod [static property]: [read-only] bool
+WoofWare.Myriad.Plugins.HttpClientAttribute.get_DefaultIsExtensionMethod [static method]: unit -> bool
 WoofWare.Myriad.Plugins.JsonParseAttribute inherit System.Attribute
 WoofWare.Myriad.Plugins.JsonParseAttribute..ctor [constructor]: bool
 WoofWare.Myriad.Plugins.JsonParseAttribute..ctor [constructor]: unit
@@ -16,4 +21,33 @@ WoofWare.Myriad.Plugins.JsonSerializeAttribute..ctor [constructor]: unit
 WoofWare.Myriad.Plugins.JsonSerializeAttribute.DefaultIsExtensionMethod [static property]: [read-only] bool
 WoofWare.Myriad.Plugins.JsonSerializeAttribute.get_DefaultIsExtensionMethod [static method]: unit -> bool
 WoofWare.Myriad.Plugins.RemoveOptionsAttribute inherit System.Attribute
-WoofWare.Myriad.Plugins.RemoveOptionsAttribute..ctor [constructor]: unit
+WoofWare.Myriad.Plugins.RemoveOptionsAttribute..ctor [constructor]: unit
+WoofWare.Myriad.Plugins.RestEase inherit obj
+WoofWare.Myriad.Plugins.RestEase+BaseAddressAttribute inherit System.Attribute
+WoofWare.Myriad.Plugins.RestEase+BaseAddressAttribute..ctor [constructor]: string
+WoofWare.Myriad.Plugins.RestEase+DeleteAttribute inherit System.Attribute
+WoofWare.Myriad.Plugins.RestEase+DeleteAttribute..ctor [constructor]: string
+WoofWare.Myriad.Plugins.RestEase+GetAttribute inherit System.Attribute
+WoofWare.Myriad.Plugins.RestEase+GetAttribute..ctor [constructor]: string
+WoofWare.Myriad.Plugins.RestEase+HeadAttribute inherit System.Attribute
+WoofWare.Myriad.Plugins.RestEase+HeadAttribute..ctor [constructor]: string
+WoofWare.Myriad.Plugins.RestEase+HeaderAttribute inherit System.Attribute
+WoofWare.Myriad.Plugins.RestEase+HeaderAttribute..ctor [constructor]: (string, string option)
+WoofWare.Myriad.Plugins.RestEase+HeaderAttribute..ctor [constructor]: (string, string)
+WoofWare.Myriad.Plugins.RestEase+HeaderAttribute..ctor [constructor]: string
+WoofWare.Myriad.Plugins.RestEase+OptionsAttribute inherit System.Attribute
+WoofWare.Myriad.Plugins.RestEase+OptionsAttribute..ctor [constructor]: string
+WoofWare.Myriad.Plugins.RestEase+PatchAttribute inherit System.Attribute
+WoofWare.Myriad.Plugins.RestEase+PatchAttribute..ctor [constructor]: string
+WoofWare.Myriad.Plugins.RestEase+PathAttribute inherit System.Attribute
+WoofWare.Myriad.Plugins.RestEase+PathAttribute..ctor [constructor]: string
+WoofWare.Myriad.Plugins.RestEase+PathAttribute..ctor [constructor]: string option
+WoofWare.Myriad.Plugins.RestEase+PathAttribute..ctor [constructor]: unit
+WoofWare.Myriad.Plugins.RestEase+PostAttribute inherit System.Attribute
+WoofWare.Myriad.Plugins.RestEase+PostAttribute..ctor [constructor]: string
+WoofWare.Myriad.Plugins.RestEase+PutAttribute inherit System.Attribute
+WoofWare.Myriad.Plugins.RestEase+PutAttribute..ctor [constructor]: string
+WoofWare.Myriad.Plugins.RestEase+QueryAttribute inherit System.Attribute
+WoofWare.Myriad.Plugins.RestEase+QueryAttribute..ctor [constructor]: string
+WoofWare.Myriad.Plugins.RestEase+TraceAttribute inherit System.Attribute
+WoofWare.Myriad.Plugins.RestEase+TraceAttribute..ctor [constructor]: string

WoofWare.Myriad.Plugins.Attributes/Test/TestSurface.fs

@@ -11,11 +11,9 @@ module TestSurface =
     [<Test>]
     let ``Ensure API surface has not been modified`` () = ApiSurface.assertIdentical assembly
 
-    (*
     [<Test>]
     let ``Check version against remote`` () =
         MonotonicVersion.validate assembly "WoofWare.Myriad.Plugins.Attributes"
-    *)
 
     [<Test ; Explicit>]
     let ``Update API surface`` () =

WoofWare.Myriad.Plugins.Attributes/Test/WoofWare.Myriad.Plugins.Attributes.Test.fsproj

@@ -12,9 +12,9 @@
     </ItemGroup>
 
     <ItemGroup>
-        <PackageReference Include="ApiSurface" Version="4.0.28" />
+        <PackageReference Include="ApiSurface" Version="4.0.39" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.9.0"/>
-        <PackageReference Include="NUnit" Version="3.13.3"/>
+        <PackageReference Include="NUnit" Version="4.1.0"/>
         <PackageReference Include="NUnit3TestAdapter" Version="4.5.0"/>
     </ItemGroup>
 

WoofWare.Myriad.Plugins.Attributes/WoofWare.Myriad.Plugins.Attributes.fsproj

@@ -19,6 +19,7 @@
 
   <ItemGroup>
     <Compile Include="Attributes.fs"/>
+    <Compile Include="RestEase.fs" />
     <EmbeddedResource Include="version.json"/>
     <EmbeddedResource Include="SurfaceBaseline.txt"/>
     <None Include="..\README.md">

WoofWare.Myriad.Plugins.Attributes/version.json

@@ -1,5 +1,5 @@
 {
-  "version": "2.1",
+  "version": "3.1",
   "publicReleaseRefSpec": [
     "^refs/heads/main$"
   ],

WoofWare.Myriad.Plugins.Test/TestCataGenerator/TestCataGenerator.fs

@@ -0,0 +1,47 @@
+namespace WoofWare.Myriad.Plugins.Test
+
+open System.Threading
+open NUnit.Framework
+open FsUnitTyped
+open ConsumePlugin
+open FsCheck
+
+[<TestFixture>]
+module TestCataGenerator =
+    let idCata<'a, 'b> : TreeCata<'a, 'b, _, _> =
+        {
+            Tree =
+                { new TreeCataCase<_, _, _, _> with
+                    member _.Const x y = Const (x, y)
+                    member _.Pair x y z = Pair (x, y, z)
+                    member _.Sequential xs = Sequential xs
+                    member _.Builder x b = Builder (x, b)
+                }
+            TreeBuilder =
+                { new TreeBuilderCataCase<_, _, _, _> with
+                    member _.Child x = Child x
+                    member _.Parent x = Parent x
+                }
+        }
+
+    [<Test>]
+    let ``Example`` () =
+        let x =
+            Tree.Pair (Tree.Const (Const.Verbatim 0, "hi"), Tree.Const (Const.String "", "bye"), PairOpKind.ThenDoSeq)
+
+        TreeCata.runTree idCata x |> shouldEqual x
+
+
+    [<Test>]
+    let ``Cata works`` () =
+        let builderCases = ref 0
+
+        let property (x : Tree<int, string>) =
+            match x with
+            | Tree.Builder _ -> Interlocked.Increment builderCases |> ignore
+            | _ -> ()
+
+            TreeCata.runTree idCata x = x
+
+        Check.QuickThrowOnFailure property
+        builderCases.Value |> shouldBeGreaterThan 10

WoofWare.Myriad.Plugins.Test/TestCataGenerator/TestDirectory.fs

@@ -0,0 +1,37 @@
+namespace WoofWare.Myriad.Plugins.Test
+
+open NUnit.Framework
+open ConsumePlugin
+open FsCheck
+
+[<TestFixture>]
+module TestDirectory =
+    let idCata : FileSystemCata<_> =
+        {
+            FileSystemItem =
+                { new FileSystemItemCataCase<_> with
+                    member _.File file = FileSystemItem.File file
+
+                    member _.Directory name dirSize results =
+                        FileSystemItem.Directory
+                            {
+                                Name = name
+                                DirSize = dirSize
+                                Contents = results
+                            }
+                }
+
+        }
+
+    // Note: this file is preserved as an example of writing an identity cata.
+    // Don't add anything else to this file, because that will muddy the example.
+
+    [<Test>]
+    let ``Cata works`` () =
+        let property (x : FileSystemItem) =
+            FileSystemItemCata.runFileSystemItem idCata x = x
+
+        Check.QuickThrowOnFailure property
+
+// Note: this file is preserved as an example of writing an identity cata.
+// Don't add anything else to this file, because that will muddy the example.

WoofWare.Myriad.Plugins.Test/TestCataGenerator/TestGift.fs

@@ -0,0 +1,99 @@
+namespace WoofWare.Myriad.Plugins.Test
+
+open NUnit.Framework
+open ConsumePlugin
+open FsCheck
+open FsUnitTyped
+
+[<TestFixture>]
+module TestGift =
+
+    let idCata : GiftCata<_> =
+        {
+            Gift =
+                { new GiftCataCase<_> with
+                    member _.Book b = Gift.Book b
+                    member _.Boxed g = Gift.Boxed g
+                    member _.Chocolate g = Gift.Chocolate g
+                    member _.WithACard g message = Gift.WithACard (g, message)
+                    member _.Wrapped g paper = Gift.Wrapped (g, paper)
+                }
+        }
+
+    let totalCostCata : GiftCata<_> =
+        {
+            Gift =
+                { new GiftCataCase<_> with
+                    member _.Book b = b.price
+                    member _.Boxed g = g + 1.0m
+                    member _.Chocolate c = c.price
+                    member _.WithACard g message = g + 2.0m
+                    member _.Wrapped g paper = g + 0.5m
+                }
+        }
+
+    let descriptionCata : GiftCata<_> =
+        {
+            Gift =
+                { new GiftCataCase<_> with
+                    member _.Book b = b.title
+                    member _.Boxed g = $"%s{g} in a box"
+                    member _.Chocolate c = $"%O{c} chocolate"
+
+                    member _.WithACard g message =
+                        $"%s{g} with a card saying '%s{message}'"
+
+                    member _.Wrapped g paper = $"%s{g} wrapped in %A{paper} paper"
+                }
+        }
+
+    [<Test>]
+    let ``Cata works`` () =
+        let property (x : Gift) = GiftCata.runGift idCata x = x
+
+        Check.QuickThrowOnFailure property
+
+    [<Test>]
+    let ``Example from docs`` () =
+        let wolfHall =
+            {
+                title = "Wolf Hall"
+                price = 20m
+            }
+
+        let yummyChoc =
+            {
+                chocType = SeventyPercent
+                price = 5m
+            }
+
+        let birthdayPresent =
+            WithACard (Wrapped (Book wolfHall, HappyBirthday), "Happy Birthday")
+
+        let christmasPresent = Wrapped (Boxed (Chocolate yummyChoc), HappyHolidays)
+
+        GiftCata.runGift totalCostCata birthdayPresent |> shouldEqual 22.5m
+
+        GiftCata.runGift descriptionCata christmasPresent
+        |> shouldEqual "SeventyPercent chocolate in a box wrapped in HappyHolidays paper"
+
+        let deeplyNestedBox depth =
+            let rec loop depth boxSoFar =
+                match depth with
+                | 0 -> boxSoFar
+                | n -> loop (n - 1) (Boxed boxSoFar)
+
+            loop depth (Book wolfHall)
+
+        deeplyNestedBox 10 |> GiftCata.runGift totalCostCata |> shouldEqual 30.0M
+        deeplyNestedBox 100 |> GiftCata.runGift totalCostCata |> shouldEqual 120.0M
+        deeplyNestedBox 1000 |> GiftCata.runGift totalCostCata |> shouldEqual 1020.0M
+        deeplyNestedBox 10000 |> GiftCata.runGift totalCostCata |> shouldEqual 10020.0M
+
+        deeplyNestedBox 100000
+        |> GiftCata.runGift totalCostCata
+        |> shouldEqual 100020.0M
+
+        deeplyNestedBox 1000000
+        |> GiftCata.runGift totalCostCata
+        |> shouldEqual 1000020.0M

WoofWare.Myriad.Plugins.Test/TestCataGenerator/TestMyList.fs

@@ -0,0 +1,77 @@
+namespace WoofWare.Myriad.Plugins.Test
+
+open NUnit.Framework
+open FsCheck
+open FsUnitTyped
+open ConsumePlugin
+
+[<TestFixture>]
+module TestMyList =
+
+    let idCata<'a> : MyListCata<'a, _> =
+        {
+            MyList =
+                { new MyListCataCase<'a, _> with
+                    member _.Nil = MyList.Nil
+
+                    member _.Cons head tail =
+                        MyList.Cons
+                            {
+                                Head = head
+                                Tail = tail
+                            }
+                }
+        }
+
+    [<Test>]
+    let ``Cata works`` () =
+        let property (x : MyList<int>) = MyListCata.runMyList idCata x = x
+
+        Check.QuickThrowOnFailure property
+
+    let toListCata<'a> =
+        {
+            MyList =
+                { new MyListCataCase<'a, 'a list> with
+                    member _.Nil = []
+                    member _.Cons (head : 'a) (tail : 'a list) = head :: tail
+                }
+        }
+
+    let toListViaCata<'a> (l : MyList<'a>) : 'a list = MyListCata.runMyList toListCata l
+
+
+    [<Test>]
+    let ``Example of a fold converting to a new data structure`` () =
+        let rec toListNaive (l : MyList<int>) : int list =
+            match l with
+            | MyList.Nil -> []
+            | MyList.Cons consCell -> consCell.Head :: toListNaive consCell.Tail
+
+        Check.QuickThrowOnFailure (fun l -> toListNaive l = toListViaCata l)
+
+    [<Test>]
+    let ``Example of equivalence with FoldBack`` () =
+        let baseCase = 0L
+        let atLeaf (head : int) (tail : int64) : int64 = int64 head + tail
+
+        let sumCata =
+            {
+                MyList =
+                    { new MyListCataCase<int, int64> with
+                        member _.Nil = baseCase
+                        member _.Cons (head : int) (tail : int64) = atLeaf head tail
+                    }
+            }
+
+        let viaCata (l : MyList<int>) : int64 = MyListCata.runMyList sumCata l
+
+        let viaFold (l : MyList<int>) : int64 =
+            // choose your favourite "to list" method - here I use the cata
+            // but that could have been done naively
+            (toListViaCata l, baseCase)
+            ||> List.foldBack (fun elt state -> atLeaf elt state)
+
+        let property (l : MyList<int>) = viaCata l = viaFold l
+
+        Check.QuickThrowOnFailure property

WoofWare.Myriad.Plugins.Test/TestCataGenerator/TestMyList2.fs

@@ -0,0 +1,25 @@
+namespace WoofWare.Myriad.Plugins.Test
+
+open NUnit.Framework
+open FsCheck
+open FsUnitTyped
+open ConsumePlugin
+
+[<TestFixture>]
+module TestMyList2 =
+
+    let idCata<'a> : MyList2Cata<'a, _> =
+        {
+            MyList2 =
+                { new MyList2CataCase<'a, _> with
+                    member _.Nil = MyList2.Nil
+
+                    member _.Cons (head : 'a) (tail : MyList2<'a>) = MyList2.Cons (head, tail)
+                }
+        }
+
+    [<Test>]
+    let ``Cata works`` () =
+        let property (x : MyList2<int>) = MyList2Cata.runMyList2 idCata x = x
+
+        Check.QuickThrowOnFailure property

WoofWare.Myriad.Plugins.Test/TestHttpClient/TestPureGymRestApi.fs

@@ -89,6 +89,7 @@ module TestPureGymRestApi =
         let api = PureGymApi.make client
 
         api.GetGymAttendance(requestedGym).Result |> shouldEqual expected
+        api.GetGymAttendance'(requestedGym).Result |> shouldEqual expected
 
     let memberCases =
         PureGymDtos.memberCases |> List.allPairs baseUris |> List.map TestCaseData
@@ -234,6 +235,33 @@ module TestPureGymRestApi =
 
         api.GetSessions(startDate, endDate).Result |> shouldEqual expected
 
+    [<TestCaseSource(nameof sessionsCases)>]
+    let ``Test GetSessionsWithQuery``
+        (baseUri : Uri, (startDate : DateOnly, (endDate : DateOnly, (json : string, expected : Sessions))))
+        =
+        let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
+            async {
+                message.Method |> shouldEqual HttpMethod.Get
+
+                // This one is specified as being absolute, in its attribute on the IPureGymApi type
+                let expectedUri =
+                    let fromDate = dateOnlyToString startDate
+                    let toDate = dateOnlyToString endDate
+                    $"https://example.com/v2/gymSessions/member?foo=1&fromDate=%s{fromDate}&toDate=%s{toDate}"
+
+                message.RequestUri.ToString () |> shouldEqual expectedUri
+
+                let content = new StringContent (json)
+                let resp = new HttpResponseMessage (HttpStatusCode.OK)
+                resp.Content <- content
+                return resp
+            }
+
+        use client = HttpClientMock.make baseUri proc
+        let api = PureGymApi.make client
+
+        api.GetSessionsWithQuery(startDate, endDate).Result |> shouldEqual expected
+
     [<Test>]
     let ``URI example`` () =
         let proc (message : HttpRequestMessage) : HttpResponseMessage Async =

WoofWare.Myriad.Plugins.Test/TestHttpClient/TestVaultClient.fs

@@ -87,8 +87,10 @@ module TestVaultClient =
     }
 }"""
 
-    [<Test>]
-    let ``URI example`` () =
+    [<TestCase 1>]
+    [<TestCase 2>]
+    [<TestCase 3>]
+    let ``URI example`` (vaultClientId : int) =
         let proc (message : HttpRequestMessage) : HttpResponseMessage Async =
             async {
                 message.Method |> shouldEqual HttpMethod.Get
@@ -112,10 +114,25 @@ module TestVaultClient =
             }
 
         use client = HttpClientMock.make (Uri "https://my-vault.com") proc
-        let api = VaultClient.make client
 
-        let vaultResponse = api.GetJwt("role", "jwt").Result
-        let value = api.GetSecret(vaultResponse, "path", "mount").Result
+        let value =
+            match vaultClientId with
+            | 1 ->
+                let api = VaultClient.make client
+                let vaultResponse = api.GetJwt("role", "jwt").Result
+                let value = api.GetSecret(vaultResponse, "path", "mount").Result
+                value
+            | 2 ->
+                let api = VaultClientNonExtensionMethod.make client
+                let vaultResponse = api.GetJwt("role", "jwt").Result
+                let value = api.GetSecret(vaultResponse, "path", "mount").Result
+                value
+            | 3 ->
+                let api = VaultClientExtensionMethod.make client
+                let vaultResponse = api.GetJwt("role", "jwt").Result
+                let value = api.GetSecret(vaultResponse, "path", "mount").Result
+                value
+            | _ -> failwith $"Unrecognised ID: %i{vaultClientId}"
 
         value.Data
         |> Seq.toList
@@ -168,3 +185,5 @@ module TestVaultClient =
                 "key8_1", "https://example.com/data8/1"
                 "key8_2", "https://example.com/data8/2"
             ]
+
+    let _canSeePastExtensionMethod = VaultClientExtensionMethod.thisClashes

WoofWare.Myriad.Plugins.Test/TestJsonParse/TestExtensionMethod.fs

@@ -1,6 +1,7 @@
 namespace WoofWare.Myriad.Plugins.Test
 
 open System
+open System.Numerics
 open System.Text.Json.Nodes
 open ConsumePlugin
 open NUnit.Framework
@@ -12,15 +13,62 @@ module TestExtensionMethod =
     [<Test>]
     let ``Parse via extension method`` () =
         let json =
-            """{"tinker": "job", "tailor": 3, "soldier": "https://example.com", "sailor": 3.1}"""
+            """{
+    "alpha": "hello!",
+    "bravo": "https://example.com",
+    "charlie": 0.3341,
+    "delta": 110033.4,
+    "echo": -0.000993,
+    "foxtrot": -999999999999,
+    "golf": -123456789101112,
+    "hotel": 18446744073709551615,
+    "india": 99884,
+    "juliette": 12223334,
+    "kilo": -2147483642,
+    "lima": 4294967293,
+    "mike": -32767,
+    "november": 65533,
+    "oscar": -125,
+    "papa": 253,
+    "quebec": 254,
+    "tango": -3,
+    "uniform": 1004443.300988393349583009,
+    "victor": "x",
+    "whiskey": 123456123456123456123456123456123456123456
+}"""
             |> JsonNode.Parse
 
         let expected =
             {
-                Tinker = "job"
-                Tailor = 3
-                Soldier = Uri "https://example.com"
-                Sailor = 3.1
+                Alpha = "hello!"
+                Bravo = Uri "https://example.com"
+                Charlie = 0.3341
+                Delta = 110033.4f
+                Echo = -0.000993f
+                Foxtrot = -999999999999.0
+                Golf = -123456789101112L
+                Hotel = 18446744073709551615UL
+                India = 99884
+                Juliette = 12223334u
+                Kilo = -2147483642
+                Lima = 4294967293u
+                Mike = -32767s
+                November = 65533us
+                Oscar = -125y
+                Papa = 253uy
+                Quebec = 254uy
+                Tango = -3y
+                Uniform = 1004443.300988393349583009m
+                Victor = 'x'
+                Whiskey =
+                    let mutable i = BigInteger 0
+
+                    for _ = 0 to 6 do
+                        i <- i * BigInteger 1000000 + BigInteger 123456
+
+                    i
             }
 
-        ToGetExtensionMethod.jsonParse json |> shouldEqual expected
+        let actual = ToGetExtensionMethod.jsonParse json
+
+        actual |> shouldEqual expected

WoofWare.Myriad.Plugins.Test/TestJsonParse/TestJsonParse.fs

@@ -7,6 +7,8 @@ open FsUnitTyped
 
 [<TestFixture>]
 module TestJsonParse =
+    let _canSeePastExtensionMethod = ToGetExtensionMethod.thisModuleWouldClash
+
     [<Test>]
     let ``Single example`` () =
         let s =

WoofWare.Myriad.Plugins.Test/WoofWare.Myriad.Plugins.Test.fsproj

@@ -21,19 +21,24 @@
     <Compile Include="TestHttpClient\TestVaultClient.fs" />
     <Compile Include="TestHttpClient\TestVariableHeader.fs" />
     <Compile Include="TestMockGenerator\TestMockGenerator.fs" />
+    <Compile Include="TestJsonSerialize\TestJsonSerde.fs" />
+    <Compile Include="TestCataGenerator\TestCataGenerator.fs" />
+    <Compile Include="TestCataGenerator\TestDirectory.fs" />
+    <Compile Include="TestCataGenerator\TestGift.fs" />
+    <Compile Include="TestCataGenerator\TestMyList.fs" />
+    <Compile Include="TestCataGenerator\TestMyList2.fs" />
     <Compile Include="TestRemoveOptions.fs"/>
     <Compile Include="TestSurface.fs"/>
     <None Include="../.github/workflows/dotnet.yaml" />
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="ApiSurface" Version="4.0.28"/>
+    <PackageReference Include="ApiSurface" Version="4.0.39"/>
     <PackageReference Include="FsCheck" Version="2.16.6"/>
     <PackageReference Include="FsUnit" Version="6.0.0"/>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0"/>
-    <PackageReference Include="NUnit" Version="4.0.1"/>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.9.0"/>
+    <PackageReference Include="NUnit" Version="4.1.0"/>
     <PackageReference Include="NUnit3TestAdapter" Version="4.5.0"/>
-    <PackageReference Include="coverlet.collector" Version="6.0.0"/>
   </ItemGroup>
 
   <ItemGroup>
@@ -41,8 +46,4 @@
     <ProjectReference Include="..\ConsumePlugin\ConsumePlugin.fsproj"/>
   </ItemGroup>
 
-  <ItemGroup>
-    <Compile Include="TestJsonSerialize\TestJsonSerde.fs" />
-  </ItemGroup>
-
 </Project>

WoofWare.Myriad.Plugins/AstHelper.fs

@@ -54,6 +54,7 @@ type internal InterfaceType =
     {
         Attributes : SynAttribute list
         Name : LongIdent
+        Inherits : SynType list
         Members : MemberInfo list
         Properties : PropertyInfo list
         Generics : SynTyparDecls option
@@ -70,9 +71,57 @@ type internal RecordType =
         Accessibility : SynAccess option
     }
 
+/// Anything that is part of an ADT.
+/// A record is a product of stuff; this type represents one of those stuffs.
+type internal AdtNode =
+    {
+        Type : SynType
+        Name : Ident option
+        /// An ordered list, so you can look up any given generic within `this.Type`
+        /// to discover what its index is in the parent DU which defined it.
+        GenericsOfParent : SynTyparDecl list
+    }
+
+/// A DU is a sum of products (e.g. `type Thing = Foo of a * b`);
+/// similarly a record is a product.
+/// This type represents a product in that sense.
+type internal AdtProduct =
+    {
+        Name : SynIdent
+        Fields : AdtNode list
+        /// This AdtProduct represents a product in which there might be
+        /// some bound type parameters. This field lists the bound
+        /// type parameters in the order they appeared on the parent type.
+        Generics : SynTyparDecl list
+    }
+
 [<RequireQualifiedAccess>]
 module internal AstHelper =
 
+    /// Given e.g. "byte", returns "System.Byte".
+    let qualifyPrimitiveType (typeName : string) : LongIdent option =
+        match typeName with
+        | "float32"
+        | "single" -> [ "System" ; "Single" ] |> Some
+        | "float"
+        | "double" -> [ "System" ; "Double" ] |> Some
+        | "byte"
+        | "uint8" -> [ "System" ; "Byte" ] |> Some
+        | "sbyte"
+        | "int8" -> [ "System" ; "SByte" ] |> Some
+        | "int16" -> [ "System" ; "Int16" ] |> Some
+        | "int"
+        | "int32" -> [ "System" ; "Int32" ] |> Some
+        | "int64" -> [ "System" ; "Int64" ] |> Some
+        | "uint16" -> [ "System" ; "UInt16" ] |> Some
+        | "uint"
+        | "uint32" -> [ "System" ; "UInt32" ] |> Some
+        | "uint64" -> [ "System" ; "UInt64" ] |> Some
+        | "char" -> [ "System" ; "Char" ] |> Some
+        | "decimal" -> [ "System" ; "Decimal" ] |> Some
+        | _ -> None
+        |> Option.map (List.map Ident.Create)
+
     let instantiateRecord (fields : (RecordFieldName * SynExpr option) list) : SynExpr =
         let fields =
             fields
@@ -107,6 +156,11 @@ module internal AstHelper =
         // TODO: consider Microsoft.FSharp.Option or whatever it is
         | _ -> false
 
+    let isUnitIdent (ident : SynLongIdent) : bool =
+        match ident.LongIdent with
+        | [ i ] when System.String.Equals (i.idText, "unit", System.StringComparison.OrdinalIgnoreCase) -> true
+        | _ -> false
+
     let isListIdent (ident : SynLongIdent) : bool =
         match ident.LongIdent with
         | [ i ] when System.String.Equals (i.idText, "list", System.StringComparison.OrdinalIgnoreCase) -> true
@@ -318,7 +372,18 @@ module internal AstHelper =
                                 }
                                 |> List.singleton
                         }
-                    | _ -> failwith $"Unrecognised args in interface method declaration: %+A{args}"
+                    | arg ->
+                        {
+                            HasParen = false
+                            Args =
+                                {
+                                    Attributes = []
+                                    IsOptional = false
+                                    Id = None
+                                    Type = arg
+                                }
+                                |> List.singleton
+                        }
                     |> fun ty ->
                         { ty with
                             HasParen = ty.HasParen || hasParen
@@ -362,27 +427,101 @@ module internal AstHelper =
 
         let attrs = attrs |> List.collect (fun s -> s.Attributes)
 
-        let members, properties =
+        let members, inherits =
             match synTypeDefnRepr with
             | SynTypeDefnRepr.ObjectModel (_kind, members, _) ->
                 members
                 |> List.map (fun defn ->
                     match defn with
-                    | SynMemberDefn.AbstractSlot (slotSig, flags, _, _) -> parseMember slotSig flags
+                    | SynMemberDefn.AbstractSlot (slotSig, flags, _, _) -> Choice1Of2 (parseMember slotSig flags)
+                    | SynMemberDefn.Inherit (baseType, _asIdent, _) -> Choice2Of2 baseType
                     | _ -> failwith $"Unrecognised member definition: %+A{defn}"
                 )
             | _ -> failwith $"Unrecognised SynTypeDefnRepr for an interface type: %+A{synTypeDefnRepr}"
             |> List.partitionChoice
 
+        let members, properties = members |> List.partitionChoice
+
         {
             Members = members
             Properties = properties
             Name = interfaceName
+            Inherits = inherits
             Attributes = attrs
             Generics = typars
             Accessibility = accessibility
         }
 
+    let getUnionCases
+        (SynTypeDefn.SynTypeDefn (info, repr, _, _, _, _))
+        : AdtProduct list * SynTyparDecl list * SynAccess option
+        =
+        let typars, access =
+            match info with
+            | SynComponentInfo (_, typars, _, _, _, _, access, _) -> typars, access
+
+        let typars =
+            match typars with
+            | None -> []
+            | Some (SynTyparDecls.PrefixList (decls, _)) -> decls
+            | Some (SynTyparDecls.SinglePrefix (l, _)) -> [ l ]
+            | Some (SynTyparDecls.PostfixList (decls, constraints, _)) ->
+                if not constraints.IsEmpty then
+                    failwith "Constrained type parameters not currently supported"
+
+                decls
+
+        match repr with
+        | SynTypeDefnRepr.Simple (SynTypeDefnSimpleRepr.Union (_, cases, _), _) ->
+            let cases =
+                cases
+                |> List.map (fun (SynUnionCase.SynUnionCase (_, ident, kind, _, _, _, _)) ->
+                    match kind with
+                    | SynUnionCaseKind.FullType _ -> failwith "FullType union cases not supported"
+                    | SynUnionCaseKind.Fields fields ->
+                        {
+                            Name = ident
+                            Fields =
+                                fields
+                                |> List.map (fun (SynField.SynField (_, _, id, ty, _, _, _, _, _)) ->
+                                    {
+                                        Type = ty
+                                        Name = id
+                                        GenericsOfParent = typars
+                                    }
+                                )
+                            Generics = typars
+                        }
+                )
+
+            cases, typars, access
+        | _ -> failwithf "Failed to get union cases for type that was: %+A" repr
+
+    let getRecordFields (SynTypeDefn.SynTypeDefn (typeInfo, repr, _, _, _, _)) : AdtNode list =
+        let (SynComponentInfo.SynComponentInfo (typeParams = typars)) = typeInfo
+
+        let typars =
+            match typars with
+            | None -> []
+            | Some (SynTyparDecls.PrefixList (decls, _)) -> decls
+            | Some (SynTyparDecls.SinglePrefix (l, _)) -> [ l ]
+            | Some (SynTyparDecls.PostfixList (decls, constraints, _)) ->
+                if not constraints.IsEmpty then
+                    failwith "Constrained type parameters not currently supported"
+
+                decls
+
+        match repr with
+        | SynTypeDefnRepr.Simple (SynTypeDefnSimpleRepr.Record (_, fields, _), _) ->
+            fields
+            |> List.map (fun (SynField.SynField (_, _, ident, ty, _, _, _, _, _)) ->
+                {
+                    Name = ident
+                    Type = ty
+                    GenericsOfParent = typars
+                }
+            )
+        | _ -> failwithf "Failed to get record elements for type that was: %+A" repr
 
 [<AutoOpen>]
 module internal SynTypePatterns =
@@ -392,6 +531,11 @@ module internal SynTypePatterns =
             Some innerType
         | _ -> None
 
+    let (|UnitType|_|) (fieldType : SynType) : unit option =
+        match fieldType with
+        | SynType.LongIdent ident when AstHelper.isUnitIdent ident -> Some ()
+        | _ -> None
+
     let (|ListType|_|) (fieldType : SynType) =
         match fieldType with
         | SynType.App (SynType.LongIdent ident, _, [ innerType ], _, _, _, _) when AstHelper.isListIdent ident ->
@@ -437,14 +581,23 @@ module internal SynTypePatterns =
             Some (key, value)
         | _ -> None
 
-    /// Returns the string name of the type.
-    let (|PrimitiveType|_|) (fieldType : SynType) =
+    let (|BigInt|_|) (fieldType : SynType) : unit option =
+        match fieldType with
+        | SynType.LongIdent ident ->
+            match ident.LongIdent |> List.map _.idText with
+            | [ "bigint" ]
+            | [ "BigInteger" ]
+            | [ "Numerics" ; "BigInteger" ]
+            | [ "System" ; "Numerics" ; "BigInteger" ] -> Some ()
+            | _ -> None
+        | _ -> None
+
+    /// Returns the type, qualified as in e.g. `System.Boolean`.
+    let (|PrimitiveType|_|) (fieldType : SynType) : LongIdent option =
         match fieldType with
         | SynType.LongIdent ident ->
             match ident.LongIdent with
-            | [ i ] ->
-                [ "string" ; "float" ; "int" ; "bool" ; "char" ]
-                |> List.tryFind (fun s -> s = i.idText)
+            | [ i ] -> AstHelper.qualifyPrimitiveType i.idText
             | _ -> None
         | _ -> None
 

WoofWare.Myriad.Plugins/HttpClientGenerator.fs

@@ -1,13 +1,16 @@
 namespace WoofWare.Myriad.Plugins
 
-open System
 open System.Net.Http
-open System.Text
 open Fantomas.FCS.Syntax
 open Fantomas.FCS.SyntaxTrivia
 open Fantomas.FCS.Xml
 open Myriad.Core
 
+type internal HttpClientGeneratorOutputSpec =
+    {
+        ExtensionMethods : bool
+    }
+
 [<RequireQualifiedAccess>]
 module internal HttpClientGenerator =
     open Fantomas.FCS.Text.Range
@@ -82,34 +85,50 @@ module internal HttpClientGenerator =
                 match attr.TypeName.AsString with
                 | "Get"
                 | "GetAttribute"
+                | "WoofWare.Myriad.Plugins.RestEase.Get"
+                | "WoofWare.Myriad.Plugins.RestEase.GetAttribute"
                 | "RestEase.Get"
                 | "RestEase.GetAttribute" -> Some (HttpMethod.Get, attr.ArgExpr)
                 | "Post"
                 | "PostAttribute"
+                | "WoofWare.Myriad.Plugins.RestEase.Post"
+                | "WoofWare.Myriad.Plugins.RestEase.PostAttribute"
                 | "RestEase.Post"
                 | "RestEase.PostAttribute" -> Some (HttpMethod.Post, attr.ArgExpr)
                 | "Put"
                 | "PutAttribute"
+                | "WoofWare.Myriad.Plugins.RestEase.Put"
+                | "WoofWare.Myriad.Plugins.RestEase.PutAttribute"
                 | "RestEase.Put"
                 | "RestEase.PutAttribute" -> Some (HttpMethod.Put, attr.ArgExpr)
                 | "Delete"
                 | "DeleteAttribute"
+                | "WoofWare.Myriad.Plugins.RestEase.Delete"
+                | "WoofWare.Myriad.Plugins.RestEase.DeleteAttribute"
                 | "RestEase.Delete"
                 | "RestEase.DeleteAttribute" -> Some (HttpMethod.Delete, attr.ArgExpr)
                 | "Head"
                 | "HeadAttribute"
+                | "WoofWare.Myriad.Plugins.RestEase.Head"
+                | "WoofWare.Myriad.Plugins.RestEase.HeadAttribute"
                 | "RestEase.Head"
                 | "RestEase.HeadAttribute" -> Some (HttpMethod.Head, attr.ArgExpr)
                 | "Options"
                 | "OptionsAttribute"
+                | "WoofWare.Myriad.Plugins.RestEase.Options"
+                | "WoofWare.Myriad.Plugins.RestEase.OptionsAttribute"
                 | "RestEase.Options"
                 | "RestEase.OptionsAttribute" -> Some (HttpMethod.Options, attr.ArgExpr)
                 | "Patch"
                 | "PatchAttribute"
+                | "WoofWare.Myriad.Plugins.RestEase.Patch"
+                | "WoofWare.Myriad.Plugins.RestEase.PatchAttribute"
                 | "RestEase.Patch"
                 | "RestEase.PatchAttribute" -> Some (HttpMethod.Patch, attr.ArgExpr)
                 | "Trace"
                 | "TraceAttribute"
+                | "WoofWare.Myriad.Plugins.RestEase.Trace"
+                | "WoofWare.Myriad.Plugins.RestEase.TraceAttribute"
                 | "RestEase.Trace"
                 | "RestEase.TraceAttribute" -> Some (HttpMethod.Trace, attr.ArgExpr)
                 | _ -> None
@@ -127,7 +146,8 @@ module internal HttpClientGenerator =
         |> List.choose (fun attr ->
             match attr.TypeName.AsString with
             | "Header"
-            | "RestEase.Header" ->
+            | "RestEase.Header"
+            | "WoofWare.Myriad.Plugins.RestEase.Header" ->
                 match attr.ArgExpr with
                 | SynExpr.Paren (SynExpr.Tuple (_, [ v1 ; v2 ], _, _), _, _, _) ->
                     Some [ SynExpr.stripOptionalParen v1 ; SynExpr.stripOptionalParen v2 ]
@@ -293,6 +313,27 @@ module internal HttpClientGenerator =
                     | None -> failwith "Unable to get parameter variable name from anonymous parameter"
                     | Some id -> id
 
+                let urlSeparator =
+                    // apparent Myriad bug: `IndexOf '?'` gets formatted as `IndexOf ?` which is clearly wrong
+                    let questionMark =
+                        SynExpr.CreateParen (
+                            SynExpr.CreateApp (
+                                SynExpr.CreateIdentString "char",
+                                SynExpr.CreateConst (SynConst.Int32 63)
+                            )
+                        )
+
+                    let containsQuestion =
+                        info.UrlTemplate
+                        |> SynExpr.callMethodArg "IndexOf" questionMark
+                        |> SynExpr.greaterThanOrEqual (SynExpr.CreateConst (SynConst.Int32 0))
+
+                    SynExpr.ifThenElse
+                        containsQuestion
+                        (SynExpr.CreateConst (SynConst.CreateString "?"))
+                        (SynExpr.CreateConst (SynConst.CreateString "&"))
+                    |> SynExpr.CreateParen
+
                 let prefix =
                     SynExpr.CreateIdent firstValueId
                     |> SynExpr.toString firstValue.Type
@@ -301,7 +342,7 @@ module internal HttpClientGenerator =
                         SynExpr.CreateLongIdent (SynLongIdent.Create [ "System" ; "Web" ; "HttpUtility" ; "UrlEncode" ])
                     )
                     |> SynExpr.CreateParen
-                    |> SynExpr.plus (SynExpr.CreateConstString ("?" + firstKey + "="))
+                    |> SynExpr.plus (SynExpr.plus urlSeparator (SynExpr.CreateConstString (firstKey + "=")))
 
                 (prefix, queryParams)
                 ||> List.fold (fun uri (paramKey, paramValue) ->
@@ -709,6 +750,10 @@ module internal HttpClientGenerator =
         attrs
         |> List.choose (fun attr ->
             match attr.TypeName.AsString with
+            | "RestEase.Query"
+            | "RestEase.QueryAttribute"
+            | "WoofWare.Myriad.Plugins.RestEase.Query"
+            | "WoofWare.Myriad.Plugins.RestEase.QueryAttribute"
             | "Query"
             | "QueryAttribute" ->
                 match attr.ArgExpr with
@@ -717,14 +762,22 @@ module internal HttpClientGenerator =
                     Some (HttpAttribute.Query (Some s))
                 | SynExpr.Const (a, _) -> failwith $"unrecognised constant arg to the Query attribute: %+A{a}"
                 | _ -> None
+            | "RestEase.Path"
+            | "RestEase.PathAttribute"
+            | "WoofWare.Myriad.Plugins.RestEase.Path"
+            | "WoofWare.Myriad.Plugins.RestEase.PathAttribute"
             | "Path"
             | "PathAttribute" ->
-                match attr.ArgExpr with
+                match attr.ArgExpr |> SynExpr.stripOptionalParen with
                 | SynExpr.Const (SynConst.String (s, SynStringKind.Regular, _), _) ->
                     Some (HttpAttribute.Path (PathSpec.Verbatim s))
                 | SynExpr.Const (SynConst.Unit, _) -> Some (HttpAttribute.Path PathSpec.MatchArgName)
                 | SynExpr.Const (a, _) -> failwith $"unrecognised constant arg to the Path attribute: %+A{a}"
                 | _ -> None
+            | "RestEase.Body"
+            | "RestEase.BodyAttribute"
+            | "WoofWare.Myriad.Plugins.RestEase.Body"
+            | "WoofWare.Myriad.Plugins.RestEase.BodyAttribute"
             | "Body"
             | "BodyAttribute" ->
                 match attr.ArgExpr with
@@ -740,8 +793,10 @@ module internal HttpClientGenerator =
             match attr.TypeName.AsString with
             | "BasePath"
             | "RestEase.BasePath"
+            | "WoofWare.Myriad.Plugins.RestEase.BasePath"
             | "BasePathAttribute"
-            | "RestEase.BasePathAttribute" -> Some attr.ArgExpr
+            | "RestEase.BasePathAttribute"
+            | "WoofWare.Myriad.Plugins.RestEase.BasePathAttribute" -> Some attr.ArgExpr
             | _ -> None
         )
 
@@ -751,25 +806,25 @@ module internal HttpClientGenerator =
             match attr.TypeName.AsString with
             | "BaseAddress"
             | "RestEase.BaseAddress"
+            | "WoofWare.Myriad.Plugins.RestEase.BaseAddress"
             | "BaseAddressAttribute"
-            | "RestEase.BaseAddressAttribute" -> Some attr.ArgExpr
+            | "RestEase.BaseAddressAttribute"
+            | "WoofWare.Myriad.Plugins.RestEase.BaseAddressAttribute" -> Some attr.ArgExpr
             | _ -> None
         )
 
-    let lowerFirstLetter (x : Ident) : Ident =
-        let result = StringBuilder x.idText.Length
-        result.Append (Char.ToLowerInvariant x.idText.[0]) |> ignore
-        result.Append x.idText.[1..] |> ignore
-        Ident.Create ((result : StringBuilder).ToString ())
-
     let createModule
         (opens : SynOpenDeclTarget list)
         (ns : LongIdent)
-        (interfaceType : SynTypeDefn)
+        (interfaceType : SynTypeDefn, spec : HttpClientGeneratorOutputSpec)
         : SynModuleOrNamespace
         =
         let interfaceType = AstHelper.parseInterface interfaceType
 
+        if not (List.isEmpty interfaceType.Inherits) then
+            failwith
+                "HttpClientGenerator does not support inheritance. Remove the `inherit` keyword if you want to use this generator."
+
         let constantHeaders =
             interfaceType.Attributes
             |> extractHeaderInformation
@@ -891,7 +946,7 @@ module internal HttpClientGenerator =
                         Some (SynBindingReturnInfo.Create pi.Type),
                         SynExpr.CreateApp (
                             SynExpr.CreateLongIdent (
-                                SynLongIdent.CreateFromLongIdent [ lowerFirstLetter pi.Identifier ]
+                                SynLongIdent.CreateFromLongIdent [ Ident.lowerFirstLetter pi.Identifier ]
                             ),
                             SynExpr.CreateConst SynConst.Unit
                         ),
@@ -909,7 +964,13 @@ module internal HttpClientGenerator =
 
         let members = propertyMembers @ nonPropertyMembers
 
-        let docString = PreXmlDoc.Create " Module for constructing a REST client."
+        let docString =
+            (if spec.ExtensionMethods then
+                 "Extension methods"
+             else
+                 "Module")
+            |> sprintf " %s for constructing a REST client."
+            |> PreXmlDoc.Create
 
         let interfaceImpl =
             SynExpr.ObjExpr (
@@ -927,7 +988,7 @@ module internal HttpClientGenerator =
             properties
             |> List.map (fun (_, pi) ->
                 SynPat.CreateTyped (
-                    SynPat.CreateNamed (lowerFirstLetter pi.Identifier),
+                    SynPat.CreateNamed (Ident.lowerFirstLetter pi.Identifier),
                     SynType.CreateFun (SynType.CreateLongIdent "unit", pi.Type)
                 )
                 |> SynPat.CreateParen
@@ -945,38 +1006,38 @@ module internal HttpClientGenerator =
                 " Create a REST client."
             else
                 " Create a REST client. The input functions will be re-evaluated on every HTTP request to obtain the required values for the corresponding header properties."
+            |> PreXmlDoc.Create
 
-        let createFunc =
-            SynBinding.SynBinding (
-                None,
-                SynBindingKind.Normal,
-                false,
-                false,
-                [],
-                PreXmlDoc.Create xmlDoc,
-                SynValData.SynValData (
-                    None,
-                    SynValInfo.SynValInfo (
-                        [ [ SynArgInfo.SynArgInfo ([], false, Some (Ident.Create "client")) ] ],
-                        SynArgInfo.Empty
-                    ),
+        let functionName = Ident.Create "client"
+
+        let valData =
+            let memberFlags =
+                if spec.ExtensionMethods then
+                    {
+                        SynMemberFlags.IsInstance = false
+                        SynMemberFlags.IsDispatchSlot = false
+                        SynMemberFlags.IsOverrideOrExplicitImpl = false
+                        SynMemberFlags.IsFinal = false
+                        SynMemberFlags.GetterOrSetterIsCompilerGenerated = false
+                        SynMemberFlags.MemberKind = SynMemberKind.Member
+                    }
+                    |> Some
+                else
                     None
-                ),
-                SynPat.CreateLongIdent (SynLongIdent.CreateString "make", headerArgs @ [ clientCreationArg ]),
-                Some (
-                    SynBindingReturnInfo.Create (
-                        SynType.LongIdent (SynLongIdent.CreateFromLongIdent interfaceType.Name)
-                    )
-                ),
-                interfaceImpl,
-                range0,
-                DebugPointAtBinding.NoneAtLet,
-                SynExpr.synBindingTriviaZero false
-            )
-            |> List.singleton
-            |> SynModuleDecl.CreateLet
 
-        let moduleName : LongIdent =
+            SynValData.SynValData (
+                memberFlags,
+                SynValInfo.SynValInfo ([ [ SynArgInfo.SynArgInfo ([], false, Some functionName) ] ], SynArgInfo.Empty),
+                None
+            )
+
+        let pattern =
+            SynPat.CreateLongIdent (SynLongIdent.CreateString "make", headerArgs @ [ clientCreationArg ])
+
+        let returnInfo =
+            SynBindingReturnInfo.Create (SynType.LongIdent (SynLongIdent.CreateFromLongIdent interfaceType.Name))
+
+        let nameWithoutLeadingI =
             List.last interfaceType.Name
             |> _.idText
             |> fun s ->
@@ -984,14 +1045,84 @@ module internal HttpClientGenerator =
                     s.[1..]
                 else
                     failwith $"Expected interface type to start with 'I', but was: %s{s}"
-            |> Ident.Create
-            |> List.singleton
+
+        let createFunc =
+            if spec.ExtensionMethods then
+                let binding =
+                    SynBinding.SynBinding (
+                        None,
+                        SynBindingKind.Normal,
+                        false,
+                        false,
+                        [],
+                        xmlDoc,
+                        valData,
+                        pattern,
+                        Some returnInfo,
+                        interfaceImpl,
+                        range0,
+                        DebugPointAtBinding.NoneAtInvisible,
+                        {
+                            LeadingKeyword = SynLeadingKeyword.StaticMember (range0, range0)
+                            InlineKeyword = None
+                            EqualsRange = Some range0
+                        }
+                    )
+
+                let mem = SynMemberDefn.Member (binding, range0)
+
+                let containingType =
+                    SynTypeDefn.SynTypeDefn (
+                        SynComponentInfo.Create (
+                            [ Ident.Create nameWithoutLeadingI ],
+                            xmldoc = PreXmlDoc.Create " Extension methods for HTTP clients"
+                        ),
+                        SynTypeDefnRepr.ObjectModel (SynTypeDefnKind.Augmentation range0, [], range0),
+                        [ mem ],
+                        None,
+                        range0,
+                        {
+                            LeadingKeyword = SynTypeDefnLeadingKeyword.Type range0
+                            EqualsRange = None
+                            WithKeyword = None
+                        }
+                    )
+
+                SynModuleDecl.Types ([ containingType ], range0)
+
+            else
+                SynBinding.SynBinding (
+                    None,
+                    SynBindingKind.Normal,
+                    false,
+                    false,
+                    [],
+                    xmlDoc,
+                    valData,
+                    pattern,
+                    Some returnInfo,
+                    interfaceImpl,
+                    range0,
+                    DebugPointAtBinding.NoneAtLet,
+                    SynExpr.synBindingTriviaZero false
+                )
+                |> List.singleton
+                |> SynModuleDecl.CreateLet
+
+        let moduleName : LongIdent =
+            if spec.ExtensionMethods then
+                [ Ident.Create (nameWithoutLeadingI + "HttpClientExtension") ]
+            else
+                [ Ident.Create nameWithoutLeadingI ]
 
         let attribs =
-            [
-                SynAttributeList.Create SynAttribute.compilationRepresentation
-                SynAttributeList.Create (SynAttribute.RequireQualifiedAccess ())
-            ]
+            if spec.ExtensionMethods then
+                [ SynAttributeList.Create SynAttribute.autoOpen ]
+            else
+                [
+                    SynAttributeList.Create SynAttribute.compilationRepresentation
+                    SynAttributeList.Create (SynAttribute.RequireQualifiedAccess ())
+                ]
 
         let modInfo =
             SynComponentInfo.Create (
@@ -1029,9 +1160,29 @@ type HttpClientGenerator () =
             let namespaceAndTypes =
                 types
                 |> List.choose (fun (ns, types) ->
-                    match types |> List.filter Ast.hasAttribute<HttpClientAttribute> with
-                    | [] -> None
-                    | types -> Some (ns, types)
+                    types
+                    |> List.choose (fun typeDef ->
+                        match Ast.getAttribute<HttpClientAttribute> typeDef with
+                        | None -> None
+                        | Some attr ->
+                            let arg =
+                                match SynExpr.stripOptionalParen attr.ArgExpr with
+                                | SynExpr.Const (SynConst.Bool value, _) -> value
+                                | SynExpr.Const (SynConst.Unit, _) -> JsonParseAttribute.DefaultIsExtensionMethod
+                                | arg ->
+                                    failwith
+                                        $"Unrecognised argument %+A{arg} to [<%s{nameof HttpClientAttribute}>]. Literals are not supported. Use `true` or `false` (or unit) only."
+
+                            let spec =
+                                {
+                                    ExtensionMethods = arg
+                                }
+
+                            Some (typeDef, spec)
+                    )
+                    |> function
+                        | [] -> None
+                        | ty -> Some (ns, ty)
                 )
 
             let modules =

WoofWare.Myriad.Plugins/Ident.fs

@@ -0,0 +1,14 @@
+namespace WoofWare.Myriad.Plugins
+
+open System
+open System.Text
+open Fantomas.FCS.Syntax
+open Myriad.Core
+
+[<RequireQualifiedAccess>]
+module internal Ident =
+    let lowerFirstLetter (x : Ident) : Ident =
+        let result = StringBuilder x.idText.Length
+        result.Append (Char.ToLowerInvariant x.idText.[0]) |> ignore
+        result.Append x.idText.[1..] |> ignore
+        Ident.Create ((result : StringBuilder).ToString ())

WoofWare.Myriad.Plugins/InterfaceMockGenerator.fs

@@ -21,6 +21,9 @@ module internal InterfaceMockGenerator =
         | None -> failwith "Expected record field to have a name, but it was somehow anonymous"
         | Some id -> id
 
+    [<RequireQualifiedAccess>]
+    type private KnownInheritance = | IDisposable
+
     let createType
         (spec : GenerateMockOutputSpec)
         (name : string)
@@ -29,6 +32,20 @@ module internal InterfaceMockGenerator =
         (fields : SynField list)
         : SynModuleDecl
         =
+        let inherits =
+            interfaceType.Inherits
+            |> Seq.map (fun ty ->
+                match ty with
+                | SynType.LongIdent (SynLongIdent.SynLongIdent (name, _, _)) ->
+                    match name |> List.map _.idText with
+                    | [] -> failwith "Unexpected empty identifier in inheritance declaration"
+                    | [ "IDisposable" ]
+                    | [ "System" ; "IDisposable" ] -> KnownInheritance.IDisposable
+                    | _ -> failwithf "Unrecognised inheritance identifier: %+A" name
+                | x -> failwithf "Unrecognised type in inheritance: %+A" x
+            )
+            |> Set.ofSeq
+
         let synValData =
             {
                 SynMemberFlags.IsInstance = false
@@ -90,6 +107,23 @@ module internal InterfaceMockGenerator =
                 )
             |> SynBindingReturnInfo.Create
 
+        let constructorFields =
+            let extras =
+                if inherits.Contains KnownInheritance.IDisposable then
+                    let unitFun = SynExpr.createLambda "_" SynExpr.CreateUnit
+
+                    [
+                        (SynLongIdent.CreateFromLongIdent [ Ident.Create "Dispose" ], true), Some unitFun
+                    ]
+                else
+                    []
+
+            let nonExtras =
+                fields
+                |> List.map (fun field -> (SynLongIdent.CreateFromLongIdent [ getName field ], true), Some failwithFun)
+
+            extras @ nonExtras
+
         let constructor =
             SynMemberDefn.Member (
                 SynBinding.SynBinding (
@@ -102,12 +136,7 @@ module internal InterfaceMockGenerator =
                     SynValData.SynValData (Some synValData, SynValInfo.Empty, None),
                     constructorIdent,
                     Some constructorReturnType,
-                    AstHelper.instantiateRecord (
-                        fields
-                        |> List.map (fun field ->
-                            ((SynLongIdent.CreateFromLongIdent [ getName field ], true), Some failwithFun)
-                        )
-                    ),
+                    AstHelper.instantiateRecord constructorFields,
                     range0,
                     DebugPointAtBinding.Yes range0,
                     { SynExpr.synBindingTriviaZero true with
@@ -117,6 +146,21 @@ module internal InterfaceMockGenerator =
                 range0
             )
 
+        let fields =
+            let extras =
+                if inherits.Contains KnownInheritance.IDisposable then
+                    [
+                        SynField.Create (
+                            SynType.CreateFun (SynType.CreateUnit, SynType.CreateUnit),
+                            Ident.Create "Dispose",
+                            xmldoc = PreXmlDoc.Create " Implementation of IDisposable.Dispose"
+                        )
+                    ]
+                else
+                    []
+
+            extras @ fields
+
         let interfaceMembers =
             let members =
                 interfaceType.Members
@@ -150,7 +194,9 @@ module internal InterfaceMockGenerator =
                                                 |> List.mapi (fun i arg ->
                                                     arg.Args
                                                     |> List.mapi (fun j arg ->
-                                                        SynArgInfo.CreateIdString $"arg_%i{i}_%i{j}"
+                                                        match arg.Type with
+                                                        | UnitType -> SynArgInfo.SynArgInfo ([], false, None)
+                                                        | _ -> SynArgInfo.CreateIdString $"arg_%i{i}_%i{j}"
                                                     )
                                                 )
                                         ],
@@ -165,10 +211,18 @@ module internal InterfaceMockGenerator =
                         |> List.mapi (fun i tupledArgs ->
                             let args =
                                 tupledArgs.Args
-                                |> List.mapi (fun j _ -> SynPat.CreateNamed (Ident.Create $"arg_%i{i}_%i{j}"))
+                                |> List.mapi (fun j ty ->
+                                    match ty.Type with
+                                    | UnitType -> SynPat.Const (SynConst.Unit, range0)
+                                    | _ -> SynPat.CreateNamed (Ident.Create $"arg_%i{i}_%i{j}")
+                                )
 
-                            SynPat.Tuple (false, args, List.replicate (args.Length - 1) range0, range0)
-                            |> SynPat.CreateParen
+                            match args with
+                            | [] -> failwith "somehow got no args at all"
+                            | [ arg ] -> arg
+                            | args ->
+                                SynPat.Tuple (false, args, List.replicate (args.Length - 1) range0, range0)
+                                |> SynPat.CreateParen
                             |> fun i -> if tupledArgs.HasParen then SynPat.Paren (i, range0) else i
                         )
 
@@ -187,7 +241,11 @@ module internal InterfaceMockGenerator =
                             memberInfo.Args
                             |> List.mapi (fun i args ->
                                 args.Args
-                                |> List.mapi (fun j args -> SynExpr.CreateIdentString $"arg_%i{i}_%i{j}")
+                                |> List.mapi (fun j arg ->
+                                    match arg.Type with
+                                    | UnitType -> SynExpr.CreateConst SynConst.Unit
+                                    | _ -> SynExpr.CreateIdentString $"arg_%i{i}_%i{j}"
+                                )
                                 |> SynExpr.CreateParenedTuple
                             )
 
@@ -264,11 +322,100 @@ module internal InterfaceMockGenerator =
             | Some (SynAccess.Internal _), _ -> SynAccess.Internal range0
             | Some (SynAccess.Private _), _ -> SynAccess.Private range0
 
+        let extraInterfaces =
+            inherits
+            |> Seq.map (fun inheritance ->
+                match inheritance with
+                | KnownInheritance.IDisposable ->
+                    let valData =
+                        SynValData.SynValData (
+                            Some
+                                {
+                                    IsInstance = true
+                                    IsDispatchSlot = false
+                                    IsOverrideOrExplicitImpl = true
+                                    IsFinal = false
+                                    GetterOrSetterIsCompilerGenerated = false
+                                    MemberKind = SynMemberKind.Member
+                                },
+                            valInfo =
+                                SynValInfo.SynValInfo (
+                                    curriedArgInfos =
+                                        [
+                                            yield
+                                                [
+                                                    SynArgInfo.SynArgInfo (
+                                                        attributes = [],
+                                                        optional = false,
+                                                        ident = None
+                                                    )
+                                                ]
+                                        ],
+                                    returnInfo =
+                                        SynArgInfo.SynArgInfo (attributes = [], optional = false, ident = None)
+                                ),
+                            thisIdOpt = None
+                        )
+
+                    let headArgs = [ SynPat.Const (SynConst.Unit, range0) ]
+
+                    let headPat =
+                        SynPat.LongIdent (
+                            SynLongIdent.CreateFromLongIdent [ Ident.Create "this" ; Ident.Create "Dispose" ],
+                            None,
+                            None,
+                            SynArgPats.Pats headArgs,
+                            None,
+                            range0
+                        )
+
+                    let binding =
+                        SynBinding.SynBinding (
+                            None,
+                            SynBindingKind.Normal,
+                            false,
+                            false,
+                            [],
+                            PreXmlDoc.Empty,
+                            valData,
+                            headPat,
+                            Some (
+                                SynBindingReturnInfo.SynBindingReturnInfo (
+                                    SynType.Unit (),
+                                    range0,
+                                    [],
+                                    SynBindingReturnInfoTrivia.Zero
+                                )
+                            ),
+                            SynExpr.CreateApp (
+                                SynExpr.CreateLongIdent (SynLongIdent.Create [ "this" ; "Dispose" ]),
+                                SynExpr.CreateUnit
+                            ),
+                            range0,
+                            DebugPointAtBinding.Yes range0,
+                            {
+                                LeadingKeyword = SynLeadingKeyword.Member range0
+                                InlineKeyword = None
+                                EqualsRange = Some range0
+                            }
+                        )
+
+                    let mem = SynMemberDefn.Member (binding, range0)
+
+                    SynMemberDefn.Interface (
+                        SynType.CreateLongIdent (SynLongIdent.Create [ "System" ; "IDisposable" ]),
+                        Some range0,
+                        Some [ mem ],
+                        range0
+                    )
+            )
+            |> Seq.toList
+
         let record =
             {
                 Name = Ident.Create name
                 Fields = fields
-                Members = Some [ constructor ; interfaceMembers ]
+                Members = Some ([ constructor ; interfaceMembers ] @ extraInterfaces)
                 XmlDoc = Some xmlDoc
                 Generics = interfaceType.Generics
                 Accessibility = Some access
@@ -333,7 +480,6 @@ module internal InterfaceMockGenerator =
 
         let typeDecl = createType spec name interfaceType docString fields
 
-
         SynModuleOrNamespace.CreateNamespace (
             namespaceId,
             decls = (opens |> List.map SynModuleDecl.CreateOpen) @ [ typeDecl ]

WoofWare.Myriad.Plugins/JsonParseGenerator.fs

@@ -62,6 +62,13 @@ module internal JsonParseGenerator =
     /// {node}.AsValue().GetValue<{typeName}> ()
     /// If `propertyName` is Some, uses `assertNotNull {node}` instead of `{node}`.
     let asValueGetValue (propertyName : SynExpr option) (typeName : string) (node : SynExpr) : SynExpr =
+        match propertyName with
+        | None -> node
+        | Some propertyName -> assertNotNull propertyName node
+        |> SynExpr.callMethod "AsValue"
+        |> SynExpr.callGenericMethod' "GetValue" typeName
+
+    let asValueGetValueIdent (propertyName : SynExpr option) (typeName : LongIdent) (node : SynExpr) : SynExpr =
         match propertyName with
         | None -> node
         | Some propertyName -> assertNotNull propertyName node
@@ -122,7 +129,12 @@ module internal JsonParseGenerator =
 
     /// Given e.g. "float", returns "System.Double.Parse"
     let parseFunction (typeName : string) : LongIdent =
-        List.append (SynExpr.qualifyPrimitiveType typeName) [ Ident.Create "Parse" ]
+        let qualified =
+            match AstHelper.qualifyPrimitiveType typeName with
+            | Some x -> x
+            | None -> failwith $"Could not recognise type %s{typeName} as a primitive."
+
+        List.append qualified [ Ident.Create "Parse" ]
 
     /// fun kvp -> let key = {key(kvp)} in let value = {value(kvp)} in (key, value))
     /// The inputs will be fed with appropriate SynExprs to apply them to the `kvp.Key` and `kvp.Value` args.
@@ -252,7 +264,7 @@ module internal JsonParseGenerator =
                         range0
                     ))
                     handler
-        | PrimitiveType typeName -> asValueGetValue propertyName typeName node
+        | PrimitiveType typeName -> asValueGetValueIdent propertyName typeName node
         | OptionType ty ->
             parseNode None options ty (SynExpr.CreateIdentString "v")
             |> createParseLineOption node
@@ -312,6 +324,11 @@ module internal JsonParseGenerator =
                 )
             )
             |> SynExpr.pipeThroughFunction (SynExpr.CreateLongIdent (SynLongIdent.Create [ "Map" ; "ofSeq" ]))
+        | BigInt ->
+            SynExpr.CreateApp (
+                SynExpr.CreateLongIdent (SynLongIdent.Create [ "System" ; "Numerics" ; "BigInteger" ; "Parse" ]),
+                SynExpr.CreateParen (node |> SynExpr.callMethod "ToJsonString")
+            )
         | _ ->
             // Let's just hope that we've also got our own type annotation!
             let typeName =

WoofWare.Myriad.Plugins/SurfaceBaseline.txt

@@ -1,3 +1,5 @@
+WoofWare.Myriad.Plugins.CreateCatamorphismGenerator inherit obj, implements Myriad.Core.IMyriadGenerator
+WoofWare.Myriad.Plugins.CreateCatamorphismGenerator..ctor [constructor]: unit
 WoofWare.Myriad.Plugins.HttpClientGenerator inherit obj, implements Myriad.Core.IMyriadGenerator
 WoofWare.Myriad.Plugins.HttpClientGenerator..ctor [constructor]: unit
 WoofWare.Myriad.Plugins.InterfaceMockGenerator inherit obj, implements Myriad.Core.IMyriadGenerator

WoofWare.Myriad.Plugins/SynExpr.fs

@@ -107,24 +107,6 @@ module internal SynExpr =
         | SynExpr.Paren (expr, _, _, _) -> stripOptionalParen expr
         | expr -> expr
 
-    /// Given e.g. "byte", returns "System.Byte".
-    let qualifyPrimitiveType (typeName : string) : LongIdent =
-        match typeName with
-        | "float32" -> [ "System" ; "Single" ]
-        | "float" -> [ "System" ; "Double" ]
-        | "byte"
-        | "uint8" -> [ "System" ; "Byte" ]
-        | "sbyte" -> [ "System" ; "SByte" ]
-        | "int16" -> [ "System" ; "Int16" ]
-        | "int" -> [ "System" ; "Int32" ]
-        | "int64" -> [ "System" ; "Int64" ]
-        | "uint16" -> [ "System" ; "UInt16" ]
-        | "uint"
-        | "uint32" -> [ "System" ; "UInt32" ]
-        | "uint64" -> [ "System" ; "UInt64" ]
-        | _ -> failwith $"Unable to identify a parsing function `string -> %s{typeName}`"
-        |> List.map Ident.Create
-
     /// {obj}.{meth} {arg}
     let callMethodArg (meth : string) (arg : SynExpr) (obj : SynExpr) : SynExpr =
         SynExpr.CreateApp (
@@ -141,8 +123,22 @@ module internal SynExpr =
     let callMethod (meth : string) (obj : SynExpr) : SynExpr =
         callMethodArg meth (SynExpr.CreateConst SynConst.Unit) obj
 
+    let callGenericMethod (meth : string) (ty : LongIdent) (obj : SynExpr) : SynExpr =
+        SynExpr.CreateApp (
+            SynExpr.TypeApp (
+                SynExpr.DotGet (obj, range0, SynLongIdent.Create [ meth ], range0),
+                range0,
+                [ SynType.LongIdent (SynLongIdent.CreateFromLongIdent ty) ],
+                [],
+                Some range0,
+                range0,
+                range0
+            ),
+            SynExpr.CreateConst SynConst.Unit
+        )
+
     /// {obj}.{meth}<ty>()
-    let callGenericMethod (meth : string) (ty : string) (obj : SynExpr) : SynExpr =
+    let callGenericMethod' (meth : string) (ty : string) (obj : SynExpr) : SynExpr =
         SynExpr.CreateApp (
             SynExpr.TypeApp (
                 SynExpr.DotGet (obj, range0, SynLongIdent.Create [ meth ], range0),
@@ -275,3 +271,55 @@ module internal SynExpr =
                 else
                     SynLeadingKeyword.Let range0
         }
+
+    /// {ident} - {rhs}
+    let minus (ident : SynLongIdent) (rhs : SynExpr) : SynExpr =
+        SynExpr.CreateApp (
+            SynExpr.CreateAppInfix (
+                SynExpr.CreateLongIdent (
+                    SynLongIdent.SynLongIdent (
+                        [ Ident.Create "op_Subtraction" ],
+                        [],
+                        [ Some (IdentTrivia.OriginalNotation "-") ]
+                    )
+                ),
+                SynExpr.CreateLongIdent ident
+            ),
+            rhs
+        )
+
+    /// {ident} - {n}
+    let minusN (ident : SynLongIdent) (n : int) : SynExpr =
+        minus ident (SynExpr.CreateConst (SynConst.Int32 n))
+
+    /// {y} > {x}
+    let greaterThan (x : SynExpr) (y : SynExpr) : SynExpr =
+        SynExpr.CreateApp (
+            SynExpr.CreateAppInfix (
+                SynExpr.CreateLongIdent (
+                    SynLongIdent.SynLongIdent (
+                        [ Ident.Create "op_GreaterThan" ],
+                        [],
+                        [ Some (IdentTrivia.OriginalNotation ">") ]
+                    )
+                ),
+                y
+            ),
+            x
+        )
+
+    /// {y} >= {x}
+    let greaterThanOrEqual (x : SynExpr) (y : SynExpr) : SynExpr =
+        SynExpr.CreateApp (
+            SynExpr.CreateAppInfix (
+                SynExpr.CreateLongIdent (
+                    SynLongIdent.SynLongIdent (
+                        [ Ident.Create "op_GreaterThanOrEqual" ],
+                        [],
+                        [ Some (IdentTrivia.OriginalNotation ">=") ]
+                    )
+                ),
+                y
+            ),
+            x
+        )

WoofWare.Myriad.Plugins/WoofWare.Myriad.Plugins.fsproj

@@ -25,8 +25,9 @@
 
   <ItemGroup>
     <Compile Include="List.fs"/>
+    <Compile Include="Ident.fs" />
     <Compile Include="AstHelper.fs"/>
-    <Compile Include="SynExpr.fs"/>
+    <Compile Include="SynExpr.fs" />
     <Compile Include="SynType.fs"/>
     <Compile Include="SynAttribute.fs"/>
     <Compile Include="RemoveOptionsGenerator.fs"/>
@@ -34,6 +35,7 @@
     <Compile Include="JsonSerializeGenerator.fs"/>
     <Compile Include="JsonParseGenerator.fs"/>
     <Compile Include="HttpClientGenerator.fs"/>
+    <Compile Include="CataGenerator.fs" />
     <EmbeddedResource Include="version.json"/>
     <EmbeddedResource Include="SurfaceBaseline.txt"/>
     <None Include="..\README.md">

WoofWare.Myriad.Plugins/version.json

@@ -1,7 +1,7 @@
 {
-  "version": "2.0",
+  "version": "2.1",
   "publicReleaseRefSpec": [
     "^refs/heads/main$"
   ],
   "pathFilters": null
-}
+}

analyzers/analyzers.fsproj

@@ -10,7 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageDownload Include="G-Research.FSharp.Analyzers" Version="[0.8.0]" />
+    <PackageDownload Include="G-Research.FSharp.Analyzers" Version="[0.10.0]" />
   </ItemGroup>
 
 </Project>

flake.nix

@@ -7,7 +7,6 @@
   };
 
   outputs = {
-    self,
     nixpkgs,
     flake-utils,
     ...

nix/deps.nix

@@ -3,23 +3,18 @@
 {fetchNuGet}: [
   (fetchNuGet {
     pname = "fsharp-analyzers";
-    version = "0.24.0";
-    sha256 = "sha256-cNaM/yHI28sHDGamKMrU237ltOyrR+8vPNUImB5RxjU=";
+    version = "0.26.0";
+    sha256 = "sha256-60Bl36LOb/zVNdH2SBSuQ5O41lP9dKTNZbs5vvYs+3U=";
   })
   (fetchNuGet {
     pname = "fantomas";
-    version = "6.3.0-alpha-007";
-    sha256 = "sha256-uZw6h6k/DS4BcYtK9cv8TLS0H8MZDO3WBaPPTdtTgu0=";
+    version = "6.3.4";
+    sha256 = "sha256-1aWqZynBkQoznenGoP0sbf1PcUXAbcHiWyECuv89xa0=";
   })
   (fetchNuGet {
     pname = "ApiSurface";
-    version = "4.0.28";
-    sha256 = "1gg0dqbgbb8aqn2lxi5gf2wq969kgskby5wph6m2b3hdkz7265ak";
-  })
-  (fetchNuGet {
-    pname = "coverlet.collector";
-    version = "6.0.0";
-    sha256 = "12j34vrkmph8lspbafnqmfnj2qvysz1jcrks2khw798s6dwv0j90";
+    version = "4.0.39";
+    sha256 = "sha256-I4K5nJbltsfL/1r+KPTIo2wUd30zsCC2pkrnIRnsRHM=";
   })
   (fetchNuGet {
     pname = "Fantomas.Core";
@@ -121,21 +116,11 @@
     version = "8.0.0";
     sha256 = "0055f69q3hbagqp8gl3nk0vfn4qyqyxsxyy7pd0g7wm3z28byzmx";
   })
-  (fetchNuGet {
-    pname = "Microsoft.CodeCoverage";
-    version = "17.8.0";
-    sha256 = "173wjadp3gan4x2jfjchngnc4ca4mb95h1sbb28jydfkfw0z1zvj";
-  })
   (fetchNuGet {
     pname = "Microsoft.CodeCoverage";
     version = "17.9.0";
     sha256 = "1gljgi69k0fz8vy8bn6xlyxabj6q4vls2zza9wz7ng6ix3irm89r";
   })
-  (fetchNuGet {
-    pname = "Microsoft.NET.Test.Sdk";
-    version = "17.8.0";
-    sha256 = "1syvl3g0hbrcgfi9rq6pld8s8hqqww4dflf1lxn59ccddyyx0gmv";
-  })
   (fetchNuGet {
     pname = "Microsoft.NET.Test.Sdk";
     version = "17.9.0";
@@ -281,21 +266,11 @@
     version = "8.0.0";
     sha256 = "1gdx7n45wwia3yvang3ls92sk3wrymqcx9p349j8wba2lyjf9m44";
   })
-  (fetchNuGet {
-    pname = "Microsoft.TestPlatform.ObjectModel";
-    version = "17.8.0";
-    sha256 = "0b0i7lmkrcfvim8i3l93gwqvkhhhfzd53fqfnygdqvkg6np0cg7m";
-  })
   (fetchNuGet {
     pname = "Microsoft.TestPlatform.ObjectModel";
     version = "17.9.0";
     sha256 = "1kgsl9w9fganbm9wvlkqgk0ag9hfi58z88rkfybc6kvg78bx89ca";
   })
-  (fetchNuGet {
-    pname = "Microsoft.TestPlatform.TestHost";
-    version = "17.8.0";
-    sha256 = "0f5jah93kjkvxwmhwb78lw11m9pkkq9fvf135hpymmmpxqbdh97q";
-  })
   (fetchNuGet {
     pname = "Microsoft.TestPlatform.TestHost";
     version = "17.9.0";
@@ -316,11 +291,6 @@
     version = "3.6.133";
     sha256 = "1cdw8krvsnx0n34f7fm5hiiy7bs6h3asvncqcikc0g46l50w2j80";
   })
-  (fetchNuGet {
-    pname = "NETStandard.Library";
-    version = "2.0.0";
-    sha256 = "1bc4ba8ahgk15m8k4nd7x406nhi0kwqzbgjk2dmw52ss553xz7iy";
-  })
   (fetchNuGet {
     pname = "NETStandard.Library";
     version = "2.0.3";
@@ -338,28 +308,23 @@
   })
   (fetchNuGet {
     pname = "NuGet.Common";
-    version = "6.8.0";
-    sha256 = "0l3ij8iwy7wj6s7f93lzi9168r4wz8zyin6a08iwgk7hvq44cia1";
+    version = "6.9.1";
+    sha256 = "0ic3d46r9v05pkczpmskw86yzixm6iwshbw0ya8i2957nhhlymw8";
   })
   (fetchNuGet {
     pname = "NuGet.Configuration";
-    version = "6.8.0";
-    sha256 = "0x03p408smkmv1gv7pmvsia4lkn0xaj4wfrkl58pjf8bbv51y0yw";
+    version = "6.9.1";
+    sha256 = "07z4qgbibpg59j2r05ifnqdyqf2xinm33rx7gjyr1f73kzg01m33";
   })
   (fetchNuGet {
     pname = "NuGet.Frameworks";
-    version = "6.5.0";
-    sha256 = "0s37d1p4md0k6d4cy6sq36f2dgkd9qfbzapxhkvi8awwh0vrynhj";
-  })
-  (fetchNuGet {
-    pname = "NuGet.Frameworks";
-    version = "6.8.0";
-    sha256 = "0i2xvhgkjkjr496i3pg8hamwv6505fia45qhn7jg5m01wb3cvsjl";
+    version = "6.9.1";
+    sha256 = "0s3az3ac53icjnmb14hfjcmkvzscvrkm62jgqf48yvsbysyhqm5s";
   })
   (fetchNuGet {
     pname = "NuGet.Packaging";
-    version = "6.8.0";
-    sha256 = "031z4s905bxi94h3f0qy4j1b6jxdxgqgpkzqvvpfxch07szxcbim";
+    version = "6.9.1";
+    sha256 = "0w0arkmzg3qh1brq4vm10zrsjm7nw706ld4y5kqcmvjpd16f4b4y";
   })
   (fetchNuGet {
     pname = "NuGet.Protocol";
@@ -368,18 +333,13 @@
   })
   (fetchNuGet {
     pname = "NuGet.Versioning";
-    version = "6.8.0";
-    sha256 = "1sd25h46fd12ng780r02q4ijcx1imkb53kj1y2y7cwg5myh537ks";
+    version = "6.9.1";
+    sha256 = "0xrs82dydy9cgxf0qypr01wawwnq1nf6fc7rwisb4y5v4r259fdm";
   })
   (fetchNuGet {
     pname = "NUnit";
-    version = "3.13.3";
-    sha256 = "0wdzfkygqnr73s6lpxg5b1pwaqz9f414fxpvpdmf72bvh4jaqzv6";
-  })
-  (fetchNuGet {
-    pname = "NUnit";
-    version = "4.0.1";
-    sha256 = "0jgiq3dbwli5r70j0bw7021d69r7bhr58s8kphlpjmf7k47l5pcd";
+    version = "4.1.0";
+    sha256 = "0fj6xwgqaxq3mrai86bklclfmjkzf038mrslwfqf4ignaz9f7g5j";
   })
   (fetchNuGet {
     pname = "NUnit3TestAdapter";