/**
* This method tests the "iterator" method.
*/
public function test_iterator()
{
$p0 = IOption\Type::some(IInt32\Type::zero());
$e0 = array(0);
$this->assertInstanceOf('\\Saber\\Data\\IOption\\Some\\Type', $p0);
$this->assertSame(count($e0), $p0->__size());
$p1 = IOption\Module::iterator($p0);
$e1 = 0;
$this->assertInstanceOf('\\Saber\\Data\\IOption\\Iterator', $p1);
foreach ($p1 as $i => $item) {
$this->assertInstanceOf('\\Saber\\Data\\IInt32\\Type', $i);
$this->assertSame($e1, $i->unbox());
$this->assertInstanceOf('\\Saber\\Core\\Type', $item);
$this->assertSame($e0[$e1], $item->unbox());
$e1++;
}
}
/**
* This method returns a pair of hash maps: those items that satisfy the predicate and
* those items that do not satisfy the predicate.
*
* @access public
* @static
* @param IHashMap\Type $xs the hash map to be partitioned
* @param callable $predicate the predicate function to be used
* @return ITuple\Type the results
*/
public static function partition(IHashMap\Type $xs, callable $predicate) : ITuple\Type
{
$passed = IHashMap\Type::empty_();
$failed = IHashMap\Type::empty_();
$xi = IHashMap\Module::iterator($xs);
$i = IInt32\Type::zero();
foreach ($xi as $k => $v) {
$entry = ITuple\Type::box2($k, $v);
if ($predicate($entry, $i)->unbox()) {
$passed->putEntry($entry->first(), $entry->second());
} else {
$failed->putEntry($entry->first(), $entry->second());
}
}
return ITuple\Type::box2($passed, $failed);
}
/**
* This method tests the "singletons" methods.
*/
public function test_singletons()
{
$p0 = IInt32\Type::negative();
$e0 = IInt32\Type::negative();
$this->assertInstanceOf('\\Saber\\Data\\IInt32\\Type', $p0);
$this->assertSame($e0->__hashCode(), $p0->__hashCode());
$p1 = $p0->unbox();
$e1 = -1;
$this->assertInternalType('integer', $p1);
$this->assertSame($e1, $p1);
$p2 = IInt32\Type::zero();
$e2 = IInt32\Type::zero();
$this->assertInstanceOf('\\Saber\\Data\\IInt32\\Type', $p2);
$this->assertSame($e2->__hashCode(), $p2->__hashCode());
$p3 = $p2->unbox();
$e3 = 0;
$this->assertInternalType('integer', $p3);
$this->assertSame($e3, $p3);
$p4 = IInt32\Type::one();
$e4 = IInt32\Type::one();
$this->assertInstanceOf('\\Saber\\Data\\IInt32\\Type', $p4);
$this->assertSame($e4->__hashCode(), $p4->__hashCode());
$p5 = $p4->unbox();
$e5 = 1;
$this->assertInternalType('integer', $p5);
$this->assertSame($e5, $p5);
}
/**
* This method rewinds the iterator.
*
* @access public
* @final
*/
public final function rewind()
{
$this->i = IInt32\Type::zero();
}
/**
* This method returns the first object in the collection that passes the truthy test, if any.
*
* @access public
* @static
* @param IOption\Type $xs the left operand
* @param callable $predicate the predicate function to be used
* @return IOption\Type an option containing the first object
* satisfying the predicate, if any
*/
public static function find(IOption\Type $xs, callable $predicate) : IOption\Type
{
if (IBool\Module::and_($xs->isDefined(), $predicate($xs->item(), IInt32\Type::zero()))->unbox()) {
return $xs;
}
return IOption\Type::none();
}
/**
* This method tests the "projectRight" method.
*/
public function test_projectRight()
{
$p0 = IEither\Type::left(IInt32\Type::zero())->projectRight();
$this->assertInstanceOf('\\Saber\\Data\\IEither\\Right\\Projection', $p0);
$p1 = IEither\Type::right(IInt32\Type::zero())->projectRight();
$this->assertInstanceOf('\\Saber\\Data\\IEither\\Right\\Projection', $p1);
}
/**
* This method returns the latter value should the former value evaluates
* to null.
*
* @access public
* @static
* @param IInt32\Type $x the value to be evaluated
* @param IInt32\Type $y the default value
* @return IInt32\Type the result
*/
public static function nvl(IInt32\Type $x = null, IInt32\Type $y = null) : IInt32\Type
{
return $x ?? $y ?? IInt32\Type::zero();
}
/**
* This method tests the "item" related methods.
*/
public function test_items()
{
$p0 = ILinkedList\Type::box2(IInt32\Type::zero(), IInt32\Type::one(), IInt32\Type::box(2));
$this->assertSame(0, $p0->item(IInt32\Type::zero())->unbox());
$this->assertSame(1, $p0->item(IInt32\Type::one())->unbox());
$this->assertSame(2, $p0->item(IInt32\Type::box(2))->unbox());
$this->assertSame(0, $p0->head()->unbox());
$p1 = $p0->tail();
$this->assertInstanceOf('\\Saber\\Data\\ILinkedList\\Type', $p1);
$this->assertSame(array(1, 2), $p1->unbox(1));
}
/**
* This method provides the data for testing that a value is converted to a string.
*
* @return array
*/
public function data_toString()
{
$data = array(array(array(new Throwable\InvalidArgument\Exception('Message', array(), IInt32\Type::zero())), array('Saber\\Throwable\\InvalidArgument\\Exception [ 0 ]: Message ~ ')));
return $data;
}
/**
* This method provides the data for testing that a value is of a particular size.
*
* @return array
*/
public function dataSize()
{
$data = array(array(array(), array(0)), array(array(IInt32\Type::zero()), array(1)), array(array(IInt32\Type::zero(), IInt32\Type::one(), IInt32\Type::box(2)), array(3)), array(array(IInt32\Type::zero(), IInt32\Type::zero(), IInt32\Type::zero()), array(1)), array(array(IInt32\Type::zero(), IInt32\Type::zero(), IInt32\Type::one(), IInt32\Type::one()), array(2)));
return $data;
}
/**
* This method provides the data for testing that a value is of a particular size.
*
* @return array
*/
public function dataSize()
{
$data = array(array(array(), array(0)), array(array(ITuple\Type::box2(IString\Type::box('key0'), IInt32\Type::zero())), array(1)), array(array(ITuple\Type::box2(IString\Type::box('key0'), IInt32\Type::zero()), ITuple\Type::box2(IString\Type::box('key1'), IInt32\Type::one())), array(2)));
return $data;
}
/**
* This method provides the data for testing that a value is converted to a string.
*
* @return array
*/
public function data_toString()
{
$data = array(array(array('Message', array(), IInt32\Type::zero()), array('Saber\\Throwable\\UnimplementedMethod\\Exception [ 0 ]: Message ~ ')));
return $data;
}
/**
* This method tests the creation of a constant function that wraps an object.
*/
public function testConstant()
{
$constant = IFunction\Utilities::constant(IInt32\Type::zero());
$this->assertInternalType('callable', $constant);
$this->assertSame(IInt32\Type::zero(), $constant());
}
/**
* This method returns whether the ratio is a whole number.
*
* @access public
* @static
* @param IRatio\Type $x the ratio to be evaluated
* @return IBool\Type whether the ratio is a whole
* number
*/
public static function isInteger(IRatio\Type $x) : IBool\Type
{
return IBool\Module::or_(IInt32\Module::eq($x->numerator(), IInt32\Type::zero()), IInt32\Module::eq($x->denominator(), IInt32\Type::one()));
}
/**
* This method tests the "nvl" method.
*/
public function test_nvl()
{
$x = IInt32\Type::one();
$y = IInt32\Type::zero();
$z = IInt32\Module::nvl($x, $y);
$this->assertInstanceOf('\\Saber\\Data\\IInt32\\Type', $z);
$this->assertSame(1, $z->unbox());
$z = IInt32\Module::nvl(null, $x);
$this->assertInstanceOf('\\Saber\\Data\\IInt32\\Type', $z);
$this->assertSame(1, $z->unbox());
$z = IInt32\Module::nvl(null, null);
$this->assertInstanceOf('\\Saber\\Data\\IInt32\\Type', $z);
$this->assertSame(0, $z->unbox());
}
/**
* This method tests the "item" related methods.
*/
public function test_items()
{
$p0 = ITuple\Type::box2(IInt32\Type::zero(), IInt32\Type::one(), IInt32\Type::box(2));
$this->assertSame(0, $p0->item(IInt32\Type::zero())->unbox());
$this->assertSame(1, $p0->item(IInt32\Type::one())->unbox());
$this->assertSame(2, $p0->item(IInt32\Type::box(2))->unbox());
$this->assertSame(0, $p0->first()->unbox());
$this->assertSame(1, $p0->second()->unbox());
}
/**
* This method tests the "item" related methods.
*/
public function test_items()
{
$p0 = IString\Type::box('012');
$this->assertSame('0', $p0->item(IInt32\Type::zero())->unbox());
$this->assertSame('1', $p0->item(IInt32\Type::one())->unbox());
$this->assertSame('2', $p0->item(IInt32\Type::box(2))->unbox());
$this->assertSame('0', $p0->head()->unbox());
$p1 = $p0->tail();
$this->assertInstanceOf('\\Saber\\Data\\IString\\Type', $p1);
$this->assertSame('12', $p1->unbox());
}
/**
* This method returns the length of this linked list.
*
* @access public
* @final
* @return IInt32\Type the length of this linked list
*/
public final function length() : IInt32\Type
{
$c = IInt32\Type::zero();
for ($zs = $this; !$zs->__isEmpty(); $zs = $zs->tail()) {
$c = IInt32\Module::increment($c);
}
return $c;
}
/**
* This method compares the operands for order.
*
* @access public
* @static
* @param ITuple\Type $xs the left operand
* @param ITuple\Type $ys the right operand
* @return ITrit\Type the order as to whether the left
* operand is less than, equals to,
* or greater than the right operand
*/
public static function compare(ITuple\Type $xs, ITuple\Type $ys) : ITrit\Type
{
$xsl = $xs->length();
$ysl = $ys->length();
$length = IInt32\Module::min($xsl, $ysl);
for ($i = IInt32\Type::zero(); IInt32\Module::lt($i, $length)->unbox(); $i = IInt32\Module::increment($i)) {
$r = $xs->item($i)->compare($ys->item($i));
if ($r->unbox() != 0) {
return $r;
}
}
return ITrit\Type::box($xsl->unbox() <=> $ysl->unbox());
}
/**
* This method returns the collection as a linked list.
*
* @access public
* @static
* @param IString\Type $xs the operand
* @return ILinkedList\Type the collection as a linked list
*/
public static function toLinkedList(IString\Type $xs) : ILinkedList\Type
{
$length = $xs->length();
$zs = ILinkedList\Type::nil();
for ($i = IInt32\Module::decrement($length); IInt32\Module::ge($i, IInt32\Type::zero())->unbox(); $i = IInt32\Module::decrement($i)) {
$zs = ILinkedList\Type::cons($xs->item($i), $zs);
}
return $zs;
}
/**
* This method applies each item in this either to the subroutine function.
*
* @access public
* @final
* @param callable $subroutine the subroutine function to be used
* @return IEither\Type the either
*/
public final function map(callable $subroutine) : IEither\Type
{
return $this->either->__isLeft() ? IEither\Type::left($subroutine($this->either->item(), IInt32\Type::zero())) : IEither\Type::right($this->either->projectRight()->item());
}
/**
* This method provides the data for testing that a value is converted to a string.
*
* @return array
*/
public function data_toString()
{
$data = array(array(array('Message', array(), IInt32\Type::zero()), array('Saber\\Throwable\\EmptyCollection\\Exception [ 0 ]: Message ~ ')));
return $data;
}
/**
* This method tests the "size" method.
*/
public function test_size()
{
$p0 = IOption\Type::some(IInt32\Type::zero())->size();
$e0 = 1;
$this->assertInstanceOf('\\Saber\\Data\\IInt32\\Type', $p0);
$this->assertSame($e0, $p0->unbox());
$p1 = IOption\Type::none()->size();
$e1 = 0;
$this->assertInstanceOf('\\Saber\\Data\\IInt32\\Type', $p1);
$this->assertSame($e1, $p1->unbox());
}
/**
* This method tests the "foldRight" method.
*
* @dataProvider data_foldRight
*/
public function test_foldRight(array $provided, array $expected)
{
$p0 = ILinkedList\Type::make($provided[0], '\\Saber\\Data\\IInt32\\Type');
$p1 = $provided[1];
$r0 = ILinkedList\Module::foldRight($p0, $p1, IInt32\Type::zero());
$e0 = $expected[0];
$this->assertInstanceOf('\\Saber\\Data\\IInt32\\Type', $r0);
$this->assertSame($e0, $r0->unbox());
}
/**
* This method returns an object with a "0" value.
*
* @access public
* @static
* @return IRatio\Type the object
*/
public static function zero()
{
if (!isset(static::$singletons[0])) {
static::$singletons[0] = new IRatio\Type(IInt32\Type::zero(), IInt32\Type::one());
}
return static::$singletons[0];
}
/**
* This method provides the data for testing the making of a boxed value.
*
* @return array
*/
public function data_singleton()
{
$data = array(array(array(IRatio\Type::one()), array(IInt32\Type::one(), IInt32\Type::one())), array(array(IRatio\Type::zero()), array(IInt32\Type::zero(), IInt32\Type::one())), array(array(IRatio\Type::negative()), array(IInt32\Type::negative(), IInt32\Type::one())));
return $data;
}
/**
* This method returns each item in this collection until the predicate fails.
*
* @access public
* @static
* @param ILinkedList\Type $xs the left operand
* @param callable $predicate the predicate function to be used
* @return ILinkedList\Type the list
*/
public static function takeWhile(ILinkedList\Type $xs, callable $predicate) : ILinkedList\Type
{
$start = ILinkedList\Type::nil();
$tail = null;
$taking = true;
$i = IInt32\Type::zero();
for ($zs = $xs; !$zs->__isEmpty() && $taking; $zs = $zs->tail()) {
$z = $zs->head();
if ($predicate($z, $i)->unbox()) {
$ys = ILinkedList\Type::cons($z);
if ($tail !== null) {
$tail->tail = $ys;
} else {
$start = $ys;
}
$tail = $ys;
} else {
$taking = false;
}
$i = IInt32\Module::increment($i);
}
return $start;
}
