The main purpose of this project is to provide an extension of Microsoft Visual Studio .NET development environment with support for the Haskell functional programming language, improve user experience and productivity related to implementation tasks.

Download and play, I say.

Erlang REPOS 1.0

REPOS stands for Repository of Erlang-Projects.Org Software selection. It is a collection of major ready-to-work Erlang software. REPOS is distributed as a CDROM image (ISO). You can use every software included in the REPOS environment either directly from CDROM from your hard-drive or from a USB key.

Seems like a nice distribution technique for non-mainstream languages.

The distribution includes several software packages along with erlang, among them Xmerl, Yaws and Wings 3D.

OO Programming Styles in ML

OO Programming Styles in ML, Bernard Berthomieu.

It is shown that the essential OO concepts and idioms, including inheritance and dynamic dispatch, can be encoded in this well understood framework, without requiring any operational or typing extensions of ML...

[The encodings] do not rely on subtyping and subsumption, but on an encoding of inheritance polymorphism into paramteric polymorphism.

This isn't new (it is dated March 2000), but seems interesting.

The ML module language put to good use!

Thanks Henry!

Skribe 1.2b released

(via comp.lang.scheme)

Erick Gallesio and Manuel Serrano have announced the release of version 1.2b of Skribe, a document processing language based on Scheme. From the home page:

Skribe is a text processor. Even [though] it is a general purpose tool, it best suits the writing of technical documents such as web pages or technical reports, API documentations, etc. At first glance, Skribe looks like a mark-up language à la HTML. So, there is no need to have developed computer programming skills to use Skribe.

A second look reveals that Skribe is actually a true programming language, provided with high level features (such as objects, higher order functions, regular and syntactic parsing, etc.). Skribe is based on the Scheme programming language.

From Skribe source files it is possible to produce various targets:

  • HTML pages that can be used to implement a web site (such as the Skribe Home Page).
  • XML files.
  • LaTeX files that can be used to produce high quality Postscript or PDF files.

What language enthusiast/researcher hasn't chafed at the language design of TeX? You should especially check out some of their cool examples.

Haskell Communities and Activities Report, Seventh Edition, November 2004

The November 2004 edition of the biannual Haskell Communities and Activities Report has been published. Lots of new stuff in the last six months, and some old stuff updated as well. The HC&AR has been steadily growing over the last three years, showing that FP is gaining users both professional and private.

Several of the HC&AR items are interesting enough to have their own LtU stories, which may appear shortly.

The Essential Haskell Compiler

On the same subject as the Scheme compiler in 90 Minutes, is the Essential Haskell Compiler. From the HC&AR summary:

The purpose of the EHC project is to provide a description a Haskell compiler which is as understandable as possible so it can be used for education as well as research

In order to avoid overwhelming the innocent reader, the description of the compiler is organised as a series of increasingly complex steps. Each step corresponds to a Haskell subset which itself is an extension of the previous step. The first step starts with the essentials, namely typed lambda calculus.

Sounds like BC Pierce's Types and Programming Languages.
Also notable is that EHC uses Utrecht's Attribute Grammars, which are interesting in their own right.

Ralf Hinze: An algebra of scans

Ralf Hinze. An algebra of scans. Proceedings of the Seventh International Conference on Mathematics of Program Construction (MPC 2004).

In this paper we show that parallel prefix circuits enjoy a very pleasant algebra. Using only two basic building blocks and four combinators all standard designs can be described succinctly and rigorously. The rules of the algebra allow us to prove the circuits correct and to derive circuit designs in a systematic manner.

Parallel prefix computations, or scans if you speak APL, determine the sums of all prefixes of a given sequence. Obviously the term sum is used loosely: scan is a high-order function, and any associative operation can be used. In J talk scan is an adverb.

I wonder when we will be seeing courses called Algebra Design in Computer Science departments around the world...

Ah right, just after all universities offer language design courses ;-)

F#, a functional language for .Net

From Microsoft Research:

F# is a variant of ML with a core language akin to that of the OCaml programming language. F# runs on top of the .NET Framework and in many ways the language is designed to be an "ML that fits with .NET". F# includes extensions for working across languages, and the aim is to have it work together seamlessly with C#, COmega, Visual Basic, SML.NET and other .NET programming languages and tools. It is the first ML language where all the types and values in an ML program can be accessed from some significant object-oriented imperative languages (e.g. C#) in a predictable and (reasonably) friendly way.

Generalized ADTs in Haskell

Simon Peyton-Jones, via Haskell-list:

I've finished my first attempt at implementing Generalised Algebraic
Data types in GHC. Ordinary algebraic data types are generalised to
allow you to write an explicit type signature for each constructor; for

     data Term a where
	Lit :: Int -> Term Int
	Succ :: Term Int -> Term Int
	IsZero :: Term Int -> Term Bool	
	If :: Term Bool -> Term a -> Term a -> Term a

Notice that some of these constructors have return types that are not
just "Term a"... that's the whole point! Now you can write typed
evaluator for these terms:

    eval :: Term a -> a
    eval (Lit i)		= i
    eval (Succ t) 	= 1 + eval t
    eval (IsZero i) 	= eval i == 0
    eval (If b e1 e2)	= if eval b then eval e1 else eval e2

This is implementation of the "wobbly types" we've discussed before in GHC, slated for release in version 6.4. Simon also give a pointer to Tim Sheard's site, as he's done a lot of related work. There I found an interesting looking paper on Omega, a language which takes the GADT idea even further.

newLisp: A better Lisp/Scheme Fusion...

I had been breathlessly watching Paul Graham's website hoping for news about Arc, his "New Lisp". But I hadn't realized that a group of developers had already beaten him to the punch!

newLisp is an updated (and scaled down) Lisp, targeted at the scripting world. From the web site:

newLISP is a general purpose scripting language for developing Web applications and programs in general and in the domain of Artificial Intelligence (AI) and statistics.

Among its many interesting features (such as useful functions for getting scripting work done, good performance, and small footprint) are:

  • Dynamic and lexical scoping with multiple name spaces
  • OOP extensions
  • TCP/IP and UDP networking functions
  • Perl compatible regular expressions, PCRE
  • Matrix and advanced math functions
  • Financial math functions
  • Statistical functions
  • XML functions and SXML support
  • Tcl/Tk Graphical Fontend
  • Modules for MYSQL, SQLite and ODBC Database access
  • CGI, SMTP, POP3 and FTP Modules
  • Complete documentation in HTML and PDF

While many new scripting languages languish with good implementations, but no fully-realized libraries or interaction with outside software, newLisp seems to have sprung fully-formed, with various useful libraries already implemented.

Newlisp compiles on most LINUX, UNIX versions, CYGWIN, Windows, and presumably Mac OS X. It is licensed under the GNU Public License, GPL

Who knows -- perhaps now Ehud will have a Lisp with which he can finally get some scripting work done!

XML feed