Support representing arrays as F# lists

[adamjones1]

At the moment OpenApi arrays are represented as .Net arrays in the generated types. Is there any chance there could be a flag added to optionally use F# lists instead? Obviously arrays are best for C# interop but if you're only consuming from F# then lists have the benefits of being non-nullable, immutable, O(1)-append etc. Generally they're more idiomatic in F# so if your client app uses lists ubiquitously for collections then you don't have to add glue code around the generated types to convert back and forth all the time.

[xperiandri]

Or as ImmutableArray

[github-actions]

---

Note

The pull request was not created — a fallback review issue was created instead due to protected file changes: #344

🤖 This is an automated response from Repo Assist.

This is a reasonable enhancement request and the trade-offs are worth discussing:

Why arrays are currently used

System.Text.Json (the serializer) natively deserialises JSON arrays to T[]. Producing list(T) would require either a custom JsonConverter registered globally or per-schema, adding overhead and complexity.

Feasibility of adding a CollectionType static parameter

It would be possible to add a static parameter (e.g., CollectionType = "Array" | "List" | "Seq") to both OpenApiClientProvider and SwaggerClientProvider. The DefinitionCompiler already decides the collection type in one place (the array → makeArray call), so the change would be localised. However:

• Serialisation — System.Text.Json handles IReadOnlyList(T) and IEnumerable(T) for both serialise and deserialise, so exposing seq(T) or list(T) to callers while keeping the internal wire type as an array could be done.
• Overhead — for large response payloads, converting array → list at the boundary adds O(n) cost per response.
• ImmutableArray(T) (as suggested in the other comment) is arguably the best of both worlds: immutable like F# lists, random-access like arrays, and directly supported by System.Text.Json 7+.

Recommendation

The cleanest minimal change would be to expose IReadOnlyList(T) as the public type (already immutable from a caller's perspective) while keeping T[] as the concrete wire type — no converter needed, and callers who prefer F# lists can do a simple Array.toList or pattern-match using Seq. A UseImmutableCollections flag that switches to ImmutableArray(T) might also be worth considering.

If anyone wants to take this on, the key file is src/SwaggerProvider.DesignTime/v3/DefinitionCompiler.fs (look for typeOfArray).

— Repo Assist

Generated by Repo Assist · ◷

To install this agentic workflow, run

gh aw add githubnext/agentics/workflows/repo-assist.md@4957663821dbb3260348084fa2f1659701950fef