// We know f is never called with a None.
let f (Some a) =    // creates warning 25, which we want to suppress
    // 2000 loc, where the incomplete match warning is beneficial

#nowarn 25
let f (Some x) =    // FS0025 suppressed
#warnon 25
    // FS0025 enabled again

type Ledger() =
    [<DefaultValue>] val mutable private _Balance: decimal
    member this.Balance with public get() = this._Balance and private set v = this._Balance <- v

type Ledger() =
    member val Balance = 0m with public get, private set

type Ledger() =
    member Balance : decimal
    member private Balance : decimal with set

// Prior to F# 10: always uses reference option
type X() =
    static member M(?x : string) =
        match x with
        | Some v -> printfn "Some %s" v
        | None -> printfn "None"

type X() =
    static member M([<Struct>] ?x : string) =
        match x with
        | ValueSome v -> printfn "ValueSome %s" v
        | ValueNone -> printfn "ValueNone"

coroutine {
    yield! subRoutine() // tail position -> YieldFromFinal if available
}

coroutine {
    try
        yield! subRoutine() // not tail -> normal YieldFrom
    finally ()
}

async {
    let! (a: int) = fetchA()
    and! (b: int) = fetchB()
    use! (d: MyDisposable) = acquireAsync()
    return a + b
}

async {
    let! a: int = fetchA()
    and! b: int = fetchB()
    use! d: MyDisposable = acquireAsync()
    return a + b
}

counterDisposable {
    use! _ = new Disposable()
    // logic
}

type U =
    | A
    | B
    module M = // Silently created a sibling module, not nested
        let f () = ()

type U =
    | A
    | B
 
module M =
    let f () = ()

[<Fact>]
let ``this is not a function`` =  // Silently ignored, not a test!
    Assert.True(false)

[<Fact>]
//^^^^ - warning FS0842: This attribute cannot be applied to property, field, return value. Valid targets are: method
let ``works correctly`` =
    Assert.True(true)

// Awaiting sequentially
task {
    let! a = fetchA()
    let! b = fetchB()
    return combineAB a b
}

// Use explicit Task combinator to await concurrently
task {
    let ta = fetchA()
    let tb = fetchB()
    let! results = Task.WhenAll([| ta; tb |])
    return combineAB ta.Result tb.Result
}

task {
    let! a = fetchA()
    and! b = fetchB()
    return combineAB a b
}