markdown doc part 1

std/Class.hx

@@ -22,7 +22,7 @@
 /**
 	An abstract type that represents a Class.
 	
-	See [Type] for the haXe Reflection API.
+	See `Type` for the haXe Reflection API.
 **/
 @:coreType @:runtimeValue abstract Class<T> {
 }

std/Date.hx

@@ -23,12 +23,13 @@
  /**
 	The Date class provides a basic structure for date and time related
 	information. Date instances can be created by
-		- new Date() for a specific date,
-		- Date.now() to obtain information about the current time,
-		- Date.fromTime() with a given timestamp or
-		- Date.fromString() by parsing from a String.
 	
-	There is some extra functions available in the [DateTools] class.
+	- new Date() for a specific date,
+	- Date.now() to obtain information about the current time,
+	- Date.fromTime() with a given timestamp or
+	- Date.fromString() by parsing from a String.
+	
+	There is some extra functions available in the `DateTools` class.
 	
 	In the context of haxe dates, a timestamp is defined as the number of
 	milliseconds elapsed since 1st January 1970.
@@ -40,11 +41,12 @@ extern class Date
 		
 		The behaviour of a Date instance is only consistent across platforms if
 		the the arguments describe a valid date.
-			- month: 0 to 11
-			- day: 1 to 31
-			- hour: 0 to 23
-			- min: 0 to 59
-			- sec: 0 to 59
+		
+		- month: 0 to 11
+		- day: 1 to 31
+		- hour: 0 to 23
+		- min: 0 to 59
+		- sec: 0 to 59
 	**/
 	function new(year : Int, month : Int, day : Int, hour : Int, min : Int, sec : Int ) : Void;
 
@@ -55,43 +57,43 @@ extern class Date
 	function getTime() : Float;
 
 	/**
-		Returns the hours of [this] Date (0-23 range).
+		Returns the hours of `this` Date (0-23 range).
 	**/
 	function getHours() : Int;
 
 	/**
-		Returns the minutes of [this] Date (0-59 range).
+		Returns the minutes of `this` Date (0-59 range).
 	**/
 	function getMinutes() : Int;
 
 	/**
-		Returns the seconds of the [this] Date (0-59 range).
+		Returns the seconds of the `this` Date (0-59 range).
 	**/
 	function getSeconds() : Int;
 
 	/**
-		Returns the full year of [this] Date (4-digits).
+		Returns the full year of `this` Date (4-digits).
 	**/
 	function getFullYear() : Int;
 
 	/**
-		Returns the month of [this] Date (0-11 range).
+		Returns the month of `this` Date (0-11 range).
 	**/
 	function getMonth() : Int;
 
 	/**
-		Returns the day of [this] Date (1-31 range).
+		Returns the day of `this` Date (1-31 range).
 	**/
 	function getDate() : Int;
 
 	/**
-		Returns the day of the week of [this] Date (0-6 range).
+		Returns the day of the week of `this` Date (0-6 range).
 	**/
 	function getDay() : Int;
 
 	/**
-		Returns a string representation of [this] Date, by using the
-		standard format [YYYY-MM-DD HH:MM:SS]. See [DateTools.format] for
+		Returns a string representation of `this` Date, by using the
+		standard format [YYYY-MM-DD HH:MM:SS]. See `DateTools.format` for
 		other formating rules.
 	**/
 	function toString():String;
@@ -102,12 +104,12 @@ extern class Date
 	static function now() : Date;
 
 	/**
-		Returns a Date from timestamp [t].
+		Returns a Date from timestamp `t`.
 	**/
 	static function fromTime( t : Float ) : Date;
 
 	/**
-		Returns a Date from a formated string [s], with the following accepted
+		Returns a Date from a formated string `s`, with the following accepted
 		formats:
 			- [YYYY-MM-DD hh:mm:ss]
 			- [YYYY-MM-DD]

std/DateTools.hx

@@ -21,7 +21,7 @@
  */
 
 /**
-	The DateTools class contains some extra functionalities for handling [Date]
+	The DateTools class contains some extra functionalities for handling `Date`
 	instances and timestamps.
 	
 	In the context of haxe dates, a timestamp is defined as the number of
@@ -105,8 +105,8 @@ class DateTools {
 	#end
 
 	/**
-		Format the date [d] according to the format [f]. The format is
-		compatible with the [strftime] standard format, except that there is no
+		Format the date `d` according to the format `f`. The format is
+		compatible with the `strftime` standard format, except that there is no
 		support in Flash and JS for day and months names (due to lack of proper
 		internationalization API). On haXe/Neko/Windows, some formats are not
 		supported.
@@ -122,10 +122,10 @@ class DateTools {
 	}
 
 	/**
-		Returns the result of adding timestamp [t] to Date [d].
+		Returns the result of adding timestamp `t` to Date `d`.
 		
 		This is a convenience function for calling
-		Date.fromTime(d.getTime() + t).
+		`Date.fromTime(d.getTime() + t)`.
 	**/
 	public static inline function delta( d : Date, t : Float ) : Date {
 		return Date.fromTime( d.getTime() + t );
@@ -134,7 +134,7 @@ class DateTools {
 	static var DAYS_OF_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
 
 	/**
-		Returns the number of days in the month of Date [d].
+		Returns the number of days in the month of Date `d`.
 		
 		This method handles leap years.
 	**/

std/EReg.hx

@@ -39,37 +39,37 @@
 class EReg {
 
 	/**
-		Creates a new regular expression with pattern [r] and modifiers [opt].
+		Creates a new regular expression with pattern `r` and modifiers `opt`.
 		
 		This is equivalent to the shorthand syntax ~/r/opt
 		
-		If [r] or [opt] are null, the result is unspecified.
+		If `r` or `opt` are null, the result is unspecified.
 	**/
 	public function new( r : String, opt : String ) {
 		throw "Regular expressions are not implemented for this platform";
 	}
 
 	/**
-		Tells if [this] regular expression matches String [s].
+		Tells if `this` regular expression matches String `s`.
 		
 		This method modifies the internal state.
 		
-		If [s] is null, the result is unspecified.
+		If `s` is null, the result is unspecified.
 	**/
 	public function match( s : String ) : Bool {
 		return false;
 	}
 
 	/**
-		Returns the matched sub-group [n] of [this] EReg.
+		Returns the matched sub-group `n` of `this` EReg.
 		
-		This method should only be called after [this].match() or
-		[this].matchSub(), and then operates on the String of that operation.
+		This method should only be called after `this.match` or
+		`this.matchSub`, and then operates on the String of that operation.
 		
-		The index [n] corresponds to the n-th set of parentheses in the pattern
-		of [this] EReg. If no such sub-group exists, an exception is thrown.
+		The index `n` corresponds to the n-th set of parentheses in the pattern
+		of `this` EReg. If no such sub-group exists, an exception is thrown.
 		
-		If [n] equals 0, the whole matched substring is returned.
+		If `n` equals 0, the whole matched substring is returned.
 	**/
 	public function matched( n : Int ) : String {
 		return null;
@@ -78,7 +78,7 @@ class EReg {
 	/**
 		Returns the part to the left of the last matched substring.
 		
-		If the most recent call to [this].match() or [this].matchSub() did not
+		If the most recent call to `this.match` or `this.matchSub` did not
 		match anything, the result is unspecified.
 		
 		If the global g modifier was in place for the matching, only the
@@ -93,7 +93,7 @@ class EReg {
 	/**
 		Returns the part to the right of the last matched substring.
 		
-		If the most recent call to [this].match() or [this].matchSub() did not
+		If the most recent call to `this.match` or `this.matchSub` did not
 		match anything, the result is unspecified.
 		
 		If the global g modifier was in place for the matching, only the
@@ -107,10 +107,10 @@ class EReg {
 
 	/**
 		Returns the position and length of the last matched substring, within
-		the String which was last used as argument to [this].match() or
-		[this].matchSub().
+		the String which was last used as argument to `this.match` or
+		`this.matchSub`.
 		
-		If the most recent call to [this].match() or [this].matchSub() did not
+		If the most recent call to `this.match` or `this.matchSub` did not
 		match anything, the result is unspecified.
 		
 		If the global g modifier was in place for the matching, the position and
@@ -121,64 +121,64 @@ class EReg {
 	}
 
 	/**
-		Tells if [this] regular expression matches a substring of String [s].
+		Tells if `this` regular expression matches a substring of String `s`.
 		
-		This function expects [pos] and [len] to describe a valid substring of
-		[s], or else the result is unspecified. To get more robust behavior,
-		[this].matchSub(s.substr(pos,len)) can be used instead.
+		This function expects `pos` and `len` to describe a valid substring of
+		`s`, or else the result is unspecified. To get more robust behavior,
+		`this.matchSub(s.substr(pos,len))` can be used instead.
 		
 		This method modifies the internal state.
 		
-		If [s] is null, the result is unspecified.
+		If `s` is null, the result is unspecified.
 	**/
 	public function matchSub( s : String, pos : Int, len : Int = 0):Bool {
 		return false;
 	}
 
 	/**
-		Splits String [s] at all substrings [this] EReg matches.
+		Splits String `s` at all substrings `this` EReg matches.
 		
-		If a match is found at the start of [s], the result contains a leading
+		If a match is found at the start of `s`, the result contains a leading
 		empty String "" entry.
 		
-		If a match is found at the end of [s], the result contains a trailing
+		If a match is found at the end of `s`, the result contains a trailing
 		empty String "" entry.
 		
 		If two matching substrings appear next to each other, the result
 		contains the empty String "" between them.
 		
-		By default, this method splits [s] into two parts at the first matched
-		substring. If the global g modifier is in place, [s] is split at each
+		By default, this method splits `s` into two parts at the first matched
+		substring. If the global g modifier is in place, `s` is split at each
 		matched substring.
 		
-		If [s] is null, the result is unspecified.
+		If `s` is null, the result is unspecified.
 	**/
 	public function split( s : String ) : Array<String> {
 		return null;
 	}
 
 	/**
-		Replaces the first substring of [s] which [this] EReg matches with [by].
+		Replaces the first substring of `s` which `this` EReg matches with `by`.
 		
-		If [this] EReg does not match any substring, the result is [s].
+		If `this` EReg does not match any substring, the result is `s`.
 		
 		By default, this method replaces only the first matched substring. If
 		the global g modifier is in place, all matched substrings are replaced.
 		
-		If [by] contains [$1] to [$9], the digit corresponds to number of a
+		If `by` contains `$1` to `$9`, the digit corresponds to number of a
 		matched sub-group and its value is used instead. If no such sub-group
-		exists, the replacement is unspecified. The string [$$] becomes [$].
+		exists, the replacement is unspecified. The string `$$` becomes `$`.
 		
-		If [s] or [by] are null, the result is unspecified.
+		If `s` or `by` are null, the result is unspecified.
 	**/
 	public function replace( s : String, by : String ) : String {
 		return null;
 	}
 
 	/**
-		For each occurence of the pattern in the string [s], the function [f] is called and
+		For each occurence of the pattern in the string `s`, the function `f` is called and
 		can return the string that needs to be replaced. All occurences are matched anyway,
-		and setting the [g] flag might cause some incorrect behavior on some platforms.
+		and setting the `g` flag might cause some incorrect behavior on some platforms.
 	**/
 	public function map( s : String, f : EReg -> String ) : String {
 		var buf = new StringBuf();

std/Enum.hx

@@ -25,7 +25,7 @@
 	
 	The corresponding enum instance type is EnumValue.
 	
-	See [Type] for the haXe Reflection API.
+	See `Type` for the Haxe Reflection API.
 **/
 @:coreType @:runtimeValue abstract Enum<T> {
 }

std/EnumValue.hx

@@ -22,7 +22,7 @@
 
 /**
 	An abstract type that represents any enum value.
-	See [Type] for the haXe Reflection API.
+	See `Type` for the haXe Reflection API.
 **/
 @:coreType abstract EnumValue {
 }

std/IntIterator.hx

@@ -37,9 +37,9 @@ class IntIterator {
 	var max : Int;
 
 	/**
-		Iterates from [min] (inclusive) to [max] (exclusive).
+		Iterates from `min` (inclusive) to `max` (exclusive).
 		
-		If [max <= min], the iterator will not act as a countdown.
+		If `max <= min`, the iterator will not act as a countdown.
 	**/
 	public function new( min : Int, max : Int ) {
 		this.min = min;

std/Lambda.hx

@@ -21,7 +21,7 @@
  */
 
 /**
-	The [Lambda] class is a collection of methods to support functional
+	The `Lambda` class is a collection of methods to support functional
 	programming. It is ideally used with 'using Lambda' and then acts as an
 	extension to Iterable types.
 	
@@ -35,9 +35,9 @@
 class Lambda {
 
 	/**
-		Creates an Array from Iterable [it].
+		Creates an Array from Iterable `it`.
 		
-		If [it] is an Array, this function returns a copy of it.
+		If `it` is an Array, this function returns a copy of it.
 	**/
 	public static function array<A>( it : Iterable<A> ) : Array<A> {
 		var a = new Array<A>();
@@ -47,9 +47,9 @@ class Lambda {
 	}
 
 	/**
-		Creates a List form Iterable [it].
+		Creates a List form Iterable `it`.
 		
-		If [it] is a List, this function returns a copy of it.
+		If `it` is a List, this function returns a copy of it.
 	**/
 	public static function list<A>( it : Iterable<A> ) : List<A> {
 		var l = new List<A>();
@@ -59,11 +59,11 @@ class Lambda {
 	}
 
 	/**
-		Creates a new List by applying function [f] to all elements of [it].
+		Creates a new List by applying function `f` to all elements of `it`.
 		
 		The order of elements is preserved.
 		
-		If [f] is null, the result is unspecified.
+		If `f` is null, the result is unspecified.
 	**/
 	public static function map<A,B>( it : Iterable<A>, f : A -> B ) : List<B> {
 		var l = new List<B>();
@@ -73,11 +73,11 @@ class Lambda {
 	}
 
 	/**
-		Similar to map, but also passes the index of each element to [f].
+		Similar to map, but also passes the index of each element to `f`.
 		
 		The order of elements is preserved.
 		
-		If [f] is null, the result is unspecified.
+		If `f` is null, the result is unspecified.
 	**/
 	public static function mapi<A,B>( it : Iterable<A>, f : Int -> A -> B ) : List<B> {
 		var l = new List<B>();
@@ -88,10 +88,10 @@ class Lambda {
 	}
 
 	/**
-		Tells if [it] contains [elt].
+		Tells if `it` contains `elt`.
 		
 		This function returns true as soon as an element is found which is equal
-		to [elt] according to the [==] operator.
+		to `elt` according to the `==` operator.
 		
 		If no such element is found, the result is false.
 	**/
@@ -103,14 +103,14 @@ class Lambda {
 	}
 
 	/**
-		Tells if [it] contains an element for which [f] is true.
+		Tells if `it` contains an element for which `f` is true.
 		
 		This function returns true as soon as an element is found for which a
-		call to [f] returns true.
+		call to `f` returns true.
 		
 		If no such element is found, the result is false.
 		
-		If [f] is null, the result is unspecified.
+		If `f` is null, the result is unspecified.
 	**/
 	public static function exists<A>( it : Iterable<A>, f : A -> Bool ) {
 		for( x in it )
@@ -120,16 +120,16 @@ class Lambda {
 	}
 
 	/**
-		Tells if [f] is true for all elements of [it].
+		Tells if `f` is true for all elements of `it`.
 		
 		This function returns false as soon as an element is found for which a
-		call to [f] returns false.
+		call to `f` returns false.
 		
 		If no such element is found, the result is true.
 		
-		In particular, this function always returns true if [it] is empty.
+		In particular, this function always returns true if `it` is empty.
 		
-		If [f] is null, the result is unspecified.
+		If `f` is null, the result is unspecified.
 	**/
 	public static function foreach<A>( it : Iterable<A>, f : A -> Bool ) {
 		for( x in it )
@@ -139,9 +139,9 @@ class Lambda {
 	}
 
 	/**
-		Calls [f] on all elements of [it], in order.
+		Calls `f` on all elements of `it`, in order.
 		
-		If [f] is null, the result is unspecified.
+		If `f` is null, the result is unspecified.
 	**/
 	public static function iter<A>( it : Iterable<A>, f : A -> Void ) {
 		for( x in it )
@@ -149,12 +149,12 @@ class Lambda {
 	}
 
 	/**
-		Returns a List containing those elements of [it] for which [f] returned
+		Returns a List containing those elements of `it` for which `f` returned
 		true.
 		
-		If [it] is empty, the result is the empty List even if [f] is null.
+		If `it` is empty, the result is the empty List even if `f` is null.
 		
-		Otherwise if [f] is null, the result is unspecified.
+		Otherwise if `f` is null, the result is unspecified.
 	**/
 	public static function filter<A>( it : Iterable<A>, f : A -> Bool ) {
 		var l = new List<A>();
@@ -165,16 +165,16 @@ class Lambda {
 	}
 
 	/**
-		Functional fold on Iterable [it], using function [f] with start argument
-		[first].
+		Functional fold on Iterable `it`, using function `f` with start argument
+		`first`.
 		
-		If [it] has no elements, the result is [first].
+		If `it` has no elements, the result is `first`.
 		
-		Otherwise the first element of [it] is passed to [f] alongside [first].
-		The result of that call is then passed to [f] with the next element of
-		[it], and so on until [it] has no more elements.
+		Otherwise the first element of `it` is passed to `f` alongside `first`.
+		The result of that call is then passed to `f` with the next element of
+		`it`, and so on until `it` has no more elements.
 		
-		If [it] or [f] are null, the result is unspecified.
+		If `it` or `f` are null, the result is unspecified.
 	**/
 	public static function fold<A,B>( it : Iterable<A>, f : A -> B -> B, first : B ) : B {
 		for( x in it )
@@ -183,8 +183,8 @@ class Lambda {
 	}
 
 	/**
-		Returns the number of elements in [it] for which [pred] is true, or the
-		total number of elements in [it] if [pred] is null.
+		Returns the number of elements in `it` for which `pred` is true, or the
+		total number of elements in `it` if `pred` is null.
 		
 		This function traverses all elements.
 	**/
@@ -201,18 +201,18 @@ class Lambda {
 	}
 
 	/**
-		Tells if Iterable [it] does not contain any element.
+		Tells if Iterable `it` does not contain any element.
 	**/
 	public static function empty<T>( it : Iterable<T> ) : Bool {
 		return !it.iterator().hasNext();
 	}
 
 	/**
-		Returns the index of the first element [v] within Iterable [it].
+		Returns the index of the first element `v` within Iterable `it`.
 		
-		This function uses operator [==] to check for equality.
+		This function uses operator `==` to check for equality.
 		
-		If [v] does not exist in [it], the result is -1.
+		If `v` does not exist in `it`, the result is -1.
 	**/
 	public static function indexOf<T>( it : Iterable<T>, v : T ) : Int {
 		var i = 0;
@@ -225,10 +225,10 @@ class Lambda {
 	}
 
 	/**
-		Returns a new List containing all elements of Iterable [a] followed by
-		all elements of Iterable [b].
+		Returns a new List containing all elements of Iterable `a` followed by
+		all elements of Iterable `b`.
 		
-		If [a] or [b] are null, the result is unspecified.
+		If `a` or `b` are null, the result is unspecified.
 	**/
 	public static function concat<T>( a : Iterable<T>, b : Iterable<T> ) : List<T> {
 		var l = new List();

std/List.hx

@@ -30,7 +30,7 @@ class List<T> {
 	private var q : Array<Dynamic>;
 
 	/**
-		The length of [this] List.
+		The length of `this` List.
 	**/
 	public var length(default,null) : Int;
 
@@ -42,9 +42,9 @@ class List<T> {
 	}
 
 	/**
-		Adds element [item] at the end of [this] List.
+		Adds element `item` at the end of `this` List.
 		
-		[this].length increases by 1.
+		`this.length` increases by 1.
 	**/
 	public function add( item : T ) {
 		var x:Array<Dynamic> = #if neko untyped __dollar__array(item,null) #else [item] #end;
@@ -57,9 +57,9 @@ class List<T> {
 	}
 
 	/**
-		Adds element [item] at the beginning of [this] List.
+		Adds element `item` at the beginning of `this` List.
 		
-		[this].length increases by 1.
+		`this.length` increases by 1.
 	**/
 	public function push( item : T ) {
 		var x : Array<Dynamic> = #if neko
@@ -74,18 +74,18 @@ class List<T> {
 	}
 
 	/**
-		Returns the first element of [this] List, or null if no elements exist.
+		Returns the first element of `this` List, or null if no elements exist.
 		
-		This function does not modify [this] List.
+		This function does not modify `this` List.
 	**/
 	public function first() : Null<T> {
 		return if( h == null ) null else h[0];
 	}
 
 	/**
-		Returns the last element of [this] List, or null if no elements exist.
+		Returns the last element of `this` List, or null if no elements exist.
 		
-		This function does not modify [this] List.
+		This function does not modify `this` List.
 	**/
 	public function last() : Null<T> {
 		return if( q == null ) null else q[0];
@@ -93,9 +93,9 @@ class List<T> {
 
 
 	/**
-		Returns the first element of [this] List, or null if no elements exist.
+		Returns the first element of `this` List, or null if no elements exist.
 		
-		The element is removed from [this] List.
+		The element is removed from `this` List.
 	**/
 	public function pop() : Null<T> {
 		if( h == null )
@@ -109,17 +109,17 @@ class List<T> {
 	}
 
 	/**
-		Tells if [this] List is empty.
+		Tells if `this` List is empty.
 	**/
 	public function isEmpty() : Bool {
 		return (h == null);
 	}
 
 	/**
-		Empties [this] List.
+		Empties `this` List.
 		
 		This function does not traverse the elements, but simply sets the
-		internal references to null and [this].length to 0.
+		internal references to null and `this.length` to 0.
 	**/
 	public function clear() : Void {
 		h = null;
@@ -128,9 +128,9 @@ class List<T> {
 	}
 
 	/**
-		Removes the first occurence of [v] in [this] List.
+		Removes the first occurence of `v` in `this` List.
 		
-		If [v] is found by checking standard equality, it is removed from [this]
+		If `v` is found by checking standard equality, it is removed from `this`
 		List and the function returns true.
 		
 		Otherwise, false is returned.
@@ -195,7 +195,7 @@ class List<T> {
 	}
 
 	/**
-		Returns a string representation of [this] List.
+		Returns a string representation of `this` List.
 		
 		The result is enclosed in { } with the individual elements being
 		separated by a comma.
@@ -218,7 +218,7 @@ class List<T> {
 	}
 
 	/**
-		Returns a string representation of [this] List, with [sep] separating
+		Returns a string representation of `this` List, with `sep` separating
 		each element.
 	**/
 	public function join(sep : String) {
@@ -237,8 +237,8 @@ class List<T> {
 	}
 
 	/**
-		Returns a list filtered with [f]. The returned list will contain all
-		elements for which [f(x) = true].
+		Returns a list filtered with `f`. The returned list will contain all
+		elements for which `f(x) == true`.
 	**/
 	public function filter( f : T -> Bool ) {
 		var l2 = new List();
@@ -254,7 +254,7 @@ class List<T> {
 
 	/**
 		Returns a new list where all elements have been converted by the
-		function [f].
+		function `f`.
 	**/
 	public function map<X>(f : T -> X) : List<X> {
 		var b = new List();

std/Map.hx

@@ -37,7 +37,7 @@ import haxe.ds.EnumValueMap;
 	A Map can be instantiated without explicit type parameters. Type inference
 	will then determine the type parameters from the usage.
 	
-	Maps can also be created with [key1 => value1, key2 => value2] syntax.
+	Maps can also be created with `key1 => value1, key2 => value2` syntax.
 	
 	Map is an abstract type, it is not available at runtime.
 **/
@@ -61,47 +61,47 @@ abstract Map<K,V>(IMap<K,V> ) {
 	public function new();
 
 	/**
-		Maps [key] to [value].
+		Maps `key` to `value`.
 		
-		If [key] already has a mapping, the previous value disappears.
+		If `key` already has a mapping, the previous value disappears.
 		
-		If [key] is null, the result is unspecified.
+		If `key` is null, the result is unspecified.
 	**/
 	public inline function set(key:K, value:V) this.set(key, value);
 	
 	/**
-		Returns the current mapping of [key].
+		Returns the current mapping of `key`.
 		
 		If no such mapping exists, null is returned.
 		
 		Note that a check like map.get(key) == null can hold for two reasons:
 		
-		1. the map has no mapping for [key]
+		1. the map has no mapping for `key`
 		2. the map has a mapping with a value of null
 		
 		If it is important to distinguish these cases, exists() should be used.
 		
-		If [key] is null, the result is unspecified.
+		If `key` is null, the result is unspecified.
 	**/
 	@:arrayAccess public inline function get(key:K) return this.get(key);
 	
 	/**
-		Returns true if [key] has a mapping, false otherwise.
+		Returns true if `key` has a mapping, false otherwise.
 		
-		If [key] is null, the result is unspecified.
+		If `key` is null, the result is unspecified.
 	**/
 	public inline function exists(key:K) return this.exists(key);
 	
 	/**
-		Removes the mapping of [key] and returns true if such a mapping existed,
+		Removes the mapping of `key` and returns true if such a mapping existed,
 		false otherwise.
 		
-		If [key] is null, the result is unspecified.
+		If `key` is null, the result is unspecified.
 	**/
 	public inline function remove(key:K) return this.remove(key);
 	
 	/**
-		Returns an Iterator over the keys of [this] Map.
+		Returns an Iterator over the keys of `this` Map.
 		
 		The order of keys is undefined.
 	**/
@@ -110,7 +110,7 @@ abstract Map<K,V>(IMap<K,V> ) {
 	}
 	
 	/**
-		Returns an Iterator over the values of [this] Map.
+		Returns an Iterator over the values of `this` Map.
 		
 		The order of values is undefined.
 	**/
@@ -119,7 +119,7 @@ abstract Map<K,V>(IMap<K,V> ) {
 	}
 	
 	/**
-		Returns a String representation of [this] Map.
+		Returns a String representation of `this` Map.
 		
 		The exact representation depends on the platform and key-type.
 	**/

std/Math.hx

@@ -76,55 +76,55 @@ extern class Math
 	static var NaN(default, null) : Float;
 
 	/**
-		Returns the absolute value of [v].
+		Returns the absolute value of `v`.
 		
-		If [v] is positive or 0, the result is unchanged. Otherwise the result
-		is -[v].
+		If `v` is positive or 0, the result is unchanged. Otherwise the result
+		is -`v`.
 		
-		If [v] is NEGATIVE_INFINITY or POSITIVE_INFINITY, the result is
+		If `v` is NEGATIVE_INFINITY or POSITIVE_INFINITY, the result is
 		POSITIVE_INFINITY.
 		
-		If [v] is NaN, the result is NaN.
+		If `v` is NaN, the result is NaN.
 	**/
 	static function abs(v:Float):Float;
 	
 	/**
-		Returns the smaller of values [a] and [b].
+		Returns the smaller of values `a` and `b`.
 		
-		If [a] or [b] are NaN, the result is NaN.
+		If `a` or `b` are NaN, the result is NaN.
 		
-		If [a] or [b] are NEGATIVE_INFINITY, the result is NEGATIVE_INFINITY.
+		If `a` or `b` are NEGATIVE_INFINITY, the result is NEGATIVE_INFINITY.
 		
-		If [a] and [b] are POSITIVE_INFINITY, the result is POSITIVE_INFINITY.
+		If `a` and `b` are POSITIVE_INFINITY, the result is POSITIVE_INFINITY.
 	**/
 	static function min(a:Float, b:Float):Float;
 	
 	/**
-		Returns the greater of values [a] and [b].
+		Returns the greater of values `a` and `b`.
 		
-		If [a] or [b] are NaN, the result is NaN.
+		If `a` or `b` are NaN, the result is NaN.
 		
-		If [a] or [b] are POSITIVE_INFINITY, the result is POSITIVE_INFINITY.
+		If `a` or `b` are POSITIVE_INFINITY, the result is POSITIVE_INFINITY.
 		
-		If [a] and [b] are NEGATIVE_INFINITY, the result is NEGATIVE_INFINITY.
+		If `a` and `b` are NEGATIVE_INFINITY, the result is NEGATIVE_INFINITY.
 	**/
 	static function max(a:Float, b:Float):Float;
 	
 	/**
-		Returns the trigonometric sine of [v].
+		Returns the trigonometric sine of `v`.
 		
-		The unit of [v] is radians.
+		The unit of `v` is radians.
 		
-		If [v] is NaN or infinite, the result is NaN.
+		If `v` is NaN or infinite, the result is NaN.
 	**/
 	static function sin(v:Float):Float;
 	
 	/**
-		Returns the trigonometric cosine of [v].
+		Returns the trigonometric cosine of `v`.
 		
-		The unit of [v] is radians.
+		The unit of `v` is radians.
 		
-		If [v] is NaN or infinite, the result is NaN.
+		If `v` is NaN or infinite, the result is NaN.
 	**/
 	static function cos(v:Float):Float;
 	
@@ -136,27 +136,27 @@ extern class Math
 	static function atan2(y:Float, x:Float):Float;
 	
 	/**
-		Returns Euler's number, raised to the power of [v].
+		Returns Euler's number, raised to the power of `v`.
 		
 		exp(1.0) is approximately 2.718281828459.
 		
-		If [v] is POSITIVE_INFINITY, the result is POSITIVE_INFINITY.
+		If `v` is POSITIVE_INFINITY, the result is POSITIVE_INFINITY.
 		
-		If [v] is NEGATIVE_INFINITY, the result is 0.0.
+		If `v` is NEGATIVE_INFINITY, the result is 0.0.
 		
-		If [v] is NaN, the result is NaN.
+		If `v` is NaN, the result is NaN.
 	**/
 	static function exp(v:Float):Float;
 	
 	/**
-		Returns the natural logarithm of [v].
+		Returns the natural logarithm of `v`.
 		
-		If [v] is negative (including NEGATIVE_INFINITY) or NaN, the result is
+		If `v` is negative (including NEGATIVE_INFINITY) or NaN, the result is
 		NaN.
 		
-		If [v] is POSITIVE_INFINITY, the result is POSITIVE_INFINITY.
+		If `v` is POSITIVE_INFINITY, the result is POSITIVE_INFINITY.
 		
-		If [v] is 0.0, the result is NEGATIVE_INFINITY.
+		If `v` is 0.0, the result is NEGATIVE_INFINITY.
 		
 		This is the inverse operation of exp, i.e. log(exp(v)) == v always
 		holds.
@@ -168,19 +168,19 @@ extern class Math
 	static function pow(v:Float, exp:Float):Float;
 	
 	/**
-		Returns the square root of [v].
+		Returns the square root of `v`.
 		
-		If [v] is negative (including NEGATIVE_INFINITY) or NaN, the result is
+		If `v` is negative (including NEGATIVE_INFINITY) or NaN, the result is
 		NaN.
 		
-		If [v] is POSITIVE_INFINITY, the result is POSITIVE_INFINITY.
+		If `v` is POSITIVE_INFINITY, the result is POSITIVE_INFINITY.
 		
-		If [v] is 0.0, the result is 0.0.
+		If `v` is 0.0, the result is 0.0.
 	**/
 	static function sqrt(v:Float):Float;
 	
 	/**
-		Rounds [v] to the nearest Int value.
+		Rounds `v` to the nearest Int value.
 
 		If v is outside of the signed Int32 range, or is NaN, NEGATIVE_INFINITY or POSITIVE_INFINITY, the result is unspecified.
 		
@@ -189,7 +189,7 @@ extern class Math
 	static function round(v:Float):Int;
 	
 	/**
-		Returns the largest Int value that is not greater than [v].
+		Returns the largest Int value that is not greater than `v`.
 		
 		If v is outside of the signed Int32 range, or is NaN, NEGATIVE_INFINITY or POSITIVE_INFINITY, the result is unspecified.		
 		
@@ -198,7 +198,7 @@ extern class Math
 	static function floor(v:Float):Int;
 	
 	/**
-		Returns the smallest Int value that is not less than [v].
+		Returns the smallest Int value that is not less than `v`.
 
 		If v is outside of the signed Int32 range, or is NaN, NEGATIVE_INFINITY or POSITIVE_INFINITY, the result is unspecified.
 		
@@ -236,9 +236,9 @@ extern class Math
 	
 
 	/**
-		Tells if [f] is a finite number.
+		Tells if `f` is a finite number.
 		
-		If [f] is POSITIVE_INFINITY, NEGATIVE_INFINITY or NaN, the result is
+		If `f` is POSITIVE_INFINITY, NEGATIVE_INFINITY or NaN, the result is
 		false.
 		
 		Otherwise the result is true.
@@ -246,9 +246,9 @@ extern class Math
 	static function isFinite( f : Float ) : Bool;
 	
 	/**
-		Tells if [f] is not a valid number.
+		Tells if `f` is not a valid number.
 		
-		If [f] is NaN, the result is true.
+		If `f` is NaN, the result is true.
 		
 		Otherwise the result is false. In particular, both POSITIVE_INFINITY and
 		NEGATIVE_INFINITY are not considered NaN.

std/Reflect.hx

@@ -26,25 +26,25 @@
 extern class Reflect {
 
 	/**
-		Tells if structure [o] has a field named [field].
+		Tells if structure `o` has a field named `field`.
 		
 		This is only guaranteed to work for anonymous structures. Refer to
-		[Type.getInstanceFields] for a function supporting class instances.
+		`Type.getInstanceFields` for a function supporting class instances.
 		
-		If [o] or [field] are null, the result is unspecified.
+		If `o` or `field` are null, the result is unspecified.
 	**/
 	public static function hasField( o : Dynamic, field : String ) : Bool;
 
 	/**
-		Returns the value of the field named [field] on object [o].
+		Returns the value of the field named `field` on object `o`.
 		
-		If [o] is not an object or has no field named [field], the result is
+		If `o` is not an object or has no field named `field`, the result is
 		null.
 		
 		If the field is defined as a property, its accessors are ignored. Refer
-		to [Reflect.getProperty] for a function supporting property accessors.
+		to `Reflect.getProperty` for a function supporting property accessors.
 		
-		If [field] is null, the result is unspecified.
+		If `field` is null, the result is unspecified.
 		
 		(As3) If used on a property field, the getter will be invoked. It is
 		not possible to obtain the value directly.
@@ -52,12 +52,12 @@ extern class Reflect {
 	public static function field( o : Dynamic, field : String ) : Dynamic;
 
 	/**
-		Sets the field named [field] of object [o] to value [value].
+		Sets the field named `field` of object `o` to value `value`.
 		
-		If [o] has no field named [field], this function is only guaranteed to
+		If `o` has no field named `field`, this function is only guaranteed to
 		work for anonymous structures.
 		
-		If [o] or [field] are null, the result is unspecified.
+		If `o` or `field` are null, the result is unspecified.
 		
 		(As3) If used on a property field, the setter will be invoked. It is
 		not possible to set the value directly.		
@@ -65,24 +65,24 @@ extern class Reflect {
 	public static function setField( o : Dynamic, field : String, value : Dynamic ) : Void;
 
 	/**
-		Returns the value of the field named [field] on object [o], taking
+		Returns the value of the field named `field` on object `o`, taking
 		property getter functions into account.
 		
 		If the field is not a property, this function behaves like
-		[Reflect.field], but might be slower.
+		`Reflect.field`, but might be slower.
 		
-		If [o] or [field] are null, the result is unspecified.
+		If `o` or `field` are null, the result is unspecified.
 	**/
 	public static function getProperty( o : Dynamic, field : String ) : Dynamic;
 
 	/**
-		Sets the field named [field] of object [o] to value [value], taking
+		Sets the field named `field` of object `o` to value `value`, taking
 		property setter functions into account.
 		
 		If the field is not a property, this function behaves like
-		[Reflect.setField], but might be slower.
+		`Reflect.setField`, but might be slower.
 		
-		If [field] is null, the result is unspecified.
+		If `field` is null, the result is unspecified.
 	**/
 	public static function setProperty( o : Dynamic, field : String, value : Dynamic ) : Void;
 
@@ -92,92 +92,92 @@ extern class Reflect {
 	public static function callMethod( o : Dynamic, func : Dynamic, args : Array<Dynamic> ) : Dynamic;
 
 	/**
-		Returns the fields of structure [o].
+		Returns the fields of structure `o`.
 		
 		This method is only guaranteed to work on anonymous structures. Refer to
-		[Type.getInstanceFields()] for a function supporting class instances.
+		`Type.getInstanceFields` for a function supporting class instances.
 		
-		If [o] is null, the result is unspecified.
+		If `o` is null, the result is unspecified.
 	**/
 	public static function fields( o : Dynamic ) : Array<String>;
 
 	/**
-		Returns true if [f] is a function, false otherwise.
+		Returns true if `f` is a function, false otherwise.
 		
-		If [f] is null, the result is false.
+		If `f` is null, the result is false.
 	**/
 	public static function isFunction( f : Dynamic ) : Bool;
 
 	/**
-		Compares [a] and [b].
+		Compares `a` and `b`.
 		
-		If [a] is less than [b], the result is negative. If [b] is less than
-		[a], the result is positive. If [a] and [b] are equal, the result is 0.
+		If `a` is less than `b`, the result is negative. If `b` is less than
+		`a`, the result is positive. If `a` and `b` are equal, the result is 0.
 		
-		This function is only defined if [a] and [b] are of the same type.
+		This function is only defined if `a` and `b` are of the same type.
 		
 		If that type is a function, the result is unspecified and
-		[Reflect.compareMethods] should be used instead.
+		`Reflect.compareMethods` should be used instead.
 		
-		For all other types, the result is 0 if [a] and [b] are equal. If they
+		For all other types, the result is 0 if `a` and `b` are equal. If they
 		are not equal, the result depends on the type and is negative if:
 			Numeric types: a is less than b
 			String: a is lexicographically less than b
 			Other: unspecified
 		
-		If [a] and [b] are null, the result is 0. If only one of them is null,
+		If `a` and `b` are null, the result is 0. If only one of them is null,
 		the result is unspecified.
 	**/
 	public static function compare<T>( a : T, b : T ) : Int;
 
 	/**
-		Compares the functions [f1] and [f2].
+		Compares the functions `f1` and `f2`.
 		
-		If [f1] or [f2] are not functions, the result is unspecified.
+		If `f1` or `f2` are not functions, the result is unspecified.
 		
-		Otherwise the result is true if [f1] and the [f2] are physically equal,
+		Otherwise the result is true if `f1` and the `f2` are physically equal,
 		false otherwise.
 	**/
 	public static function compareMethods( f1 : Dynamic, f2 : Dynamic ) : Bool;
 
 	/**
-		Tells if [v] is an object.
+		Tells if `v` is an object.
 		
-		The result is true if [v] is one of the following:
+		The result is true if `v` is one of the following:
 			- class instance
 			- structure
 			- Class<T>
 			- Enum<T>
 			
-		Otherwise, including if [v] is null, the result is false.
+		Otherwise, including if `v` is null, the result is false.
 	**/
 	public static function isObject( v : Dynamic ) : Bool;
 
 	/**
-		Tells if [v] is an enum value.
+		Tells if `v` is an enum value.
 		
-		The result is true if [v] is of type EnumValue, i.e. an enum
+		The result is true if `v` is of type EnumValue, i.e. an enum
 		constructor.
 		
-		Otherwise, including if [v] is null, the result is false.
+		Otherwise, including if `v` is null, the result is false.
 	**/
 	public static function isEnumValue( v : Dynamic ) : Bool;
 	
 	/**
-		Removes the field named [field] from structure [o].
+		Removes the field named `field` from structure `o`.
 		
 		This method is only guaranteed to work on anonymous structures.
 		
-		If [o] or [field] are null, the result is unspecified.
+		If `o` or `field` are null, the result is unspecified.
 	**/
 	public static function deleteField( o : Dynamic, field : String ) : Bool;
 
 	/**
-		Copies the fields of structure [o].
+		Copies the fields of structure `o`.
 		
 		This is only guaranteed to work on anonymous structures.
 		
-		If [o] is null, the result is unspecified.
+		If `o` is null, the result is unspecified.
 	**/
 	public static function copy<T>( o : T ) : T;
 

std/Std.hx

@@ -36,17 +36,17 @@ extern class Std {
 	/**
 		Converts any value to a String.
 
-		If s is of String, Int, Float or Bool, its value is returned.
+		If `s` is of `String`, `Int`, `Float` or `Bool`, its value is returned.
 
-		If s is an instance of a class and that class or one of its parent classes has
-		a toString() method, that method is called. If no such method is present, the result
+		If `s` is an instance of a class and that class or one of its parent classes has
+		a `toString` method, that method is called. If no such method is present, the result
 		is unspecified.
 
-		If s is an enum constructor without argument, the constructor's name is returned. If
+		If `s` is an enum constructor without argument, the constructor's name is returned. If
 		arguments exists, the constructor's name followed by the String representations of
 		the arguments is returned.
 
-		If s is a structure, the field names along with their values are returned. The field order
+		If `s` is a structure, the field names along with their values are returned. The field order
 		and the operator separating field names and values are unspecified.
 
 		If s is null, "null" is returned.
@@ -54,21 +54,21 @@ extern class Std {
 	public static function string( s : Dynamic ) : String;
 
 	/**
-		Converts a Float to an Int, rounded towards 0.
+		Converts a `Float` to an `Int`, rounded towards 0.
 
-		If x is outside of the signed Int32 range, or is NaN, NEGATIVE_INFINITY or POSITIVE_INFINITY, the result is unspecified.
+		If `x` is outside of the signed Int32 range, or is NaN, NEGATIVE_INFINITY or POSITIVE_INFINITY, the result is unspecified.
 	**/
 	public static function int( x : Float ) : Int;
 
 	/**
-		Converts a String to an Int.
+		Converts a `String` to an `Int`.
 
 		Leading whitespaces are ignored.
 
-		If x starts with 0x or 0X, hexadecimal notation is recognized where the following digits may
+		If `x` starts with 0x or 0X, hexadecimal notation is recognized where the following digits may
 		contain 0-9 and A-F.
 
-		Otherwise x is read as decimal number with 0-9 being allowed characters. x may also start with
+		Otherwise `x` is read as decimal number with 0-9 being allowed characters. `x` may also start with
 		a - to denote a negative value.
 
 		In decimal mode, parsing continues until an invalid character is detected, in which case the
@@ -83,19 +83,19 @@ extern class Std {
 	public static function parseInt( x : String ) : Null<Int>;
 
 	/**
-		Converts a String to a Float.
+		Converts a `String` to a `Float`.
 
-		The parsing rules for parseInt() apply here as well, with the exception of invalid input
+		The parsing rules for `parseInt` apply here as well, with the exception of invalid input
 		resulting in a NaN value instead of null.
 
-		Additionally, decimal notation may contain a single . to denote the start of the fractions.
+		Additionally, decimal notation may contain a single `.` to denote the start of the fractions.
 	**/
 	public static function parseFloat( x : String ) : Float;
 
 	/**
-		Return a random integer between 0 included and x excluded.
+		Return a random integer between 0 included and `x` excluded.
 
-		If x is <= 1, the result is always 0.
+		If `x <= 1`, the result is always 0.
 	**/
 	public static function random( x : Int ) : Int;
 }

std/StdTypes.hx

@@ -22,7 +22,7 @@
 // standard haXe types
 
 /**
-	The standard Void type. Only [null] values can be of the type [Void].
+	The standard Void type. Only `null` values can be of the type `Void`.
 **/
 @:coreType abstract Void { }
 
@@ -49,8 +49,8 @@
 #end
 
 /**
-	[Null] can be useful in two cases. In order to document some methods
-	that accepts or can return a [null] value, or for the Flash9 compiler and AS3
+	`Null` can be useful in two cases. In order to document some methods
+	that accepts or can return a `null` value, or for the Flash9 compiler and AS3
 	generator to distinguish between base values that can be null and others that
 	can't.
 **/
@@ -100,7 +100,7 @@ typedef Iterator<T> = {
 
 /**
 	An Iterable is a data structure which has an iterator() method.
-	See [Lambda] for generic functions on iterable structures.
+	See `Lambda` for generic functions on iterable structures.
 **/
 typedef Iterable<T> = {
 	function iterator() : Iterator<T>;

std/String.hx

@@ -23,7 +23,7 @@
 	The basic String class.
 	
 	A haxe String is immutable, it is not possible to modify individual
-	characters. No method of this class changes the state of [this] String.
+	characters. No method of this class changes the state of `this` String.
 	
 	Strings can be constructed using the string literal syntax "string value".
 	
@@ -33,7 +33,7 @@
 extern class String {
 
 	/**
-		The number of characters in [this] String.
+		The number of characters in `this` String.
 	**/
 	var length(default,null) : Int;
 
@@ -43,31 +43,31 @@ extern class String {
 	function new(string:String) : Void;
 
 	/**
-		Returns a String where all characters of [this] String are upper case.
+		Returns a String where all characters of `this` String are upper case.
 		
-		Affects the characters [a-z]. Other characters remain unchanged.
+		Affects the characters `a-z`. Other characters remain unchanged.
 	**/
 	function toUpperCase() : String;
 
 	/**
-		Returns a String where all characters of [this] String are lower case.
+		Returns a String where all characters of `this` String are lower case.
 		
-		Affects the characters [A-Z]. Other characters remain unchanged.
+		Affects the characters `A-Z`. Other characters remain unchanged.
 	**/
 	function toLowerCase() : String;
 
 	/**
-		Returns the character at position [index] of [this] String.
+		Returns the character at position `index` of `this` String.
 		
-		If [index] is negative or exceeds [this].length, the empty String ""
+		If `index` is negative or exceeds `this.length`, the empty String ""
 		is returned.
 	**/
 	function charAt(index : Int) : String;
 
 	/**
-		Returns the character code at position [index] of [this] String.
+		Returns the character code at position `index` of `this` String.
 		
-		If [index] is negative or exceeds [this].length, null is returned.
+		If `index` is negative or exceeds `this.length`, null is returned.
 		
 		To obtain the character code of a single character, "x".code can be used
 		instead to inline the character code at compile time. Note that this
@@ -76,78 +76,78 @@ extern class String {
 	function charCodeAt( index : Int) : Null<Int>;
 
 	/**
-		Returns the position of the leftmost occurence of [str] within [this]
+		Returns the position of the leftmost occurence of `str` within `this`
 		String.
 		
-		If [startIndex] is given, the search is performed within the substring
-		of [this] String starting from [startIndex]. Otherwise the search is
-		performed within [this] String. In either case, the returned position
-		is relative to the beginning of [this] String.
+		If `startIndex` is given, the search is performed within the substring
+		of `this` String starting from `startIndex`. Otherwise the search is
+		performed within `this` String. In either case, the returned position
+		is relative to the beginning of `this` String.
 		
-		If [str] cannot be found, -1 is returned.
+		If `str` cannot be found, -1 is returned.
 	**/
 	function indexOf( str : String, ?startIndex : Int ) : Int;
 
 	/**
-		Returns the position of the rightmost occurence of [str] within [this]
+		Returns the position of the rightmost occurence of `str` within `this`
 		String.
 		
-		If [startIndex] is given, the search is performed within the substring
-		of [this] String from 0 to [startIndex]. Otherwise the search is
-		performed within [this] String. In either case, the returned position
-		is relative to the beginning of [this] String.
+		If `startIndex` is given, the search is performed within the substring
+		of `this` String from 0 to `startIndex`. Otherwise the search is
+		performed within `this` String. In either case, the returned position
+		is relative to the beginning of `this` String.
 		
-		If [str] cannot be found, -1 is returned.
+		If `str` cannot be found, -1 is returned.
 	**/
 	function lastIndexOf( str : String, ?startIndex : Int ) : Int;
 
 	/**
-		Splits [this] String at each occurence of [delimiter].
+		Splits `this` String at each occurence of `delimiter`.
 		
-		If [delimiter] is the empty String "", [this] String is split into an
-		Array of [this].length elements, where the elements correspond to the
-		characters of [this] String.
+		If `delimiter` is the empty String "", `this` String is split into an
+		Array of `this.length` elements, where the elements correspond to the
+		characters of `this` String.
 		
-		If [delimiter] is not found within [this] String, the result is an Array
-		with one element, which equals [this] String.
+		If `delimiter` is not found within `this` String, the result is an Array
+		with one element, which equals `this` String.
 		
-		If [delimiter] is null, the result is unspecified.
+		If `delimiter` is null, the result is unspecified.
 		
-		Otherwise, [this] String is split into parts at each occurence of
-		[delimiter]. If [this] String starts (or ends) with [delimiter}, the
+		Otherwise, `this` String is split into parts at each occurence of
+		`delimiter`. If `this` String starts (or ends) with [delimiter}, the
 		result Array contains a leading (or trailing) empty String "" element.
 		Two subsequent delimiters also result in an empty String "" element.
 	**/
 	function split( delimiter : String ) : Array<String>;
 
 	/**
-		Returns [len] characters of [this] String, starting at position [pos].
+		Returns `len` characters of `this` String, starting at position `pos`.
 		
-		If [len] is omitted, all characters from position [pos] to the end of
-		[this] String are included.
+		If `len` is omitted, all characters from position `pos` to the end of
+		`this` String are included.
 		
-		If [pos] is negative, its value is calculated from the end of [this]
-		String by [this].length + [pos]. If this yields a negative value, 0 is
+		If `pos` is negative, its value is calculated from the end of `this`
+		String by `this.length + pos`. If this yields a negative value, 0 is
 		used instead.
 		
-		If the calculated position + [len] exceeds [this].length, the characters
-		from that position to the end of [this] String are returned.
+		If the calculated position + `len` exceeds `this.length`, the characters
+		from that position to the end of `this` String are returned.
 		
-		If [len] is negative, the result is unspecified.
+		If `len` is negative, the result is unspecified.
 	**/
 	function substr( pos : Int, ?len : Int ) : String;
 
 	/**
-		Returns the part of [this] String from [startIndex] to [endIndex].
+		Returns the part of `this` String from `startIndex` to `endIndex`.
 		
-		If [startIndex] or [endIndex] are negative, 0 is used instead.
+		If `startIndex` or `endIndex` are negative, 0 is used instead.
 		
-		If [startIndex] exceeds [endIndex], they are swapped.
+		If `startIndex` exceeds `endIndex`, they are swapped.
 		
-		If the (possibly swapped) [endIndex] is omitted or exceeds
-		[this].length, [this].length is used instead.
+		If the (possibly swapped) `endIndex` is omitted or exceeds
+		`this.length`, `this.length` is used instead.
 		
-		If the (possibly swapped) [startIndex] exceeds [this].length, the empty
+		If the (possibly swapped) `startIndex` exceeds `this.length`, the empty
 		String "" is returned.
 	**/
 	function substring( startIndex : Int, ?endIndex : Int ) : String;
@@ -158,9 +158,9 @@ extern class String {
 	function toString() : String;
 
 	/**
-		Returns the String corresponding to the character code [code].
+		Returns the String corresponding to the character code `code`.
 		
-		If [code] is negative or has another invalid value, the result is
+		If `code` is negative or has another invalid value, the result is
 		unspecified.
 	**/
 	static function fromCharCode( code : Int ) : String;

std/StringBuf.hx

@@ -35,7 +35,7 @@ class StringBuf {
 	var b:String = "";
 	
 	/**
-		The length of [this] StringBuf in characters.
+		The length of `this` StringBuf in characters.
 	**/
 	public var length(get,never) : Int;
 
@@ -51,22 +51,22 @@ class StringBuf {
 	}
 
 	/**
-		Appends the representation of [x] to [this] StringBuf.
+		Appends the representation of `x` to `this` StringBuf.
 		
-		The exact representation of [x] may vary per platform. To get more
+		The exact representation of `x` may vary per platform. To get more
 		consistent behavior, this function should be called with
 		Std.string(x).
 		
-		If [x] is null, the String "null" is appended.
+		If `x` is null, the String "null" is appended.
 	**/
 	public inline function add( x : Dynamic ) : Void {
 		b += x;
 	}
 
 	/**
-		Appends the character identified by [c] to [this] StringBuf.
+		Appends the character identified by `c` to `this` StringBuf.
 		
-		If [c] is negative or has another invalid value, the result is
+		If `c` is negative or has another invalid value, the result is
 		unspecified.
 	**/
 	public inline function addChar( c : Int ) : Void {
@@ -74,23 +74,23 @@ class StringBuf {
 	}
 
 	/**
-		Appends a substring of [s] to [this] StringBuf.
+		Appends a substring of `s` to `this` StringBuf.
 		
-		This function expects [pos] and [len] to describe a valid substring of
-		[s], or else the result is unspecified. To get more robust behavior,
-		[this].add(s.substr(pos,len)) can be used instead.
+		This function expects `pos` and `len` to describe a valid substring of
+		`s`, or else the result is unspecified. To get more robust behavior,
+		`this.add(s.substr(pos,len))` can be used instead.
 		
-		If [s] or [pos] are null, the result is unspecified.
+		If `s` or `pos` are null, the result is unspecified.
 		
-		If [len] is omitted or null, the substring ranges from [pos] to the end
-		of [s].
+		If `len` is omitted or null, the substring ranges from `pos` to the end
+		of `s`.
 	**/
 	public inline function addSub( s : String, pos : Int, ?len : Int) : Void {
 		b += (len == null ? s.substr(pos) : s.substr(pos, len));
 	}
 
 	/**
-		Returns the content of [this] StringBuf as String.
+		Returns the content of `this` StringBuf as String.
 		
 		The buffer is not emptied by this operation.
 	**/

std/StringTools.hx

@@ -82,13 +82,13 @@ class StringTools {
 	}
 
 	/**
-		Escapes HTML special characters of the string [s].
+		Escapes HTML special characters of the string `s`.
 
 		The following replacements are made:
 			- & becomes &
 			- < becomes &lt;
 			- > becomes &gt;
-		If [quotes] is true, the following characters are also replaced:
+		If `quotes` is true, the following characters are also replaced:
 			- " becomes &quot;
 			- ' becomes &#039;
 	**/
@@ -98,7 +98,7 @@ class StringTools {
 	}
 
 	/**
-		Unescapes HTML special characters of the string [s].
+		Unescapes HTML special characters of the string `s`.
 
 		This is the inverse operation to htmlEscape, i.e. the following always
 		holds: htmlUnescape(htmlEscape(s)) == s
@@ -115,11 +115,11 @@ class StringTools {
 	}
 
 	/**
-		Tells if the string [s] starts with the string [start].
+		Tells if the string `s` starts with the string `start`.
 
-		If [start] is null, the result is unspecified.
+		If `start` is null, the result is unspecified.
 
-		If [start] is the empty String "", the result is true.
+		If `start` is the empty String "", the result is true.
 	**/
 	public static #if (cs || java) inline #end function startsWith( s : String, start : String ) : Bool {
 		#if java
@@ -132,11 +132,11 @@ class StringTools {
 	}
 
 	/**
-		Tells if the string [s] ends with the string [end].
+		Tells if the string `s` ends with the string `end`.
 
-		If [end] is null, the result is unspecified.
+		If `end` is null, the result is unspecified.
 
-		If [end] is the empty String "", the result is true.
+		If `end` is the empty String "", the result is true.
 	**/
 	public static #if (cs || java) inline #end function endsWith( s : String, end : String ) : Bool {
 		#if java
@@ -151,13 +151,13 @@ class StringTools {
 	}
 
 	/**
-		Tells if the character in the string [s] at position [pos] is a space.
+		Tells if the character in the string `s` at position `pos` is a space.
 
 		A character is considered to be a space character if its character code
 		is 9,10,11,12,13 or 32.
 
-		If [s] is the empty String "", or if pos is not a valid position within
-		[s], the result is false.
+		If `s` is the empty String "", or if pos is not a valid position within
+		`s`, the result is false.
 	**/
 	public static function isSpace( s : String, pos : Int ) : Bool {
 		var c = s.charCodeAt( pos );
@@ -165,12 +165,12 @@ class StringTools {
 	}
 
 	/**
-		Removes leading space characters of [s].
+		Removes leading space characters of `s`.
 
 		This function internally calls isSpace() to decide which characters to
 		remove.
 
-		If [s] is the empty String "" or consists only of space characters, the
+		If `s` is the empty String "" or consists only of space characters, the
 		result is the empty String "".
 	**/
 	public #if cs inline #end static function ltrim( s : String ) : String {
@@ -190,12 +190,12 @@ class StringTools {
 	}
 
 	/**
-		Removes trailing space characters of [s].
+		Removes trailing space characters of `s`.
 
 		This function internally calls isSpace() to decide which characters to
 		remove.
 
-		If [s] is the empty String "" or consists only of space characters, the
+		If `s` is the empty String "" or consists only of space characters, the
 		result is the empty String "".
 	**/
 	public #if cs inline #end static function rtrim( s : String ) : String {
@@ -216,7 +216,7 @@ class StringTools {
 	}
 
 	/**
-		Removes leading and trailing space characters of [s].
+		Removes leading and trailing space characters of `s`.
 
 		This is a convenience function for ltrim(rtrim(s)).
 	**/
@@ -231,16 +231,16 @@ class StringTools {
 	}
 
 	/**
-		Concatenates [c] to [s] until [s].length is at least [l].
+		Concatenates `c` to `s` until `s.length` is at least `l`.
 
-		If [c] is the empty String "" or if [l] does not exceed [s].length,
-		[s] is returned unchanged.
+		If `c` is the empty String "" or if `l` does not exceed `s.length`,
+		`s` is returned unchanged.
 
-		If [c].length is 1, the resulting String length is exactly [l].
+		If `c.length` is 1, the resulting String length is exactly `l`.
 
-		Otherwise the length may exceed [l].
+		Otherwise the length may exceed `l`.
 
-		If [c] is null, the result is unspecified.
+		If `c` is null, the result is unspecified.
 	**/
 	public static function lpad( s : String, c : String, l : Int ) : String {
 		if (c.length <= 0)
@@ -253,16 +253,16 @@ class StringTools {
 	}
 
 	/**
-		Appends [c] to [s] until [s].length is at least [l].
+		Appends `c` to `s` until `s.length` is at least `l`.
 
-		If [c] is the empty String "" or if [l] does not exceed [s].length,
-		[s] is returned unchanged.
+		If `c` is the empty String "" or if `l` does not exceed `s.length`,
+		`s` is returned unchanged.
 
-		If [c].length is 1, the resulting String length is exactly [l].
+		If `c.length` is 1, the resulting String length is exactly `l`.
 
-		Otherwise the length may exceed [l].
+		Otherwise the length may exceed `l`.
 
-		If [c] is null, the result is unspecified.
+		If `c` is null, the result is unspecified.
 	**/
 	public static function rpad( s : String, c : String, l : Int ) : String {
 		if (c.length <= 0)
@@ -275,15 +275,15 @@ class StringTools {
 	}
 
 	/**
-		Replace all occurences of the String [sub] in the String [s] by the
-		String [by].
+		Replace all occurences of the String `sub` in the String `s` by the
+		String `by`.
 
-		If [sub] is the empty String "", [by] is inserted after each character
-		of [s]. If [by] is also the empty String "", [s] remains unchanged.
+		If `sub` is the empty String "", `by` is inserted after each character
+		of `s`. If `by` is also the empty String "", `s` remains unchanged.
 
-		This is a convenience function for [s].split([sub]).join([by]).
+		This is a convenience function for `s.split(sub).join(by)`.
 
-		If [sub] or [by] are null, the result is unspecified.
+		If `sub` or `by` are null, the result is unspecified.
 	**/
 	public static function replace( s : String, sub : String, by : String ) : String {
 		#if java
@@ -302,10 +302,10 @@ class StringTools {
 	}
 
 	/**
-		Encodes [n] into a hexadecimal representation.
+		Encodes `n` into a hexadecimal representation.
 
-		If [digits] is specified, the resulting String is padded with "0" until
-		its length equals [digits].
+		If `digits` is specified, the resulting String is padded with "0" until
+		its length equals `digits`.
 	**/
 	public static function hex( n : Int, ?digits : Int ) {
 		#if flash9
@@ -327,13 +327,13 @@ class StringTools {
 	}
 
 	/**
-		Returns the character code at position [index] of String [s].
+		Returns the character code at position `index` of String `s`.
 
 		This method is faster than String.charCodeAt() on most platforms.
 		However, unlike String.charCodeAt(), the result is unspecified if
-		[index] is negative or exceeds [s].length.
+		`index` is negative or exceeds `s.length`.
 
-		This operation is not guaranteed to work if [s] contains the \0
+		This operation is not guaranteed to work if `s` contains the \0
 		character.
 	**/
 	public static inline function fastCodeAt( s : String, index : Int ) : Int untyped {
@@ -361,7 +361,7 @@ class StringTools {
 	}
 
 	/*
-		Tells if [c] represents the end-of-file (EOF) character.
+		Tells if `c` represents the end-of-file (EOF) character.
 	*/
 	@:noUsing public static inline function isEof( c : Int ) : Bool {
 		#if (flash9 || cpp)

std/Type.hx

@@ -21,7 +21,6 @@
  */
 /**
 	The diffent possible runtime types of a value.
-	See [Type] for the haXe Reflection API.
 **/
 enum ValueType {
 	TNull;
@@ -44,21 +43,21 @@ enum ValueType {
 extern class Type {
 
 	/**
-		Returns the class of [o], if [o] is a class instance.
+		Returns the class of `o`, if `o` is a class instance.
 		
-		If [o] is null or of a different type, null is returned.
+		If `o` is null or of a different type, null is returned.
 		
 		In general, type parameter information cannot be obtained at runtime.
 	**/
 	public static function getClass<T>( o : T ) : Class<T>;
 
 	/**
-		Returns the enum of enum instance [o].
+		Returns the enum of enum instance `o`.
 		
 		An enum instance is the result of using an enum constructor. Given an
-		enum Color { Red; }, getEnum(Red) returns Enum<Color>.
+		`enum Color { Red; }`, `getEnum(Red)` returns `Enum<Color>`.
 		
-		If [o] is null, null is returned.
+		If `o` is null, null is returned.
 		
 		In general, type parameter information cannot be obtained at runtime.
 	**/
@@ -66,11 +65,11 @@ extern class Type {
 
 
 	/**
-		Returns the super-class of class [c].
+		Returns the super-class of class `c`.
 		
-		If [c] has no super class, null is returned.
+		If `c` has no super class, null is returned.
 		
-		If [c] is null, the result is unspecified.
+		If `c` is null, the result is unspecified.
 		
 		In general, type parameter information cannot be obtained at runtime.
 	**/
@@ -78,34 +77,34 @@ extern class Type {
 
 
 	/**
-		Returns the name of class [c], including its path.
+		Returns the name of class `c`, including its path.
 		
-		If [c] is inside a package, the package structure is returned dot-
+		If `c` is inside a package, the package structure is returned dot-
 		separated, with another dot separating the class name:
 			pack1.pack2.(...).packN.ClassName
-		If [c] is a sub-type of a haxe module, that module is not part of the
+		If `c` is a sub-type of a haxe module, that module is not part of the
 		package structure.
 			
-		If [c] has no package, the class name is returned.
+		If `c` has no package, the class name is returned.
 		
-		If [c] is null, the result is unspecified.
+		If `c` is null, the result is unspecified.
 		
 		The class name does not include any type parameters.
 	**/
 	public static function getClassName( c : Class<Dynamic> ) : String;
 
 	/**
-		Returns the name of enum [e], including its path.
+		Returns the name of enum `e`, including its path.
 		
-		If [e] is inside a package, the package structure is returned dot-
+		If `e` is inside a package, the package structure is returned dot-
 		separated, with another dot separating the enum name:
 			pack1.pack2.(...).packN.EnumName
-		If [e] is a sub-type of a haxe module, that module is not part of the
+		If `e` is a sub-type of a haxe module, that module is not part of the
 		package structure.
 			
-		If [e] has no package, the enum name is returned.
+		If `e` has no package, the enum name is returned.
 		
-		If [e] is null, the result is unspecified.
+		If `e` is null, the result is unspecified.
 		
 		The enum name does not include any type parameters.
 	**/
@@ -114,11 +113,11 @@ extern class Type {
 	/**
 		Resolves a class by name.
 		
-		If [name] is the path of an existing class, that class is returned.
+		If `name` is the path of an existing class, that class is returned.
 		
 		Otherwise null is returned.
 		
-		If [name] is null or the path to a different type, the result is
+		If `name` is null or the path to a different type, the result is
 		unspecified.
 		
 		The class name must not include any type parameters.
@@ -128,20 +127,20 @@ extern class Type {
 	/**
 		Resolves an enum by name.
 		
-		If [name] is the path of an existing enum, that enum is returned.
+		If `name` is the path of an existing enum, that enum is returned.
 		
 		Otherwise null is returned.
 		
-		If [name] is null the result is unspecified.
+		If `name` is null the result is unspecified.
 		
-		If [name] is the path to a different type, null is returned.
+		If `name` is the path to a different type, null is returned.
 		
 		The enum name must not include any type parameters.
 	**/
 	public static function resolveEnum( name : String ) : Enum<Dynamic>;
 
 	/**
-		Creates an instance of class [cl], using [args] as arguments to the
+		Creates an instance of class `cl`, using `args` as arguments to the
 		class constructor.
 		
 		This function guarantees that the class constructor is called.
@@ -149,9 +148,9 @@ extern class Type {
 		Default values of constructors arguments are not guaranteed to be
 		taken into account.
 		
-		If [cl] or [args] are null, or if the number of elements in [args] does
+		If `cl` or `args` are null, or if the number of elements in `args` does
 		not match the expected number of constructor arguments, or if any
-		argument has an invalid type,  or if [cl] has no own constructor, the
+		argument has an invalid type,  or if `cl` has no own constructor, the
 		result is unspecified.
 		
 		In particular, default values of constructor arguments are not
@@ -160,41 +159,41 @@ extern class Type {
 	public static function createInstance<T>( cl : Class<T>, args : Array<Dynamic> ) : T;
 	
 	/**
-		Creates an instance of class [cl].
+		Creates an instance of class `cl`.
 		
 		This function guarantees that the class constructor is not called.
 		
-		If [cl] is null, the result is unspecified.
+		If `cl` is null, the result is unspecified.
 	**/
 	public static function createEmptyInstance<T>( cl : Class<T> ) : T;
 
 	/**
-		Creates an instance of enum [e] by calling its constructor [constr] with
-		arguments [params].
+		Creates an instance of enum `e` by calling its constructor `constr` with
+		arguments `params`.
 		
-		If [e] or [constr] is null, or if enum [e] has no constructor named
-		[constr], or if the number of elements in [params] does not match the
+		If `e` or `constr` is null, or if enum `e` has no constructor named
+		`constr`, or if the number of elements in `params` does not match the
 		expected number of constructor arguments, or if any argument has an
 		invalid type, the result is unspecified.
 	**/
 	public static function createEnum<T>( e : Enum<T>, constr : String, ?params : Array<Dynamic> ) : T;
 
 	/**
-		Creates an instance of enum [e] by calling its constructor number
-		[index] with arguments [params].
+		Creates an instance of enum `e` by calling its constructor number
+		`index` with arguments `params`.
 		
 		The constructor indices are preserved from haxe syntax, so the first
 		declared is index 0, the next index 1 etc.
 		
-		If [e] or [constr] is null, or if enum [e] has no constructor named
-		[constr], or if the number of elements in [params] does not match the
+		If `e` or `constr` is null, or if enum `e` has no constructor named
+		`constr`, or if the number of elements in `params` does not match the
 		expected number of constructor arguments, or if any argument has an
 		invalid type, the result is unspecified.
 	**/
 	public static function createEnumIndex<T>( e : Enum<T>, index : Int, ?params : Array<Dynamic> ) : T;
 
 	/**
-		Returns a list of the instance fields of class [c].
+		Returns a list of the instance fields of class `c`.
 		
 		This only includes fields which are known at compile-time. In
 		particular, using getInstanceFields(getClass(obj)) will not include
@@ -202,97 +201,97 @@ extern class Type {
 		
 		The order of the fields in the returned Array is unspecified.
 		
-		If [c] is null, the result is unspecified.
+		If `c` is null, the result is unspecified.
 		
 		(As3) This method only returns instance fields that are public.
 	**/
 	public static function getInstanceFields( c : Class<Dynamic> ) : Array<String>;
 
 	/**
-		Returns a list of static fields of class [c].
+		Returns a list of static fields of class `c`.
 		
 		This does not include static fields of parent classes.
 		
 		The order of the fields in the returned Array is unspecified.
 		
-		If [c] is null, the result is unspecified.
+		If `c` is null, the result is unspecified.
 		
 		(As3) This method only returns class fields that are public.
 	**/
 	public static function getClassFields( c : Class<Dynamic> ) : Array<String>;
 
 	/**
-		Returns a list of the names of all constructors of enum [e].
+		Returns a list of the names of all constructors of enum `e`.
 		
 		The order of the constructor names in the returned Array is preserved
 		from the original syntax.
 		
-		If [c] is null, the result is unspecified.
+		If `c` is null, the result is unspecified.
 	**/
 	public static function getEnumConstructs( e : Enum<Dynamic> ) : Array<String>;
 
 	/**
-		Returns the runtime type of value [v].
+		Returns the runtime type of value `v`.
 		
-		The result corresponds to the type [v] has at runtime, which may vary
+		The result corresponds to the type `v` has at runtime, which may vary
 		per platform. Assumptions regarding this should be minimized to avoid
 		surprises.
 	**/
 	public static function typeof( v : Dynamic ) : ValueType;
 
 	/**
-		Recursively compares two enum instances [a] and [b] by value.
+		Recursively compares two enum instances `a` and `b` by value.
 		
-		Unlike [a] == [b], this function performs a deep equality check on the
+		Unlike `a == b`, this function performs a deep equality check on the
 		arguments of the constructors, if exists.
 		
-		If [a] or [b] are null, the result is unspecified.
+		If `a` or `b` are null, the result is unspecified.
 	**/
 	public static function enumEq<T:EnumValue>( a : T, b : T ) : Bool;
 
 	/**
-		Returns the constructor name of enum instance [e].
+		Returns the constructor name of enum instance `e`.
 		
 		The result String does not contain any constructor arguments.
 		
-		If [e] is null, the result is unspecified.
+		If `e` is null, the result is unspecified.
 	**/
 	public static function enumConstructor( e : EnumValue ) : String;
 
 	/**
-		Returns a list of the constructor arguments of enum instance [e].
+		Returns a list of the constructor arguments of enum instance `e`.
 		
-		If [e] has no arguments, the result is [].
+		If `e` has no arguments, the result is [].
 		
-		Otherwise the result are the values that were used as arguments to [e],
+		Otherwise the result are the values that were used as arguments to `e`,
 		in the order of their declaration.
 		
-		If [e] is null, the result is unspecified.
+		If `e` is null, the result is unspecified.
 	**/
 	public static function enumParameters( e : EnumValue ) : Array<Dynamic>;
 
 	/**
-		Returns the index of enum instance [e].
+		Returns the index of enum instance `e`.
 		
-		This corresponds to the original syntactic position of [e]. The index of
+		This corresponds to the original syntactic position of `e`. The index of
 		the first declared constructor is 0, the next one is 1 etc.
 		
-		If [e] is null, the result is unspecified.
+		If `e` is null, the result is unspecified.
 	**/
 	public static function enumIndex( e : EnumValue ) : Int;
 
 	/**
-		Returns a list of all constructors of enum [e] that require no
+		Returns a list of all constructors of enum `e` that require no
 		arguments.
 		
-		This may return the empty Array [] if all constructors of [e] require
+		This may return the empty Array [] if all constructors of `e` require
 		arguments.
 		
-		Otherwise an instance of [e] constructed through each of its non-
+		Otherwise an instance of `e` constructed through each of its non-
 		argument constructors is returned, in the order of the constructor
 		declaration.
 		
-		If [e] is null, the result is unspecified.
+		If `e` is null, the result is unspecified.
 	**/
 	public static function allEnums<T>( e : Enum<T> ) : Array<T>;
 

std/Xml.hx

@@ -21,8 +21,8 @@
  */
 /**
 	An abstract type representing the type of the Xml
-	Node. You can compare it to [Xml] statics and can
-	use [Std.string(t)] to get a string reprensation
+	Node. You can compare it to `Xml` statics and can
+	use `Std.string` to get a string reprensation
 	of the type.
 **/