Stax Proposals:

1 ) Remove JSON from collection classes and seperate : +reduce code weight
2 ) Split Stax into relevant parts( now found in package stax) : +reduce code weight -more import statements
3 ) Remove Collection dependencies from FoldableExtensions, now found in collection modules. +needed all collections for anything foldable
4 ) Remove groupBy from IterableExtensions / ArrayExtensions /FoldableExtensions, placed in haxe.data.collections.Group +

using lambdas alone now weighs in as 40kb(swf), which includes Stax and Tuples, down from 100kb+
Tuples now 35k

All previously passing unit tests still pass, with modest changes.
Known issues, no handling for subclasses of collections for JSON

haxe.data.collections.IterableExtensions now stax.Iterables
haxe.data.collections.ArrayExtensions now stax.Arrays

Stax (the class) has the following Lambdas for Iterables and Arrays:
map
flatMap
foldl
filter
size

Int and Float methods in stax.Maths
Method Chaining etc in stax.Functions
Tuples in stax.Tuples
etc

Equal,Hash,Show,Order & Meta in stax.plus.*

I don’t think the Tuples base class should rely on that but I haven’t implemented it.

Prelude is simply a collection of Typedefs

I renamed foreach to forEach for two reasons

1) forAll and forAny are capitalised
2) foreach in Lambda can cause confusion.

Stax v0.1

Stax is a new standard library for HaXe designed for developers who prefer declarative programming and productivity over program size and speed.

The standard library that comes with HaXe is pragmatically designed. The library is small, and there are only a few abstractions. As a result, the HaXe standard library is an excellent choice when the most important features are program size and performance.

Stax lies on the other end of the spectrum. Stax emphasizes functional concepts, generic abstractions, productivity, composability, and testability. When these features are most important, Stax makes an excellent choice.

Getting Starting with Stax

Stax includes a useful bundle of functionality in the Prelude. To get started using the functionality in the Prelude, simply add the following two lines to your applications:

  import Prelude;
  using PreludeExtensions;

This brings a slew of functionality into your application:

• Tuples, of arity 1 – 5, which are ideal containers for a bundle of times when a class would be too heavyweight. var t = Tuple2.create(23, "foo");
• Option, which eliminates the need for null and makes code much safer. var o = Some(23); var n = None;
• Future, which makes it easy to chain asynchronous operations.
• Conversions, which enable you to convert between primitives. var float = 12.toFloat();
• Array enhancements, which allow you to write functional code with arrays. [123, 24].map(function(i) return i * 2;);
• Function enhancements, which allow you to manipulate functions like first-class values. var h = f.compose(g); h.curry()(2)(3);
• Basic typeclasses, which allow you to hash, order, and show all built-in HaXe primitives. var hasher = Int.HasherF(); var hash = hasher.hash(3243);

The major abstractions introduced in the Prelude are covered in more depth in section 3.

The above constitutes all the functionality built into the Prelude. However, Stax includes many more components, such as:

• A unified collections library, including immutable, fully-featured versions of Set, Map, and List.
• JSON encoding, decoding, and transformation;
• Functional reactive library;
• Logging;
• Configuration;
• IO;
• And more!

Using Prelude Abstractions

Stax Collections Library

The Stax collections library, contained in the package haxe.data.collections, includes three types of collections:

• Lists (haxe.data.collections.List), which represent ordered sequences of elements;
• Sets (haxe.data.collections.Set), which represent unordered collections of unique elements;
• Maps (haxe.data.collections.Map), which represent partial functions from one type (the key) to another (the value).

All collection are immutable, support arbitrary element types, and are unifed via a Collection interface, which provides access to functionality that is universally available across all kinds of collections (add(), addAll(), remove(), removeAll(), size, contains(), and iterator()).

Collections implement the Foldable interface, so it’s possible to gain access to more advanced functionality by using the Foldable extensions:

  using haxe.functional.FoldableExtensions;

Collections can be created through a static factory method on the collection classes named create. This function typically requires access to equal, hash, or ordering type classes for the specified element type(s).

Stax JavaScript

Stax has a fully-typed representation of the vast majority of the DOM, including the latest W3C standards and widely supported non-standards.

You can import this representation and helper functions with the following two lines of code:

  import js.Env;
  import Dom;

The first line imports a Env class that provides access to top-level JavaScript objects and functions. The second line imports the external declarations that inform HaXe how every element in the DOM is typed.