Allow yielding from a `do` block

[charlesroddie]

I propose we ... (describe your suggestion here)

Allow yielding from a do block. E.g.

[
    do
        let item00 = ...
        let item01 = ...
        yield (item00, item01)
    do
        let item10 = ...
        let item11 = ...
        yield (item00, item11)
]

This currently gives the error

FS0747 "This construct may only be used within list, array and sequence expressions, e.g. expressions of the form 'seq { ... }', '[ ... ]' or '[| ... |]'. These use the syntax 'for ... in ... do ... yield...' to generate elements"

Do blocks are nice because they allow things to be defined in smaller scopes.

The existing way of approaching this problem in F# is ...

Use a match expression (very ugly)

[
    match () with
    | () ->
        let item00 = ...
        let item01 = ...
        yield (item00, item01)
    match () with
    | () ->
        let item10 = ...
        let item11 = ...
        yield (item00, item11)
]

Or put everything in one scope

let item00 = ...
let item01 = ...
let item10 = ...
let item11 = ...
[
    (item00, item01)
    (item10, item11)
]

Pros and Cons

The advantages of making this adjustment to F# are ...

Allow defining items to be placed in lists in a smaller scope.

The disadvantages of making this adjustment to F# are ...

None

Extra information

Estimated cost (XS, S, M, L, XL, XXL): S/M

Related suggestions: (put links to related suggestions here)

Affidavit (please submit!)

Please tick these items by placing a cross in the box:

• [ x ] This is not a question (e.g. like one you might ask on StackOverflow) and I have searched StackOverflow for discussions of this issue
• [ x ] This is a language change and not purely a tooling change (e.g. compiler bug, editor support, warning/error messages, new warning, non-breaking optimisation) belonging to the compiler and tooling repository
• [ x ] This is not something which has obviously "already been decided" in previous versions of F#. If you're questioning a fundamental design decision that has obviously already been taken (e.g. "Make F# untyped") then please don't submit it
• [ x ] I have searched both open and closed suggestions on this site and believe this is not a duplicate

Please tick all that apply:

• [ x ] This is not a breaking change to the F# language design
• [ x ] I or my company would be willing to help implement and/or test this

For Readers

If you would like to see this issue implemented, please click the 👍 emoji on this issue. These counts are used to generally order the suggestions by engagement.

[brianrourkeboll]

What about just using parentheses for scope?

let _ =
    [
        (
            let x = 1
            let y = 2
            x, y
        )
        (
            let x' = 1
            let y' = 2
            x', y'
        )
    ]

[BentTranberg]

Isn't scope what begin-end is for? Yield didn't work here, but is that a problem? I can't remember when explicit yield is better and when it isn't better.

let x =
    [
        begin
            let item00 = 1
            let item01 = 2
            item00, item01
        end
        begin
            let item10 = 3
            let item11 = 4
            item10, item11
        end
    ]

[Tarmil]

begin..end is actually exactly equivalent to parentheses, so @brianrourkeboll and @BentTranberg your proposals are essentially the same. Either way, what you're doing is putting an implicit yield outside the wrapped expression:

[
    yield (
        let item00 = 1
        let item01 = 2
        item00, item01
    )
    yield begin
        let item10 = 3
        let item11 = 4
        item10, item11
    end
]

So they work fine as long as you're yielding exactly one item from inside. But they don't allow something like this:

[
    do
        let item00 = ...
        let item01 = ...
        // With parens or begin/end, you couldn't yield twice
        yield (item00, 1)
        yield (item01, 2)
    do
        let item10 = ...
        let item11 = ...
        // With parens or begin/end, you couldn't yield different times based on a condition
        if ... then
            yield (item00, item11)
]

[brianrourkeboll]

@Tarmil Indeed.

For your first example, you could also use yield! with a nested list expression:

[
    yield! [
        let item00 = ...
        let item01 = ...
        (item00, 1)
        (item01, 2)
    ]
]

I still don't fully understand the desire to special-case do here. If separate scope is ever desired, it can nearly always be handled by binding an expression to a named value or to a function and yielding (or yield!ing) that. And in nearly all cases it is not strictly necessary, since F# has immutability by default and supports shadowing.

Anyway, I suppose that the generalized form of this proposal would be inline yield, analogous to inline bind #1070.