bit-badger/inspired-by-fsharp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 6 Wiki Activity

Change functions to properties

Browse Source 
- Force PHP 8.4
This commit is contained in:
Daniel J. Summers
2024-09-30 22:59:46 -04:00
parent 6779b2c554
commit 483d7875d5
6 changed files with 126 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files

64
tests/OptionTest.php
View File

@@ -20,43 +20,43 @@ use PHPUnit\Framework\TestCase;
*/
class OptionTest extends TestCase
{
#[TestDox('Get succeeds for Some')]
public function testGetSucceedsForSome(): void
#[TestDox('Value succeeds for Some')]
public function testValueSucceedsForSome(): void
{
$it = Option::Some(9);
$this->assertTrue($it->isSome(), 'The option should have been "Some"');
$this->assertEquals(9, $it->get(), 'The value was incorrect');
$this->assertTrue($it->isSome, 'The option should have been "Some"');
$this->assertEquals(9, $it->value, 'The value was incorrect');
}
#[TestDox('Get fails for None')]
public function testGetFailsForNone(): void
#[TestDox('Value fails for None')]
public function testValueFailsForNone(): void
{
$this->expectException(InvalidArgumentException::class);
Option::None()->get();
Option::None()->value;
}
#[TestDox('IsNone succeeds with None')]
public function testIsNoneSucceedsWithNone(): void
{
$this->assertTrue(Option::None()->isNone(), '"None" should return true');
$this->assertTrue(Option::None()->isNone, '"None" should return true');
}
#[TestDox('IsNone succeeds with Some')]
public function testIsNoneSucceedsWithSome(): void
{
$this->assertFalse(Option::Some(8)->isNone(), '"Some" should return false');
$this->assertFalse(Option::Some(8)->isNone, '"Some" should return false');
}
#[TestDox('IsSome succeeds with None')]
public function testIsSomeSucceedsWithNone(): void
{
$this->assertFalse(Option::None()->isSome(), '"None" should return false');
$this->assertFalse(Option::None()->isSome, '"None" should return false');
}
#[TestDox('IsSome succeeds with Some')]
public function testIsSomeSucceedsWithSome(): void
{
$this->assertTrue(Option::Some('boo')->isSome(), '"Some" should return true');
$this->assertTrue(Option::Some('boo')->isSome, '"Some" should return true');
}
#[TestDox('GetOrDefault succeeds with None')]
@@ -105,7 +105,7 @@ class OptionTest extends TestCase
{
$original = Option::None();
$bound = $original->bind(fn($it) => Option::Some('value'));
$this->assertTrue($bound->isNone(), 'The option should have been None');
$this->assertTrue($bound->isNone, 'The option should have been None');
$this->assertSame($original, $bound, 'The same None instance should have been returned');
}
@@ -113,15 +113,15 @@ class OptionTest extends TestCase
public function testBindSucceedsWithSomeAndSome(): void
{
$bound = Option::Some('hello')->bind(fn($it) => Option::Some('goodbye'));
$this->assertTrue($bound->isSome(), 'The option should have been Some');
$this->assertEquals('goodbye', $bound->get(), 'The bound function was not called');
$this->assertTrue($bound->isSome, 'The option should have been Some');
$this->assertEquals('goodbye', $bound->value, 'The bound function was not called');
}
#[TestDox('Bind succeeds with Some and None')]
public function testBindSucceedsWithSomeAndNone(): void
{
$bound = Option::Some('greetings')->bind(fn($it) => Option::None());
$this->assertTrue($bound->isNone(), 'The option should have been None');
$this->assertTrue($bound->isNone, 'The option should have been None');
}
#[TestDox('Contains succeeds with None')]
@@ -182,7 +182,7 @@ class OptionTest extends TestCase
$tattle->called = true;
return 'hello';
});
$this->assertTrue($mapped->isNone(), 'The mapped option should be "None"');
$this->assertTrue($mapped->isNone, 'The mapped option should be "None"');
$this->assertFalse($tattle->called, 'The mapping function should not have been called');
$this->assertSame($none, $mapped, 'The same "None" instance should have been returned');
}
@@ -191,8 +191,8 @@ class OptionTest extends TestCase
public function testMapSucceedsWithSome(): void
{
$mapped = Option::Some('abc ')->map(fn($it) => str_repeat($it, 2));
$this->assertTrue($mapped->isSome(), 'The mapped option should be "Some"');
$this->assertEquals('abc abc ', $mapped->get(), 'The mapping function was not called correctly');
$this->assertTrue($mapped->isSome, 'The mapped option should be "Some"');
$this->assertEquals('abc abc ', $mapped->value, 'The mapping function was not called correctly');
}
#[TestDox('Map fails with Some when mapping is null')]
@@ -228,7 +228,7 @@ class OptionTest extends TestCase
$tattle->called = true;
return true;
});
$this->assertTrue($filtered->isNone(), 'The filtered option should have been "None"');
$this->assertTrue($filtered->isNone, 'The filtered option should have been "None"');
$this->assertFalse($tattle->called, 'The callable should not have been called');
$this->assertSame($none, $filtered, 'The "None" instance returned should have been the one passed');
}
@@ -238,8 +238,8 @@ class OptionTest extends TestCase
{
$some = Option::Some(12);
$filtered = $some->filter(fn($it) => $it % 2 === 0);
$this->assertTrue($filtered->isSome(), 'The filtered option should have been "Some"');
$this->assertEquals(12, $filtered->get(), 'The filtered option value is incorrect');
$this->assertTrue($filtered->isSome, 'The filtered option should have been "Some"');
$this->assertEquals(12, $filtered->value, 'The filtered option value is incorrect');
$this->assertSame($some, $filtered, 'The same "Some" instance should have been returned');
}
@@ -248,7 +248,7 @@ class OptionTest extends TestCase
{
$some = Option::Some(23);
$filtered = $some->filter(fn($it) => $it % 2 === 0);
$this->assertTrue($filtered->isNone(), 'The filtered option should have been "None"');
$this->assertTrue($filtered->isNone, 'The filtered option should have been "None"');
}
#[TestDox('Unwrap succeeds with None')]
@@ -269,7 +269,7 @@ class OptionTest extends TestCase
$value = '';
$original = Option::Some('testing');
$tapped = $original->tap(
function (Option $it) use (&$value) { $value = $it->isSome() ? $it->get() : 'none'; });
function (Option $it) use (&$value) { $value = $it->isSome ? $it->value : 'none'; });
$this->assertEquals('testing', $value, 'The tapped function was not called');
$this->assertSame($original, $tapped, 'The same option should have been returned');
}
@@ -280,7 +280,7 @@ class OptionTest extends TestCase
$value = '';
$original = Option::None();
$tapped = $original->tap(
function (Option $it) use (&$value) { $value = $it->isSome() ? $it->get() : 'none'; });
function (Option $it) use (&$value) { $value = $it->isSome ? $it->value : 'none'; });
$this->assertEquals('none', $value, 'The tapped function was not called');
$this->assertSame($original, $tapped, 'The same option should have been returned');
}
@@ -323,7 +323,7 @@ class OptionTest extends TestCase
public function testSomeSucceedsWithValue(): void
{
$it = Option::Some('hello');
$this->assertTrue($it->isSome(), 'The option should have been "Some"');
$this->assertTrue($it->isSome, 'The option should have been "Some"');
}
public function testSomeFailsWithNull(): void
@@ -335,34 +335,34 @@ class OptionTest extends TestCase
public function testNoneSucceeds(): void
{
$it = Option::None();
$this->assertTrue($it->isNone(), 'The option should have been "None"');
$this->assertTrue($it->isNone, 'The option should have been "None"');
}
public function testOfSucceedsWithNull(): void
{
$it = Option::of(null);
$this->assertTrue($it->isNone(), '"null" should have created a "None" option');
$this->assertTrue($it->isNone, '"null" should have created a "None" option');
}
public function testOfSucceedsWithNonNull(): void
{
$it = Option::of('test');
$this->assertTrue($it->isSome(), 'A non-null value should have created a "Some" option');
$this->assertEquals('test', $it->get(), 'The value was not assigned correctly');
$this->assertTrue($it->isSome, 'A non-null value should have created a "Some" option');
$this->assertEquals('test', $it->value, 'The value was not assigned correctly');
}
#[TestDox('Of succeeds with PhpOption\Some')]
public function testOfSucceedsWithPhpOptionSome(): void
{
$it = Option::of(Some::create('something'));
$this->assertTrue($it->isSome(), 'A "Some" PhpOption should have created a "Some" option');
$this->assertEquals('something', $it->get(), 'The value was not assigned correctly');
$this->assertTrue($it->isSome, 'A "Some" PhpOption should have created a "Some" option');
$this->assertEquals('something', $it->value, 'The value was not assigned correctly');
}
#[TestDox('Of succeeds with PhpOption\None')]
public function testOfSucceedsWithPhpOptionNone(): void
{
$it = Option::of(None::create());
$this->assertTrue($it->isNone(), 'A "None" PhpOption should have created a "None" option');
$this->assertTrue($it->isNone, 'A "None" PhpOption should have created a "None" option');
}
}

72
tests/ResultTest.php
View File

@@ -18,76 +18,76 @@ use PHPUnit\Framework\TestCase;
*/
class ResultTest extends TestCase
{
#[TestDox('GetOK succeeds for OK result')]
public function testGetOKSucceedsForOKResult(): void
#[TestDox('OK property succeeds for OK result')]
public function testOKPropertySucceedsForOKResult(): void
{
$result = Result::OK('yay');
$this->assertEquals('yay', $result->getOK(), 'The OK result should have been returned');
$this->assertEquals('yay', $result->ok, 'The OK result should have been returned');
}
#[TestDox('GetOK fails for Error result')]
public function testGetOKFailsForErrorResult(): void
#[TestDox('OK property fails for Error result')]
public function testOKPropertyFailsForErrorResult(): void
{
$this->expectException(InvalidArgumentException::class);
Result::Error('whoops')->getOK();
Result::Error('whoops')->ok;
}
#[TestDox('GetError succeeds for Error result')]
public function testGetErrorSucceedsForErrorResult(): void
#[TestDox('Error property succeeds for Error result')]
public function testErrorPropertySucceedsForErrorResult(): void
{
$result = Result::Error('boo');
$this->assertEquals('boo', $result->getError(), 'The Error result should have been returned');
$this->assertEquals('boo', $result->error, 'The Error result should have been returned');
}
#[TestDox('GetError fails for OK result')]
public function testGetErrorFailsForOKResult(): void
#[TestDox('Error property fails for OK result')]
public function testErrorPropertyFailsForOKResult(): void
{
$this->expectException(InvalidArgumentException::class);
Result::OK('yeah')->getError();
Result::OK('yeah')->error;
}
#[TestDox('IsOK succeeds for OK result')]
public function testIsOKSucceedsForOKResult(): void
{
$result = Result::OK('ok');
$this->assertTrue($result->isOK(), 'The check for "OK" should have returned true');
$this->assertTrue($result->isOK, 'The check for "OK" should have returned true');
}
#[TestDox('IsOK succeeds for Error result')]
public function testIsOKSucceedsForErrorResult(): void
{
$result = Result::Error('error');
$this->assertFalse($result->isOK(), 'The check for "OK" should have returned false');
$this->assertFalse($result->isOK, 'The check for "OK" should have returned false');
}
#[TestDox('IsError succeeds for Error result')]
public function testIsErrorSucceedsForErrorResult(): void
{
$result = Result::Error('not ok');
$this->assertTrue($result->isError(), 'The check for "Error" should have returned true');
$this->assertTrue($result->isError, 'The check for "Error" should have returned true');
}
#[TestDox('IsError succeeds for OK result')]
public function testIsErrorSucceedsForOKResult(): void
{
$result = Result::OK('fine');
$this->assertFalse($result->isError(), 'The check for "Error" should have returned false');
$this->assertFalse($result->isError, 'The check for "Error" should have returned false');
}
#[TestDox('Bind succeeds for OK with OK')]
public function testBindSucceedsForOKWithOK(): void
{
$result = Result::OK('one')->bind(fn($it) => Result::OK("$it two"));
$this->assertTrue($result->isOK(), 'The result should have been OK');
$this->assertEquals('one two', $result->getOK(), 'The bound function was not called');
$this->assertTrue($result->isOK, 'The result should have been OK');
$this->assertEquals('one two', $result->ok, 'The bound function was not called');
}
#[TestDox('Bind succeeds for OK with Error')]
public function testBindSucceedsForOKWithError(): void
{
$result = Result::OK('three')->bind(fn($it) => Result::Error('back to two'));
$this->assertTrue($result->isError(), 'The result should have been Error');
$this->assertEquals('back to two', $result->getError(), 'The bound function was not called');
$this->assertTrue($result->isError, 'The result should have been Error');
$this->assertEquals('back to two', $result->error, 'The bound function was not called');
}
#[TestDox('Bind succeeds for Error')]
@@ -95,7 +95,7 @@ class ResultTest extends TestCase
{
$original = Result::Error('oops');
$result = $original->bind(fn($it) => Result::OK('never mind - it worked!'));
$this->assertTrue($result->isError(), 'The result should have been Error');
$this->assertTrue($result->isError, 'The result should have been Error');
$this->assertSame($original, $result, 'The same Error result should have been returned');
}
@@ -153,8 +153,8 @@ class ResultTest extends TestCase
{
$ok = Result::OK('yard');
$mapped = $ok->map(fn($it) => strrev($it));
$this->assertTrue($mapped->isOK(), 'The mapped result should be "OK"');
$this->assertEquals('dray', $mapped->getOK(), 'The mapping function was not called correctly');
$this->assertTrue($mapped->isOK, 'The mapped result should be "OK"');
$this->assertEquals('dray', $mapped->ok, 'The mapping function was not called correctly');
}
#[TestDox('Map fails for OK result when mapping is null')]
@@ -174,7 +174,7 @@ class ResultTest extends TestCase
$tattle->called = true;
return 'hello';
});
$this->assertTrue($mapped->isError(), 'The mapped result should be "Error"');
$this->assertTrue($mapped->isError, 'The mapped result should be "Error"');
$this->assertFalse($tattle->called, 'The mapping function should not have been called');
$this->assertSame($error, $mapped, 'The same "Error" instance should have been returned');
}
@@ -189,7 +189,7 @@ class ResultTest extends TestCase
$tattle->called = true;
return 'hello';
});
$this->assertTrue($mapped->isOK(), 'The mapped result should be "OK"');
$this->assertTrue($mapped->isOK, 'The mapped result should be "OK"');
$this->assertFalse($tattle->called, 'The mapping function should not have been called');
$this->assertSame($ok, $mapped, 'The same "OK" instance should have been returned');
}
@@ -199,8 +199,8 @@ class ResultTest extends TestCase
{
$error = Result::Error('taco');
$mapped = $error->mapError(fn($it) => str_repeat('*', strlen($it)));
$this->assertTrue($mapped->isError(), 'The mapped result should be "Error"');
$this->assertEquals('****', $mapped->getError(), 'The mapping function was not called correctly');
$this->assertTrue($mapped->isError, 'The mapped result should be "Error"');
$this->assertEquals('****', $mapped->error, 'The mapping function was not called correctly');
}
#[TestDox('MapError fails for Error result when mapping is null')]
@@ -246,15 +246,15 @@ class ResultTest extends TestCase
public function testToOptionSucceedsForOKResult()
{
$value = Result::OK(99)->toOption();
$this->assertTrue($value->isSome(), 'An "OK" result should map to a "Some" option');
$this->assertEquals(99, $value->get(), 'The value is not correct');
$this->assertTrue($value->isSome, 'An "OK" result should map to a "Some" option');
$this->assertEquals(99, $value->value, 'The value is not correct');
}
#[TestDox('ToOption succeeds for Error result')]
public function testToOptionSucceedsForErrorResult()
{
$value = Result::Error('file not found')->toOption();
$this->assertTrue($value->isNone(), 'An "Error" result should map to a "None" option');
$this->assertTrue($value->isNone, 'An "Error" result should map to a "None" option');
}
#[TestDox('Tap succeeds for OK result')]
@@ -263,7 +263,7 @@ class ResultTest extends TestCase
$value = '';
$original = Result::OK('working');
$tapped = $original->tap(function (Result $it) use (&$value) {
$value = $it->isOK() ? 'OK: ' . $it->getOK() : 'Error: ' . $it->getError();
$value = $it->isOK ? 'OK: ' . $it->ok : 'Error: ' . $it->error;
});
$this->assertEquals('OK: working', $value, 'The tapped function was not called');
$this->assertSame($original, $tapped, 'The same result should have been returned');
@@ -275,7 +275,7 @@ class ResultTest extends TestCase
$value = '';
$original = Result::Error('failed');
$tapped = $original->tap(function (Result $it) use (&$value) {
$value = $it->isOK() ? 'OK: ' . $it->getOK() : 'Error: ' . $it->getError();
$value = $it->isOK ? 'OK: ' . $it->ok : 'Error: ' . $it->error;
});
$this->assertEquals('Error: failed', $value, 'The tapped function was not called');
$this->assertSame($original, $tapped, 'The same result should have been returned');
@@ -285,8 +285,8 @@ class ResultTest extends TestCase
public function testOKSucceedsForNonNullResult(): void
{
$result = Result::OK('something');
$this->assertTrue($result->isOK(), 'The result should have been "OK"');
$this->assertEquals('something', $result->getOK(), 'The "OK" value was incorrect');
$this->assertTrue($result->isOK, 'The result should have been "OK"');
$this->assertEquals('something', $result->ok, 'The "OK" value was incorrect');
}
#[TestDox('OK fails for null result')]
@@ -300,8 +300,8 @@ class ResultTest extends TestCase
public function testErrorSucceedsForNonNullResult(): void
{
$result = Result::Error('sad trombone');
$this->assertTrue($result->isError(), 'The result should have been "Error"');
$this->assertEquals('sad trombone', $result->getError(), 'The "Error" value was incorrect');
$this->assertTrue($result->isError, 'The result should have been "Error"');
$this->assertEquals('sad trombone', $result->error, 'The "Error" value was incorrect');
}
#[TestDox('Error fails for null result')]