Fsharp

Syntax and Formatting

• Follow F# Coding Guidelines (https://learn.microsoft.com/en-us/dotnet/fsharp/style-guide/)
• Align function parameters and pipelined operations for readability.
• Use lightweight syntax with minimal noise (e.g., indentation over explicit delimiters).
• Use double-backtick syntax for names with special characters or spaces when necessary.
• Use tuple deconstruction and let-bindings for clarity and conciseness.

Error Handling and Validation

• Use discriminated unions or Result types for explicit error handling.
• Use pattern matching for safe and expressive error recovery.
• Utilize computational expressions for workflows that include error handling (e.g., ResultBuilder, asyncResult).
• Validate inputs using active patterns or higher-order validation functions.

API Design

• Embrace functional-first design for APIs: design small, composable functions.
• Prefer domain modeling with records and discriminated unions.
• Design APIs to be composable and testable with clear type signatures.
• Use meaningful types to encode constraints and invariants (e.g., NonEmptyList, PositiveInt).
• Expose workflows via computational expressions if they involve state or side effects.

Performance Optimization

• Prefer tail-recursive functions for large recursive operations.
• Use arrays for performance-critical operations; prefer immutable collections otherwise.
• Avoid excessive allocation by leveraging value types and structs when appropriate.
• Optimize computation-heavy workflows with parallelism (e.g., Async.Parallel, Parallel.For).
• Avoid premature optimization; rely on profiling tools to identify bottlenecks.

Key Conventions

• Use Dependency Injection via functions or lightweight abstractions.
• Avoid heavy reliance on classes; prefer modules and functions.
• Leverage computational expressions for custom workflows (e.g., monads, DSLs).
• Design pure functions wherever possible and minimize side effects.
• Use lazy evaluation (e.g., Lazy, Seq) for deferred computations.

Testing

• Write unit tests using FsUnit or Expecto.
• Use Property-Based Testing (FsCheck) to verify function correctness across input spaces.
• Design testable modules by keeping functions pure and dependencies minimal.
• Mock dependencies minimally; prefer dependency injection and parameterized tests.
• Use integration tests for system-wide behaviors and edge cases.

Security

• Use F#'s strong type system to enforce safety (e.g., type-safe SQL, URL encoding).
• Implement secure workflows using cryptographic libraries (e.g., .NET System.Security.Cryptography).
• Use HTTPS for all endpoints and enforce SSL.
• Validate and sanitize inputs rigorously.
• Implement OAuth2/JWT for authentication and authorization.

API Documentation

• Use XML documentation comments for public APIs.
• Generate API documentation using tools like FsDocs or DocFX.
• Provide meaningful examples and type annotations for all public functions.
• Encourage self-documenting code by using descriptive names and minimal magic values.

Follow official F# documentation and .NET guidelines to ensure idiomatic, performant, and maintainable F# code for modern applications. `, author: { name: "Dexter", url: "https://x.com/dexcompiler", avatar: "", }, }, ];