内置f#运算符，用于组合具有相同输入但不同输出的函数？

我知道（右舵：'a->'a）->'a

我经常发现自己想要类似于

（lhs:'a->'b）->（rhs:'c->'b）->'b

，以防我对副作用感兴趣，而不是返回值'b可能是单位类型。只有在连续两行将某些内容持久化到数据库时，才会出现这种情况

有没有一种内置的函数或惯用的F#方式来实现这一点，而不用编写类似的代码

let myCompose lhs rhs arg =
    lhs arg
    rhs arg

---

（对于构成任意类型的
f:'a->unit
函数的数量，任意所需顺序，您可以简单地折叠它们的列表：

("whatever",[ printfn "funX: %A"; printfn "funY: %A"; printfn "funZ: %A" ])
||> List.fold (fun arg f -> f arg; arg )
|> ignore

进入FSI

funX: "whatever"
funY: "whatever"
funZ: "whatever"
val it : unit = ()

反向合成操作符
（我从
fsi
：
val myCompose:lhs:（'a->unit）->rhs:（'a->'b）->arg:'a->'b
。你确定这就是你的意思吗？我不确定你对
'T3）->func1:（'T1->'T2）->（'T1->'T3）
（&&&）
是F#中的标准运算符（按位和）。在我看来，最好选择其他运算符；用完全不同的行为替换标准运算符感觉像是“代码气味”。不知怎的，
func2
和
func1
的类型被切换为
的第一个签名（@kvb好球！它们现在被修复了。
> let (<<!) func2 func1 arg = func1 arg; func2 arg; ();;

val ( <<! ) : func2:('a -> unit) -> func1:('a -> unit) -> arg:'a -> unit

("whatever",[ printfn "funX: %A"; printfn "funY: %A"; printfn "funZ: %A" ])
||> List.fold (fun arg f -> f arg; arg )
|> ignore

funX: "whatever"
funY: "whatever"
funZ: "whatever"
val it : unit = ()

( << ) : ('b -> 'c) -> ('a -> 'b) -> 'a -> 'c`

let ( |>! ) x f = f x; x
// Usage:
let ret =
    x
    |>! f1
    |>! f2
    |> f3

let ( |>!! ) x f = ignore(f x); x

val (&&&) : ('a -> 'b) -> ('a -> 'c) -> 'a -> 'b * 'c

/// Applying two functions to the same argument.
let (.&.) f g x = (f x, g x)

// Usage
let ret1, ret2 =
   x
   |> (f .&. g)