markdown doc part 2

std/haxe/CallStack.hx

@@ -22,7 +22,7 @@
 package haxe;
 
 /**
-	Elements return by [Stack] methods.
+	Elements return by `CallStack` methods.
 **/
 enum StackItem {
 	CFunction;

std/haxe/EnumFlags.hx

@@ -34,43 +34,43 @@ package haxe;
 abstract EnumFlags<T:EnumValue>(Int) {
 
 	/**
-		Initializes the bitflags to [i].
+		Initializes the bitflags to `i`.
 	**/
 	public inline function new(i = 0) {
 		this = i;
 	}
 
 	/**
-		Checks if the index of enum instance [v] is set.
+		Checks if the index of enum instance `v` is set.
 		
-		This method is optimized if [v] is an enum instance expression such as
+		This method is optimized if `v` is an enum instance expression such as
 		SomeEnum.SomeCtor.
 		
-		If [v] is null, the result is unspecified.
+		If `v` is null, the result is unspecified.
 	**/
 	public inline function has( v : T ) : Bool {
 		return this & (1 << Type.enumIndex(v)) != 0;
 	}
 
 	/**
-		Sets the index of enum instance [v].
+		Sets the index of enum instance `v`.
 		
-		This method is optimized if [v] is an enum instance expression such as
+		This method is optimized if `v` is an enum instance expression such as
 		SomeEnum.SomeCtor.
 		
-		If [v] is null, the result is unspecified.
+		If `v` is null, the result is unspecified.
 	**/
 	public inline function set( v : T ) : Void {
 		this |= 1 << Type.enumIndex(v);
 	}
 
 	/**
-		Unsets the index of enum instance [v].
+		Unsets the index of enum instance `v`.
 		
-		This method is optimized if [v] is an enum instance expression such as
+		This method is optimized if `v` is an enum instance expression such as
 		SomeEnum.SomeCtor.
 		
-		If [v] is null, the result is unspecified.
+		If `v` is null, the result is unspecified.
 	**/
 	public inline function unset( v : T ) : Void {
 		this &= 0xFFFFFFF - (1 << Type.enumIndex(v));

std/haxe/EnumTools.hx

@@ -24,17 +24,17 @@ package haxe;
 
 extern class EnumTools {
 	/**
-		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.
 	**/
@@ -43,11 +43,11 @@ extern class EnumTools {
 	}
 		
 	/**
-		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.
 	**/
@@ -56,14 +56,14 @@ extern class EnumTools {
 	}
 	
 	/**
-		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.
 	**/
@@ -72,29 +72,29 @@ extern class EnumTools {
 	}
 		
 	/**
-		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.
 	**/
 	static public inline function createAll<T>(e:Enum<T>):Array<T> {
 		return Type.allEnums(e);
 	}
 		
 	/**
-		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.
 	**/
 	static public inline function getConstructors<T>(e:Enum<T>):Array<String> {
 		return Type.getEnumConstructs(e);
@@ -104,49 +104,49 @@ extern class EnumTools {
 extern class EnumValueTools {
 	
 	/**
-		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.
 	**/
 	static public inline function equals<T:EnumValue>(a:T, b:T):Bool {
 		return Type.enumEq(a, b);
 	}
 		
 	/**
-		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.
 	**/
 	static public inline function getName(e:EnumValue):String {
 		return Type.enumConstructor(e);
 	}
 		
 	/**
-		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.
 	**/
 	static public inline function getParameters(e:EnumValue):Array<Dynamic> {
 		return Type.enumParameters(e);
 	}
 		
 	/**
-		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.
 	**/
 	static public inline function getIndex(e:EnumValue):Int {
 		return Type.enumIndex(e);

std/haxe/Http.hx

@@ -49,7 +49,7 @@ private typedef AbstractSocket = {
 class Http {
 
 	/**
-		The url of [this] request. It is used only by the request() method and
+		The url of `this` request. It is used only by the request() method and
 		can be changed in order to send the same request to different target
 		Urls.
 	**/
@@ -74,11 +74,11 @@ class Http {
 	#end
 
 	/**
-		Creates a new Http instance with [url] as parameter.
+		Creates a new Http instance with `url` as parameter.
 
 		This does not do a request until request() is called.
 
-		If [url] is null, the field url must be set to a value before making the
+		If `url` is null, the field url must be set to a value before making the
 		call to request(), or the result is unspecified.
 
 		(Php) Https (SSL) connections are allowed only if the OpenSSL extension
@@ -99,9 +99,9 @@ class Http {
 	}
 
 	/**
-		Sets the header identified as [header] to value [value].
+		Sets the header identified as `header` to value `value`.
 
-		If [header] or [value] are null, the result is unspecified.
+		If `header` or `value` are null, the result is unspecified.
 
 		This method provides a fluent interface.
 	**/
@@ -111,9 +111,9 @@ class Http {
 	}
 
 	/**
-		Sets the parameter identified as [param] to value [value].
+		Sets the parameter identified as `param` to value `value`.
 
-		If [header] or [value] are null, the result is unspecified.
+		If `header` or `value` are null, the result is unspecified.
 
 		This method provides a fluent interface.
 	**/
@@ -124,12 +124,12 @@ class Http {
 
 	#if !flash8
 	/**
-		Sets the post data of [this] Http request to [data].
+		Sets the post data of `this` Http request to `data`.
 
 		There can only be one post data per request. Subsequent calls overwrite
 		the previously set value.
 
-		If [data] is null, the post data is considered to be absent.
+		If `data` is null, the post data is considered to be absent.
 
 		This method provides a fluent interface.
 	**/
@@ -140,20 +140,20 @@ class Http {
 	#end
 
 	/**
-		Sends [this] Http request to the Url specified by [this].url.
+		Sends `this` Http request to the Url specified by `this.url`.
 
-		If [post] is true, the request is sent as POST request, otherwise it is
+		If `post` is true, the request is sent as POST request, otherwise it is
 		sent as GET request.
 
 		Depending on the outcome of the request, this method calls the
 		onStatus(), onError() or onData() callback functions.
 
-		If [this].url is null, the result is unspecified.
+		If `this.url` is null, the result is unspecified.
 
-		If [this].url is an invalid or inaccessible Url, the onError() callback
+		If `this.url` is an invalid or inaccessible Url, the onError() callback
 		function is called.
 
-		(Js) If [this].async is false, the callback functions are called before
+		(Js) If `this.async` is false, the callback functions are called before
 		this method returns.
 	**/
 	public function request( ?post : Bool ) : Void {
@@ -695,7 +695,7 @@ class Http {
 #end
 
 	/**
-		This method is called upon a successful request, with [data] containing
+		This method is called upon a successful request, with `data` containing
 		the result String.
 
 		The intended usage is to bind it to a custom function:
@@ -705,7 +705,7 @@ class Http {
 	}
 
 	/**
-		This method is called upon a request error, with [msg] containing the
+		This method is called upon a request error, with `msg` containing the
 		error description.
 
 		The intended usage is to bind it to a custom function:
@@ -715,7 +715,7 @@ class Http {
 	}
 
 	/**
-		This method is called upon a Http status change, with [status] being the
+		This method is called upon a Http status change, with `status` being the
 		new status.
 
 		The intended usage is to bind it to a custom function:
@@ -726,12 +726,12 @@ class Http {
 
 #if !flash
 	/**
-		Makes a synchronous request to [url].
+		Makes a synchronous request to `url`.
 
 		This creates a new Http instance and makes a GET request by calling its
 		request(false) method.
 
-		If [url] is null, the result is unspecified.
+		If `url` is null, the result is unspecified.
 	**/
 	public static function requestUrl( url : String ) : String {
 		var h = new Http(url);

std/haxe/Log.hx

@@ -28,9 +28,9 @@ package haxe;
 class Log {
 
 	/**
-		Outputs [v] in a platform-dependent way.
+		Outputs `v` in a platform-dependent way.
 
-		The second parameter [infos] is injected by the compiler and contains
+		The second parameter `infos` is injected by the compiler and contains
 		information about the position where the trace() call was made.
 
 		This method can be rebound to a custom function:
@@ -112,7 +112,7 @@ class Log {
 
 	#if flash
 	/**
-		Sets the color of the trace output to [rgb].
+		Sets the color of the trace output to `rgb`.
 	**/
 	public static dynamic function setColor( rgb : Int ) {
 		untyped flash.Boot.__set_trace_color(rgb);

std/haxe/Resource.hx

@@ -75,9 +75,9 @@ class Resource {
 	}
 
 	/**
-		Retrieves the resource identified by [name] as a String.
+		Retrieves the resource identified by `name` as a String.
 
-		If [name] does not match any resource name, null is returned.
+		If `name` does not match any resource name, null is returned.
 	**/
 	public static function getString( name : String ) : String {
 		#if java
@@ -107,10 +107,10 @@ class Resource {
 	}
 
 	/**
-		Retrieves the resource identified by [name] as an instance of
+		Retrieves the resource identified by `name` as an instance of
 		haxe.io.Bytes.
 
-		If [name] does not match any resource name, null is returned.
+		If `name` does not match any resource name, null is returned.
 	**/
 	public static function getBytes( name : String ) : haxe.io.Bytes {
 		#if java

std/haxe/Serializer.hx

@@ -37,7 +37,7 @@ package haxe;
 	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 {
 
@@ -74,14 +74,14 @@ class Serializer {
 	var scount : Int;
 
 	/**
-		The individual cache setting for [this] Serializer instance.
+		The individual cache setting for `this` Serializer instance.
 
 		See USE_CACHE for a complete description.
 	**/
 	public var useCache : Bool;
 
 	/**
-		The individual enum index setting for [this] Serializer instance.
+		The individual enum index setting for `this` Serializer instance.
 
 		See USE_ENUM_INDEX for a complete description.
 	**/
@@ -90,11 +90,11 @@ class Serializer {
 	/**
 		Creates a new Serializer instance.
 
-		Subsequent calls to [this].serialize() will append values to the
+		Subsequent calls to `this.serialize` will append values to the
 		internal buffer of this String. Once complete, the contents can be
-		retrieved through a call to [this].toString() .
+		retrieved through a call to `this.toString`.
 
-		Each Serializer instance maintains its own cache if [this].useCache is
+		Each Serializer instance maintains its own cache if this.useCache` is
 		true.
 	**/
 	public function new() {
@@ -107,7 +107,7 @@ class Serializer {
 	}
 
 	/**
-		Return the String representation of [this] Serializer.
+		Return the String representation of `this` Serializer.
 
 		The exact format specification can be found here:
 		http://haxe.org/manual/serialization/format
@@ -212,13 +212,13 @@ class Serializer {
 	}
 
 	/**
-		Serializes [v].
+		Serializes `v`.
 
 		All haxe-defined values and objects with the exception of functions can
 		be serialized. Serialization of external/native objects is not
 		guaranteed to work.
 
-		The values of [this].useCache and [this].useEnumIndex may affect
+		The values of `this.useCache` and `this.useEnumIndex` may affect
 		serialization output.
 	**/
 	public function serialize( v : Dynamic ) {
@@ -512,10 +512,10 @@ class Serializer {
 	}
 
 	/**
-		Serializes [v] and returns the String representation.
+		Serializes `v` and returns the String representation.
 
 		This is a convenience function for creating a new instance of
-		Serializer, serialize [v] into it and obtain the result through a call
+		Serializer, serialize `v` into it and obtain the result through a call
 		to toString().
 	**/
 	public static function run( v : Dynamic ) {

std/haxe/Template.hx

@@ -70,14 +70,14 @@ class Template {
 	var buf : StringBuf;
 
 	/**
-		Creates a new Template instance from [str].
+		Creates a new Template instance from `str`.
 		
-		[str] is parsed into tokens, which are stored for internal use. This
+		`str` is parsed into tokens, which are stored for internal use. This
 		means that multiple execute() operations on a single Template instance
 		are more efficient than one execute() operations on multiple Template
 		instances.
 		
-		If [str] is null, the result is unspecified.
+		If `str` is null, the result is unspecified.
 	**/
 	public function new( str : String ) {
 		var tokens = parseTokens(str);
@@ -87,19 +87,19 @@ class Template {
 	}
 
 	/**
-		Executes [this] Template, taking into account [context] for
-		replacements and [macros] for callback functions.
+		Executes `this` Template, taking into account `context` for
+		replacements and `macros` for callback functions.
 		
-		If [context] has a field 'name', its value replaces all occurrences of
+		If `context` has a field 'name', its value replaces all occurrences of
 		::name:: in the Template. Otherwise Template.globals is checked instead,
 		If 'name' is not a field of that either, ::name:: is replaced with null.
 		
-		If [macros] has a field 'name', all occurrences of $$name(args) are
+		If `macros` has a field 'name', all occurrences of $$name(args) are
 		replaced with the result of calling that field. The first argument is
 		always the the resolve() method, followed by the given arguments.
-		If [macros] has no such field, the result is unspecified.
+		If `macros` has no such field, the result is unspecified.
 		
-		If [context] is null, the result is unspecified. If [macros] is null,
+		If `context` is null, the result is unspecified. If `macros` is null,
 		no macros are used.
 	**/
 	public function execute( context : Dynamic, ?macros : Dynamic ):String {

std/haxe/Timer.hx

@@ -39,12 +39,12 @@ class Timer {
 	private var id : Null<Int>;
 
 	/**
-		Creates a new timer that will run every [time_ms] milliseconds.
+		Creates a new timer that will run every `time_ms` milliseconds.
 		
-		After creating the Timer instance, it calls [this].run() repeatedly,
-		with delays of [time_ms] milliseconds, until [this].stop() is called.
+		After creating the Timer instance, it calls `this].run` repeatedly,
+		with delays of `time_ms` milliseconds, until `this.stop` is called.
 		
-		The first invocation occurs after [time_ms] milliseconds, not
+		The first invocation occurs after `time_ms` milliseconds, not
 		immediately.
 		
 		The accuracy of this may be platform-dependent.
@@ -63,12 +63,12 @@ class Timer {
 	}
 
 	/**
-		Stops [this] Timer.
+		Stops `this` Timer.
 		
-		After calling this method, no additional invocations of [this].run()
+		After calling this method, no additional invocations of `this.run`
 		will occur.
 		
-		It is not possible to restart [this] Timer once stopped.
+		It is not possible to restart `this` Timer once stopped.
 	**/
 	public function stop() {
 		if( id == null )
@@ -84,28 +84,28 @@ class Timer {
 	}
 
 	/**
-		This method is invoked repeatedly on [this] Timer.
+		This method is invoked repeatedly on `this` Timer.
 		
 		It can be overridden in a subclass, or rebound directly to a custom
 		function:
 			var timer = new haxe.Timer(1000); // 1000ms delay
 			timer.run = function() { ... }
 			
-		Once bound, it can still be rebound to different functions until [this]
-		Timer is stopped through a call to [this].stop().
+		Once bound, it can still be rebound to different functions until `this`
+		Timer is stopped through a call to `this.stop`.
 	**/
 	public dynamic function run() {
 		trace("run");
 	}
 
 	/**
-		Invokes [f] after [time_ms] milliseconds.
+		Invokes `f` after `time_ms` milliseconds.
 		
 		This is a convenience function for creating a new Timer instance with
-		[time_ms] as argument, binding its run() method to [f] and then stopping
-		[this] Timer upon the first invocation.
+		`time_ms` as argument, binding its run() method to `f` and then stopping
+		`this` Timer upon the first invocation.
 		
-		If [f] is null, the result is unspecified.
+		If `f` is null, the result is unspecified.
 	**/
 	public static function delay( f : Void -> Void, time_ms : Int ) {
 		var t = new haxe.Timer(time_ms);
@@ -119,15 +119,15 @@ class Timer {
 	#end
 
 	/**
-		Measures the time it takes to execute [f], in seconds with fractions.
+		Measures the time it takes to execute `f`, in seconds with fractions.
 		
 		This is a convenience function for calculating the difference between
-		Timer.stamp() before and after the invocation of [f].
+		Timer.stamp() before and after the invocation of `f`.
 		
 		The difference is passed as argument to Log.trace(), with "s" appended
-		to denote the unit. The optional [pos] argument is passed through.
+		to denote the unit. The optional `pos` argument is passed through.
 		
-		If [f] is null, the result is unspecified.
+		If `f` is null, the result is unspecified.
 	**/
 	public static function measure<T>( f : Void -> T, ?pos : PosInfos ) : T {
 		var t0 = stamp();

std/haxe/Unserializer.hx

@@ -31,10 +31,11 @@ typedef TypeResolver = {
 	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
+	
+	- 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
 **/
 class Unserializer {
@@ -46,9 +47,10 @@ class Unserializer {
 		default, the haxe Type Api is used.
 
 		A type resolver must provide two methods:
-			resolveClass(name:String):Class<Dynamic> is called to determine a
+		
+		1. resolveClass(name:String):Class<Dynamic> is called to determine a
 				Class from a class name
-			resolveEnum(name:String):Enum<Dynamic> is called to determine an
+		2. resolveEnum(name:String):Enum<Dynamic> is called to determine an
 				Enum from an enum name
 
 		This value is applied when a new Unserializer instance is created.
@@ -86,10 +88,10 @@ class Unserializer {
 
 	/**
 		Creates a new Unserializer instance, with its internal buffer
-		initialized to [buf].
+		initialized to `buf`.
 
-		This does not parse [buf] immediately. It is parsed only when calls to
-		[this].unserialize are made.
+		This does not parse `buf` immediately. It is parsed only when calls to
+		`this.unserialize` are made.
 
 		Each Unserializer instance maintains its own cache.
 	**/
@@ -111,9 +113,9 @@ class Unserializer {
  	}
 
 	/**
-		Sets the type resolver of [this] Unserializer instance to [r].
+		Sets the type resolver of `this` Unserializer instance to `r`.
 
-		If [r] is null, a special resolver is used which returns null for all
+		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.
@@ -129,7 +131,7 @@ class Unserializer {
 	}
 
 	/**
-		Gets the type resolver of [this] Unserializer instance.
+		Gets the type resolver of `this` Unserializer instance.
 
 		See DEFAULT_RESOLVER for more information on type resolvers.
 	**/
@@ -194,14 +196,14 @@ class Unserializer {
 	}
 
 	/**
-		Unserializes the next part of [this] Unserializer instance and returns
+		Unserializes the next part of `this` Unserializer instance and returns
 		the according value.
 
-		This function may call [this].resolver.resolveClass to determine a
-		Class from a String, and [this].resolver.resolveEnum to determine an
+		This function may call `this.resolver.resolveClass` to determine a
+		Class from a String, and `this.resolver.resolveEnum` to determine an
 		Enum from a String.
 
-		If [this] Unserializer instance contains no more or invalid data, an
+		If `this` Unserializer instance contains no more or invalid data, an
 		exception is thrown.
 
 		This operation may fail on structurally valid data if a type cannot be
@@ -421,10 +423,10 @@ class Unserializer {
  	}
 
 	/**
-		Unserializes [v] and returns the according value.
+		Unserializes `v` and returns the according value.
 
 		This is a convenience function for creating a new instance of
-		Unserializer with [v] as buffer and calling its unserialize() method
+		Unserializer with `v` as buffer and calling its unserialize() method
 		once.
 	**/
 	public static function run( v : String ) : Dynamic {

std/haxe/Utf8.hx

@@ -51,7 +51,7 @@ class Utf8 {
 	}
 
 	/**
-		Call the [chars] function for each UTF8 char of the string.
+		Call the `chars` function for each UTF8 char of the string.
 	**/
 	public static function iter( s : String, chars : Int -> Void ) {
 		for( i in 0...s.length )
@@ -76,7 +76,7 @@ class Utf8 {
 	}
 
 	/**
-		Similar to [String.charCodeAt] but uses the UTF8 character position.
+		Similar to `String.charCodeAt` but uses the UTF8 character position.
 	**/
 	public static inline function charCodeAt( s : String, index : Int ) : Int {
 		return s.charCodeAt(index);
@@ -105,7 +105,7 @@ class Utf8 {
 	}
 
 	/**
-		This is similar to [String.substr] but the [pos] and [len] parts are considering UTF8 characters.
+		This is similar to `String.substr` but the `pos` and `len` parts are considering UTF8 characters.
 	**/
 	public static inline function sub( s : String, pos : Int, len : Int ) : String {
 		return s.substr(pos,len);