Xoltar

en masse · really

ghc -package Cabal Setup.lhs -o setup

setup configure

setup build

setup install

for
for
if
goto

This long awaited release adds many improvements to the possible interactions

with Java libraries and tools. It improves some error messages, and fixes a

large number of bugs.

Thanks to the hard work of Luc Perrin and Arjan Boeijink, an important part of

the Nice compiler has been converted from Java to Nice itself!

Changes:

  * Better error messages for wrong constructor calls and method

    implementations with wrong parameter names.

  * Default value of fields can be overriden in subclasses. For instance:

      class A {

        int x = 1;

      }

      class B extends A {

        override x = 5;

      }

    This also works for final fields.

  * Imported methods can be generalized. That is, it is possible to

    define a new method which is more general than an existing one,

    and the existing method will be recognized as a special case of the

    general one. For instance, consider:

      abstract interface Addable { void add(T item); }

      interface java.util.Collection implements Addable;

    Method java.util.Collection.add() is recognized as implementing

    the new add method, which makes Collection a valid Addable class.

  * Java methods and fields with parametric types are given a type with

    UnknownTypes as type parameters instead of being ignored.

  * Number of errors and warning are printed to the console.

  * Improved source information for debuggers.

  * Generated classes are smaller, thanks to smaller debugging information.

  * Niceunit now reports test failures with the source file and line number

    information for the failed assertion.

  * Native compilation with gcj is twice faster.

  * Bug fixes (disallowed redefinition of parameters, execution order of

    initializers in super classes, visibility checking of java classes,

    cyclic custom constructors, methods and fields in classes with less type

    parameters, 'this' in custom constructors, comparison of possibly null

    values with primitive values, ... )

darcs record
xf86cfg
enable
sudo dhclient
cupsd

* Assertions about the type of variables are used by the typechecker, so that

    casts are not necessary. For instance:

      Object o = ...;

      // We happen to know by design than the object must be a string

      assert o instanceof String;

      // Here o can be used as a string without cast

    The same construct can be used with '!= null' tests.

  * java.lang.Class is now parameterized by the type it represents.

    In particular, newInstance is now declared in nice.lang with

       T newInstance(Class);

    This make it possible to write type-safe code that uses reflexion,

    in particular when using class literals.

  * Subclasses can have less type parameters than their parent by fixing

    the value of the others. For instance:

      class BitField implements List { ... }

  * Improved speed of coverage tests for some methods.

  * Much improved nicedoc tool.

  * Removed the '--strict' compiler option.

  * Underscores are allowed and ignored in literal numbers. example:

      long x = 1_000_123_000_456;

  * The indexing operator supports multiple arguments now. For instance

    'a[x,y]' is syntactic sugar for 'a.get(x,y)'.

  * Lists now support a wide array of slicing and indexing

    operations. There is a new bit of syntax, '@', which indicates

    the index of the last item in a list, which can be used for working

    with indexes relative to the end of the list, instead of the beginning.

    For instance, given a list of ints from 0 to 6 called

    'intList':

	intList[@] is 6,

	intList[@-1] is 5,

	intList[1..2] is the list [1,2].

	intList[1..@-1] is a list of all but the first and last

		elements of ints, i.e., [1,2,3,4,5]

	intList[1..] is a list of all but the first element of intList

	intList[..] is a complete copy of intList

	intList[..@-1] is a list of all but the last element of intList

	intList[int i => i % 2 == 0] is a list of all the even ints

		in intList: [0,2,4,6]

	Several more options are available, an update to the manual will

	reflect this.

   intList[@] is 6,

   intList[@-1] is 5

from the front:     0    1    2    3    4    5

(or: )              0   0+1  0+2  0+3  0+4  0+5

                  ["a", "b", "c", "d", "e", "f"]

from the back:     @-5  @-4  @-3  @-2  @-1   @

   intList[1..2] is the list [1,2].

   intList[1..@-1] is a list of all but the first and last

       elements of ints, i.e., [1,2,3,4,5]

   intList[1..] is a list of all but the first element of intList

   intList[..] is a complete copy of intList

   intList[..@-1] is a list of all but the last element of intList

   intList[@-2..@-1] is the third-from-last and second-from-last: [4,5]

   intList[1:-1]

   intList[1..@-1]

   intList[int i => i % 2 == 0] is a list of all the even ints in intList, i.e.: [0,2,4,6]

   intList[[2,3,0,1, @]] is [2,3,0,1,6]

   intList[int i => i % 2 == 0] = 27 makes intList into: [27, 1, 27, 3, 27, 5, 27]

   intList[[0,2] = -3 makes intList into: [-3, 1, -3, 3, 4, 5, 6]

   intList[3..] = 9 makes intList into: [0,1,2, 9, 9, 9, 9]

   intList[3..] = [5,4,3,2] makes intList into: [0,1,2,5,4,3,2]

   intList.removeAt(3..) makes intList into: [0,1,2]

interface Node {}

class Box implements Node {

	List children = new ArrayList();

	void `<<` (Node argNode) { children.add(argNode); }	

}

class Elephant implements Node {}

int num_elephants(Node n);

num_elephants(Elephant e) = 1;

num_elephants(Box b) {

	var result = 0;

	for (node: b.children) {

		result += node.num_elephants();

	}

	return result;

}

	int num_elephants(Object o) = 0;

	num_elephants(Elephant e) = // Same as original

	num_elephants(Box b) = //Same as original

	num_elephants(Box b) = b.children.map(num_elephants).foldLeft(

		(int i, int j) => i + j);

	num_elephants(String s) = s.indexOf("Elephant") > -1 ? 1 : 0

	num_elephants("SpecialElephant") = 5;

 List get(List list, T->boolean function) = 

	list.filter(function);

myTuple = 1, 2, 3;

print myTuple[2];

anotherTuple = (1, (2, 3), 4);

print anotherTuple[2:3];

list = { 1, 2, 3 };

list.add(4);

print list[2:4];

block = { print 'hello'; };

block.call();

block = { x : print x; }

block.call('hello');

list = [ 'a', 'b', 'c' ];

list.each { i : print i; }

map = [ 1 : 'bob', 2 : 'james' ];

print map[1];

map[4] = 'jon';

let myTuple = (1, 2, 3);

let (a0, a1, a2) = myTuple;

println(a2);

let anotherTuple = (1, (2, 3), 4);

let (b0, b1, b2) = anotherTuple;

println(b1, b2);

let list = [ 1, 2, 3 ];

list.add(4);

println(list[2..3]);

let block = () => { println("hello"); };

block();

let list = [ 'a', 'b', 'c' ];

list.foreach(int i => println(i); }

// or, equivalently:

list.foreach(println);

// or, again:

for(i:list) { println(i); }

let map = [(1,"bob"), (2,"james")].listToMap();

println(map[1]);

map[4] = "jon";

package nice.sql;

import nice.functional;

import java.sql.*;

Connection connect() { throw new Exception("Not implemented"); }

//Generic query. Not sure what this ought to look like, but this will work

//for our examples here.

var ?Connection conn = null;

Iterator<ResultSet> query(String sqlQuery, ?List<Object> binders = null) {

    if (conn == null) {

        conn = connect();

    }

    let c = conn;

    if (c != null) {

    let stmt = c.createStatement();

    try {

        if (binders != null) {

            //Replace all the ? chars with our given binders.

            let tokens = binders.map(sql).iterator();

            while(sqlQuery.indexOf("?") > -1 && tokens.hasNext())

                sqlQuery = sqlQuery.replace('?', tokens.next());

                }

            return iterator(stmt.executeQuery(sqlQuery));

    } finally {

       stmt.close();

    }

   }

   throw new Exception("Couldn't connect");

}

//Wrap up ResultSets as Iterators, so we can use all the built-in

//methods for iterators that Nice already supports.

Iterator<ResultSet> iterator(ResultSet res) {

    return iterator(() => {

    if (res.next())

        return res;

    return stop();

    });

}

//Support [] operator for indexes, dynamic typing here!

<T> T get(ResultSet r, int i) = cast(r.get(i));

//Support [] operator for column names, dynamic typing here!

<T> T get(ResultSet r, String col) = cast(r.get(col));

//Handy SQL formatting

String sql(?Object obj) = obj == null ? "null" : obj.toString();

sql(String s) = "'" + s + "'";

//Need one for dates...

import groovy.sql.Sql

import groovy.sql.TestHelper

foo = 'cheese'

sql = TestHelper.makeSql()

sql.eachRow("select * from FOOD where type=${foo}") { 

    println "Gromit likes ${it.name}" 

}

import nice.sql;

void main(String[] args) {

	let foo = "cheese";

	for(r : query("select * from FOOD where type = ?", [foo])) {

		println("Gromit likes " r["name"]);

	}

}

import groovy.sql.Sql

import groovy.sql.TestHelper

foo = 'cheese'

sql = TestHelper.makeSql()

answer = 0

sql.eachRow("select count(*) from FOOD where type=${foo}") { row |

	answer = row[0]

}

assert answer > 0

import nice.sql;

void main(String[] args) {

	let foo = 'cheese'

	int answer;

	for(row : query("select count(*) from FOOD where type= ?", [foo]))

		answer = row[0];

	assert answer > 0;

}

import groovy.sql.Sql

import groovy.sql.TestHelper

sql = TestHelper.makeSql()

food = sql.dataSet('FOOD')

cheese = food.findAll { it.type == 'cheese' }

cheese.each { println "Eat ${it.name}" }

import nice.sql;

void main(String[] args) {

	let food = query("FOOD");

	let cheese = food[ResultSet r => r["type"] == "cheese"];

	for(r:cheese)

		println("Eat " r["name"]);

}

someBuilder = new NodeBuilder()

someBuilder.people(kind:'folks', groovy:true) {

  person(x:123,  name:'James', cheese:'edam') {

    project(name:'groovy')

    project(name:'geronimo')

  }

  person(x:234,  name:'bob', cheese:'cheddar') {

    project(name:'groovy')

    project(name:'drools')

  }

}

if (customer.orders.any { it.amount > 1000 && 

	it.product.type == "cheese"} ) {

  doSomething();

}

if (customers.orders.any(Order ord => ord.amount > 1000 && 

	ord.product.type == "cheese")) {

  doSomething();

}

if (customers.orders.any(ord => ord.amount > 1000 && 

	ord.product.type == "cheese")) {

  doSomething();

}

if (customers.any { it.location.code == "UK" && 

	it.orders.any { it.amount > 1000 && 

		it.product.type == "cheese"}} ) {

  doSomething();

}

if (customers.any(Customer c => c.location.code == "UK" && 

	c.orders.any(Order o => o.amount > 1000 &&

		o.product.type == "cheese")) ) {

  doSomething();

}

for (order in customers.findAll { it.location.code == "UK" }.orders) {

  println("order ${order.id} has value ${order.value}");

}

for (order : customers[

	Customer it => it.location.code == "UK"].map(orders).concat) {

  println("order " order.id " has value " order.value);

}

class MyClass {

  /*..*/

  MyClass plus(MyClass other) { /*..*/ }

}

class MyClass { /*..*/ }

MyClass `+` (MyClass lhs, MyClass rhs) { /*.. */ }

if (customers.any { c | c.location.code == "UK" && 

	c.orders.any { o | o.amount > 1000 && 

		o.product.type == "cheese"}} ) {

  doSomething();

}

<MODE NAME="nice"		FILE="nice.xml"

				FILE_NAME_GLOB="*.nice" />

ObjectResultSet emps = connection.executeQuery("select * from emp");

while(emps.next()) {

	Employee emp = emps.get();

	if (isHireAnniversary(emp))

	   emp.setSalary(emp.getSalary() + emp.getSalary() * 0.05);

}

commit();

Iterator<(int, Date, BigDecimal)> emps = 

	connection.executeQuery("select id, hiredate, salary from emp");

for((id, hire, salary):emps) {

	if (isHireAnniversary(hire))

	   connection.update("update emp set salary = " +

	   	salary + salary * 0.05 + " where id = " + id ); 

}

commit();

* Nice methods are now compiled inside classes whenever possible. This does

  not make any difference for Nice programs, but simplifies integration with

  Java tools and usage of Nice code from Java sources.

* Is is now possible to make a class of an imported package implement

  an interface defined in the current package, with:

    class some.pkg.ClassName implements MyInterface;

* Type parameters can always be qualified with nullness markers '?' and '!'.

  For instance, a class declaration can be

    class OptionalRef

    {

      // The value might be null

      ?T value;

    }

* Allow calls to Java methods defined in a Java class that implements

  several Java interfaces declaring that same method, like

  java.io.ObjectOutputStream.flush()

* Reduced compilation time (about 20%) and memory consumption.

* Smaller generated bytecode.

* Fixed native compilation using gcj. It used to block when gcj produced

  too much output.

let name = "Nice";

let version = 0.97;

let String name = "Nice";

let float version = 0.97;

let list = new ArrayList();

list.add("A");

list.add(2); //Compile error!

/**

 * A generator which yields natural numbers.

 */

()->int naturals() 

{

  var int num = 1;

  return (()=>num++);

}

//return only odd numbers

let odds = naturals().filter(int n => n % 2 != 0);

//Add the first 10 numbers togther:

let sum = naturals().take(10).fold(0, (int acc, int n)=> acc + n);

//Generate consecutively numbered filenames:

let fileNameGenerator = naturals().map(

	int n => "backup_" + n + ".zip");

if (DEBUG) {

	logger.debug("This manager has " + 

		manager.getEmployees().size() + 

		" employees");

}

logger.debug(DEBUG,

	()=> "This manager has " + 

		manager.getEmployees().size() + 

		" employees");

void debug(Log logger, 

	  void->String message,

	  boolean when = logger.isDebugEnabled())

{

  if (when) {

      info(logger, message());

  }

}

void debug(Log logger, 

	  void->String message,

	  ?Throwable err = null,

	  boolean when = logger.isDebugEnabled())

{

  if (when) {

      info(logger, message(), err);

  }

}

logger.debug() {

	return "This manager has " + 

		manager.getEmployees().size() + 

		" employees";

}

logger.debug(when: isTuesday()) {

	return "This manager has " + 

		manager.getEmployees().size() + 

		" employees";

}

try {

	//...

} catch (Exception e) {

	logger.debug(when: isTuesday(), err: e) {

		return "This manager has " + 

			manager.getEmployees().size() + 

			" employees";

	}

}

listOfTuples = zip(listOne, listTwo)

listOfTuples = []

for i in range(min(len(listOne), len(listTwo))):

	listOfTuples.append(listOne[i], listTwo[i])

import Data.IORef

-- Define 'foreach'

foreach = flip mapM_

-- Define 'while'

while test action = do

  val <- test

  if val then do {action;while test action}

         else return ()

-- Some helpers for use with 'while':

incr ref = modifyIORef ref (+1)

test ref f = do { val <- readIORef ref; return (f val) }

-- Exercise them. Equivalent Python code:

-- for x in range(1,11): 

--     print x

-- i = 0

-- while i < 5:

--     print "Still running"

--     i += 1

main = do

  foreach [1..10] print

  ref <- newIORef 0

  while (test ref (< 5))

        (do 

	  print "Still running!"

          incr ref)

(foo, bar, baz) = list_of_stuff

let (foo, bar, baz) = (list_of_stuff !! 0, list_of_stuff !! 1, list_of_stuff !! 2)

let (foo, bar, baz) = $(tuple 3) list_of_stuff

tuple :: Int -> ExpQ

tuple n = [|\list -> $(tup (exprs [|list|])) |]

  where

    exprs list = [infixE (Just (list))

		         (var "!!")

		         (Just (lit (Integer (toInteger num))))

		    | num <- [0..(n - 1)]]

>>> from partial import _

>>> addWorld = _ + " world!"

>>> addWorld("Hello,")

"Hello, world"

>>> mapcall(_.upper, ["list", "of", "strings"])

["LIST", "OF", "STRINGS"]

    Void objects are stand-ins, blanks, or holes in an expression,

    which can later be filled in. For example:

    v = Void()

    add_one = v + 1

    Now add_one is a function which takes one argument, and returns the

    argument plus one. This module exports "_", a single underscore, as

    an instance of Void, because it is suggestive of a blank or missing

    piece. Here are some more examples:

    import sys

    from operator import add

    adder = add(1,_)

    assert map(adder, range(3)) == [1,2,3]

    assert (_ + 5)(5) == 10

    assert (5 + _)(5) == 10

    assert (5 * _)(5) == 25

    assert (_ * 5)(5) == 25

    assert ((5 + _) * 5)(3) == 40, ((5 + _) * 5)(3)

    assert ((5 + _) * _)(3)(5) == 40

    assert ((5 + _) * _)(3, 5) == 40

    lst = []

    (_.append)(lst)(5)

    assert lst == [5], lst

    unsplit = ["foo", "ba ba", "baz"]

    postsplit = [["foo"], ["ba", "ba"], ["baz"]]

    assert mapcall(_.split, unsplit) == postsplit

    assert mapcall(None, map(_.split, unsplit)) == postsplit

    assert mapcall(_.split, unsplit, 'o') == [['f','',''], ['ba ba'], ['baz']]

    assert map(_ + 5, [1,2,3]) == [6,7,8]

    assert map(_['key'], [{'key':5}]) == [5]

    assert map(_[0], [(1,2,3),("a", "b", "c"), (10, 20, 30)]) == [1, "a", 10]

    assert map(_[1:3], [(1,2,3),("a", "b", "c"), (10, 20, 30)]) == [(2,3), ("b", "c"), (20, 30)]

    if sys.version_info[0] > 2 or sys.version_info[1] > 2:

        revtest = map(_[3:0:-1], [(1,2,3),("a", "b", "c"), (10, 20, 30)])

        assert revtest == [(3,2), ("c", "b"), (30, 20)], revtest

    assert len(((_ + 2) * "foo")(3)) == 15

	void foo(String arg) {...}

	void bar(?String arg) {
		if (arg != null) {
			//Here Nice knows arg is not null, so it can 
			// be passed to a method which takes a String!
			foo(arg);	
		} 
		foo(arg); //Here arg may or may not be null, 
			  //so Nice gives a compile error.
	}

Xoltar

Lambda the Ultimate Killfile

Using the FTP protocol for more than serving files

Dynamic Applications From the Ground Up

Settling down and choosing a language

Factor

New math site: Arsmathematica.net

Haskell-related blog

Cabal build system works well!

Desert Spring-Time

Reading Math

PLNews

Python to lose reduce()

Higher Order Perl

Nice 0.9.10 Released

Darcs infected

Seaside gets a new website

Solved: personal firewall

Haskell's overlooked object system

Living with Linux

Microsoft VPN

External serial mouse

The LCD/CRT switch

Migrating Thunderbird mail

Wireless PCMCIA card

Printing to Windows printers

Sound

Personal firewall

Interview with David Roundy, creator of Darcs

Nice appears in the alt.lang.jre series

Haskell Performance

Changes to RSS feed

Nice Programming Language 0.9.9 released

A slice of Nice

A plan for NullPointerExceptions

Plan B

Courtesy Implementation in Nice

More personality quizzes

Groovy features in Nice, part 2

Native Syntax for Lists and Maps

Groovy SQL

Groovy features in Nice

Groovy Markup

Path expression language

Operator Overloading

Closures

Polymorphic iteration and autoboxing

Nice programming language mode for JEdit

Narrowing down editor choices

Denial of Service

Partial continuations

Continuations in Java

Epigram - a new language with dependent typing

Boo - a new .Net language

André Pang comments on "Modern Static Typing: Less Code, Better Code"

Thoughts on a Nice database API

Query Language

Object Mapping

Nice Programming Language 0.9.8 released

Lambda the Ultimate has moved

How dynamic typing will save the world (not).

The Seventh ICFP Programming Contest

It's all clear to me now.

Type Inference in Nice

Creator of the Nice Programming Language gets a blog

An Ideal Source Code Management System

darcs - a thoughtful replacement for CVS

Macro envy

Nice generator library in CVS

Type safety in Nice

Better logging - how Nice!

The Scala Language

Financial contracts - commercial software in Caml

Two interesting new books on computer science

Site upgrade for Mozilla users

Context, metadata, and zip()

Smooth dynamic typing in Nice

Inching Toward Blogdom (again)

Loops in Haskell

Send a programmer to do a graphic artist's job...