let foo = 1
let _ = print_int foo (* печатает 1 *)

let foo = foo + 1
let _ = print_int foo (* печатает 2 *)

let foo = foo + 2
let _ = print_int foo (* печатает 4 *)

Кё>я про рекурсивные функции

let foo () = 1
let _ = print_int (foo ())

let foo () = foo () + 1
let _ = print_int (foo ())

let foo () = foo () + 2
let _ = print_int (foo ())

Somasegar, the head of the Developer Division at Microsoft, has announced the productization of F#.

let foo _ = ...
let foo_old = foo
let rec foo = ... (foo_old x) ... (foo y)

type varname = string
type expr =
    Int of int                      |
    Bool of bool                    |
    Var of varname                  |
    Plus of expr * expr             |
    Mult of expr * expr             |
    Eq of expr * expr               |
    If of expr * expr * expr        |
    Lambda of varname * expr        |
    Application of expr * expr      |
    Let of varname *expr * expr     |
    LetRec of varname * expr * expr

type value = VInt of int | VBool of bool | VClosure of (value -> value)
type binding = varname * value
type environment = binding list

exception EvalError of string

let error msg = raise (EvalError msg)
let internal_error () = failwith "The world is upside down"

let lookup_var (var : varname) (env : environment) : value =
  try
    List.assoc var env
  with Not_found -> error ("Unbound variable " ^ var)


let rec eval (e : expr) (env : environment) : value = match e with
  | Int x    -> VInt x
  | Bool x   -> VBool x
  | Var name -> lookup_var name env
  | Plus (e1, e2) ->
        (match (eval e1 env, eval e2 env) with
           | (VInt x, VInt y) -> VInt (x+y)
           | _                -> error "Non-int in addition")
  | Mult (e1, e2) ->
        (match (eval e1 env, eval e2 env) with
           | (VInt x, VInt y) -> VInt (x*y)
           | _                -> error "Non-int in multiplication")
  | Eq (e1, e2) ->
        (match (eval e1 env, eval e2 env) with
           | (VInt x, VInt y) -> VBool (x==y)
           | _                -> error "Non-int in comparision")
  | If (cond, thenExpr, elseExpr) ->
        (match eval cond env with
           | VBool x   -> if x then eval thenExpr env
                               else eval elseExpr env
           | _         -> error "Non-boolean in conditional")
  | Lambda (var, body) ->
        VClosure (fun x -> eval body ((var, x)::env))
  | Application (func, arg) ->
        (match eval func env with
          | VClosure f -> f (eval arg env)
          | _          -> error "Non-function in application")
  | Let (var, value, body) ->
        eval body ((var, eval value env)::env)
  | LetRec (var, value, body) ->
        (match value with
           | Lambda _ ->
                 let rec new_env =
                   let rec func x = 
                     match eval value new_env with
                       | VClosure f -> f x
                       | _ -> internal_error ()
                   in ((var, VClosure func)::env)
                 in eval body new_env
           | _ -> error "Only functions are allowed on the right-hand side of letrec")

(*** tests *********************************)

(* fun n -> if n==0 then 1 else n * fact (n + (-1)) *)
let (factorial_body : expr) =
  (Lambda ("n",
           If (Eq (Var "n", Int 0),
               Int 1,
               (Mult (Var "n",
                      Application (Var "fact",
                                   Plus (Var "n", Int (-1))))))))


let tests =
  [
      (* let x = 5 in x + 4 *)
      Let ("x", Int 5, Plus (Var "x", Int 4));

      (* non-recursive function: let f = fun x -> x*2 in f 4 *)
      Let ("f", Lambda ("x", Mult (Var "x", Int 2)), Application (Var "f", Int 4));

      (* incorrect factorial *)
      Let ("fact", factorial_body, (Application (Var "fact", Int 5)));

      (* correct factorial *)
      LetRec ("fact", factorial_body, (Application (Var "fact", Int 5)));
  ]

let print_val = function
  | VInt n     -> print_int n
  | VBool b    -> print_string (if b then "true" else "false")
  | VClosure _ -> print_string "<function>"


let run_eval expr =
  try
    (print_val (eval expr []);
     print_endline "")
  with EvalError msg -> print_endline msg


let main () =  List.iter run_eval tests

let _ = main ()

PM>  | LetRec (var, value, body) ->
PM>        (match value with
PM>           | Lambda _ ->
PM>                 let rec new_env =
PM>                   let (* rec *) func x = (* здесь rec ни к чему *)
PM>                     match eval value new_env with
PM>                       | VClosure f -> f x
PM>                       | _ -> internal_error ()
PM>                   in ((var, VClosure func)::env)
PM>                 in eval body new_env
PM>           | _ -> error "Only functions are allowed on the right-hand side of letrec")

let x = 1
let x = x + 5 (* здесь x справа от '=' ссылается на переменную x 
                 в области видимости, результат = 6 *)

let foo x = x 
let foo x = if x > 0 then x * foo (x-1) (* а здесь, по-твоему, должен быть рекурсивный вызов - 
                                           с какой стати? функции - это те же переменные,
                                           поиск имен должен работать однообразно независимо от типа *)

(* понять, что sum - это функция, можно только после вывода типов,
   который, естественно, делается уже при построенном AST. 
   различие между let и letrec - синтаксическое.
 *)
let sum = List.fold_left (+) 0 

(* а теперь представим себе следующую ситуацию *)
let foo f y z = ...

let bar = ...

let bar = foo bar (* какой bar здесь имеется в виду? bar - функция, но на основании 
                     одного лишь синтаксиса это определить невозможно *)

# re: F# — A Functional Programming Language
Wednesday, October 17, 2007 5:03 PM by LukeH
Jordan —

No, F# won't be included in the box with Visual Studio 2008.

We have not finalized how or when we will ship the productized version of F#. We will, however, want to get community feedback during the development phase with CTPs and Beta releases that developers can try out along the way. You can watch Don Syme’s blog for updates as we have them.

Note that in the meantime, the Microsoft Research download of F# is available from http://research.microsoft.com/fsharp, and provides everything you need to learn more about F#.

Thanks,

Luke Hoban

CTPs and Beta releases

S>[offtop]И за что такая враждебность к Камлу? Правда, мсье Леруа принципиально забил на полноценную поддержку многопоточности (форкайте и будет вам щастье, а вне юникса щастья не бывает — это краткое обобщение его ответов), и тем, кажется, совсем добил свое детище. Жаль.[/offtop]

S>То-то я смотрю, с тех пор как братья-поляки съездили в MS Research, развитие языка продолжается силами RSDN-энтузиастов

S> Чего стоят одни только анонимные делегаты в C# 2.0 — это больше похоже на диверсию, чем на прогресс. Дискредитация, так сказать, светлой идеи лямбды

...
public abstract class Function ['p1, 'r]
{
  public static @>>[B] (fab : 'p1 -> B, fbc : B -> 'r) : 'p1 -> 'r
  {
    a => fbc(fab(a))
  }

  public static @>>[B] (fab : void -> B, fbc : B -> 'r) : void -> 'r
  {
    () => fbc(fab())
  }
...

S>Вот таких мелочей толи не нашел в Немерле, толи нет их там. А как-то без них грустно (прошу не считать блабописцем )

S> А для большинства, судя по всему, так и остается уготована участь писать на C#/VB. Ну подумай сам, если взять в оборот Nemerle, это же, понимаешь, еще и Хейлсберга увольнять придется — кому тогда C# нужен будет? И Хейлсберг, наверное, это понимает (если таки сумел найти документацию на сайте Nemerle)

S>Nemerle по своей сути претендует скорее на замещение C#, чем на дополнение линейки языков. Потому и не дают. Слишком хорошо — тоже плохо

From 1999 to 2004 I worked extensively with the .NET Common Language Runtime Team, both on the design and implementation of generics and on other issues related to the .NET Common IL's type system. During 2002 and 2003 Andrew Kennedy and I were working essentially full-time as as an adjunct members of the CLR team in a mix of architectural, development, testing and program management roles (thankfully our workload has eased off...) Some of those who I had the pleasure of working with were Dario Russi, Vance Morrison, Sean Trowbridge, Simon Hall, Shri Borde, Ian Bearman, Chris Brumme and Patrick Dussud.
From 1999 to 2003 I was involved with the design of C#, authoring the first draft of the C# language design for generics. I also prototyped the initial support for generics in the Microsoft C# compiler. During this time I had the pleasure of working with Anders Hejlsberg, Peter Golde, Peter Hallam and others.

let FileContents fname =
    try
        use stream = new IO.FileStream(fname, IO.FileMode.Open)
        (* конструкция use аналогична let, но обеспечивает реализацию Dispose-паттерна *)
        use reader = new IO.StreamReader(stream)
        Some (reader.ReadToEnd())
    with _ -> None

def my_filter (f, l)  { List.Rev (List.FoldLeft(l, [], (elem, acc) => if (f (elem)) elem::acc else acc)) }
def x = my_filter( (x) => x>0, [1,2,3,-5,-9,7] )

// оффтоп - во прикол: подсветка для ML на RSDN есть, а для Nemerle нету.

let my_filter f = List.fold_left (fun acc elem -> if f elem then elem::acc else acc) [] >> List.rev
let x = my_filter (fun x -> x > 0 ) [1; 2; -9; 14; -5; 7]

def my_filter (f, l)  { List.Rev (List.FoldLeft(l, [], (elem, acc) => if (f (elem)) elem::acc else acc)) }
def x = my_filter( (x) => x>0, [1,2,3,-5,-9,7] )

def longEnough(str:string) {str.Length > 5}
def x2 = my_filter ( longEnough , ["String1", "Str2"] )

let my_filter f = List.fold_left (fun acc elem -> if f elem then elem::acc else acc) [] >> List.rev
let x = my_filter (fun x -> x > 0 ) [1; 2; -9; 14; -5; 7]

let longEnough (s:string) = s.Length > 5
let x2 = my_filter longEnough ["String1"; "Str2"; "String4"]

(* вот так работает *)
let x = "SomeString" |> (fun s -> s.Length) 
(* вот так, увы, нет *)
let x = (fun s -> s.Length) "SomeString"

VD>Хотя конму оно нужно? Ему про Фому, а он про Ерему. Ему о том, что язык настолько враждебен тем кто привык к С-подобному синтаксису, что его попросту не примут. А он про какие-то там мелочевки о которых сам-то по наслишке знает.

VD>Да и какая разница, на замену или рядом? Главное чтобы он был. А чтобы он был нужны вливания денег и поддержка. В прочем, велика вероятность, что он таки будет во преки всему.

S>// какой страшный ужас :), для начала можно переписать так
S>//                      l.FoldLeft([], (elem, acc) => if (f(elem)) elem::acc else acc).Rev()
S>def my_filter (f, l)  { List.Rev (List.FoldLeft(l, [], (elem, acc) => if (f (elem)) elem::acc else acc)) }
S>//                 лишние скобки
S>def x = my_filter( (x) => x>0, [1,2,3,-5,-9,7] )
S>//          Nemerle это уточнение типа не нужно
S>def longEnough(str:string) {str.Length > 5}
S>def x2 = my_filter ( longEnough , ["String1", "Str2"] )
S>

def my_filter(f, l) { $[x | x in l, f(x)] }
def x = my_filter(_ > 0, [1, 2, 3, -5, -9, 7]);
def longEnough = str => str.Length > 5;

// нормальный обобщенный метод расширения, как раз такой есть в ст. библиотеке под названием Filter ;)
public static MyFilter[T](this l : list[T], f : T->bool) : list[T] { $[x | x in l, f(x)] }
// ocaml
let my_filter f = List.fold_left (fun acc elem -> if f elem then elem::acc else acc) [] >> List.rev

Console.WriteLine 1
let f = System.Console.WriteLine in f "test"

S>>// какой страшный ужас :), для начала можно переписать так
S>>//                      l.FoldLeft([], (elem, acc) => if (f(elem)) elem::acc else acc).Rev()
S>>def my_filter (f, l)  { List.Rev (List.FoldLeft(l, [], (elem, acc) => if (f (elem)) elem::acc else acc)) }
S>>//                 лишние скобки
S>>def x = my_filter( (x) => x>0, [1,2,3,-5,-9,7] )
S>>//          Nemerle это уточнение типа не нужно
S>>def longEnough(str:string) {str.Length > 5}
S>>def x2 = my_filter ( longEnough , ["String1", "Str2"] )
S>>
VK>

VK>def my_filter(f, l) { $[x | x in l, f(x)] }
VK>def x = my_filter(_ > 0, [1, 2, 3, -5, -9, 7]);
VK>def longEnough = str => str.Length > 5;
VK>

(* вот list comprehension  *)
[ for e in l when f e -> e ]
(* а вот array comprehension  *)
[| for e in l when f e -> e |]
(* а вот так - IEnumerable comprehension  *)
{ for e in l when f e -> e }

VK>// нормальный обобщенный метод расширения, как раз такой есть в ст. библиотеке под названием Filter ;)
VK>public static MyFilter[T](this l : list[T], f : T->bool) : list[T] { $[x | x in l, f(x)] }
VK>// ocaml
VK>let my_filter f = List.fold_left (fun acc elem -> if f elem then elem::acc else acc) [] >> List.rev
VK>

let my_filter f l = [for e in l when f e -> e]

(forall t_a20T (m:: * -> *) . (Monad m) => (t_a20T -> Bool) -> ([t_a20T], [t_a20T]) -> m ([t_a20T], [t_a20T])) — жуть.

S>let FileContents fname =
S>    try
S>        use stream = new IO.FileStream(fname, IO.FileMode.Open)
S>        (* конструкция use аналогична let, но обеспечивает реализацию Dispose-паттерна *)
S>        use reader = new IO.StreamReader(stream)
S>        Some (reader.ReadToEnd())
S>    with _ -> None
S>

S>def my_filter (f, l)  { List.Rev (List.FoldLeft(l, [], (elem, acc) => if (f (elem)) elem::acc else acc)) }
S>def x = my_filter( (x) => x>0, [1,2,3,-5,-9,7] )

S>def longEnough(str:string) {str.Length > 5}
S>def x2 = my_filter ( longEnough , ["String1", "Str2"] )
S>

S>let my_filter f = List.fold_left (fun acc elem -> if f elem then elem::acc else acc) [] >> List.rev
S>let x = my_filter (fun x -> x > 0 ) [1; 2; -9; 14; -5; 7]

S>let longEnough (s:string) = s.Length > 5
S>let x2 = my_filter longEnough ["String1"; "Str2"; "String4"] 
S>

def result = [1, 2, 3, -5, -9, 7].Filter(_ > 0);
def result = ["String1", "Str2", "String4"].Filter(str => str.Length > 5);

S>(* вот так работает *)
S>let x = "SomeString" |> (fun s -> s.Length) 
S>(* вот так, увы, нет *)
S>let x = (fun s -> s.Length) "SomeString" 
S>

S>Так это же замечательно, что балуются, а не объявляют себя законченным решением. А то так можно и до уровня Оберона закостенеть.

VD>>Да и какая разница, на замену или рядом? Главное чтобы он был. А чтобы он был нужны вливания денег и поддержка. В прочем, велика вероятность, что он таки будет во преки всему.

S>Дык я ж разве против? Опять-же см. п.2 дисклеймера про богатство выбора. Вот.

S>(* вот list comprehension  *)
S>[ for e in l when f e -> e ]
S>(* а вот array comprehension  *)
S>[| for e in l when f e -> e |]
S>(* а вот так - IEnumerable comprehension  *)
S>{ for e in l when f e -> e }
S>

def my_filter(f, l) { $[x | x in l, f(x)] }
def x = my_filter(_ > 0, array[1, 2, 3, -5, -9, 7]);

def my_filter(f, l) { $[x | x in l, f(x)] }
def x = my_filter(_ > 0, array[1, 2, 3, -5, -9, 7] : Collections.Generic.IEnumerable[int]);

VD>def result = [1, 2, 3, -5, -9, 7].Filter(_ > 0);
VD>def result = ["String1", "Str2", "String4"].Filter(str => str.Length > 5);
VD>

let result = ["String1";"String2";"Str3"].Filter (fun x -> x.Length > 5)

def result = ["String1", "Str2", "String4"].Filter(_.Length > 5);

VD>Что-то ответ я так и не увидел?

VD>Посему уж если давать бабки на F#, то глупо не дать их и на Немреле. Более того. Разумно было бы объеденить или хотя бы скоординировать усилия двух направлений. Вместе разультат мог бы оказаться куда лучше. Скажем F# и Немерле могли бы использовать одни и те же общие ФП-библиотеки. Код между ними стал бы переносим. А там уже не загорами фунциональные оптимизации в CLR (Нью-Васюки, значич ).

S>Разумно. Почему не стали — . Может, Москаль не так уж и стремился к тому, чтобы далее плотно работать с Немерле? Раз он там так плотно засел за систему доказательства теорем. Кстати, если им там все-таки на первом этапе выделили какое-то финансирование, что-нибудь в плане развития Немерле за этим последовало? Может, просто МС решил, что от этой команды отдачи не будет?

S>let result = ["String1";"String2";"Str3"].Filter (fun x -> x.Length > 5)
S>

S>Называется, найдите 10 отличий

S>def result = ["String1", "Str2", "String4"].Filter(_.Length > 5);
S>

def result = ["String1", "Str2", "String4"].Filter((x => x.Length) > 5);

def result = ["String1", "Str2", "String4"].Filter(x => x.Length > 5);

S>Но всегда есть надежда, что от ежа и ужа родится корова, несущая золотые страусиные яйца в промышленных масштабах.

VD>>Что-то ответ я так и не увидел?

type 'a List with
    member x.FilterLazy f = Seq.filter f x
    
let result = [1;2;3;4;5;6].FilterLazy (fun x -> x>3)
(* result : int seq *)

let result = [1;2;3;4;5;6] |> Seq.filter (fun x -> x>3)

VD>А кого убеждать то? Такое ощущение что тут везде бродят казначеи из МС.

Так вот, сам по себе Nemerle, без этой самой макросистемы, как мне кажется, представляет собой довольно осторожный шаг в сторону ФП. Возможно, соизмеримый с тем, чего планируется достигнуть в рамках эволюции C#, пусть даже и с заимствованием немерловых идей. F# все-таки более ориентирован на функциональный стиль программирования, пусть и ценой существенного отличия от мэйнстрима в синтаксисе, и, видимо, поэтому стал "более проходным" с точки зрения MS, поскольку в случае Nemerle получается некоторое дублирование.

S>type 'a List with
S>    member x.FilterLazy f = Seq.filter f x
    
S>let result = [1;2;3;4;5;6].FilterLazy (fun x -> x>3)
S>(* result : int seq *)
S>

type 'a IEnumerable with
    member x.FilterLazy f = ...

S>let result = [1;2;3;4;5;6] |> Seq.filter (fun x -> x>3)
S>

public static @|> (a : 'p1, fac : 'p1 -> 'r) : 'r
{
    fac(a)
}    

public static @|> (a : 'p1, fac : 'p1 -> void) : void
{
    fac(a)
}

VD>>А кого убеждать то? Такое ощущение что тут везде бродят казначеи из МС.

От: Michael Nikolaev — просмотр профиля
Дата: Пн. 13 Янв. 2003 01:35
Электронная почта: Michael Nikolaev <michael.nikol...@p40.f58.n463.z2.fidonet.org>
Группы: fido7.su.softw


Hello Alexander!

Saturday January 11 2003 00:33, Anton Moscal wrote to you:

AM> From: "Anton Moscal" <m...@post.tepkom.ru>

AM> Fri Jan 10 2003 16:05, Alexander Krotov wrote to Vitaly Lugovsky:

AK>> From: a...@despammed.com (Alexander Krotov)

AK>> Vitaly Lugovsky <v...@ontil.ihep.su> wrote:

VL>>> А кто когда либо обещал возможность писать эффективно на
VL>>> ленивых чисто функциональных языках? Хочешь оптимизаций —
VL>>> используй императивные фичи, вроде тех же ексепшинов...

AK>> Hе флейма ради, а токма из любопытства:
AK>> исключения, как мне до сих пор кажется, являются скорее
AK>> порождением FP, чем императивщины. All, Так ли это ?

Hасколько я помню, это не совсем так. Исключения понадобились для выpажения
семантики GOTO пpи спецификации языков типа ПЛ/1 на языке спецификаций META-IV
Венского метода спецификаций. Основными pазpаботчиками там были
D. Bjorner, C.B, Jones. Это где-то 1977-1978 гг. Если я сильно поищy,
то, может быть, даже найдy y себя их "дpевние" статьи по этомy поводy.
Там было две основные констpyкции — неpекypсивная и pекypсивная:

1. trap exit(id) with F(id) in C(...)

Если пpи вычислении С(...) исключение, поpождённое опеpатоpом exit(v) не бyдет
пеpехвачено внyтpи этого блока, его значение связывается с идентификатоpом
id и вычисляется выpажение F(id), значение котоpого и бyдет тогда pезyльтатом
в?числения всего выpажения. Исключения в F(id) "пpоходят наpyжy", т.е. должны
пеpехватываться "охватывающими" выpажениями.

2. tixe [F(i) -> G(i) | P(i)] in C(...) Здесь значение исключения
2. tixe [F(i) -> сопоставляется с обpазцом F(j). Если для этого
обpазца выполняется yсловие, заданное пpедикатом P(j), то вычисляется
выpажение G(j). Если пpи вычислении этого выpажения возникнет исключение,
снова пpоизводится сопоставление с обpазцом и т.д., пока пpедикат не бyдет
выполняться для исключения, либо исключений не бyдет.

Исключения С++ весьма похожи на пеpвый ваpиант, не пpавда ли?
Это почти 20 лет спyстя!

C.B. Jones доказывал в каких-то своих pаботах эквивалентность этого
механихма и механизма "continuations" (не знаю даже, как это по-pyсски
сказать).

Я сам пpогpаммиpовал с использованием ваpианта этого механизма на C еще в
сеpедине 80-х. Помню, что многие тогда меня pyгали, потомy, что не могли
вpyбиться в смысл соответствyющих констpyкций.

Подpобнее об этом можно почитать в
Lecture Notes in Computer Science. #61. The Vienna Development Method:
Th Meta-Language. Springer-Verlag< 1978.

AM> Видимо нет. Исключения позволяют определить порядок вычисления
AM> подвыражений, а потому не являются "pure functional" (насколько я
AM> помню — в Java с исключениями связаны похожие проблемы с
AM> неоднозначностью семантики).

AM> "pure functional" решением проблемы является явный возврат состояния:
AM> то есть тип вроде:

AM> data Value a = Value a | Error String

AM> и операция последовательного исполнения (см. монады):

a >>> = b =
AM> case a of
AM> | Error msg -> Error msg
AM> | Value a -> b a

AM> Hо реально — это довольно нетривиальная тема. Монады imho — чуть ли не
AM> единственая нетривальная управляющая структура, которая была
AM> изобретена с времен структурного программирования. Тут на пальцах
AM> объяснить довольно трудно.

AK>> --
AK>> Успехов,
AK>> Саша.

AM> Антон

AM> -+- ifmail v.2.15dev5
AM> + Origin: FidoNet Online — http://www.fido-online.com (2:5020/175.2)

Всех благ,
Михаил

E-Mail: m...@gu.kiev.ua