/** * This method (aka "every" and "forall") iterates over the items in the list, yielding * each item to the predicate function, or fails the truthy test. Opposite of "none". * * @access public * @static * @param IString\Type $xs the left operand * @param callable $predicate the predicate function to be used * @return IBool\Type whether each item passed the * truthy test */ public static function all(IString\Type $xs, callable $predicate) : IBool\Type { $xi = IString\Module::iterator($xs); foreach ($xi as $i => $x) { if (!$predicate($x, $i)->unbox()) { return IBool\Type::false(); } } return IBool\Type::true(); // yes, empty returns "true" }
/** * This method (aka "exists" or "some") returns whether some of the items in the list passed the truthy * test. * * @access public * @static * @param IHashMap\Type $xs the hash map * @param callable $predicate the predicate function to be used * @return IBool\Type whether some of the items * passed the truthy test */ public static function any(IHashMap\Type $xs, callable $predicate) : IBool\Type { $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()) { return IBool\Type::true(); } $i = IInt32\Module::increment($i); } return IBool\Type::false(); }
/** * This method evaluates whether the specified object is identical to the current object. * * @access public * @static * @param IOption\Type $xs the left operand * @param Core\Type $ys the object to be evaluated * @return IBool\Type whether the specified object is identical * to the current object */ public static function id(IOption\Type $xs, Core\Type $ys) : IBool\Type { if ($ys !== null) { if ($xs->__typeOf() === $ys->__typeOf()) { if ($ys instanceof IOption\Some\Type) { $x = $xs->item(); $y = $ys->item(); if ($x === null) { return IBool\Type::box($y === null); } else { if ($x instanceof Core\Equality\Type) { return $x->id($y); } } return IBool\Type::box(spl_object_hash($x) === spl_object_hash($y)); } else { if ($ys instanceof IOption\None\Type) { return IBool\Type::true(); } } } } return IBool\Type::false(); }
/** * This method tests the "xor_" method. */ public function test_xor_() { $x = IBool\Type::true(); $y = IBool\Type::false(); $z = IBool\Module::xor_($x, $y); $this->assertInstanceOf('\\Saber\\Data\\IBool\\Type', $z); $this->assertSame(true, $z->unbox()); $z = IBool\Module::xor_($x, $x); $this->assertInstanceOf('\\Saber\\Data\\IBool\\Type', $z); $this->assertSame(false, $z->unbox()); $z = IBool\Module::xor_($y, $x); $this->assertInstanceOf('\\Saber\\Data\\IBool\\Type', $z); $this->assertSame(true, $z->unbox()); $z = IBool\Module::xor_($y, $y); $this->assertInstanceOf('\\Saber\\Data\\IBool\\Type', $z); $this->assertSame(false, $z->unbox()); }
/** * This method returns a value as a boxed object. A value is typically a PHP typed * primitive or object. It is considered type-safe. * * @access public * @static * @param mixed $value the value(s) to be boxed * @return IBool\Type the boxed object */ public static function make($value) : IBool\Type { if (is_string($value) && in_array(strtolower($value), array('false', 'f', 'no', 'n', '0', 'null', 'nil'))) { return IBool\Type::false(); } return $value ? IBool\Type::true() : IBool\Type::false(); }
/** * This method returns whether the second hash set is a superset of the first hash set. * * @access public * @static * @param IHashSet\Type $xs the first hash set * @param IHashSet\Type $ys the second hash set * @return IBool\Type whether the second hash set is a * superset of the first hash set */ public static function isSuperset(IHashSet\Type $xs, IHashSet\Type $ys) : IBool\Type { $xi = IHashSet\Module::iterator($xs); foreach ($xi as $x) { if (!$ys->__hasItem($x)) { return IBool\Type::false(); } } return IBool\Type::true(); }
/** * This method returns an array list containing only unique items from the specified * array list (i.e. duplicates are removed). * * @access public * @static * @param IArrayList\Type $xs the array list to be processed * @return IArrayList\Type an array list with the duplicates * removed */ public static function nub(IArrayList\Type $xs) : IArrayList\Type { $zs = IHashSet\Type::empty_(); return IArrayList\Module::filter($xs, function (Core\Type $x, IInt32\Type $i) use($zs) : IBool\Type { if ($zs->__hasItem($x)) { return IBool\Type::false(); } $zs->putItem($x); return IBool\Type::true(); }); }
/** * This method tests the "singletons" methods. */ public function test_singletons() { $p0 = IBool\Type::true(); $e0 = IBool\Type::true(); $this->assertInstanceOf('\\Saber\\Data\\IBool\\Type', $p0); $this->assertSame($e0->__hashCode(), $p0->__hashCode()); $p1 = $p0->unbox(); $e1 = true; $this->assertInternalType('boolean', $p1); $this->assertSame($e1, $p1); $p2 = IBool\Type::false(); $e2 = IBool\Type::false(); $this->assertInstanceOf('\\Saber\\Data\\IBool\\Type', $p2); $this->assertSame($e2->__hashCode(), $p2->__hashCode()); $p3 = $p2->unbox(); $e3 = false; $this->assertInternalType('boolean', $p3); $this->assertSame($e3, $p3); }
/** * This method evaluates whether the left operand is identical to the right operand. * * @access public * @static * @param ILinkedList\Type $xs the left operand * @param Core\Type $ys the right operand * @return IBool\Type whether the left operand is identical * to the right operand */ public static function id(ILinkedList\Type $xs, Core\Type $ys) : IBool\Type { // === if ($ys !== null && $xs->__typeOf() == $ys->typeOf()) { for ($as = $xs, $bs = $ys; !$as->__isEmpty() && !$bs->__isEmpty(); $as = $as->tail(), $bs = $bs->tail()) { $r = $as->head()->id($bs->head()); if (!$r->unbox()) { return $r; } } $x_length = $xs->__length(); $y_length = $ys->__length(); if ($x_length == $y_length) { return IBool\Type::true(); } } return IBool\Type::false(); }