上述答案在具体细节上是正确的，但您可以创建一个看起来像您想要的API形状。
抱歉回答有点长，但关于CE和它们的构建器的能力，实际上很少有信息。您还应该查看
Bolero的HTML构建器，其中包含一些非常不错的想法。
如果提供适当的
_.Yield、
_.Combine和
_.Delay实现，您可以使用嵌套计算。此外，由于F# 6.0
[<InlineIfLambda>]属性，您可以为这些类型的表达式生成非常好的、高效的内联代码。
以下代码提供了您尝试使用稍微不同的计算构建器
SettingsBuilder实现的API。
...
let mySettings =
Settings {
Buffer "b1" {
Capacity 100.0
}
Constraint "c1" {
Limit 10.0
}
}
...
val mySettings: Setting list =
[Buffer { Name = "b1"
Capacity = 100.0 }; Constraint { Name = "c1"
Limit = 10.0 }]
让API符合您的要求的关键是不要在
SettingsBuilder上为
Buffer和
Constraint创建
自定义操作，而是创建按名称创建
BufferBuilder和
ConstraintBuilder实例的函数，然后包括
_.Yield方法，该方法接受这些构建器的
_.Run(...)方法的结果。
...
let inline Buffer name = BufferBuilder name
...
let inline Constraint name = ConstraintBuilder name
...
type SettingsBuilder () =
...
member inline _.Yield (b:Buffer) = Setting.Buffer b
member inline _.Yield (c:Constraint) = Setting.Constraint c
...
您还需要设置正确的
_.Delay和
_.Combine方法，使用
_.Delay而不是
_.Zero非常关键。如果使用
Zero，则必须在
Buffer "b1" { ... }行之前使用
yield，例如：
yield Buffer "b1" { ... }，否则
Buffer "b1" { ... }的值将被忽略，因为它们会被编译为F#代码
Sequences而不是
_.Delay调用。
注意* 如果CE中出现奇怪的东西，请尝试将CE视为引用。 <@ Settings { Buffer "b1" { Capacity 100.0 } } @>。这将生成许多语法树节点，但可以解释为什么某些内容被忽略！
我还向SettingsBuilder添加了一个自定义操作empty，以便您可以指定空的设置结果(即[])。
...
let emptySettings =
Settings {
empty
}
...
val emptySettings: Setting list = []
由于我们正在为
Buffer和
Constraint设置动态分配构建器，因此我们希望它们成为结构体，以便在使用它们时不需要支付堆分配的代价。当您的构建器将动态创建时，请确保在Builder类型上放置
[<Struct>]属性；否则，请使用普通类，因为它将通过静态属性引用访问构建器实例。
另外，_.Yield (u:unit)、_.Delay(a:unit->unit)和_.For(s:unit,f:unit->unit)方法共同使得empty操作只能单独存在于Settings CE中。
你可以在这里找到代码的要点
Sharplab.IO Gist。
type Buffer =
{
Name : string
Capacity : float
}
type Constraint =
{
Name : string
Limit : float
}
[<RequireQualifiedAccess>]
type Setting =
| Buffer of Buffer
| Constraint of Constraint
// we make this type a Struct so that we can allocate on the stack for very low cost
type [<Struct; NoComparison; NoEquality>] BufferBuilder (name:string) =
member this.Yield _ : Buffer = { Name = name; Capacity = 0.0 }
member inline _.Run x : Buffer = x
[<CustomOperation("Capacity")>]
member inline _.Capacity (b: Buffer, newCapacity) =
{ b with Capacity = newCapacity }
let inline Buffer name = BufferBuilder name
type [<Struct; NoComparison; NoEquality>] ConstraintBuilder (name:string) =
member this.Yield _ : Constraint = { Name = name; Limit = 0.0 }
member inline _.Run x : Constraint = x
[<CustomOperation("Limit")>]
member inline _.Limit (b: Constraint, newLimit) =
{ b with Limit = newLimit }
let inline Constraint name = ConstraintBuilder name
type SettingsBuilder () =
member inline _.Yield (u:unit) = () // used to indicate we are at the front of the computation expression with nothing defined yet
member inline _.Yield (b:Buffer) = Setting.Buffer b
member inline _.Yield (c:Constraint) = Setting.Constraint c
// we use Delay and InlineIfLambda so that the aggressive F# compiler inlining will remove all the "function" calls
// this produces straight line code after compilation
member inline _.Delay([<InlineIfLambda>] a:unit -> Setting list) = a() // normal delay method for
member inline _.Delay([<InlineIfLambda>] a:unit -> Setting) = [a()] // used to convert the last setting in the computation
// expression into Setting list
member inline _.Delay([<InlineIfLambda>] a:unit -> unit) = [] // used to allow empty to be used by itself
member inline _.Combine(x1 : Setting, x2 : Setting list) = // this is working backwards from the end of the computation
// to the front
x1 :: x2
member inline _.For(s:unit, [<InlineIfLambda>] f:unit -> unit) = // this makes empty only allowed in an empty Settings expression
f()
[<CustomOperation("empty")>]
member inline _.Empty(s:unit) = () // this only can be called if the computation expression prior to here is the value unit which
// can only happen if _.Yield (u:unit) = () was called prior to this and by returning unit we force
// the For and Delay operations to have to use unit->unit which mean we can restrict this operation to
// be the only operation allowed
member inline _.Run(s:Setting) = [s] // allow a single Setting to be returned as a list
member inline _.Run (x : Setting list) = x
let Settings = SettingsBuilder()
// This Computation Expression does work, in with the same API shape you would like to have
let mySettings =
Settings {
Buffer "b1" {
Capacity 100.0
}
Constraint "c1" {
Limit 10.0
}
}
let emptySettings =
Settings {
empty
}
// Below shows that the desired outcome of `mySettings` would be
let b1 = { Name = "b1"; Capacity = 100.0 }
let c1 = { Name = "c1"; Limit = 10.0 }
let desiredSettings = [
Setting.Buffer b1
Setting.Constraint c1
]
mySettings = desiredSettings
