* `@see` links

* small documentation additions

std/Array.hx

@@ -22,6 +22,9 @@
 /**
 	An Array is a storage for values. You can access it using indexes or
 	with its API.
+
+	@see http://haxe.org/manual/std-Array.html
+	@see http://haxe.org/manual/lf-array-comprehension.html
 **/
 extern class Array<T> {
 

std/Class.hx

@@ -23,6 +23,8 @@
 	An abstract type that represents a Class.
 
 	See `Type` for the Haxe Reflection API.
+
+	@see http://haxe.org/manual/types-class-instance.html
 **/
 @:coreType @:runtimeValue abstract Class<T> {
 }

std/EReg.hx

@@ -34,7 +34,7 @@
 	its methods.
 
 	A detailed explanation of the supported operations is available at
-	http://haxe.org/manual/std-regex.html
+	<http://haxe.org/manual/std-regex.html>
 **/
 class EReg {
 

std/Enum.hx

@@ -26,6 +26,8 @@
 	The corresponding enum instance type is `EnumValue`.
 
 	See `Type` for the Haxe Reflection API.
+
+	@see http://haxe.org/manual/types-enum-instance.html
 **/
 @:coreType @:runtimeValue abstract Enum<T> {
 }

std/EnumValue.hx

@@ -23,6 +23,8 @@
 /**
 	An abstract type that represents any enum value.
 	See `Type` for the Haxe Reflection API.
+
+	@see http://haxe.org/manual/types-enum-instance.html
 **/
 @:coreType abstract EnumValue {
 }

std/IntIterator.hx

@@ -30,6 +30,8 @@
 	field, it is worth noting that IntIterator does not reset after being used
 	in a for-loop. Subsequent uses of the same instance will then have no
 	effect.
+
+	@see http://haxe.org/manual/lf-iterators.html
 **/
 class IntIterator {
 

std/Lambda.hx

@@ -31,6 +31,8 @@
 
 	If the first argument to any of the methods is null, the result is
 	unspecified.
+
+	@see http://haxe.org/manual/std-Lambda.html
 **/
 class Lambda {
 

std/List.hx

@@ -24,6 +24,8 @@
 	A linked-list of elements. The list is composed of element container objects
 	that are chained together. It is optimized so that adding or removing an
 	element does not imply copying the whole list content every time.
+
+	@see http://haxe.org/manual/std-List.html
 **/
 class List<T> {
 

std/Map.hx

@@ -41,6 +41,8 @@ import haxe.Constraints.IMap;
 	Maps can also be created with `key1 => value1, key2 => value2` syntax.
 
 	Map is an abstract type, it is not available at runtime.
+
+	@see http://haxe.org/manual/std-Map.html
 **/
 @:multiType(@:followWithAbstracts K)
 abstract Map<K,V>(IMap<K,V> ) {

std/Math.hx

@@ -21,6 +21,8 @@
  */
 /**
 	This class defines mathematical functions and constants.
+
+	@see http://haxe.org/manual/std-math.html
 **/
 #if cpp @:include("hxMath.h") #end
 extern class Math

std/Reflect.hx

@@ -22,6 +22,8 @@
 /**
 	The Reflect API is a way to manipulate values dynamically through an
 	abstract interface in an untyped manner. Use with care.
+
+	@see http://haxe.org/manual/std-reflection.html
 **/
 extern class Reflect {
 

std/StdTypes.hx

@@ -23,6 +23,8 @@
 
 /**
 	The standard `Void` type. Only `null` values can be of the type `Void`.
+
+	@see http://haxe.org/manual/types-void.html
 **/
 @:coreType abstract Void { }
 
@@ -31,6 +33,12 @@
 
 	On static targets, `null` cannot be assigned to Float. If this is necessary,
 	`Null<Float>` can be used instead.
+
+	`Std.int` converts a `Float` to an `Int`, rounded towards 0.  
+	`Std.parseFloat` converts a `String` to a `Float`.
+
+	@see http://haxe.org/manual/types-basic-types.html
+	@see http://haxe.org/manual/types-nullability.html
 **/
 @:coreType @:notNull @:runtimeValue abstract Float { }
 
@@ -39,6 +47,13 @@
 
 	On static targets, `null` cannot be assigned to `Int`. If this is necessary,
 	`Null<Int>` can be used instead.
+
+	`Std.int` converts a `Float` to an `Int`, rounded towards 0.  
+	`Std.parseInt` converts a `String` to an `Int`.
+
+	@see http://haxe.org/manual/types-basic-types.html
+	@see http://haxe.org/manual/std-math-integer-math.html
+	@see http://haxe.org/manual/types-nullability.html
 **/
 @:coreType @:notNull @:runtimeValue abstract Int to Float { }
 
@@ -51,6 +66,8 @@
 	that accept or can return a `null` value, or for the Flash compiler and AS3
 	generator to distinguish between base values that can be `null` and others that
 	can't.
+
+	@see http://haxe.org/manual/types-nullability.html
 **/
 typedef Null<T> = T
 
@@ -59,6 +76,9 @@ typedef Null<T> = T
 
 	On static targets, `null` cannot be assigned to `Bool`. If this is necessary,
 	`Null<Bool>` can be used instead.
+
+	@see http://haxe.org/manual/types-bool.html
+	@see http://haxe.org/manual/types-nullability.html
 **/
 @:coreType @:notNull @:runtimeValue abstract Bool {
 }
@@ -68,6 +88,8 @@ typedef Null<T> = T
 
 	Use of `Dynamic` should be minimized as it prevents several compiler
 	checks and optimizations.
+
+	@see http://haxe.org/manual/types-dynamic.html
 **/
 @:coreType @:runtimeValue abstract Dynamic<T> {
 }
@@ -78,6 +100,8 @@ typedef Null<T> = T
 	Any class with matching `hasNext()` and `next()` fields is considered an `Iterator`
 	and can then be used e.g. in `for`-loops. This makes it easy to implement
 	custom iterators.
+
+	@see http://haxe.org/manual/lf-iterators.html
 **/
 typedef Iterator<T> = {
 
@@ -107,6 +131,8 @@ typedef Iterator<T> = {
 /**
 	An `Iterable` is a data structure which has an `iterator()` method.
 	See `Lambda` for generic functions on iterable structures.
+
+	@see http://haxe.org/manual/lf-iterators.html
 **/
 typedef Iterable<T> = {
 	function iterator() : Iterator<T>;
@@ -118,6 +144,8 @@ typedef Iterable<T> = {
 
 	This interface should be used for externs only. Haxe does not support custom
 	array access on classes. However, array access can be implemented for
-	abstract types (see http://haxe.org/manual/types-abstract-array-access.html).
+	abstract types.
+
+	@see http://haxe.org/manual/types-abstract-array-access.html
 **/
 extern interface ArrayAccess<T> { }

std/StringTools.hx

@@ -21,7 +21,8 @@
  */
 /**
 	This class provides advanced methods on Strings. It is ideally used with
-	`using StringTools` and then acts as an extension to the String class.
+	`using StringTools` and then acts as an [extension](http://haxe.org/manual/lf-static-extension.html)
+	to the `String` class.
 
 	If the first argument to any of the methods is null, the result is
 	unspecified.

std/Type.hx

@@ -39,6 +39,9 @@ enum ValueType {
 
 	This class complements the more lightweight Reflect class, with a focus on
 	class and enum instances.
+
+	@see http://haxe.org/manual/types.html
+	@see http://haxe.org/manual/std-reflection.html
 **/
 extern class Type {
 

std/UInt.hx

@@ -22,8 +22,10 @@
 
 #if ((flash || flash9doc || cs || hl) && !doc_gen)
 /**
-	The unsigned Int type is only defined for Flash and C#. It's currently
+	The unsigned `Int` type is only defined for Flash and C#. It's currently
 	handled the same as a normal Int.
+
+	@see http://haxe.org/manual/types-basic-types.html
 **/
 @:coreType
 @:notNull
@@ -92,8 +94,10 @@ abstract UInt to Int from Int
 }
 #else
 /**
-	The unsigned Int type is only defined for Flash and C#.
+	The unsigned `Int` type is only defined for Flash and C#.
 	Simulate it for other platforms.
+
+	@see http://haxe.org/manual/types-basic-types.html
 **/
 abstract UInt(Int) from Int to Int {
 

std/Xml.hx

@@ -22,6 +22,8 @@
 
 /**
 	Xml node types.
+
+	@see http://haxe.org/manual/std-Xml.html
 **/
 @:enum abstract XmlType(Int) {
 	/**

std/haxe/Json.hx

@@ -22,9 +22,11 @@
 package haxe;
 
 /**
-	Crossplatform JSON API : it will automatically use the optimized native API if available.
-	Use -D haxeJSON to force usage of the Haxe implementation even if a native API is found : this will provide
-	extra encoding features such as enums (replaced by their index) and StringMaps.
+	Crossplatform JSON API: it will automatically use the optimized native API if available.
+	Use `-D haxeJSON` to force usage of the Haxe implementation even if a native API is found: 
+	this will provide extra encoding features such as enums (replaced by their index) and StringMaps.
+	=
+	@see http://haxe.org/manual/std-Json.html
 **/
 class Json {
 
@@ -35,6 +37,8 @@ class Json {
 		are parsed into Array<Dynamic>.
 
 		If given `text` is not valid JSON, an exception will be thrown.
+
+		@see http://haxe.org/manual/std-Json-parsing.html
 	**/
 	public static inline function parse( text : String ) : Dynamic {
 		return haxe.format.JsonParser.parse(text);
@@ -49,6 +53,8 @@ class Json {
 		
 		If `space` is given and is not null, the result will be pretty-printed.
 		Successive levels will be indented by this string.
+
+		@see http://haxe.org/manual/std-Json-encoding.html
 	**/
 	public static inline function stringify( value : Dynamic, ?replacer:Dynamic -> Dynamic -> Dynamic, ?space : String ) : String {
 		return haxe.format.JsonPrinter.print(value, replacer, space);

std/haxe/Serializer.hx

@@ -22,22 +22,22 @@
 package haxe;
 
 /**
-	The Serializer class can be used to encode values and objects into a String,
-	from which the Unserializer class can recreate the original representation.
+	The Serializer class can be used to encode values and objects into a `String`,
+	from which the `Unserializer` class can recreate the original representation.
 
 	This class can be used in two ways:
 
-	- create a new Serializer() instance, call its serialize() method with
+	- create a `new Serializer()` instance, call its serialize() method with
 		any argument and finally retrieve the String representation from
-		toString()
-	- call Serializer.run() to obtain the serialized representation of a
+		`toString()`
+	- call `Serializer.run()` to obtain the serialized representation of a
 		single argument
 
 	Serialization is guaranteed to work for all haxe-defined classes, but may
 	or may not work for instances of external/native classes.
 
 	The specification of the serialization format can be found here:
-	`http://haxe.org/manual/serialization/format`
+	<http://haxe.org/manual/serialization/format>
 **/
 class Serializer {
 

std/haxe/Template.hx

@@ -47,7 +47,7 @@ private typedef ExprToken = {
 	String, and to have some basic logic.
 
 	A complete documentation of the supported syntax is available at:
-	<a href="http://haxe.org/manual/std-template.html">http://haxe.org/manual/std-template.html</a>
+	<http://haxe.org/manual/std-template.html>
 **/
 class Template {
 

std/haxe/Unserializer.hx

@@ -28,16 +28,19 @@ typedef TypeResolver = {
 }
 
 /**
-	The Unserializer class is the complement to the Serializer class. It parses
-	a serialization String and creates objects from the contained data.
+	The `Unserializer` class is the complement to the `Serializer` class. It parses
+	a serialization `String` and creates objects from the contained data.
 
 	This class can be used in two ways:
 
-	- create a new Unserializer() instance with a given serialization
-		String, then call its unserialize() method until all values are
+	- create a `new Unserializer()` instance with a given serialization
+		String, then call its `unserialize()` method until all values are
 		extracted
-	- call Unserializer.run() to unserialize a single value from a given
+	- call `Unserializer.run()`  to unserialize a single value from a given
 		String
+
+	The specification of the serialization format can be found here:
+	<http://haxe.org/manual/serialization/format>
 **/
 class Unserializer {
 
@@ -119,7 +122,7 @@ class Unserializer {
 		If `r` is null, a special resolver is used which returns null for all
 		input values.
 
-		See DEFAULT_RESOLVER for more information on type resolvers.
+		See `DEFAULT_RESOLVER` for more information on type resolvers.
 	**/
  	public function setResolver( r ) {
 		if( r == null )
@@ -131,7 +134,7 @@ class Unserializer {
 	/**
 		Gets the type resolver of `this` Unserializer instance.
 
-		See DEFAULT_RESOLVER for more information on type resolvers.
+		See `DEFAULT_RESOLVER` for more information on type resolvers.
 	**/
  	public function getResolver() {
 		return resolver;

std/haxe/ds/GenericStack.hx

@@ -53,6 +53,8 @@ private class GenericStackIterator<T> extends cpp.FastIterator<T> {
 
 	The generated name is an implementation detail and should not be relied
 	upon.
+
+	@see http://haxe.org/manual/std-GenericStack.html
 **/
 #if (flash || cpp)
 @:generic

std/haxe/ds/HashMap.hx

@@ -21,27 +21,61 @@
  */
 package haxe.ds;
 
+/**
+	HashMap allows mapping of hashable objects to arbitrary values.
+
+	See `Map` for documentation details.
+
+	@see http://haxe.org/manual/std-Map.html
+**/
 abstract HashMap<K:{ function hashCode():Int; }, V >(HashMapData<K,V>) {
+	/**
+		Creates a new HashMap.
+	**/
 	public inline function new() {
 		this = new HashMapData();
 	}
+
+	/**
+		See `Map.set`
+	**/
 	public inline function set(k:K, v:V) {
 		this.keys.set(k.hashCode(), k);
 		this.values.set(k.hashCode(), v);
 	}
+
+	/**
+		See `Map.get`
+	**/
 	public inline function get(k:K) {
 		return this.values.get(k.hashCode());
 	}
+
+	/**
+		See `Map.exists`
+	**/
 	public inline function exists(k:K) {
 		return this.values.exists(k.hashCode());
 	}
+
+	/**
+		See `Map.remove`
+	**/
 	public inline function remove(k:K) {
 		this.values.remove(k.hashCode());
 		return this.keys.remove(k.hashCode());
 	}
+
+	/**
+		See `Map.keys`
+	**/
 	public inline function keys() {
 		return this.keys.iterator();
 	}
+
+	/**
+		See `Map.iterator`
+	**/
 	public inline function iterator() {
 		return this.values.iterator();
 	}

std/haxe/ds/IntMap.hx

@@ -25,6 +25,8 @@ package haxe.ds;
 	IntMap allows mapping of Int keys to arbitrary values.
 
 	See `Map` for documentation details.
+
+	@see http://haxe.org/manual/std-Map.html
 **/
 extern class IntMap<T> implements haxe.Constraints.IMap<Int,T> {
 

std/haxe/ds/ListSort.hx

@@ -24,7 +24,7 @@ package haxe.ds;
 
 /**
 	ListSort provides a stable implementation of merge sort through its `sort`
-	method. It has a O(N.log(N)) complexity and does not require additional memory allocation
+	method. It has a O(N.log(N)) complexity and does not require additional memory allocation.
 **/
 class ListSort {
 

std/haxe/ds/ObjectMap.hx

@@ -29,6 +29,8 @@ package haxe.ds;
 	to `haxe.ds.WeakMap` for a weak reference version.
 
 	See `Map` for documentation details.
+
+	@see http://haxe.org/manual/std-Map.html
 **/
 extern class ObjectMap < K: { }, V > implements haxe.Constraints.IMap<K,V> {
 

std/haxe/ds/Option.hx

@@ -25,6 +25,8 @@ package haxe.ds;
 /**
 	An Option is a wrapper type which can either have a value (Some) or not a
 	value (None).
+
+	@see http://haxe.org/manual/std-Option.html
 **/
 enum Option<T> {
 	Some(v:T);

std/haxe/ds/StringMap.hx

@@ -26,6 +26,8 @@ package haxe.ds;
 	StringMap allows mapping of String keys to arbitrary values.
 
 	See `Map` for documentation details.
+
+	@see http://haxe.org/manual/std-Map.html
 **/
 extern class StringMap<T> implements haxe.Constraints.IMap<String,T> {
 

std/haxe/ds/Vector.hx

@@ -40,6 +40,8 @@ private typedef VectorData<T> = #if flash10
 /**
 	A Vector is a storage of fixed size. It can be faster than Array on some
 	targets, and is never slower.
+
+	@see http://haxe.org/manual/std-vector.html
 **/
 abstract Vector<T>(VectorData<T>) {
 	/**

std/haxe/ds/WeakMap.hx

@@ -28,6 +28,8 @@ package haxe.ds;
 	The keys are considered to be weak references on static targets.
 
 	See `Map` for documentation details.
+
+	@see http://haxe.org/manual/std-Map.html
 **/
 class WeakMap<K: { },V> implements haxe.Constraints.IMap<K,V> {
 

std/haxe/format/JsonParser.hx

@@ -26,6 +26,8 @@ package haxe.format;
 
 	This class is used by `haxe.Json` when native JSON implementation
 	is not available.
+
+	@see http://haxe.org/manual/std-Json-parsing.html
 **/
 class JsonParser {
 
@@ -33,7 +35,7 @@ class JsonParser {
 		Parses given JSON-encoded `str` and returns the resulting object.
 
 		JSON objects are parsed into anonymous structures and JSON arrays
-		are parsed into Array<Dynamic>.
+		are parsed into `Array<Dynamic>`.
 
 		If given `str` is not valid JSON, an exception will be thrown.
 

std/haxe/format/JsonPrinter.hx

@@ -26,6 +26,8 @@ package haxe.format;
 
 	This class is used by `haxe.Json` when native JSON implementation
 	is not available.
+
+	@see http://haxe.org/manual/std-Json-encoding.html
 **/
 class JsonPrinter {