Мучаю .Net и Mono

[balu]

Второй день играюсь с такими инструментами, как Boo и F#. Это такие языки для платформы .Net и ее свободной реализации Mono. Воо - это Python, таки доведенный до ума - с выборочной статической или динамической типизацией, генериками, выводом типов и макросами. А F# это майкрософтовская реализация ЯП Ocaml, что интересно, распространяющаяся под открытой лицензией. Оба языка обладают схожими возможностями и оба мне понравились. Можно, конечно, сказать, что .NET/Mono тормоза, не нужны и т.д. Смогу сказать только насчет скорости. Тут предложен интересный бенчмарк - объектный Фибоначчи - тест по ссылке измеряет генерацию объектов и скорость доступа к методам, проверяет язык на умение держать рекурсию. В таблице соответствующие выводы + тут обновлены некоторые данные для Воо. Я тоже сделал аналогичные тесты для последнихо Воо и F#.
для Boo

import System

class Fib:
    _value as uint

    def constructor(n as uint):
        _value = n

    def value() as uint:
        if(_value <= 2):
            return 1

        return Fib(_value - 1).value() + Fib(_value - 2).value()
print DateTime.Now
print Fib(40).value()
print DateTime.Now

На моей машине для .Net - 5 сек., для Mono/Windows - 33 сек., Mono/Linux - 11сек.

для F#:

open System

type test(i)= //Заметим, что тут тип вычисляется
    let rec I = i  
    member x.value =  match I with
                      1 | 2 -> 1
                      | I -> (new test(I-1)).value + (new test(I-2)).value
printfn "%a" output_any (DateTime.Now)
let v = test(40)
printfn "%i" (v.value)
printfn "%a" output_any (DateTime.Now)

Результат на моей машине для .Net - 4 сек., для Mono/Windows - 35 сек., Mono/Linux - 11 сек

А вот мало что демонстрирующий числодробильный вариант:
F#
let rec fib i = 
  match i with
  | 1 | 2 -> 1 
  | i -> fib(i-1) + fib(i-2);;
.Net сделал за 1.6 сек , а вот вариант Воо не порадовал:
def fib(i):  
    if(i <= 2):
        return 1
    return fib(i-1)+fib(i-2)
он вообще отказался работать, в отличие от такого же кода на Python.
Зато Воо порвал F#, як Тузик грелку на числодробильном итеративном варинте:
Воо:
def fib2(num as int):
   
    f = i = 0
    s = 1
   
    while ++i < num:
        sum = f + s
        f = s
        s = sum
       
    return sum

против функционального варианта

let rec fib_tmp(a, b, count) =
  if count = 0 then b
  else fib_tmp(a+b, a, count-1)

let rec fib_iter n = fib_tmp(1, 0, n)


и циклического варианта F#
 let fib_iter_ckl n =
  if n <= 2 then
    1
  else let fib_prev = ref 1
  and fib = ref 1 in
    for num = 2 to n - 1 do
      let temp = !fib in
        fib := !fib + !fib_prev;
        fib_prev := temp
    done;
    !fib

0.07 сек. против 0.01 сек. на . Net  и 0.11 сек. против 0.08 сек. на Mono. Впрочем, результаты не удивительны.
И об организационном моменте - у Воо очень плохая документация, в отличие от F#, который, скорее всего войдет в следующую версию Visual Studio.

Надо сказать, что я все больше присматриваюсь к этим платформам для моей дальнейшей разработки. И мое, первоначально скептическое, отношение к .Net все больше сменяется на вполне рабочий вариатн. Примерно 60/40 по отношению к жабе.

Comments

[b-al-u.livejournal.com]

Я Це-шарпа не знаю - он мне мало интересен - та же жаба, но с еще больше закрученным синтаксисом. На них пейсать без ИДЕ низзя. А вот F# - действительно интересная вещь. Была бы жаба нормальной платформой и не смотрел бы на бибизяну эту.

[lilits-daughter.livejournal.com]

ну нам ооп на нём преподают