Nemerle

Nemerle
Paradigm	multi-paradigm: functional, object-oriented, imperative
Designed by	Kamil Skalski, Michał Moskal, Prof. Leszek Pacholski and Paweł Olszta at Wrocław University
Stable release	1.0.0 Beta 2 Update / September 24, 2010
Typing discipline	static, strong, inferred
Platform	CLR
Website	http://nemerle.org/Main_Page
Major implementations
	Nemerle
Influenced by
	C#, ML, Lisp

Nemerle is a high-level statically typed programming language for the .NET (see also Mono) platform. It offers functional, object-oriented and imperative features. It has a simple C#-like syntax and a powerful metaprogramming system.

It has been named after the archmage Nemmerle from "A Wizard of Earthsea" by Ursula K. Le Guin (spelling with a single m is a design decision).

Features

Probably the most important feature of Nemerle is the ability to mix object oriented and functional programming styles. The top-level program structure is object oriented, while in the body of methods one can (but is not forced to) use functional style. This is very handy in some programming problems. The feature set includes functional values, variants and pattern matching.

Another very important feature is taking a high-level approach in all aspects of the language—trying to lift as much of the burden from the programmer as possible. Features like macros and type inference fit here.

Features that come from the functional land are variants (aka algebraic data types), pattern matching, type inference and parameter polymorphism (aka generics). The metaprogramming system allows great compiler extensibility, embedding domain specific languages, partial evaluation and aspect-oriented programming.

Last but not least, the usage of more mundane library functionality from .NET is as easy as in C#.

Type inference

def x = 1; // int
def myList = List(); // generic List[T], type T is deduced from the usage in the next line
myList.Add(x);       // compiler deduces type of T as int making myList type of List[int]

Everything is an expression

def x = 
  { // similar to x = 3
    def y = 1;
    def z = 2;
    y + z   // this last statement is a block return value
  }

def x = 
  if (DateTime.Now.DayOfWeek == DayOfWeek.Monday)  // if, using, try  are also expressions
    "Monday"
  else
    "other day";

def x = try 
{
  Int32.Parse(someString)
}
catch
{
  | FormatException() => 0;
}

Tuples

def k = (1, "one"); // k : (int * string)
def (a, b) = k; // a = 1, b = "one"

Pattern matching

def result = match (number)
{
  | 0            => "zero"
  | 1            => "one"
  | x when x < 0 => "negative"
  | _            => "more than one"
}

Functional types and local functions

def next(x) { x + 1 }; 

def mult(x, y) { x * y } 

def fibbonacci(i)
{
  | 0     => 0
  | 1     => 1
  | other => other + fibbonacci(i - 1)
}

Console.WriteLine(next(9));        // 10
Console.WriteLine(mult(2, 2));     // 4
Console.WriteLine(fibbonacci(10)); // 55

Metaprogramming

Nemerle allows to create, analyze and modify code of a program during a compilation process using a powerfull macro system. Macros can be used in a form of a method call or even a new language construction. Most of the Nemerle language constructions are macros (if, for, foreach, while, using etc.).

"if" macro example:

macro @if (cond, e1, e2)
syntax ("if", "(", cond, ")", e1, Optional (";"), "else", e2)
{
  /*
    <[ ]> defines an area of quasi-quotation, the Nemerle compiler transforms a code in a such block
    to an AST tree, such transformations are somewhat similar to an Expression compiling in C#
  */
  <[ 
    match ($cond : bool)
    {
      | true => $e1
      | _ => $e2
    }
  ]>
}

// now we can use this macro in our code:
def max = if (a > b) a else b;
// during a compile time the upper line will be transformed to the following:
def max = match (a > b)
{
  | true => a
  | _    => b
}

IDE

Nemerle can be integrated into Visual Studio 2008. Also it has a completely free IDE based on Visual Studio 2008 Shell (like Visual Studio Express Editions).

Examples

Hello, World!

The traditional "Hello World!" can be implemented in a more C#-like fashion:

class Hello {
  static Main () : void {
    System.Console.WriteLine ("Hello, world!");
  }
}

or more simply:

System.Console.WriteLine("Hello, world!");

Examples of macros

Macros allow you to have boilerplate code generated for you under the hood, with additional static checks performed by the compiler. They give you the power to programatically generate code.

Database accessibility

For example, using Nemerle macros for SQL you can write:

ExecuteReaderLoop (
  "SELECT firstname, lastname FROM employee WHERE firstname = $myparm",
  dbcon,
  {
    System.Console.WriteLine ($"Name: $firstname $lastname") 
  });

instead of

string sql = "SELECT firstname, lastname FROM employee WHERE firstname = :a";
NpgsqlCommand dbcmd = new NpgsqlCommand (sql, dbcon, dbtran);
dbcmd.Parameters.Add("a", myparm);
 
NpgsqlReader reader = dbcmd.ExecuteReader();
 
while(reader.Read()) {
  string firstname = reader.GetString (0);
  string lastname = reader.GetString (1);
  System.Console.WriteLine ("Name: {0} {1}", firstname, lastname) 
}
reader.Close();
dbcmd.Dispose();

and this is not just hiding some operations in a library, but additional work performed by the compiler to understand the query string, the variables used there, and the columns returned from the database. The ExecuteReaderLoop macro will generate code roughly equivalent to what you would have to type manually. Moreover, it connects to the database at compilation time to check that your SQL query really makes sense.

New language constructs

With Nemerle macros you can also introduce some new syntax into the language:

macro ReverseFor (i, begin, body) 
syntax ("ford", "(", i, ";", begin, ")", body)
{
  <[ for ($i = $begin; $i >= 0; $i--) $body ]>
}

defines a macro introducing the ford (EXPR ; EXPR) EXPR syntax and can be used like

ford (i ; n) print (i);

Nemerle with ASP.NET

Nemerle can be either embedded directly into ASP.NET:

<%@ Page Language="Nemerle" %>
<script runat="server">

    Page_Load(_ : object, _ : EventArgs) : void {
        Message.Text = $"You last accessed this page at: $(DateTime.Now)";
    }

    EnterBtn_Click(_ : object, _ : EventArgs) : void {
        Message.Text = $"Hi $(Name.Text), welcome to ASP.NET!";
    }

</script>

<html>
    <body>
        <form runat="server">
            Please enter your name: <asp:TextBox ID="Name" runat="server" />
            <asp:Button OnClick="EnterBtn_Click" Text="Enter" runat="server" />

            <p><asp:Label ID="Message" runat="server" /></p>
        </form>
    </body>
</html>

...Or stored in a separate file and entered with a single line:

<%@ Page Language="Nemerle" Src="test.n" Inherits="Test" %>

PInvoke

Nemerle can take advantage of native platform libraries. The syntax is very similar to C#'s and other .NET languages. Here is the simplest example:

using System;
using System.Runtime.InteropServices;

class PlatformInvokeTest
{
    [DllImport("msvcrt.dll")]
    public extern static puts(c : string) : int;
 
    [DllImport("msvcrt.dll")]
    internal extern static _flushall() : int;
    
    public static Main() : void
    {
        _ = puts("Test");
        _ = _flushall();
    }
}

External links

Books about Nemerle

Nemerle, Lambert M. Timpledon, Miriam T. Markeseken, Susan F. Surhone, Betascript Publishing (2010), ISBN-10: 6130909896, ISBN-13: 978-6130909895
ML Programming Language Family: ML, Standard ML, Objective Caml, Mythryl, F Sharp, Nemerle, Alice, Standard ML of New Jersey, Concurrent ML, Books LLC, ISBN-10: 1155461290, ISBN-13: 978-1155461298