vector-php / vector Goto Github PK

View Code? Open in Web Editor NEW

19.0 2.0 0.0 1.16 MB

A PHP functional programming library.

License: MIT License

PHP 99.73% Shell 0.21% Dockerfile 0.06%

autoload php vector functional memoization library currying

vector's Introduction

The Elevator Pitch

Vector gives you php functional superpowers.

The evolution:
- Native PHP
```
  array_sum(
      array_map(
          fn($a) => $a + 1,
          [1, 2, 3]
      )
  );
  // 9
```
  - 👎 More than 1 or 2 function chains is unmaintainable
- Laravel Collections
```
  collect([1, 2, 3])
      ->map(fn($a) => $a + 1)
      ->sum();
      // 9
```
  - 👍 More than 1 or 2 function chains is unmaintainable
  - 👎 Unfortunately you can't do this with every type in the same elegant way (only works with collections)
- Vector
```
   vector([1, 2, 3])
       ->pipe(Arrays::map(Math::add(1))) // or `fn($a) => $a + 1)` 
       ->pipe(Math::sum())();
       // [2, 3, 4]
```
  - 👍 Works super similarly to collections, but just accepts & returns normal arrays (no ->toArray()-ing necessary)
  - 👍 Works super similarly to collections for everything else too!
  - 👎 Unfortunately it is an extra dependency (we don't have the native pipe operator yet https://wiki.php.net/rfc/pipe-operator-v2)
You can add currying to any function, it isn't only limited to Vector built ins.
- Module::curry('explode')(',')('a,b,c')(PHP_INT_MAX) // ['a', 'b', 'c']

PHP Version Support

8.0+

Install

composer require vector/core

Show Me Some More Code

More automatic currying.

$addOne = Arrays::map(Math::add(1));
$addOne([1, 2, 3]); // [2, 3, 4]

First class composition (Functional Pipelines).

$addSix = Lambda::compose(Math::add(4), Math::add(2)); // (Or ::pipe for the opposite flow direction)
$addSix(4); // 10;

Pattern Matching (Maybe & Result monads included).

Pattern::match([
    fn(Just $value) => fn ($unwrapped) => $unwrapped,
    fn(Nothing $value) => 'nothing',
])(Maybe::just('just')); // 'just'

Granular control flow (without try/catch).

$errorHandler = function (Err $err) {
    return Pattern::match([
        function (QueryException $exception) {
            Log::info($exception);
            return response(404);
        },
        function (DBException $exception) {
            Log::error($exception);
            return response(500);
        },
    ]);
};

return Pattern::match([
    fn(Ok $value) => fn (User $user) => $user,
    $errorHandler
])(Result::from(fn() => User::findOrFail(1)));

Make your own modules with auto-curried methods

use Vector\Core\Curry;
use Vector\Core\Module;

class MyModule
{
    use Module;
    
    #[Curry]
    protected static function myCurriedFunction($a, $b)
    {
        return $a + $b;
    }
}

vector's People

Contributors

Stargazers

Watchers

vector's Issues

ArrayList \ DropLast

dropLast :: Int -> [a] -> [a]
Returns the given list sans the last n elements

ArrayList \ Zip

zip :: [a] -> [b] -> [[a, b]]
Zip two lists together into a 2-d array pairwise

ArrayList \ Flatten

flatten :: [a] -> [b]
Flattens nested arrays

ArrayList \ All

all :: (a -> Bool) -> [a] -> Bool
Returns true if every element of [a] passes the given test.

ArrayList \ FoldR

foldr :: (a -> b -> b) -> b -> t a -> b
Reduce right

Missing Documentation \ Module

The module lacks documentation. Things that should be covered in the docs:

How Module works
How to create your own module

Apply from Control\Applicative should work with arrays.

Right now it only works with Applicative Functors interface-ing classes.
It should be overridden similar to Control\Functor::fmap to work with arrays, since [] is technically applicative.

Object \ Call

call :: String -> Object -> a
Call the method String on the given Object and return its result

Update Documenation \ Functional Basics

A few things have changed since the functional basics page was written - go back through and update terminology, method names, and module names.

ArrayList \ DropWhile

dropWhile :: (a -> Bool) -> [a] -> [a]
Returns the list sans the first elements that pass the given test

ArrayList \ FoldL

foldl :: (b -> a -> b) -> b -> [a] -> b
Reduce left

Math \ Range

range :: Int -> Int -> [Int]
Returns all integers between the given arguments, inclusive

ArrayList \ FindIndex

findIndex :: (a -> Bool) -> [a] -> Maybe Int
Attempts to find an element's index by using a given test

ArrayList \ TakeLast

takeLast :: Int -> [a] -> [a]
Take n items from a list starting at the back

ArrayList \ Contains

contains :: a -> [a] -> Bool
Returns true if [a] contains a

ArrayList \ Adjust

adjust :: (a -> a) -> Int -> [a] -> [a]
Applies a function to the value at a given index.

Math \ Negate

negate :: Num -> Num
Returns the given number * -1

Monad \ Sequence

sequence :: Monad m => [m a] -> m [a]
Convert a list of monad into a monad of list

Math \ Max

max :: Num -> Num -> Num
Returns the maximum of its two arguments

Math \ Min

min :: Num -> Num -> Num
Returns the minimum of its two arguments

ArrayList \ TakeWhile

takeWhile :: (a -> Bool) -> [a] -> [a]
Take items from a list while a given test passes

ArrayList \ Unique

unique :: [a] -> [a]
Return an array with duplicates removed

ArrayList \ Any

any :: (a -> Bool) -> [a] -> Bool
Returns true if any element of [a] passes the given test

Math \ Product

product :: [Num] -> Num
Returns the product of the given list

Strings \ Trim

trim :: String -> String
Returns a string with leading and trailing whitespace removed

ArrayList \ IndexOf

indexOf :: a -> [a] -> Maybe Int
Finds the index of the given element

ArrayList \ Drop

drop :: Int -> [a] -> [a]
Returns the given list sans the first n elements

ArrayList \ Repeat

repeat :: a -> Int -> [a]
Repeat the given item n times

Memoize 'using' on module import.

This is low hanging fruit for optimization. When calling Module::using() in multiple places and requesting the same function, memoize and store the result of the internal reflection call so that a single reflection is never duplicated.