# Release 0.1.0

**Posted:**January 31st, 2012 |

**Author:**Mars |

**Filed under:**Progress | Comments Off

I’ve just tagged `v0.1.0`

in the git repository and uploaded a new Mac OS X binary build. Changes since last month’s release 0.0.0:

- A string is a sequence of characters, not a sequence of bytes. When iterating over the characters in a string literal, the contents are no longer returned as individual UTF-8 bytes, but as Unicode code points.
- Symbol lookup time is now O(log n) in the worst case, not O(n), since the index is now an AA-tree rather than an unbalanced binary tree.
- A race condition in the symbol allocator has been corrected; it is no longer possible to get duplicate symbols when the first lookup happens simultaneously on different processors.
`io.print`

function emits UTF-8 byte streams instead of mangling non-ASCII characters.- The identifiers
`task`

,`generator`

, and`yield`

have been reserved for use as syntax keywords. - String literals implement a
`compare_to`

method, which allows them to be compared and used as keys in a map container. This method uses a simple ordinal comparison, not one of the specific Unicode-defined lexical comparisons. `Import`

statement allows an optional aliasing clause, where the local symbol has a different name than the symbol defined in the target module. The complete syntax is:

`'import' identifier ['=' identifier] ['from' expression]`

As with all declarations, the first identifier token is the declared name; the optional second identifier specifies the target to import.- Expressions can now be split and continued on the next line after any binop token, including the comma and period tokens. Comments between a binop token and the end of line will be ignored.
- Tuples implement the
`sequence`

interface. - Map constructor no longer tries to double up as a set constructor. Entries must have both a key and a value.
- Unary operators (negate, not, poison, and yield) no longer parse an entire expression instead of a single term. This caused baffling precedence errors.
- Numerics package supports rational as well as integer arithmetic. Division of two integers will now yield a rational number instead of truncating the remainder and returning an integer. Rational numbers are represented as a pair of integers, numerator and denominator. Rational numbers are normalized such that the numerator and denominator have no common factors and the denominator is always positive and greater than 1.

Number type has two new predicates:`rational?`

, which is currently true for all numbers, and`integer?`

, which is true only for integral values. The shifting and bitwise arithmetic operations are only defined for integers, not for all rationals. - Functions in the
`number`

module allow rounding of rational numbers in three modes:`ceiling`

rounds toward positive infinity,`floor`

rounds toward negative infinity, and`truncate`

rounds toward zero. `Sign`

function in the`number`

module returns -1 for negative numbers, 1 for positive numbers, and 0 for all numbers which are equal to zero.- New
`generator`

block type lets you define a function which returns a

sequence. The generator supplies each value in the sequence by executing a`yield`

statement. This is not very useful, as you cannot put yield statements inside nested loops or conditionals, but it is a sign of things to come.