The latest release of Microsoft’s F# language, version 10, introduces several new features that developers have been waiting for. One of the most notable additions is the ability to control compiler warnings within specific parts of the code using new directives. This means you can now turn warnings on or off precisely where needed, making your code cleaner and less cluttered with unnecessary alerts.

Scoped Warning Management with #warnon and #nowarn

Before F# 10, managing warnings was more of a global affair, which sometimes led to suppressing important warnings or missing out on helpful feedback. Now, with the introduction of the #warnon and #nowarn directives, developers can selectively disable or enable warnings in specific code segments. This scoped approach helps keep the overall codebase warning-free without hiding issues across the board.

This change was part of the broader F# 10 update launched alongside .NET 10 on November 11. However, some of these updates involved breaking changes, especially related to the consistency of how #nowarn and #warnon are used. Developers updating their projects should review their warning management practices to ensure compatibility and avoid unexpected issues.

Enhanced Property Access and Performance Improvements

F# 10 also gives developers more control over properties. Now, you can assign different access modifiers to the getter and setter of a property directly inline. For example, you can make a property publicly readable but only privately writable, all without adding extra boilerplate code. This feature helps write clearer, more concise property definitions that match common patterns in software design.

Another performance-focused update involves optional parameters. When using the [] attribute, optional parameters can now use a struct-based ValueOption<‘T> instead of the usual reference type. This change reduces heap allocations, which can make a big difference in high-performance scenarios where every bit of efficiency counts.

Other Notable Changes and Improvements

F# 10 enhances computation expressions, allowing tail-call optimizations to be enabled more easily, which improves performance for recursive workflows. Additionally, the syntax for type annotations within computation expressions has been simplified, removing the need for extra parentheses around the bindings. The discard pattern ( _ ) also now works in use! bindings, making resource management in asynchronous workflows more straightforward.

Structural validation has been tightened to prevent confusing module placements inside types. Now, if a module is indented at the same level as a type declaration, the compiler will raise an error. This helps keep the code structure clear and consistent, reducing bugs caused by misplacement of modules. On the performance side, the compiler now caches the results of type relationship checks, speeding up compile times and improving the overall developer experience.

In the core library, support for the and! operator within the task computation expression has been added. This operator is useful when working with asynchronous workflows, especially for C# interoperability. The build process also benefits from smarter trimming: when publishing with trimming enabled, F# automatically generates a substitutions file for tooling resources. This reduces the output size, cuts down on boilerplate, and simplifies maintenance tasks.

Overall, F# 10 delivers a mix of developer-friendly features and performance enhancements. The improvements to warning management and property access simplify coding patterns, while the build and compile optimizations ensure faster, more efficient workflows. As always, upgrading to the latest version can help developers write cleaner, faster, and more maintainable code.

Inspired by

• https://www.infoworld.com/article/4094019/f-10-features-scoped-warning-suppression.html

Sources

• gmpg.org
• flickr.com
• microsoft.com
• microsoft.com
• microsoft.com