运行具有大量迭代的空for循环,运行所需的时间长得非常不同:

public static class Program
{
    static void Main()
    {
        var sw = new Stopwatch();
        sw.Start();
        for (var i = 0; i < 1000000000; ++i)
        {
        }
        sw.Stop();
        Console.WriteLine(sw.ElapsedMilliseconds);
    }
}

以上将在我的机器上运行大约200ms,但如果我将它增加到1000000001,那么它需要4倍的时间!然后,如果我将它设为1000000002,那么它再次下降到200ms!

这似乎发生在偶数次迭代中.如果我去for (var i = 1; i < 1000000001,(注意从1开始而不是0)那么它是200ms.或者如果我这样做i <= 1000000001(注意小于或等于)那么它是200ms.或者(var i = 0; i < 2000000000; i += 2)也是.

这似乎只出现在x64上,但在所有.NET版本上都达到(至少)4.0.此外,它仅在处于释放模式且调试器已分离时才会出现.

更新我认为这可能是由于jit中的一些聪明的位移,但以下似乎反驳了:如果你做了类似在该循环内创建一个对象的东西,那么这也需要大约4倍的时间:

public static class Program
{
    static void Main()
    {
        var sw = …

我甚至不确定任何一种单子都有可能; 它违反了monad法律吗？但似乎在某种构造或其他方面应该是可能的.具体是有什么方法可以写一些我可以写的东西

do
  someOp ()
  someOtherOp ()
  thirdOp ()

它会打印出来

step 1 of 3
step 2 of 3
step 3 of 3

这需要模板Haskell还是monad工作？(如果需要Template Haskell,那么怎么做？)

我对PyPy项目非常感兴趣,但对于下面列出的第一个(但不太知名)的目的:

• 一套用于为解释语言实现解释器的工具
• 使用此工具链实现Python

在以下博文中,http://morepypy.blogspot.com/2011/04/tutorial-writing-interpreter-with-pypy.html和http://morepypy.blogspot.com/2011/04/tutorial-part -2-adding-jit.html有关于如何使用RPython实现脑力叉解释器的详细教程,并添加了一个JIT.

但是我在其他地方读过RPython可能很麻烦 - 为动态类型创建的语法突然限制为推断的静态类型导致难以理解的编译错误.

所以我的问题是,是否有任何其他项目可以让你像上面的教程一样编写脑力翻译/ JIT？或者PyPy是这么简单的唯一选择吗？

(旁白):如果存在,一般来说RPython有什么意义？是否只是为了表明Python的子集可以是类型安全的,并且在该子集中实现了Python？在现有的翻译创建工具中做"PyPy"会更有意义吗？

我正在尝试用compojure编写我的第一个Web应用程序.我正在使用ccw,而且我File-New-Project, Clojure Project使用"compojure"leiningen模板.最终看起来像project.clj

(defproject asdf "0.1.0-SNAPSHOT"
  :description "FIXME: write description"
  :url "http://example.com/FIXME"
  :dependencies [[org.clojure/clojure "1.4.0"]
                 [compojure "1.1.5"]]
  :plugins [[lein-ring "0.8.2"]]
  :ring {:handler asdf.handler/app}
  :profiles
  {:dev {:dependencies [[ring-mock "0.1.3"]]}})

src/asdf/handler.clj看起来像

(ns asdf.handler
  (:use compojure.core)
  (:require [compojure.handler :as handler]
            [compojure.route :as route]))

(defroutes app-routes
  (GET "/" [] "Hello World")
  (route/not-found "Not Found"))

(def app
  (handler/site app-routes))

我发现我可以从命令行运行它lein ring server,但我不知道如何从eclipse运行它.我当然希望不仅能够运行它,还能调试它并设置断点等.在eclipse中有没有办法做到这一点？或者,如果没有,IntelliJ/La-Clojure怎么样？(我现在有点害怕emacs,但也许如果它超级简单我会尝试一下).

或者,这不是一个compojure应用程序的典型开发过程吗？(如果不是,那是什么？只是跑步lein ring server并祈祷？)

如果它有所作为,这是在Win7上.

如果我的项目正在使用带有形状的"人物"地图{:firstName :lastName :address},并且我想将该形状更改为{:name {:firstName :lastName} :address},我该怎么做才能确保我在使用这些对象的地方做出相应的更改？

在Java中,它很简单,因为我仍然有person.firstName会发出编译错误.在Clojure中,我可能甚至没有得到运行时错误,只是将错误数据保存到服务器.我认为不可能保证正确性,但除了细齿梳之外还有什么？

我有一个应用程序必须执行以下类型的操作,最好是在GUI线程上,因为这是大多数操作发生的地方,并且没有长时间运行的操作:

Wait 1000
FuncA()
Wait 2000
FuncB()
Wait 1000
FuncC()

我意识到我可以使用具有状态机样式OnTick功能的计时器,但这似乎很麻烦:

    int _state;
    void OnTick(object sender, EventArgs e) {
        switch (_state) {
            case 0:
                FuncA();
                _timer.Interval = TimeSpan.FromSeconds(2);
                _state = 1;
                break;
            case 1:
                FuncB();
                _timer.Interval = TimeSpan.FromSeconds(1);
                _state = 2;
                break;
            case 2:
                FuncC();
                _timer.IsEnabled = false;
                _state = 0;
        }
    }

另外,我希望能够使它足够通用,以便做类似的事情

RunSequenceOnGuiThread(new Sequence {
    {1000, FuncA}
    {2000, FuncB}
    {1000, FuncC}};

有没有惯用的方法来做这种事情？鉴于所有的TPL内容,或者Rx,甚至F#中的计算表达式,我都假设存在,但我找不到它.

我有一个创建Async工作流的函数,以及以咖喱风格获取10个参数的函数.例如

let createSequenceCore a b c d e f g h i j = 
  async { 
    ... 
  }

我想创建另一个函数来启动该工作流程,所以我有

let startSequenceCore a b c d e f g h i j =
  Async.StartImmediate (createSequenceCore a b c d e f g h i j)

有什么办法可以摆脱那些多余的参数吗？我尝试了<<操作员,但这只能让我删除一个.

let startSequenceCore a b c d e f g h i =
  Async.StartImmediate << (createSequenceCore a b c d e f g h i)

(我将Haskell和Scala添加到这个问题中,即使代码本身是F#,我真正想要的是如何做这种currying,这适用于任何;我认为Haskell或Scala的答案很容易便携式到F#,很可能被标记为正确的答案).

注意合理地表明没有一个简单的解决方案也可以得到赏金.

更新 geesh我不会给出一个与问题争论的答案而不是回答100分,即使它是最高的投票,所以这里:

我有一个创建Async工作流的函数,以及以咖喱风格获取4个参数的函数.例如

let …

我是Haskell的新手.鉴于Haskell的整个前提是函数将始终返回相同的值,我希望有一些方法可以在编译时计算常量的fibonacci值,就像我可以在C++中使用模板元编程一样,但我可以看不出怎么做.有办法吗？

我正在使用一个externDLL,它有一堆返回ReturnCode枚举的例程,所以我编写了以下帮助函数来记录所有错误:

let mutable LastError = ReturnCode.OK
let mutable LastReturnCode = ReturnCode.OK
let mutable TotalErrors = 0

let Run (call: unit -> ReturnCode) =
  LastReturnCode <- call()
  if LastReturnCode <> ReturnCode.OK then
    LastError <- LastReturnCode
    TotalErrors <- TotalErrors + 1

很棒,除了一些DLL的函数有out参数.所以现在我做的事情就像

let CreateEvfImageRef (streamHandle: int) =
  let mutable evfImageHandle = 0
  Run (fun () -> Extern.EdsCreateEvfImageRef (streamHandle, &evfImageHandle))
  evfImageHandle

编译器给我一个"可变变量无法通过闭包捕获"的错误.除了在任何Run地方进行内容之外我还能做些什么吗？这在C#中运行良好.

(下面的extern声明示例)

[<DllImport(EDSDKPath)>]
extern ReturnCode EdsCreateEvfImageRef(int inStreamHandle, [<Out>] int& outEvfImageHandle);

如果我有一个类层次结构,如

type Employee(name) =
  member val name: string = name

type HourlyEmployee(name, rate) =
  inherit Employee(name)
  member val rate: int = rate

type SalariedEmployee(name, salary) =
  inherit Employee(salary)
  member val salary: int = salary

我想要一个name以纯粹方式更新字段的函数,这怎么可能？一对失败的选择:

let changeName(employee: Employee) = 
  // no idea what class this was, so this can only return the base class

let changeName<'a when 'a :> Employee>(employee: 'a) =
  // 'a has no constructor

我提出的最接近的事情就是虚拟Employee.changeName并在每个类上实现它.这似乎是很多额外的工作加上它容易出错,因为返回类型是Employee并且必须被上传回原始类.

似乎应该有一种更简单,更安全的方式来完成这样的任务.这是必须使用类型类的东西吗？

更新

是的,我可以让name …