小编rmu*_*unn的帖子

我正在尝试用F#创建单身的各种方法,这样我就能更好地理解细微之处.我不知道单身模式在F#中是否有用,但我想尝试一下.我对这些单例实例中涉及静态构造函数的一个结果感到惊讶.首先,我将向您展示我的代码,然后我会详细介绍我的问题.

在一个名为的项目中TrySingleton,我创建了三个模块.这是Eager.fs:

module TrySingleton.Eager

type EagerClass() =
    do
        printfn "Initializing eager class..."

    static do
        printfn "Static constructor of eager class"

let Instance = EagerClass()

这是Lazy.fs:

module TrySingleton.Lazy

type LazyClass() =
    do
        printfn "Initializing lazy class..."

    static do
        printfn "Static constructor of lazy class"

let Instance = lazy LazyClass()

以下是我称之为Main.fs:

module TrySingleton.Main

[<EntryPoint>]
let main argv =
    printfn "Starting main with args %A" argv
    printfn "Accessing eager instance:"
    printfn "%A" Eager.Instance …

我有一个场景,标准List.groupBy功能不是我想要的,但我不知道这个功能的正确名称,所以它使搜索变得困难.

我有一个类型的项目列表'T,以及一个'T -> 'k密钥生成函数.这些项目已经在列表中稍微"分组"在一起,因此当您通过键功能映射列表时,其结果将倾向于连续多次使用相同的键,例如[1; 1; 1; 2; 2; 1; 1; 3; 3; 3; 1; 1].我想要的是获得一个列表列表,其中内部列表包含密钥生成函数返回相同值的所有项目 - 但它不应该将1的不同序列组合在一起.

换句话说,我的数据是一个字符串列表,而密钥生成函数是String.length.所以输入是:

["a"; "e"; "i"; "to"; "of"; "o"; "u"; "and"; "for"; "the"; "I"; "O"]

我正在寻找的输出将是:

[["a"; "e"; "i"]; ["to"; "of"]; ["o"; "u"]; ["and"; "for"; "the"]; ["I"; "O"]]

以另一种方式来思考:这就像获取列表的第一项并存储调用键函数的结果一样.然后你takeWhile (fun x -> keyFun x = origKeyFunResult)用来生成第一个段.然后,当它takeWhile停止返回值时,您会记录它何时停止,以及keyFun x第一个值的值不会返回原始结果 - 并从那里继续.(除了那将是O(N*M),其中M是序列的数量,并且在许多情况下将转换为O(N ^ 2) - 而应该可以在O(N)时间内实现该函数).

现在,我可以很容易地编写该功能.那不是问题.我想知道的是这个函数是否有标准名称.因为我认为它会被调用groupBy,但那是另一回事.(List.groupBy …

我想将文件上传到我的 Fable-Elmish, end 以便我可以将其发送到服务器进行处理。但是，我找不到任何文档/示例来涵盖这一点。这是我的更新功能：

let update msg model : Model * Cmd<Msg> =
    match msg with
    | QueryResults ->
        {model with results = None}, Cmd.ofPromise getData "" FetchSuccess FetchFailure
    | FetchSuccess data -> 
        { model with results = Some data }, []
    | FetchFailure ex ->
        Browser.console.log (unbox ex.Message)
        Browser.console.log "exception occured" |> ignore
        model, []
    | FileUploaded ->
        Browser.console.log "file selected!" |> ignore
        model, []

这是包含文件上传的视图函数的一部分：

R.input [
        Type "file"
        OnChange (fun x -> FileUploaded |> ignore)
    ] [] …

我有一个像这样的字典:

a PluggableDictionary(
    Rankable1->8.5
    Rankable2->9.0
)

我只需要一个OrderedCollection,其Rankable对象按降序排列:

a OrderedCollection(
    Rankable2
    Rankable1
)

我注意到按键排序很容易,但我发现按值排序有点困难.这样做的小方法是什么？

开始F#程序员的一个常见惊喜是以下是一个不完整的匹配:

let x, y = 5, 10
match something with
| _ when x < y -> "Less than"
| _ when x = y -> "Equal"
| _ when x > y -> "Greater than"

但我刚刚遇到一个让我感到惊讶的情况.这里有一小段示例代码来演示它:

type Tree =
| Leaf of int
| Branch of Tree list

let sapling = Branch [Leaf 1]  // Small tree with one leaf
let twoLeafTree = Branch [Leaf 1; Leaf 2]

let describe saplingsGetSpecialTreatment tree =
    match tree with
    | …

我正在编写 C# 代码来从现有 MongoDB 数据库中提取数据并将其放入各种 C# 类中。数据库的一部分是多态的：如果字段type是 A，则该文档中将存在一组特定字段。如果type是B，则将存在一组不同的字段。这是 的完美用例ScalarDiscriminatorConvention，所以我正在使用ScalarDiscriminatorConvention("type"). 但我不知道如何让 MongoDB 驱动程序使用该约定！

关于约定的 MongoDB 手册页让我认为这可行：

var pack = new ConventionPack();
pack.Add(new CamelCaseElementNameConvention());
pack.Add(new ScalarDiscriminatorConvention("type"));

ConventionRegistry.Register(
    "My Custom Conventions",
    pack,
    t => t.FullName.StartsWith("MyNamespace."));

但这会失败，因为它不像其他约定那样ScalarDiscriminatorConvention从接口派生。IConvention它派生自IDiscriminatorConvention，这是它自己的接口，但不派生自IConvention。并ConventionPack.Add期望一个IConvention参数。

那么如何注册不同的鉴别器字段呢？我已经翻阅 MongoDB 手册至少一个小时了，但我很茫然。他们似乎没有在我能找到的任何地方记录它。

我正在尝试使用XmlProvider来解析一些非常大的数据文件(大约50 MB).由于它们太大,使用真实数据文件作为样本是不切实际的,所以我创建了一个示例XML文件,我希望它是可用数据的代表性样本.但是,我并不是100%确定我已经覆盖了50兆字节文件中的所有可能元素,所以我试图验证我的样本是否具有代表性.我正在尝试使用反射来帮助验证,但我遇到了一个问题.

一,背景.我不确定的原因是因为我正在解析的XML文件基本上具有以下(非常扁平的)数据结构:

<root-element>
<object class="Foo" guid="Guid001">
    <color>Brown</color>
    <shape>Square</shape>
    <children>
        <childRef guid="Guid003" />
    </children>
</object>
<object class="Bar" guid="Guid002">
    <firstName>John</firstName>
    <lastName>Smith</lastName>
</object>
<object class="Quux" guid="Guid003" parentGuid="Guid001">
    <secondaryColor>Maroon</secondaryColor>
    <stroke>Dashed</stroke>
    <shape>Circle</shape>
</object>
<object class="Quux" guid="Guid004">
    <color>Blue</color>
    <stroke>Dotted</stroke>
    <shape>Hexagon</shape>
</object>
</root-element>

(在真实数据文件中,"Guid001"等是真正的GUID;但对于这个虚构的例子,我保持简单.)

基本上,它是一个包含大量object元素的平面数据文件,每个元素都来自该数据来自的程序中的C#类实例.元素半随机混合在一起,在同一数据文件中表示几个不同的类族.(这就是我的虚构数据文件将绘图形状与人物记录混合的原因 - 我正在使用的真实数据文件在单个文件中具有类似的关注点.)

正如我所说,我为我的代表性样本或多或少随机选择了一堆记录.我试图从每个班级中挑选至少一个,这样我就可以覆盖大部分属性名称,但是如果(例如)我最终选择Guid004用于Quux类而不是Guid003？然后我提供的类型实际上不知道该SecondaryColor属性.我想我可以.GetType()在我提供的类型上使用,然后调用.GetProperties()以获取我提供的类型认为它知道的所有属性的列表.但是当我这样做时:

let firstObject = rootElement.Objects[0]
printfn "%A" firstObject.GetType().GetProperties()

相反,越来越命名属性的列表Color,Shape,Children,FirstName,等,我期待,我所得到的恰恰是2和性能,XElement和_Print.

我想,我可以遍历XElement …

在寻找答案时,我发现了几个与我的情况不太匹配的问题 - 所以我会问一个新问题.

我正在为数据结构编写一些FsCheck测试,我想在我构建的数据结构的每个副本上检查20个不同的属性.到目前为止我所做的是为每个属性编写一个谓词,然后我创建了一个谓词列表,我将依次调用它们List.forall,如下所示:

module PropertyChecks =
    let ``Tail length plus tree length should equal vector length`` vec =
        treeLength vec.root + Array.length vec.tail = vec.len

    let ``The tail may only be empty iff the vector is empty`` vec =
        (vec.len = 0) = (Array.length vec.tail = 0)

    let ``The tail's length may not exceed tailMax`` vec =
        Array.length vec.tail < tailMax

    let ``If vec.len <= tailMax, all items are in tail and root is empty`` vec = …

在case语句结尾处实现通配符意味着什么？

采用以下语法:

match imp req with
| Success () -> this.Ok () :> _

这是一样的:

| Success () -> this.Ok () :> IHttpActionResult

编写这种语法有什么好处？

这是我的问题的背景:

type PushController (imp) =
    inherit ApiController ()

    member this.Post (portalId : string, req : PushRequestDtr) : IHttpActionResult =
        match imp req with
        | Success () -> this.Ok () :> _
        | Failure (ValidationFailure msg) -> this.BadRequest msg :> _
        | Failure (IntegrationFailure msg) ->
            this.InternalServerError (InvalidOperationException msg) :> _

我正在解决我在C#中解决的问题的解决方案,但现在我将我的代码移植到F#.我有一个字节数组,我需要在这个数组中搜索两个值(x,y).当我找到时x,需要检查:如果y是下一个索引,我们有匹配.如果y不在下一个索引上,搜索将继续.我该如何解决这个问题？我试图使用Array.findIndex,但没有成功,因为我不知道如何继续搜索时y不在下一个索引.

编辑:

public void GetValue(byte[] data)
        {
            byte[] temp = new byte[4];
            for (int i = 0; i < data.Length; i++)
            {
                if (data[i] == Adress[0] && data[i + 1] == Adress[1])
                {
                    for (int j = 0; j < temp.Length; j++)
                    {
                        temp[j] = data[j + i + 2];
                    }
                    Value = BitConverter.ToInt32(temp, 0) * 0.01;
                    break;
                }

            }