Add formatting guidance for multiline lazy expressions in F#

[Copilot]

Summary

Addresses the user question in issue about how to format multiline lazy expressions in F#. The issue asked whether lazy expressions with multiline content should follow the function application rule or the constructor/member invocation rule.

Changes

1. Added "Formatting lazy expressions" section to F# formatting guide

Added a new section in docs/fsharp/style-guide/formatting.md that provides clear guidance on formatting both single-line and multiline lazy expressions:

Single-line lazy expressions:

let x = lazy (computeValue())

Multiline lazy expressions:

let v =
    lazy (
        // some code
        let x = computeExpensiveValue()
        let y = computeAnotherValue()
        x + y
    )

The guidance clarifies that lazy expressions follow the function application pattern: the opening parenthesis remains on the same line as the lazy keyword, with the expression body indented one level and the closing parenthesis aligned with the opening.

2. Enhanced lazy expressions reference documentation

Updated docs/fsharp/language-reference/lazy-expressions.md to include:

• A new "Formatting" section with a practical multiline example
• Cross-reference link to the detailed formatting guidance in the style guide

Resolution

This provides the answer to the user's question: multiline lazy expressions should follow the function application rule, with the pattern lazy ( keeping the opening parenthesis on the same line as lazy, which is consistent with other function applications that have multiline arguments in the F# style guide.

Fixes #<issue_number>

Original prompt

---

This section details on the original issue you should resolve

<issue_title>Lazy multiline parenthesis expression</issue_title>
<issue_description>Hello, I'm wondering what the recommended way is to write a multiline lazy expression.

let v =
    lazy (
        // some code
        // other code
        myFunctionCall x y z
    )

Should it follow the function application rule and be something like

lazy
    (multlilineExpression)

or does it follow the Formatting constructors, static members, and member invocations rule?

lazy (
    multilineExpression
)

---

Document Details

⚠ Do not edit this section. It is required for docs.microsoft.com ➟ GitHub issue linking.

• ID: 8c09996f-24ac-cf39-ef43-d7909cbc2b89
• Version Independent ID: 1efdd523-8552-6421-e149-74f76826ef8f
• Content: F# code formatting guidelines
• Content Source: docs/fsharp/style-guide/formatting.md
• Product: dotnet-fsharp
• GitHub Login: @cartermp
• Microsoft Alias: phcart</issue_description>

Comments on the Issue (you are @copilot in this section)

Fixes #24977

---

💬 Share your feedback on Copilot coding agent for the chance to win a $200 gift card! Click here to start the survey.

---

Internal previews

📄 File	🔗 Preview link
docs/fsharp/language-reference/lazy-expressions.md	docs/fsharp/language-reference/lazy-expressions
docs/fsharp/style-guide/formatting.md	docs/fsharp/style-guide/formatting

[BillWagner]

This is ready for final review.