小编Ove*_*ive的帖子

我有一个做了一个简单的函数,它包装签名的共同F#的功能'a -> 'b -> 'c option更多的"C#兼容"功能:'a -> b -> byref<'c> -> bool.但不知何故,当我尝试在类中包装这样的方法时,我收到错误FS0001,我找不到错误.

代码如下

open System
open System.Runtime.InteropServices

// Given a function, f: 'a -> 'b -> 'c option returns
// A new function g: 'a -> 'b -> byref<'c> -> bool
let wrapOptionF f a b (g:byref<'c>) =
    match f a b with
    | Some v ->
        do g <- v
        true
    | None -> 
        false

let tryDivide (a:int) (b:int) =
    match Math.DivRem(a,b) with
    | v, …

我正在尝试制作一个素数生成器,它应该能够返回一个素数序列,直到第n个数.现在我认为除了我当前的解决方案之外,还应该有一种更优雅的方式来处理序列,感觉有点冗长,我不得不使用mutables.

0
|> Seq.unfold (fun x -> if isPrime x 
                          then Some(x, x + 1) 
                         else 
                          let mutable y = x
                          while isPrime y <> true do
                           y <- y + 1
                          Some(y, y + 1)) 
|> Seq.take(n)

我有一个关于在F#中使用do块的约定的问题.在使用.NET库类和其他.NET代码时,首先会出现这种情况.

让我给你举个例子.

1.使用do块包含语句:

let drawHelloName (width:int, height:int) name = 
    let bmp = new Bitmap(width, height)
    use fnt = new Font("Arial", 12.0f)
    use gr = Graphics.FromImage(bmp)
    do
        gr.Clear(Color.White)
        gr.DrawString(name, fnt, Brushes.Black, PointF(10.0f, 10.0f))
    bmp

2.没有阻止:

let drawHelloName (width:int, height:int) name = 
    let bmp = new Bitmap(width, height)
    use fnt = new Font("Arial", 12.0f)
    use gr = Graphics.FromImage(bmp)
    gr.Clear(Color.White)
    gr.DrawString(name, fnt, Brushes.Black, PointF(10.0f, 10.0f))
    bmp

现在在我看来,我认为例子1更清晰,更符合F#的观点和风格.由于在函数式编程中处理语句并不是"自然",因此我们将语句显式地包装在do块中以表明它们是副作用.但我想知道,关于这个的惯例是什么？

这是一件非常微不足道的事情，但我真的很难让它发挥作用。我想转换sqrt nwhere nis 类型的结果，int64最后将它传递给一个接受 an 的函数，int但我真的很难找到一个像样的解决方案，这是我想出的方法，但这是可怕的，我可以'不相信在例如 C# 中如此微不足道的事情在 F# 中应该如此困难。

n 
|> float 
|> sqrt 
|> int 
|> function

我意识到受歧视的工会不一定和enums一样.但在这些类型的DU的情况下:

type Colors = Red | Green | Blue

它们被视为一个类Colors,其中每种颜色都是一个引用Colors该类实例的只读属性.

对于这些类型的可以比作枚举的DU,为什么它们不被视为C#中的枚举？

我是一个真正的新手程序员,我正试图做一个共享变量的重载.基本上我想要做的是有一个带有一个重载的方法,它将整数值写入其中的变量,另一个重载只返回该值.

现在我尝试这样做:

private int GetQID(int qID)
    {
        int ID = qID;
    }    
private int GetQID()
    {
        return ID;
    }

遗憾的是,这不起作用,因为第二个重载不能访问第一个重载的"ID"变量.有没有办法不诉诸全局变量,我可以这样做吗？

我正在编写一个 csv 转换器来将交易的文本文档转换为 csv 文档，但我遇到了一个小问题..

    foreach (var transaction in transactions)
    {
        output.Append(
            string.Format("{0:dd/MM/yy},{1},{2},{3},{4:0.##},{5}", 
            transaction.Date, 
            transaction.Payee, 
            transaction.Category,
            transaction.Memo,
            transaction.Outflow,
            transaction.Inflow));
        output.AppendLine();
    }

这一切都很好，我遇到的小问题是该Outflow属性是一个浮点数，并且我的语言环境使用逗号作为十进制分隔符，这在CSV 中显然是一个很大的问题，所以不是让我们说 10.50 它会输出 10,50，有什么简单的方法可以解决这个问题吗？

在F#中,编写这样的函数之间有什么区别......

let add x y = x + y

或这个...

let add = fun x y -> x + y

当我看到IL时,它们似乎产生完全相同类型的IL.他们肯定"似乎"做同样的事情,但从概念上来说,我觉得它们是不同的,第一个是函数声明,第二个是值"声明",它是一个函数.

此外,如果我们做一个稍微详细的例子..

这个...

let add x = 
    let rnd = System.Random()
    let rnd = rnd.Next(100)
    x + rnd

......与此相比

let add = 
    let rnd = System.Random()
    let rnd = rnd.Next(100) 
    (fun x -> x + rnd)

这些示例遵循与前两个相同的原则,但这两个示例将完全不同于彼此.

我对有点删除枚举标志感到有点困惑.

让我举一个例子,假设我们有一个看起来像这样的枚举

[Flags]
enum Letter 
{
    A = 1, // 1
    B = 2, // 10
    C = 4  // 100
}

现在,如果我想让变量保持Letter.AB我可以做的标志foo = Letter.A | Letter.B.现在这对我来说很有意义,我可以计算一下它会有意义:

   01
OR 10
 = 11 = 3 = 1 + 2 = A + B = AB

当谈到删除标志时,我很困惑,直觉上我想要做的是使用XOR运算符这样做,如下所示:

bar = Letter.A | Letter.B | Letter.C // Set bar to ABC
// Now let's remove everything but Letter.C
bar = bar ^ (Letter.A | Letter.B)

手动计算应该产生:

    111
XOR …