- RankNTypes

This experimental feature allows polymorphic types (introduced with `forall`) to appear on the left of a function arrow, or as the type of a record field, etc. For example:

rank2 :: (forall a. a -> a) -> Number

rank2 = \f -> if f true then f 1 else f 2

- Modules

- Polymorphic Object Update

Records now support member update in which the type of the field changes during the update. For example:

data Wrap a = Wrap a

update = \o -> o { prop = Wrap o.prop }

- Naked expressions as statements

Naked expressions of type `{}` can now be used as statements.

- Split code generation into `AST -> JS` and `JS -> String`

JavaScript generation is now split into the generation of a JavaScript AST, and the pretty-printing of that AST. This enables some optimizations, and a better JavaScript pretty-printer.

- Syntactic sugar for introducing curried functions

Single-argument functions and multiple-argument functions can now be introduced in the same way:

test = \a (b, c) d -> a + b + c + d

- JavaScript optimizations

Some basic dead-variable elimination, inlining and eta-conversion are now performed on the generated JavaScript.

- Generate formatted Javascript

The generated JavaScript is now formatted to be more readable. In particular, newlines get generated, and the correct indentation is used.

- More valid infix operators

The colon and period characters are now valid in infix operator names.

- Avoid 'do' keyword for blocks

`do` will be used later for Haskell-like monad comprehensions, so its previous use in introducing blocks of statements is now invalid. The `do` keyword is still reserved.

- Member foreign import syntax

- Make FFI syntax match Haskell

Use `foreign import` instead of `extern`.

- Make record declaration syntax match Haskell

- Simplify array binders

There are now two types of array binders: cons binders `x : xs -> ...` and array binders `[x, y, z] -> ...` instead of the previously confusing `[x:xs]`.

- Array indexing syntax is ambiguous

sum (x:xs) = x + sum xs

- Basic support for type classes has been added. Polymorphic types of the form `forall a. (C a) => ...` will not be inferred but can be checked. Type inference still works if all type class instances can be determined. There is not yet support for functionality like GHC's `FlexibleInstances`, `FlexibleContexts` or `MultiParamTypesClasses`. For example:

class Truthy a where

isTrue :: a -> Boolean

instance Truthy Boolean where

isTrue b = b

instance Truthy String where

isTrue "" = false

isTrue _ = true

ifThenElse :: forall a b. (Truthy a) => a -> b -> b -> b

ifThenElse a tr fa = if isTrue a then tr else fa

- There is now support for `do` notation, using the `Monad` type class from the `Prelude` module. For example:

data Maybe = Nothing | Just a

instance Prelude.Monad Maybe where

ret = Just

(>>=) Nothing _ = Nothing

(>>=) (Just a) f = f a

test = do

x <- Just 1

y <- Just 2

ret $ x + y

- There is now a better story for side-effects. The `Eff` module in the `Prelude` defines a monad `Eff e` where e is a row of effect types. The kind system now defines a new kind `!` of effects. Row polymorphism allows different native effects to be interleaved. For example:

test = do

trace "Testing"

throwError "Error!"

has inferred type `forall eff. Eff (trace :: Trace | error :: Error String | eff)`.

See the `/examples/passing/Eff.purs` file for a more in-depth set of examples.

Supported native effects currently include `ST`, `Trace`, `Error` and `DOM` (via the `libraries/jquery` module).

- Try out the latest features [here](http://tryps.functorial.com).

- Multiple argument functions are no longer available.

- When used in the browser, PureScript modules are now accessed through `window.PS.<ModuleName>`. The `PS` object name can be changed via the `--browser-namespace` compiler argument.

- The `--run-main` argument has been replaced with `--main` which can now accept a module name in which to find the `main` function.

- Dead code elimination. The new compiler argument `--module=` can be used to specify one or more modules that should be kept in the generated code along with their dependencies. If no modules are specified, all code is exported.

- The `->` and `[]` types are now usable in type class instances.

- The file path is included in syntax error messages.

- Most reserved Javascript names (`return`, `const`, etc) are now usable.

- It is no longer necessary to sort modules in order of dependencies manually.

- Case statements matching data constructors no longer generate unnecessary constructor checks at runtime if there is only a single data constructor.

- New optimizer rules were added to inline JavaScript's built-in operators.

- Floats parse correctly.

- Using data constructors in pattern matches now works properly across modules.

- PureScript modules no longer overwrite global objects with the same name.

- A bug which allowed skolem variables to escape their scope was add (thanks to Brian McKenna).

- Modules containing mutually recursive type synonyms and data declarations now compile correctly.

- A number of bugs in the optimizer were addressed.

- The `Prelude` has been greatly expanded. Definitions for built-in JavaScript operators have been moved into the Prelude.

- The escape check was removed, since it was too restrictive (paf31)

- The binary operator reordering step was greatly simplified (paf31)

- The Object type constructor can now be referenced explicitly as `Prim.Object` (with kind `# * -> *`) (paf31)

- Unary minus and signed numeric literals are now supported again (paf31, garyb)

- Type errors have been simplified, the full trace can be enabled with `--verbose-errors` or `-v` (paf31)

- Error messages now display source positions (paf31, garyb)

- `(++)` is now an alias for the Semigroup operator `(<>)` (paf31)

- Error messages for classes with undefined or missing members have been improved (garyb)

- The SYB dependency was removed, and traversals rewritten by hand, for a large performance increase (paf31)

- The subsumes relation has been fixed for object types (paf31)

- The `grunt-purescript` plugin has been updated to provide support for new command line options.

- There is a new `gulp-purescript` plugin available for compiling with Gulp.

- There is a new `hierarchy` executable which will generate `.dot` diagrams based on the type class hierarchy of a module. The Prelude docs have been updated to include such a type class diagram. (joneshf)