'linebreak_after_opening_tag' => true,
'array_syntax' => ['syntax' => 'short'],
'declare_strict_types' => true,
+ 'phpdoc_align' => true,
])
->setFinder($finder);
\ No newline at end of file
/**
* @param string $key
- * @param mixed $value
+ * @param mixed $value
*
* @return self
*/
/**
* reduce :: (b -> a -> b) -> b -> b
*
- * @param callable $function Binary function ($accumulator, $value)
- * @param mixed $accumulator Value to witch reduce
+ * @param callable $function Binary function ($accumulator, $value)
+ * @param mixed $accumulator Value to witch reduce
*
- * @return mixed Same type as $accumulator
+ * @return mixed Same type as $accumulator
*/
public function reduce(callable $function, $accumulator);
}
*
* @param callable $f (a -> f b)
*
- * @return Applicative f (t b)
+ * @return Applicative f (t b)
*/
public function traverse(callable $f);
}
/**
* applicator :: a -> (a -> b) -> b
*
- * @param mixed $x
+ * @param mixed $x
* @param callable $f
*
* @return mixed
* invoke :: a -> #{a: (_ -> b)} -> b
*
* @param string $method
- * @param mixed $object
+ * @param mixed $object
*
* @return mixed
*/
/**
* Curry function
*
- * @param int $numberOfArguments
+ * @param int $numberOfArguments
* @param callable $function
- * @param array $args
+ * @param array $args
*
* @return callable
*/
* Curry function
*
* @param callable $function
- * @param array $args
+ * @param array $args
*
* @return callable
*/
* Call $function with $value and return $value
*
* @param callable $function
- * @param mixed $value
+ * @param mixed $value
*
* @return \Closure
*/
* @return mixed|\Closure
*
* @param callable $transformation
- * @param Functor $value
+ * @param Functor $value
*/
function map(callable $transformation = null, Functor $value = null)
{
* @return mixed|\Closure
*
* @param callable $function
- * @param Monad $value
+ * @param Monad $value
*/
function bind(callable $function = null, Monad $value = null)
{
/**
* reduce :: Foldable t => (b -> a -> b) -> b -> t a -> b
*
- * @param callable $callable Binary function ($accumulator, $value)
- * @param mixed $accumulator
+ * @param callable $callable Binary function ($accumulator, $value)
+ * @param mixed $accumulator
* @param Foldable $foldable
*
* @return mixed
* Foldr is expresed by foldl (reduce) so it loose some properties.
* For more reading please read this article https://wiki.haskell.org/Foldl_as_foldr
*
- * @param callable $callable Binary function ($value, $accumulator)
- * @param mixed $accumulator
+ * @param callable $callable Binary function ($value, $accumulator)
+ * @param mixed $accumulator
* @param Foldable $foldable
*
* @return mixed
* @param callable $a
* @param callable $b,...
*
- * @return \Closure func($mValue) : mixed
+ * @return \Closure func($mValue) : mixed
*/
function mpipeline(callable $a, callable $b)
{
* @param callable $a
* @param callable $b,...
*
- * @return \Closure func($mValue) : mixed
+ * @return \Closure func($mValue) : mixed
*/
function mcompose(callable $a, callable $b)
{
* liftM2 (+) (Just 1) Nothing = Nothing
*
* @param callable $transformation
- * @param Monad $ma
- * @param Monad $mb
+ * @param Monad $ma
+ * @param Monad $mb
*
* @return Monad|\Closure
*/
/**
* liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
*
- * @param callable $transformation
+ * @param callable $transformation
* @param Applicative $fa
* @param Applicative $fb
*
*
* Map each element of a structure to an action, evaluate these actions from left to right, and collect the results
*
- * @param callable $transformation (a -> f b)
- * @param Traversable $t t a
+ * @param callable $transformation (a -> f b)
+ * @param Traversable $t t a
*
- * @return Applicative f (t b)
+ * @return Applicative f (t b)
*/
function traverse(callable $transformation, Traversable $t = null)
{
* foldr :: (a -> b -> b) -> b -> t a -> b
* liftA2 :: (a -> b -> c) -> f a -> f b -> f c
*```
- * @param callable $f (a -> m Bool)
+ * @param callable $f (a -> m Bool)
* @param Foldable $xs [a]
*
* @return Monad m [a]
* foldr :: (a -> b -> b) -> b -> t a -> b
* ```
*
- * @param callable $f (a -> b -> m a)
- * @param null $z0
+ * @param callable $f (a -> b -> m a)
+ * @param null $z0
* @param Foldable $xs [b]
*
* @return mixed m a
* ```haskell
* iterate f x == [x, f x, f (f x), ...]
* ```
- * @param callable $fn
- * @param mixed $a
+ * @param callable $fn
+ * @param mixed $a
* @return Listt
*/
function iterate(callable $fn, $a = null)
* replicate n x is a list of length n with x the value of every element.
* It is an instance of the more general genericReplicate, in which n may be of any integral type.
*
- * @param int $n
- * @param mixed $a
+ * @param int $n
+ * @param mixed $a
* @return Listt
*/
function replicate(int $n, $a = null): Listt
*
* cycle ties a finite list into a circular one, or equivalently, the infinite repetition of the original list. It is the identity on infinite lists.
*
- * @param Listt $xs
+ * @param Listt $xs
* @return Listt
* @throws EmptyListError
*/
*
* Adapt any native PHP value that is iterable into Listt.
*
- * @param iterable $i
+ * @param iterable $i
* @return Listt
*/
function fromIterable(iterable $i): Listt
* Utility function. Must not be used directly.
* Use fromValue() or fromIterable()
*
- * @param SnapshotIterator $i
+ * @param SnapshotIterator $i
* @return Listt
*/
function fromSnapshotIterator(SnapshotIterator $i): Listt
*
* Create list containing only one value.
*
- * @param mixed $value
+ * @param mixed $value
* @return Listt
*/
function fromValue($value): Listt
/**
* prepend :: a -> [a] -> [a]
*
- * @param mixed $x
- * @param Listt $xs
+ * @param mixed $x
+ * @param Listt $xs
* @return Listt
*/
function prepend($x, Listt $xs = null)
*
* If the first list is not finite, the result is the first list.
*
- * @param Listt $a
- * @param Listt|null $b
+ * @param Listt $a
+ * @param Listt|null $b
* @return Listt|callable
*/
function append(Listt $a, Listt $b = null)
*
* Extract the first element of a list, which must be non-empty.
*
- * @param Listt $l
+ * @param Listt $l
* @return mixed
* @throws \Widmogrod\Primitive\EmptyListError
*/
*
* Extract the elements after the head of a list, which must be non-empty.
*
- * @param Listt $l
+ * @param Listt $l
* @return Listt
* @throws \Widmogrod\Primitive\EmptyListError
*/
* The default implementation is optimized for structures that are similar to cons-lists,
* because there is no general way to do better.
*
- * @param Foldable $t
+ * @param Foldable $t
* @return int
*/
function length(Foldable $t): int
* @param callable $a
* @param callable $b,...
*
- * @return \Closure func($value) : mixed
+ * @return \Closure func($value) : mixed
*/
function compose(callable $a, callable $b)
{
* @param callable $a
* @param callable $b,...
*
- * @return \Closure func($value) : mixed
+ * @return \Closure func($value) : mixed
*/
function pipeline(callable $a, callable $b)
{
/**
* orr :: (a -> Bool) -> (a -> Bool) -> a -> Bool
*
- * @param callable $predicateA
+ * @param callable $predicateA
* @param callable|null $predicateB
- * @param mixed $value
+ * @param mixed $value
*
* @return mixed
*/
*
* take n, applied to a list xs, returns the prefix of xs of length n, or xs itself if n > length xs:
*
- * @param int $n
- * @param Listt $xs
+ * @param int $n
+ * @param Listt $xs
* @return Listt
*/
function take(int $n, Listt $xs = null)
* drop :: Int -> [a] -> [a]
*
* drop n xs returns the suffix of xs after the first n elements, or [] if n > length xs:
- * @param int $n
- * @param Listt $xs
+ * @param int $n
+ * @param Listt $xs
* @return Listt
*/
function drop(int $n, Listt $xs = null)
* zip takes two lists and returns a list of corresponding pairs. If one input list is short, excess elements of the longer list are discarded.
* zip is right-lazy:
*
- * @param Listt $xs
- * @param Listt|null $ys
+ * @param Listt $xs
+ * @param Listt|null $ys
* @return Listt
*/
function zip(Listt $xs, Listt $ys = null)
*
* unzip transforms a list of pairs into a list of first components and a list of second components.
*
- * @param Listt $xs
+ * @param Listt $xs
* @return array
*/
function unzip(Listt $xs): array
/**
* Generic test to verify if a type obey the applicative laws.
*
- * @param callable $assertEqual Asserting function (Applicative $a1, Applicative $a2, $message)
- * @param callable $pure Applicative "constructor"
- * @param Applicative $u Applicative f => f (a -> b)
- * @param Applicative $v Applicative f => f (a -> b)
- * @param Applicative $w Applicative f => f (a -> b)
- * @param callable $f (a -> b)
- * @param mixed $x Value to put into a applicative
+ * @param callable $assertEqual Asserting function (Applicative $a1, Applicative $a2, $message)
+ * @param callable $pure Applicative "constructor"
+ * @param Applicative $u Applicative f => f (a -> b)
+ * @param Applicative $v Applicative f => f (a -> b)
+ * @param Applicative $w Applicative f => f (a -> b)
+ * @param callable $f (a -> b)
+ * @param mixed $x Value to put into a applicative
*/
public static function test(
callable $assertEqual,
* Generic test to verify if a type obey the functor laws.
*
* @param callable $assertEqual Asserting function (Functor $f1, Functor $f2, $message)
- * @param callable $f (a -> b)
- * @param callable $g (a -> b)
- * @param Functor $x f a
+ * @param callable $f (a -> b)
+ * @param callable $g (a -> b)
+ * @param Functor $x f a
*/
public static function test(
callable $assertEqual,
* Generic test to verify if a type obey the monad laws.
*
* @param callable $assertEqual Asserting function (Monad $m1, Monad $m2, $message)
- * @param callable $return Monad "constructor"
- * @param callable $f Monadic function
- * @param callable $g Monadic function
- * @param mixed $x Value to put into a monad
+ * @param callable $return Monad "constructor"
+ * @param callable $f Monadic function
+ * @param callable $g Monadic function
+ * @param mixed $x Value to put into a monad
*/
public static function test(
callable $assertEqual,
* Generic test to verify if a type obey the monodic laws.
*
* @param callable $assertEqual Asserting function (Monoid $m1, Monoid $m2, $message)
- * @param Monoid $x
- * @param Monoid $y
- * @param Monoid $z
+ * @param Monoid $x
+ * @param Monoid $y
+ * @param Monoid $z
*/
public static function test(
callable $assertEqual,
{
/**
* @param callable $assertEqual
- * @param Setoid $a
- * @param Setoid $b
- * @param Setoid $c
+ * @param Setoid $a
+ * @param Setoid $b
+ * @param Setoid $c
*/
public static function test(
callable $assertEqual,
/**
* Depending on if is Left or is Right then it apply corresponding function
*
- * @param callable $left (a -> b)
+ * @param callable $left (a -> b)
* @param callable $right (c -> b)
*
- * @return mixed b
+ * @return mixed b
*/
public function either(callable $left, callable $right);
}
*
* either :: (a -> c) -> (b -> c) -> Either a b -> c
*
- * @param callable $left (a -> c)
- * @param callable $right (b -> c)
- * @param Either $either Either a b
+ * @param callable $left (a -> c)
+ * @param callable $right (b -> c)
+ * @param Either $either Either a b
*
- * @return mixed c
+ * @return mixed c
*/
function either(callable $left, callable $right = null, Either $either = null)
{
*
* @param callable $left
* @param callable $right
- * @param Either $either
+ * @param Either $either
*
* @return Left|Right
*/
*
* tryCatch :: Exception e => (a -> b) -> (e -> c) -> a -> Either c b
*
- * @param callable $function (a -> b)
+ * @param callable $function (a -> b)
* @param callable $catchFunction (e -> c)
- * @param mixed $value a
+ * @param mixed $value a
*
* @return Either|\Closure
*/
* foldFree f (Free as) = f as >>= foldFree f
* ```
*
- * @param callable $f (f x -> m x)
+ * @param callable $f (f x -> m x)
* @param callable $return
*
* @return FantasyLand\Monad
* foldFree f (Free as) = f as >>= foldFree f
* ```
*
- * @param callable $interpreter (f x => m x)
+ * @param callable $interpreter (f x => m x)
* @param MonadFree $free
- * @param callable $return
+ * @param callable $return
*
* @return Monad|callable
*/
/**
* tryCatch :: Exception e => IO a -> (e -> IO a) -> IO a
*
- * @param M\IO $io
+ * @param M\IO $io
* @param callable $catchFunction
*
* @return M\IO
* until :: (a -> Bool) -> (a -> b -> b) -> b -> IO a -> IO b
*
* @param callable $predicate (a -> Bool)
- * @param callable $do (a -> b -> a)
- * @param mixed $base b
- * @param M\IO $ioValue IO a
+ * @param callable $do (a -> b -> a)
+ * @param mixed $base b
+ * @param M\IO $ioValue IO a
*
* @return M\IO
*/
/**
* maybe :: b -> (a -> b) -> Maybe a -> b
*
- * @param null $default
+ * @param null $default
* @param callable $fn
- * @param Maybe $maybe
+ * @param Maybe $maybe
*
* @return mixed|\Closure
*/
* Unwrap a reader monad computation as a function.
*
* @param M\Reader $reader
- * @param mixed $env
+ * @param mixed $env
*
* @return mixed
*/
* Unwrap a state monad computation as a function.
*
* @param M\State $state
- * @param mixed $initialState
+ * @param mixed $initialState
*
* @return mixed
*/
* Evaluate a state computation with the given initial state and return the final value, discarding the final state.
*
* @param M\State $state
- * @param mixed $initialState
+ * @param mixed $initialState
*
* @return mixed
*/
* Evaluate a state computation with the given initial state and return the final state, discarding the final value.
*
* @param M\State $state
- * @param mixed $initialState
+ * @param mixed $initialState
*
* @return mixed
*/
{
/**
* should be used with conjuction
- * @param callable $fn
+ * @param callable $fn
* @return mixed
*/
public function patternMatched(callable $fn);
/**
* match :: #{ Pattern -> (a -> b)} -> a -> b
*
- * @param array $patterns
- * @param mixed $value
+ * @param array $patterns
+ * @param mixed $value
* @throws PatternNotMatchedError
*
* @return mixed
projects / php-functional.git / commitdiff
