iterators

A collection of useful iterators.
https://github.com/RealyUniqueName/Iterators

To install, run:

haxelib install iterators 1.2.2 

See using Haxelib in Haxelib documentation for more information.

README.md

Iterators Build Status

This is a set of frequently used iterators for Haxe collections and other types.

All iterators are designed to have zero impact on runtime performance.

Compatible with Haxe 3.4 and 4.0

Installation

haxelib install iterators

Usage

using Iterators;

for(i in 10.to(0).step(-2)) { //.step() is optional
	trace(i);
}

var str = 'hello';
for(c in str.chars()) {
	trace(c);
}

Full list of available iterators:

class MapIterators {
	/**
	 *  Map iterator which allows you to get key & value in one go.
	 *  ```
	 *  var m = [1 => 'hello'];
	 *  for(p in map.pairs()) {
	 *  	trace(p.key); // 1
	 *  	trace(p.value); // hello
	 *  }
	 *  ```
	 */
	static public inline function pairs<K,V>(map:Map<K,V>) return new MapPairIterator(map);
}
class DynamicAccessIterators {
	/**
	 *  Iterator for `haxe.DynamicAccess` which allows you to get key & value in one go.
	 *  ```
	 *  var obj:DynamicAccess<String> = {hello:'world'};
	 *  for(p in obj.pairs()) {
	 *  	trace(p.key); // hello
	 *  	trace(p.value); // world
	 *  }
	 *  ```
	 */
	static public inline function pairs<V>(obj:DynamicAccess<V>) return new KeyValueDynamicAccessIterator(obj);
}
class ArrayIterators {
	/**
	 *  Array iterator which allows you to get index & value in one go.
	 *  ```
	 *  var a = ['hello'];
	 *  for(p in a.pairs()) {
	 *  	trace(p.index); // 0
	 *  	trace(p.value); // 'hello'
	 *  }
	 *  ```
	 */
	static public inline function pairs<V>(array:Array<V>) return new IndexValueIterator(array);
	/**
	 *  Array iterator which iterates from the end to the beginning of an array and allows you to get index & value in one go.
	 */
	static public inline function reversePairs<V>(array:Array<V>) return new IndexValueReversiveIterator(array);
	/**
	 *  Array iterator which iterates from the end to the beginning of an array.
	 */
	static public inline function reverseValues<V>(array:Array<V>) return new ValueReversiveIterator(array);
}
class StringIterators {
	/**
	 *  String iterator which allows you to get index & character in one go.
	 *  ```
	 *  var str = 'hello';
	 *  for(p in str.pairs()) {
	 *  	trace(p.index);
	 *  	trace(p.char);
	 *  }
	 *  ```
	 */
	static public inline function pairs(str:String) return new IndexCharIterator(str);
	/**
	 *  String iterator which iterates from the end to the beginning of a string and allows you to get index & character in one go.
	 */
	static public inline function reversePairs(str:String) return new IndexCharReversiveIterator(str);
	/**
	 *  String iterator over characters.
	 *  ```
	 *  var str = 'hello';
	 *  for(c in str.chars()) {
	 *  	trace(c); // Sequentially prints: h, e, l, l, o
	 *  }
	 *  ```
	 */
	static public inline function chars(str:String) return new CharIterator(str);
	/**
	 *  String iterator over characters from the end to the beginnning of a string.
	 */
	static public inline function reverseChars(str:String) return new CharReversiveIterator(str);
	/**
	 *  String iterator over codes of characters.
	 *  ```
	 *  var str = 'hi';
	 *  for(c in str.charCodes()) {
	 *  	trace(c); // Sequentially prints: 104, 105
	 *  }
	 *  ```
	 */
	static public inline function charCodes(str:String) return new CharCodeIterator(str);
	/**
	 *  String iterator over codes of characters from the end to the beginnning of a string.
	 *  ```
	 *  var str = 'hi';
	 *  for(c in str.charCodes()) {
	 *  	trace(c); // Sequentially prints: 105, 104
	 *  }
	 *  ```
	 */
	static public inline function reverseCharCodes(str:String) return new CharCodeReversiveIterator(str);
}
class LengthIterators {
	/**
	 *  Iterator for values with `length` field which iterates over indices from the end to the beginning of a `value`.
	 */
	@:generic
	static public inline function reverseIndices<T:{var length(default,never):Int;}>(value:T) return new IndexReversiveIterator(value.length);
}
class IntIterators {
	/**
	 *  Int iterator from `from` (including) to `to` (excluding).
	 *  ```
	 *  var value = 10;
	 *  for(i in value.to(13)) {
	 *  	trace(i); // Sequentially prints: 10, 11, 12
	 *  }
	 *  for(i in value.to(7)) {
	 *  	trace(i); // Sequentially prints: 10, 9, 8
	 *  }
	 *  for(i in value.to(15).step(2)) {
	 *  	trace(i); // Sequentially prints: 10, 12, 14
	 *  }
	 *  ```
	 */
	static inline public function to(from:Int, to:Float) return new IntIterator(from, to);
}
class FloatIterators {
	/**
	 *  Float iterator from `from` (including) to `to` (excluding).
	 *  ```
	 *  var value = 10.5;
	 *  for(i in value.floatTo(13)) {
	 *  	trace(i); // Sequentially prints: 10.5, 11.5, 12.5
	 *  }
	 *  for(i in value.floatTo(7)) {
	 *  	trace(i); // Sequentially prints: 10.5, 9.5, 8.5
	 *  }
	 *  for(i in value.floatTo(12).step(0.5)) {
	 *  	trace(i); // Sequentially prints: 10.5, 11, 11.5
	 *  }
	 *  ```
	 */
	static inline public function floatTo(from:Float, to:Float) return new FloatIterator(from, to);
}
class AnonymousObjectIterators {
	/**
	 *  Object iterator which allows you to get field name & value in one go.
	 *  It is only guaranteed to work with anonymous objects.
	 *
	 *  @throws iterators.exceptions.IllegalValueException - if `object` is not an object.
	 *
	 *  ```
	 *  var obj:Any = Json.parse(data);
	 *  for(f in obj.fields()) {
	 *  	trace(f.name);
	 *  	trace(f.value);
	 *  }
	 *  ```
	 */
	static public inline function fields(object:Dynamic) return new FieldValueIterator(object);
}
Contributors
RealyUniqueName
Version
1.2.2
Published
7 years ago
Dependencies
License
MIT

All libraries are free

Every month, more than a thousand developers use Haxelib to find, share, and reuse code — and assemble it in powerful new ways. Enjoy Haxe; It is great!

Explore Haxe

Haxe Manual

Haxe Code Cookbook

Haxe API documentation

You can try Haxe in the browser! try.haxe.org

Join us on GitHub!

Haxe is being developed on GitHub. Feel free to contribute or report issues to our projects.

Haxe on GitHub

⌂