小编MyB*_*g18的帖子

我正在学习 F#。我用 Haskell 开始了 FP，对此我很好奇。

由于 F# 是 .NET 语言，我认为Mappable像 haskellFunctor类型类一样声明接口似乎更合理。

但是就像上图一样，F# 函数是分开的，并且是自己实现的。这种设计的设计目的是什么？对我来说，Mappable.map为每种数据类型引入和实现它会更方便。

我输入了错误的ID（我的错误），并且我的计算机的IP被永久禁止。我想取消禁止我的IP，以便可以将git clone克隆到所需的git存储库。当我尝试git克隆我的git存储库时，它说 remote: HTTP Basic: Access denied fatal: Authentication failed for "~~my repository"

如何重新访问git存储库？或者我该如何重设禁令状态？我认为只输入一次错误的ID并被永久禁止是有点苛刻的。

我的主要语言是 C#，我正在学习具有稀缺 C++ 背景的 opengl。

// readShaderSource returns const string

// no warning
auto vShaderStr = readShaderSource("vshader.glsl");
auto vShaderSource = vShaderStr.c_str();

// dangling pointer warning
auto vShaderSource = readShaderSource("vshader.glsl").c_str();

我对悬垂指针的看法是这样的：

int* a()
{
    auto a = 10;
    return &a

    // a dies here, so &a becomes dangling pointer
}

情况似乎并非如此。

为什么我必须通过字符串变量？直接访问成员函数不行吗？是否与返回值优化有关？我很困惑...

我正在学习 F#。我来这里是因为我对价值限制有一些难以理解的事情。

以下是我正在学习的书中的示例。

let mapFirst = List.map fst\n

由于我用 haskell 学习了 FP，所以我非常确定这段代码可以很好地编译，但事实并非如此。结果出现错误FS0030（抱歉，我无法复制粘贴 fsi 错误消息，因为它是用韩语编写的）。相反，我必须提供一个明确的论点，例如：

let mapFirst inp = List.map fst inp   // or inp |> List.map fst\n

但为什么？我认为通过上面的例子，编译器肯定可以推断出给定值的类型：

let mapFirst inp = List.map fst inp   // or inp |> List.map fst\n

如果我没记错的话，我在 haskell 中调用了这个东西eta-conversion，上面两个例子是完全相同的。（但也许不完全是）。为什么我应该显式地向可以柯里化的函数提供参数而不丢失任何信息？

我明白了类似的事情

val mapFirst : (\'a * \'b) list -> \'a list\n

不会编译，为什么，但我不认为它与我的问题有关。

\xe2\x80\xbb 我看了一下这个问题，但没有帮助。

我正在尝试解析字符串以创建 Func 实例。

public class A
{
    public int fieldA { get; private set; }
    public bool fieldB { get; private set; }
    public List<int> fieldC { get; private set; }
}

检查A类实例的条件：

{
    "Type" : "A"
    "Condition" : "fieldA > 0 && fieldB == true"
}

当然可以修改字符串的格式，以便于解析。

我想要创建的实际上是：

{
    "Type" : "A"
    "Condition" : "fieldA > 0 && fieldB == true"
}

解析condition字符串不会很困难，但是由于A实例太多，因此在检查条件时使用反射是不可取的。我想要做的是预先从字符串“构造”这个函数并将其缓存在某处，并在我想检查条件时调用缓存函数。

你能给我什么建议吗？

我正在学习 F# 并被mutable关键字的概念所困扰。

请看下面的例子：

let count =
    let mutable a = 1
    fun () -> a <- a + 1; a

val count: unit -> int

每次使用(). 但下一个代码没有：

let count =
    let mutable a = 1
    a <- a + 1
    a

val count: int

这总是2.

在我正在研究的书中，它用第一个例子说，“可变值的初始化a只在函数第一次调用时完成一次。”

当我开始用 haskell 学习 FP 时，它处理这种副作用的方式完全烧毁了我的大脑，但 F#mutable再次以不同的方式摧毁了我的大脑。以上两个片段有什么区别？还有，上面那句关于可变值初始化的真正含义和条件是什么？

我正在学习 c++ (20)。请看我的代码：

MyClass.h

class Spec\n{\nprivate:\n    int number;\n\npublic:\n    Spec() = delete;\n    Spec(int);\n};\n\nclass MyClass\n{\nprivate:\n    int id;\n    Spec spec;\n\npublic:\n    MyClass() = delete;\n    MyClass(int, Spec);\n};\n

我的类.cpp

#include "MyClass.h"\n\nSpec::Spec(int number)\n{\n    this->number = number;\n}\n\nMyClass::MyClass(int id, Spec spec)\n{\n    this->id = id;\n    this->spec = spec;\n}\n

编译时返回：

/src/Hai.cpp: In constructor \xe2\x80\x98MyClass::MyClass(int, Spec)\xe2\x80\x99:\n/src/Hai.cpp:8:35: error: use of deleted function \xe2\x80\x98Spec::Spec()\xe2\x80\x99\n    8 | MyClass::MyClass(int id, Spec spec)\n

我没有使用任何默认构造函数，而且我什至删除了它以确保。我不会在任何地方调用这些类的默认构造函数，并且我不希望这些类被默认构造。买了为什么编译器仍然问我应该有默认构造函数？与复制操作有关系吗？添加默认构造函数将处理错误，但我只想知道为什么。