FM / core

/home/vianto5/.trash/cititower.mx/wp-content/plugins/otgs-installer-plugin/fp/core/

/home/vianto5/.trash/cititower.mx/wp-content/plugins/otgs-installer-plugin/fp/core

Name	Size	Mode	Actions
Functor/	-	0755	rm
traits/	-	0755	rm
Cast.php	497	0644	edit dl rm
Debug.php	1427	0644	edit dl rm
Either.php	5456	0644	edit dl rm
Filter.php	1018	0644	edit dl rm
Fns.php	15586	0644	edit dl rm
FP.php	1882	0644	edit dl rm
functions.php	6474	0644	edit dl rm
Invoker.php	610	0644	edit dl rm
Json.php	792	0644	edit dl rm
Logic.php	5164	0644	edit dl rm
Lst.php	11655	0644	edit dl rm
Math.php	733	0644	edit dl rm
Maybe.php	4621	0644	edit dl rm
Obj.php	14164	0644	edit dl rm
Promise.php	1502	0644	edit dl rm
Relation.php	1840	0644	edit dl rm
Strings.php	3865	0644	edit dl rm
strings_functions.php	1177	0644	edit dl rm
system.php	1696	0644	edit dl rm
SystemClass.php	246	0644	edit dl rm
Undefined.php	232	0644	edit dl rm
Validator.php	1004	0644	edit dl rm
Wrapper.php	941	0644	edit dl rm

Edit: /home/vianto5/.trash/cititower.mx/wp-content/plugins/otgs-installer-plugin/fp/core/Maybe.php (4621B)

<?php

namespace WPML\INSTALLER\FP;

use WPML\Collect\Support\Traits\Macroable;
use WPML\INSTALLER\FP\Functor\Functor;
use WPML\INSTALLER\FP\Functor\Pointed;

/**
 * Class Maybe
 * @package WPML\INSTALLER\FP
 * @method static callable|Just|Nothing fromNullable( ...$value ) - Curried :: a → Nothing | Just a
 *
 * if $value is null or false it returns a Nothing otherwise returns a Just containing the value
 *
 * @method static callable safe( ...$fn ) - Curried :: ( a → b ) → ( a → Maybe b )
 *
 * returns a function that when called will run the passed in function and put the result into a Maybe
 *
 * @method static callable safeAfter( ...$predicate, ...$fn ) - Curried :: ( b → bool ) → ( a → b ) → ( a → Maybe b )
 *
 * returns a function that when called will run the passed in function and pass the result of the function
 * to the predicate. If the predicate returns true the result will be a Just containing the result of the function.
 * Otherwise it returns a Nothing if the predicate returns false.
 *
 * @method static callable safeBefore( ...$predicate, ...$fn ) - Curried :: ( a → bool ) → ( a → b ) → ( a → Maybe b )
 *
 * returns a function that when called will pass the given value to the predicate.
 * If the predicate returns true the value will be lifted into a Just instance and
 * the passed in function will then be mapped.
 * Otherwise it returns a Nothing if the predicate returns false.
 *
 * @method static callable|Just just( ...$value ) - Curried :: a → Just a
 *
 * returns a Just containing the value.
 *
 * @method static callable|Just of( ...$value ) - Curried :: a → Just a
 *
 * returns a Just containing the value.
 *
 */
class Maybe {

use Macroable;

/**
	 * @return void
	 */
	public static function init() {
		self::macro( 'just', Just::of() );

self::macro( 'of', Just::of() );

self::macro( 'fromNullable', curryN( 1, function ( $value ) {
			return is_null( $value ) || $value === false ? self::nothing() : self::just( $value );
		} ) );

Maybe::macro( 'safe', curryN( 1, function ( $fn ) {
			return pipe( $fn, self::fromNullable() );
		} ) );

Maybe::macro( 'safeAfter', curryN( 2, function ( $predicate, $fn ) {
			return pipe( $fn, Logic::ifElse( $predicate, self::just(), [ self::class, 'nothing' ] ) );
		} ) );

Maybe::macro( 'safeBefore', curryN( 2, function ( $predicate, $fn ) {
			return pipe( Logic::ifElse( $predicate, self::just(), [ self::class, 'nothing' ] ), Fns::map( $fn ) );
		} ) );

}

/**
	 * @return Nothing
	 */
	public static function nothing() {
		return new Nothing();
	}

/**
	 * @return bool
	 */
	public function isNothing() {
		return false;
	}

/**
	 * @return bool
	 */
	public function isJust() {
		return false;
	}
}

class Just extends Maybe {
	use Functor;
	use Pointed;
	use Applicative;

/**
	 * @param callable $fn
	 *
	 * @return Just|Nothing
	 */
	public function map( callable $fn ) {
		return Maybe::fromNullable( $fn( $this->value ) );
	}

/**
	 * @param mixed $other
	 *
	 * @return mixed
	 */
	public function getOrElse( $other ) {
		return $this->value;
	}

/**
	 * @param callable $fn
	 *
	 * @return Just|Nothing
	 */
	public function filter( $fn = null ) {
		$fn = $fn ?: Fns::identity();

return Maybe::fromNullable( $fn( $this->value ) ? $this->value : null );
	}

/**
	 * @param callable $fn
	 *
	 * @return Just|Nothing
	 */
	public function reject( $fn = null ) {
		$fn = $fn ?: Fns::identity();

return $this->filter( Logic::complement( $fn ) );
	}

/**
	 * @param callable $fn
	 *
	 * @return mixed
	 */
	public function chain( callable $fn ) {
		return $fn( $this->value );
	}

/**
	 * @return bool
	 */
	public function isJust() {
		return true;
	}
}

class Nothing extends Maybe {
	use ConstApplicative;

/**
	 * @param callable $fn
	 *
	 * @return Nothing
	 */
	public function map( callable $fn ) {
		return $this;
	}

/**
	 * @return void
	 * @throws \Exception
	 */
	public function get() {
		throw new \Exception( "Can't extract the value of Nothing" );
	}

/**
	 * @param mixed|callable $other
	 *
	 * @return mixed
	 */
	public function getOrElse( $other ) {
		return value( $other );
	}

/**
	 * @param callable $fn
	 *
	 * @return Nothing
	 */
	public function filter( callable $fn ) {
		return $this;
	}

/**
	 * @param callable $fn
	 *
	 * @return Nothing
	 */
	public function reject( callable $fn ) {
		return $this;
	}

/**
	 * @param callable $fn
	 *
	 * @return Nothing
	 */
	public function chain( callable $fn ) {
		return $this;
	}

/**
	 * @return bool
	 */
	public function isNothing() {
		return true;
	}

}

Maybe::init();

cmd: