Comparación de Nemerle y F # Por Funcional En .Net

Question

Wiki de la Comunidad Pregunta:

De conformidad con esta pregunta: What are the benefits of using Scala in .Net? otra pregunta viene a la mente. ¿Puede alguien exponer las ventajas (y desventajas) comparativas de Nemerle y F # para el desarrollo funcional en la plataforma .Net? Acabo de mirar a Nemerle de pasada. Suena como que juega en el mismo estadio de juego que F #, así que me preguntaba qué diferencias existen aparte de las obvias diferencias de sintaxis y la gran ventaja que F # tiene de estar respaldado por Microsoft.

Answer 1

Conozco muy poco sobre Nemerle, pero creo que una de sus características principales son las macros (a la manera de las macros felices como las de Scheme-like, en lugar de las feas macros tipo C). Nunca entendí por qué a la gente le encantan las macros, pero nunca he explicado por qué la gente le gusta tanto los tipos de datos algebraicos y la coincidencia de patrones, hasta que comencé a usar F #. Así que sospecho que si amas macros y usas .NET, entonces eres un fanático de Nemerle.

Answer 2

Toqué estos dos idiomas y mis impresiones sobre Nemerle son brevemente las siguientes: (Supongo que la mayoría de la audiencia está familiarizada con F # y Nemerle es menos popular, por lo que en aras de la equidad lo cubriré un poco más):

• La comunidad F # es bastante grande y crece constantemente debido a la gran cantidad de publicaciones de blog, artículos, etc. También se difunde en todos los países. Por el contrario, los entusiastas de Nemerle son básicamente de habla rusa y se concentran en el sitio RSDN.ru.
• La sintaxis de Nemerle es IMO mucho más amigable para los desarrolladores con el fondo en lenguajes tipo C.
• Nemerle (así como F #) tiene características de inferencia tipo. El mecanismo de inferencia tipo en Nemerle está ligado al cuerpo del método (funciones locales, variables, etc.), opuesto al alcance de inferencia de tipo global F #. Sin embargo, el compilador de Nemerle no impone ningún modismo específico de escritura de código para ayudar a escribir el mecanismo de inferencia.

F #

open System.Text 

let l = [1; 2; 3] 
let r1 = l |> List.fold(fun (sb : StringBuilder) v -> sb.Append(v).AppendLine()) (StringBuilder()) // type annotation is required on the function argument 
let r2 = (StringBuilder(), l) ||> List.fold(fun sb v -> sb.Append(v).AppendLine()) //here compiler can infer type of State parameter 

Nemerle

using System.Console; 
using System.Collections.Generic; 
using System.Text; 

def l = [1,2,3]; 
def res = l.FoldLeft(StringBuilder(), (v, acc) => acc.Append(v).AppendLine()); 
WriteLine($"Result:\n$res"); 

def d = Dictionary(); // generic parameters are absent (even placeholders!!!) 
d.Add(1, "!"); 
WriteLine(d.GetType()); // System.Collections.Generic.Dictionary`2[System.Int32,System.String] 

También se puede notar otra característica de Nemerle compilador - puede inferir tipos de uso posterior. Para deducir los tipos, F # utiliza el enfoque basado en el algoritmo de Hindley-Milner e intenta inferir el tipo más genérico. Nemerle, al contrario, nunca infiere tipos polimórficos y siempre busca el tipo más específico.

F #

let addInt = (+) 5 
let addString = (+) "!!!" 

let run f x = f (f x) // ('T -> 'T) -> 'T -> 'T 

run addInt 5 
run addString "S" 

Nemerle en las mismas condiciones inferirá tipo de carrera como (INT> int) * int -> int.

Más detalles sobre Nemerle mecanismo de inferencia de tipos se pueden encontrar en MSc tesis de Michal Moskal: Type Inference With Deferral

• Nemerle tiene capacidades metaprogramación ricos. La mayoría de las construcciones de control de lenguaje, como bucles, expresiones condicionales, soporte de LINQ, característica de próxima aparición de análisis incluyen fuentes de C# y muchas más; todas ellas se crean utilizando macros. Se puede encontrar una muestra de aplicaciones de macros here. Por cierto, las capacidades de formato de cadenas con $ sintaxis en el ejemplo anterior - también es la macro incorporada.

EDIT: Agregado muestra un poco más grande

using System.Console; 
using System.Collections.Generic; 
using System.Text; 

variant Expr 
{ 
    | Const { value : double } 
    | Var { name : string } 
    | Operation { id : string; left : Expr; right : Expr } 

    public Eval(operations : Dictionary[string, double*double -> double], context : Dictionary[string, double]) : double 
    { 
    match(this) 
    { 
     | Const (value) => value 
     | Var(name) => context[name] 
     | Operation(id, left, right) => 
      def f = operations[id]; 
      f(left.Eval(operations, context), right.Eval(operations, context)) 
    } 
    } 
} 

module Program 
{ 
    public Main() : void 
    { 
     def expr = 
      Expr.Operation(
       "*", 
       Expr.Const(10), 
       Expr.Operation(
       "+", 
       Expr.Var("n"), 
       Expr.Const(5) 
       ) 
      ); 
     def operations = Dictionary.[string, double * double -> double](); 
     operations["+"] = (x, y) => x + y; 
     operations["*"] = _ * _; 

     def vars = Dictionary(); 
     vars["n"] = 3.0; 

     def result = expr.Eval(operations, vars); 
     WriteLine($"Result is $result"); 
    } 
}