функциональная проблема с оберткой: X <|fun () -> A

Question

Итак, я просто хотел спросить, почему это работает:

let internal X th =
    foo()
    th()
    bar()

let Start() = 
    X <| fun () -> ( foo(); bar(); etc... )

И это не работает:

let internal XD A =
    let X th =
        foo()
        th()
        bar()
    (X <| fun () -> A)

let Start() = 
    XD ( foo(); bar(); etc... )

для меня это выглядит так же, но первый вариант работает как обертка, и я совершенно не могу понять, как работает второй вариант.

Answer 1

Полагаю, сбивает с толку то, что во второй версии переменная A это просто unit.Компилятор F # выводит это из того факта, что вы возвращаете A из функции, которая используется как th, а тип th равен unit -> unit.Это означает, что foo вызывается в Start перед входом в XD.

Однако, довольно сложно определить, каких результатов вы ожидали.Вы хотели передать foo в XD как функцию вместо немедленного вызова?Если да, то вам нужно:

let internal XD A =
    let X th =
        foo()
        th()
        bar()
    (X <| fun () -> A()) // Change: Call A with unit argument: 'A ()'

XD foo // Change: Pass a function instead of calling it

Answer 2

Ниже приведен правильный код для 2-й версии для того, чего вы хотите достичь (без лямбды с использованием ленивых значений).

let internal XD (A:Lazy<unit>) =
    let X th =
        foo()
        th()
        bar()
    X <| (fun () -> A.Force())

let Start() = 
    XD ( lazy(foo(); bar();) )