Encontrei recentemente uma apresentação sobre F # para programadores Python, e depois de assisti-lo, decidi implementar uma solução para o "quebra-cabeça da formiga" sozinh

Existe uma formiga que pode andar em uma grade plana. A formiga pode mover um espaço de cada vez para a esquerda, direita, para cima ou para baixo. Ou seja, da célula (x, y) a formiga pode ir para as células (x + 1, y), (x-1, y), (x, y + 1) e (x, y-1). Os pontos em que a soma dos dígitos das coordenadas xey é maior que 25 são inacessíveis à formiga. Por exemplo, o ponto (59,79) é inacessível porque 5 + 9 + 7 + 9 = 30, que é maior que 25. A questão é: quantos pontos a formiga pode acessar se começar em (1000, 1000), incluindo (1000, 1000) em si?

Implementei minha solução em 30 linhas deOCaml first e tentei:

$ ocamlopt -unsafe -rectypes -inline 1000 -o puzzle ant.ml
$ time ./puzzle
Points: 148848

real    0m0.143s
user    0m0.127s
sys     0m0.013s

Bom, meu resultado é o mesmo de implementação de leonardo, em D e C ++. Comparando com a implementação de C ++ de leonardo, a versão do OCaml é executada aproximadamente duas vezes mais lenta que o C ++. O que é bom, já que leonardo usou uma fila para remover a recursã

Eu então traduziu o código para F # ... e aqui está o que eu tenho:

Thanassis@HOME /g/Tmp/ant.fsharp
$ /g/Program\ Files/FSharp-2.0.0.0/bin/fsc.exe ant.fs
Microsoft (R) F# 2.0 Compiler build 2.0.0.0
Copyright (c) Microsoft Corporation. All Rights Reserved.

Thanassis@HOME /g/Tmp/ant.fsharp
$ ./ant.exe

Process is terminated due to StackOverflowException.
Quit

Thanassis@HOME /g/Tmp/ant.fsharp
$ /g/Program\ Files/Microsoft\ F#/v4.0/Fsc.exe ant.fs
Microsoft (R) F# 2.0 Compiler build 4.0.30319.1
Copyright (c) Microsoft Corporation. All Rights Reserved.

Thanassis@HOME /g/Tmp/ant.fsharp
$ ./ant.exe

Process is terminated due to StackOverflowException

Stack overflow ... com as duas versões do F # que tenho na minha máquina ... Por curiosidade, peguei o binário gerado (ant.exe) e o executei sob o Arch Linux / Mono:

$ mono -V | head -1
Mono JIT compiler version 2.10.5 (tarball Fri Sep  9 06:34:36 UTC 2011)

$ time mono ./ant.exe
Points: 148848

real    1m24.298s
user    0m0.567s
sys     0m0.027s

urpreendentemente, ele não está sob o Mono 2.10.5 (ou seja, não há excesso de pilha) - mas leva 84 segundos, ou seja, 587 vezes mais lento que o OCaml - oop

Então este programa ...

corre bem sob OCaml não funciona em .NET / F # funciona, mas é muito lento, sob Mono / F #.

Por quê

EDITAR Estranho continua - Usar "--optimize + --checked-" faz o problema desaparecer, mas apenas sob ArchLinux / Mono; no Windows XP e Windows 7 / 64bit, até a versão otimizada da pilha binária transbord

Final EDIT: Eu mesmo descobri a resposta - veja abaix