loophp\fpt\FPT

Complexity

Total Complexity

20

Size/Duplication

Total Lines	160
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

20 Methods

Rating	Name	Duplication	Size	Complexity
A	compose()	0	3	1
A	reduce()	0	3	1
A	filter()	0	3	1
A	flip()	0	3	1
A	curryLeft()	0	3	1
A	partialLeft()	0	3	1
A	operator()	0	3	1
A	identity()	0	3	1
A	map()	0	3	1
A	not()	0	3	1
A	nary()	0	3	1
A	partialRight()	0	3	1
A	curryRight()	0	3	1
A	end()	0	3	1
A	fold()	0	3	1
A	arg()	0	3	1
A	current()	0	3	1
A	thunk()	0	3	1
A	uncurry()	0	3	1
A	reduction()	0	3	1

<?php

declare(strict_types=1);

namespace loophp\fpt;

use Closure;
use loophp\fpt\Contract\FPTInterface;

/**
 * @psalm-immutable
 */
final class FPT implements FPTInterface
{
    /**
     * @psalm-pure
     */
    public static function arg(): Closure
    {
        return Arg::of();
    }

    /**
     * @psalm-pure
     */
    public static function compose(): Closure
    {
        return Compose::of();
    }

    /**
     * @psalm-pure
     */
    public static function current(): Closure
    {
        return Current::of();
    }

    /**
     * @psalm-pure
     */
    public static function curryLeft(): Closure
    {
        return CurryLeft::of();
    }

    /**
     * @psalm-pure
     */
    public static function curryRight(): Closure
    {
        return CurryRight::of();
    }

    /**
     * @psalm-pure
     */
    public static function end(): Closure
    {
        return End::of();
    }

    /**
     * @psalm-pure
     */
    public static function filter(): Closure
    {
        return Filter::of();
    }

    /**
     * @psalm-pure
     */
    public static function flip(): Closure
    {
        return Flip::of();
    }

    /**
     * @psalm-pure
     */
    public static function fold(): Closure
    {
        return Fold::of();
    }

    /**
     * @psalm-pure
     */
    public static function identity(): Closure
    {
        return Identity::of();
    }

    /**
     * @psalm-pure
     */
    public static function map(): Closure
    {
        return Map::of();
    }

    /**
     * @psalm-pure
     */
    public static function nary(): Closure
    {
        return Nary::of();
    }

    /**
     * @psalm-pure
     */
    public static function not(): Closure
    {
        return Not::of();
    }

    /**
     * @psalm-pure
     */
    public static function operator(): Closure
    {
        return Operator::of();
    }

    /**
     * @psalm-pure
     */
    public static function partialLeft(): Closure
    {
        return PartialLeft::of();
    }

    /**
     * @psalm-pure
     */
    public static function partialRight(): Closure
    {
        return PartialRight::of();
    }

    /**
     * @psalm-pure
     */
    public static function reduce(): Closure
    {
        return Reduce::of();
    }

    /**
     * @psalm-pure
     */
    public static function reduction(): Closure
    {
        return Reduction::of();
    }

    /**
     * @psalm-pure
     */
    public static function thunk(): Closure
    {
        return Thunk::of();
    }

    /**
     * @psalm-pure
     */
    public static function uncurry(): Closure
    {
        return Uncurry::of();
    }
}