Cravenly unobtrusive force multiplier library for Haxe. i.e My version of the stuff that everyone has a version of. Should play nice with everyone, tell me otherwise and I'll fix it.
using stx.Pico pulls in...
Option<O>
Either<L,R>
Outcome<S,F>
ArrayLiftenum Option<T>{
Some(t:T);
None;
}
//-------------
var a = Some(1);
var b = a.map(
(x) -> x + 1 // if defined, add one
).flat_map(
(x) -> None // if defined, return None
).defv(9);//default value, results in 9function make<T>(t: T): Option<T> Produces Some(t) if t is not null, None otherwise.
function fromNullT<T>(v:Null<T>):Option<T>function flatten<T>(self: Option<Option<T>>): Option<T>Produces an Option where self may contain another Option.
These are automatically available to all haxe.ds.Option, but are available as static functions via Option._
function fold<T,TT>(self:OptionSum<T>,ok:T->TT,no:Void->TT):TTsupply handlers for the cases and retrieve one ore other values.
function map<T, TT>(self: OptionSum<T>,f: T -> TT):Option<TT>Performs f on the contents of self if self != None
function flat_map<T, TT>(self: OptionSum<T>,f: T -> Option<TT>): Option<TT>Produces the Option result of f which takes the contents of self as a parameter
function or<T>(self: OptionSum<T>, thunk: Void -> OptionSum<T>):Option<T>Produces self if it is Some(x), the result of thunk otherwise.
function filter<T>(self:OptionSum<T>,fn:T->Bool):Option<T>returns None if filter returns false, Some(t:T) otherwise.
function def<T>(self: OptionSum<T>, thunk: Void->T): TProduces the value of self if not None, the result of thunk otherwise.
function defv<T>(self:OptionSum<T>,v:T):TReturns the inner value of self or the value v if self is None
function is_defined<T>(self:OptionSum<T>)returns true if self is Some(v), false otherwise.
function iterator<T>(self:OptionSum<T>):Iterator<T>{returns an Iterator. makes Option avaliable for use in array comprehensions.
function merge<T>(self:OptionSum<T>,that:OptionSum<T>,fn : T -> T -> T):OptionSum<T>Produces one or other value if only one is defined, or calls fn on the two and returns the result
function toArray<T>(self: OptionSum<T>): Array<T>Produces an Array of length 0 if self is None, length 1 otherwise.
enum Either<L,R>{
Left(l:L);
Right(r:R);
}function fold<Ti,Tii,R>(self:EitherSum<Ti,Tii>,lhs:Ti->R,rhs:Tii->R):R{Applies lhs if the value is Left and rhs if the value is Right, returning the result.
function map<Ti,Tii,R>(self:Either<Ti,Tii>,fn:Tii->R):Either<Ti,R>applies fn if the value is Right, producing Right(R)
function flat_map<Ti,Tii,R>(self:Either<Ti,Tii>,fn:Tii->Either<Ti,R>:Either<Ti,R>maps and then flatten the Right value if it exists, or pass the Left untouched.
function flip<Ti,Tii>(self:Either<Ti,Tii>):Either<Tii,Ti>makes a Left a Right and vice-versa.
enum Outcome<T,E>{
Success(t:T);
Failure(e:E);
}function map<T,E,TT>(self:OutcomeSum<T,E>,fn:T->TT):Outcome<TT,E>applies function fn if outcome is Success, or passes error E
function flat_map<T,E,TT>(self:OutcomeSum<T,E>,fn:T->OutcomeSum<TT,E>:Outcome<TT,E>applies function fn, allowing the change from Success to Failure if self is Success
function fold<T,E,TT>(self:OutcomeSum<T,E>,fn:T->TT,er:E->TT):TTsupply handlers and receive one or other of the values, depending on self
function fudge<T,E>(self:OutcomeSum<T,E>):T
return the inner value or throw E if self is Failure
function elide<T,E>(self:OutcomeSum<T,E>):Outcome<Dynamic,E>untype the T type
function flatten<T>(arrs: Array<Array<T>>): Array<T> produces an Array from an Array of Arrays.
function interleave<T>(alls: StdArray<StdArray<T>>): Array<T> Weaves an Array of arrays so that [ array0[0] , array1[0] ... arrayn[0] , array0[1], array1[1] ... ]. Continues to operate to the length of the shortest array, and drops the rest of the elements.
function is_defined<T>(self:StdArray<T>):BoolReturn true if the length of self is greater than 0.
function cons<T>(self:StdArray<T>,t:T):Array<T>Return an Array including t:T at the beginning.
function snoc<T>(self:StdArray<T>,t:T):Array<T>Return an Array including t:T at the end.
function set<T>(self:StdArray<T>,i:Int,v:T):Array<T>Produces an Array wherein the value at self[i] is t.
function get<T>(self:StdArray<T>,i:Int):TProduces the element of self at index i
function head<T>(self:StdArray<T>):Option<T>Produces the first element of self as an Option, Option.None if the Array is empty or the value is null.
function tail<T>(self:StdArray<T>):Array<T>Produces an Array of all elements after the first.
function last<T>(self:StdArray<T>):Option<T>
Produces the last element of self if defined.
function copy<T>(self:StdArray<T>):Array<T>Produces a seperate, shallow copy of self.
function concat<T>(self:StdArray<T>,that:Iterable<T>):Array<T>Produces an Array containing the contents of self followed by the contents of that.
function bind_fold<T,Ti,TT>(self:StdArray<T>,pure:Ti->TT,init:Ti,bind:TT->(Ti->TT)->TT,fold:T->Ti->Ti):TTAchieves a flat_map by passing the bind function as a parameter.
function reduce<T,TT>(self:StdArray<T>,unit:Void->TT,pure:T->TT,plus:TT->TT->TT):TTFolds self into TT by first constructing a pure value from each element.
function map<T,TT>(self:StdArray<T>,fn:T->TT):Array<TT>Produces an Array containing the results of f applied to self.
function mapi<T,TT>(self:StdArray<T>,fn:Int->T->TT):Array<TT>Applies function f to each element in self, passing the index in the left hand parameter, returning an Array.
function flat_map<T,TT>(self:StdArray<T>,fn:T->Iterable<TT>):Array<TT>Applies function f to each element in self, concatenating and returning the results.
function lfold<T,TT>(self:StdArray<T>,fn:T->TT->TT,memo:TT):TTUsing starting var tt, run f on each element, storing the result, and passing that result into the next call:
[1,2,3,4,5].lfold( function(next,memo) return init + v, 100 ));//(((((100 + 1) + 2) + 3) + 4) + 5)function lfold1<T>(self:StdArray<T>,fn:T->T->T):Option<T>Performs a lfold, using the first value of arr as the memo value.
function rfold<T,TT>(self:StdArray<T>,fn:T->TT->TT,z:TT):TT As with lfold but working from the right hand side.
function lscan<T>(self:StdArray<T>,f: T -> T -> T,init: T): Array<T> Takes an initial value which is passed to function f along with each element
one by one, accumulating the results. f(next,memo)
function lscan1<T>(self:StdArray<T>,f: T -> T -> T): Array<T>As lscan, but using the first element as the second parameter of f
function rscan<T>(self:StdArray<T>,init: T, f: T -> T -> T): Array<T>As lscan but from the end of the Array.
function rscan1<T>(self:StdArray<T>,f: T -> T -> T): Array<T>As rscan, but using the first element as the second parameter of f
function filter<T>(self:StdArray<T>,fn:T->Bool):Array<T>
Call f on each element in self, returning an Array where f(e) = true.
function map_filter<T,TT>(self:StdArray<T>,fn:T->Option<TT>):Array<TT>Call f on each element in self, returning an Array where the result is Some(tt:TT)
function whilst<T>(self:StdArray<T>,fn:T->Bool):Array<T>As with filter, but produces nothing more after the predicate p first returns false.
function ltaken<T>(self:StdArray<T>,n):Array<T>Produces an Array from self[0] to self[n]
function ldropn<T>(self:StdArray<T>,n):Array<T>Produces an Array from self[n] up to and including the last element.
function rdropn<T>(self:StdArray<T>,n:Int):Array<T>Produces an Array from self[0] to self[a.length-n].
function ldrop<T>(self: StdArray<T>, p: T -> Bool): Array<T>Drops values from self while the predicate returns true.
function search<T>(self:StdArray<T>,fn:T->Bool):Option<T>Produces an Option.Some(element) the first time the predicate returns true, None otherwise.
function all<T>(self:StdArray<T>,fn:T->Bool):BoolProduces true if the predicate returns true for all elements, false otherwise.
function any<T>(self:StdArray<T>,fn:T->Bool): BoolProduces true if the predicate returns true for any element, false otherwise.
function zip_with<T,Ti,TT>(self:StdArray<T>,that:StdArray<Ti>,fn:T->Ti->TT):Array<TT>Produces an Array of f(l_element,r_element). Goes to the shorter of the two Arrays.
function cross_with<T,Ti,TT>(self : Array<T>, that : Array<Ti>,fn : T -> Ti -> TT):Array<TT>from thx.core It returns the cross product between two arrays.
var r = [1,2,3].cross_with([4,5,6],(lhs,rhs) -> [lhs,rhs]);
trace(r); // [[1,4],[1,5],[1,6],[2,4],[2,5],[2,6],[3,4],[3,5],[3,6]]function difference_with<T>(self:Array<T>, that:Array<T>,eq:T->T->Bool)Produces an Array that contains all elements from self which are not elements of that, using f.
If self contains duplicates, the resulting Array contains duplicates.
function union_with<T>(self:Array<T>, that:Array<T>,eq:T->T->Bool)Produces an Array that contains all elements from self which are also elements of that.
If self contains duplicates, so will the result.
function unique_with<T>(self:StdArray<T>,eq:T->T->Bool):Array<T>{
function nub_with<T>(self:StdArray<T>,f: T -> T -> Bool): Array<T>Produces an Array with no duplicate elements as determined by f.
function intersect_with<T>(self: StdArray<T>, that: StdArray<T>,f:T -> T -> Bool): Array<T> Intersects two Arrays, determining equality by f.
function reversed<T>(self: StdArray<T>): Array<T> Produces an Array with the elements in reversed order.
function count<T>(self: StdArray<T>, f: T -> Bool): Int Counts some property of the elements of self using predicate p.
For the length of the Array @see size().
function size<T>(self: StdArray<T>): Int
Returns the number of elements in self
function index_of<T>(self: StdArray<T>, t: T->Bool): Int Produces the index of element t. For a function producing an Option, see findArrayOf.
function has<T>(self: StdArray<T>,obj:T): Option<Int>Determines if a value is contained in self by identity.
function partition<T>(self: StdArray<T>,f: T -> Bool): { a : StdArray<T>, b : StdArray<T> }Produces a tuple containing two Arrays, a being elements where f(e) == true, and b, the rest.
function chunk<T>(self : StdArray<T>, size : StdArray<Int>):Array<Array<T>>Produces an Array of Arrays of size size.
function pad<T>(self:StdArray<T>,len:Int,?val:T):Array<T>Pads out to len with val, ignores if len is less than Array.size().
function fill<T>(self:StdArray<T>,def:T):Array<T>Fills null values in self with def.
function toIterable<T>(self:StdArray<T>:Iterable<T>function toMap<T>(self:StdArray<Void -> { a : String, b : T }>:Map<String,T>Produces a haxe.ds.Map
function random<T>(self:StdArray<T>):Null<T>function shuffle<T>(self: StdArray<T>): Array<T>function and_with<T>(self:Array<T>,that:Array<T>,eq:T->T->Bool):Bool;function rotate<T>(self:Array<T>,num:Int):Array<T>requires lalochezia
echo "hello"