ACIL FM

Nama	Ukuran	Aksi
Functor	-	Open
Invoker	-	Open
monoid	-	Open
traits	-	Open
Cast.php	798 B	View DL Edit
Debug.php	1.37 MB	View DL Edit
Either.php	5.29 MB	View DL Edit
Filter.php	1008 B	View DL Edit
Fns.php	15.17 MB	View DL Edit
FP.php	1.81 MB	View DL Edit
functions.php	6.35 MB	View DL Edit
Json.php	782 B	View DL Edit
Lens.php	1.89 MB	View DL Edit
Logic.php	5.13 MB	View DL Edit
Lst.php	11.88 MB	View DL Edit
Math.php	892 B	View DL Edit
Maybe.php	4.47 MB	View DL Edit
Obj.php	15.42 MB	View DL Edit
Promise.php	1.46 MB	View DL Edit
Relation.php	1.78 MB	View DL Edit
Strings.php	5.39 MB	View DL Edit
strings_functions.php	1.1 MB	View DL Edit
system.php	1.78 MB	View DL Edit
SystemClass.php	220 B	View DL Edit
Type.php	2.98 MB	View DL Edit
Undefined.php	212 B	View DL Edit
Validator.php	974 B	View DL Edit
Wrapper.php	908 B	View DL Edit

Edit file: /home/mhhtmff/www/site/wp-content/plugins/sitepress-multilingual-cms/vendor/wpml/fp/core/Lst.php

<?php

namespace WPML\FP;

use WPML\Collect\Support\Collection;
use WPML\Collect\Support\Traits\Macroable;
use WPML\Collect\Support\Arr;

/**
 * Lst class contains functions for working on ordered arrays indexed with numerical keys
 *
 * @method static callable|array append( mixed ...$newItem, array ...$data ) - Curried :: mixed->array->array
 * @method static callable|array fromPairs( array ...$array ) - Curried :: [[a, b]] → [a => b]
 * @method static callable|array toObj( array ...$array ) - Curried :: array → object
 * @method static callable|array pluck( ...$prop, ...$array ) - Curried :: string → array → array
 * @method static callable|array partition( ...$predicate, ...$target ) - Curried :: ( a → bool ) → [a] → [[a], [a]]
 * @method static callable|array sort( ...$fn, ...$target ) - Curried :: ( ( a, a ) → int|bool ) → [a] → [a]
 * @method static callable|array unfold( ...$fn, ...$seed ) - Curried :: ( a → [b] ) → * → [b]
 * @method static callable|array zip( ...$a, ...$b ) - Curried :: [a] → [b] → [[a, b]]
 * @method static callable|array zipObj( ...$a, ...$b ) - Curried :: [a] → [b] → [a => b]
 * @method static callable|array zipWith( ...$f, ...$a, ...$b ) - Curried :: ( ( a, b ) → c ) → [a] → [b] → [c]
 * @method static callable|string join( ...$glue, ...$array ) - Curried :: string → [a] → string
 * @method static callable|string joinWithCommasAndAnd( ...$array ) - Curried :: [a] → string
 * @method static callable|array concat( ...$a, ...$b ) - Curried :: [a] → [a] → [a]
 * @method static callable|array|null find( ...$predicate, ...$array ) - Curried :: ( a → bool ) → [a] → a | null
 * @method static callable|array flattenToDepth( ...$depth, ...$array ) - Curried :: int → [[a]] → [a]
 * @method static callable|array flatten( ...$array ) - Curried :: [[a]] → [a]
 * @method static callable|bool includes( ...$val, ...$array ) - Curried :: a → [a] → bool
 * @method static callable|bool includesAll( ...$values, ...$array ) - Curried :: [a] → [a] → bool
 *
 * Determines if all the values are in the given array
 *
 * ```
 * $includes10and20 = Lst::includesAll( [ 10, 20 ] );
 *
 * $this->assertTrue( $includes10and20( [ 5, 10, 15, 20 ] ) );
 * $this->assertFalse( $includes10and20( [ 5, 15, 20 ] ) );
 * ```
 * @method static callable|bool nth( ...$n, ...$array ) - Curried :: int → [a] → a | null
 * @method static callable|bool first( ...$array ) - Curried :: [a, b] → a | null
 * @method static callable|bool last( ...$array ) - Curried :: [a, b] → b | null
 * @method static callable|int length( ...$array ) - Curried :: [a] → int
 * @method static callable|array take( ...$n, ...$array ) - Curried :: int → [a] → [a]
 * @method static callable|array takeLast( ...$n, ...$array ) - Curried :: int → [a] → [a]
 * @method static callable|array slice( ...$offset, ...$limit, ...$array ) - Curried :: int → int->[a] → [a]
 * @method static callable|array drop( ...$n, ...$array ) - Curried :: int → [a] → [a]
 * @method static callable|array dropLast( ...$n, ...$array ) - Curried :: int → [a] → [a]
 * @method static callable|array makePair( ...$a, ...$b ) - Curried :: mixed → mixed → array
 * @method static callable|array make ( ...$a ) - Curried :: mixed → array
 * @method static callable|array insert( ...$index, ...$v, ...$array ) - Curried :: int → mixed → array → array
 * @method static callable|array range( ...$from, ...$to )  - Curried :: int → int → array
 * @method static callable|array xprod( ...$a, ...$b ) - Curried :: [a]->[b]->[a, b]
 *
 * Creates a new list out of the two supplied by creating each possible pair from the lists.
 *
 * ```
 * $a              = [ 1, 2, 3 ];
 * $b              = [ 'a', 'b', 'c' ];
 * $expectedResult = [
 *   [ 1, 'a' ], [ 1, 'b' ], [ 1, 'c' ],
 *   [ 2, 'a' ], [ 2, 'b' ], [ 2, 'c' ],
 *   [ 3, 'a' ], [ 3, 'b' ], [ 3, 'c' ],
 * ];
 *
 * $this->assertEquals( $expectedResult, Lst::xprod( $a, $b ) );
 * ```
 * @method static callable|array prepend( ...$val, ...$array ) - Curried:: a → [a] → [a]
 *
 * Returns a new array with the given element at the front, followed by the contents of the list.
 *
 * @method static callable|array reverse( ...$array ) - Curried:: [a] → [a]
 *
 * Returns a new array with the elements reversed.
 *
 */
class Lst {

use Macroable;

/**
	 * @return void
	 */
	public static function init() {

self::macro( 'append', curryN( 2, function ( $newItem, array $data ) {
			$data[] = $newItem;

return $data;
		} ) );

self::macro( 'fromPairs', curryN( 1, function ( array $data ) {
			$fromPair = function ( array $result, array $pair ) {
				$result[ $pair[0] ] = $pair[1];

return $result;
			};

return Fns::reduce( $fromPair, [], $data );
		} ) );

self::macro( 'toObj', curryN( 1, function ( array $data ) { return (object) $data; } ) );

self::macro( 'pluck', curryN( 2, function ( $prop, $data ) {
			return Fns::map( Obj::prop( $prop ), $data );
		} ) );

self::macro( 'partition', curryN( 2, function ( $predicate, $data ) {
			return [ Fns::filter( $predicate, $data ), Fns::reject( $predicate, $data ) ];
		} ) );

self::macro( 'sort', curryN( 2, function ( $compare, $data ) {
			if ( $data instanceof Collection ) {
				return wpml_collect( self::sort( $compare, $data->toArray() ) );
			}
			$intCompare = function ( $a, $b ) use ( $compare ) {
				return (int) $compare( $a, $b );
			};
			usort( $data, $intCompare );

return $data;
		} ) );

self::macro( 'unfold', curryN( 2, function ( $fn, $seed ) {
			$result = [];
			do {
				$iteratorResult = $fn( $seed );
				if ( is_array( $iteratorResult ) ) {
					$result[] = $iteratorResult[0];
					$seed     = $iteratorResult[1];
				}
			} while ( $iteratorResult !== false );

return $result;

} ) );

self::macro( 'zip', curryN( 2, function ( $a, $b ) {
			$result = [];
			for ( $i = 0; $i < min( count( $a ), count( $b ) ); $i ++ ) {
				$result[] = [ $a[ $i ], $b[ $i ] ];
			}

return $result;
		} ) );

self::macro( 'zipObj', curryN( 2, function ( $a, $b ) {
			$result = [];
			for ( $i = 0; $i < min( count( $a ), count( $b ) ); $i ++ ) {
				$result[ $a[ $i ] ] = $b[ $i ];
			}

return $result;
		} ) );

self::macro( 'zipWith', curryN( 3, function ( $fn, $a, $b ) {
			$result = [];
			for ( $i = 0; $i < min( count( $a ), count( $b ) ); $i ++ ) {
				$result[] = $fn( $a[ $i ], $b[ $i ] );
			}

return $result;
		} ) );

self::macro( 'join', curryN( 2, 'implode' ) );

self::macro( 'joinWithCommasAndAnd', curryN( 1, function ( $array ) {
			$last = Lst::last( $array );
			if ( $last ) {
				if ( Lst::length( $array ) > 1 ) {
					return str_replace( '  ', ' ', Lst::join( ', ', Lst::dropLast( 1, $array ) ) . ' ' . __( ' and ', 'sitepress' ) . ' ' . $last );
					// TODO Replace above with following (after 4.5.0 release to get 'and' translated):
					// return Lst::join( ', ', Lst::dropLast( 1, $array ) ) . ' ' . __( 'and', 'sitepress' ) . ' ' . $last;
				} else {
					return $last;
				}
			} else {
				return '';
			}
		} ) );

self::macro( 'concat', curryN( 2, 'array_merge' ) );

self::macro( 'find', curryN( 2, function ( $predicate, $array ) {
			foreach ( $array as $value ) {
				if ( $predicate( $value ) ) {
					return $value;
				}
			}

return null;
		} ) );

self::macro( 'flattenToDepth', curryN( 2, flip( Arr::class . '::flatten' ) ) );

self::macro( 'flatten', curryN( 1, Arr::class . '::flatten' ) );

self::macro( 'includes', curryN( 2, function ( $val, $array ) {
			return in_array( $val, $array, true );
		} ) );

self::macro( 'includesAll', curryN( 2, function ( $values, $array ) {
			foreach ( $values as $val ) {
				if ( ! in_array( $val, $array, true ) ) {
					return false;
				}
			}
			return true;
		} ) );

self::macro( 'nth', curryN( 2, function ( $n, $array ) {
			$count = count( $array );
			if ( $n < 0 ) {
				$n += $count;
			}

return $n >= 0 && $n < $count ? $array[ $n ] : null;

} ) );

self::macro( 'first', self::nth( 0 ) );

self::macro( 'last', self::nth( - 1 ) );

self::macro( 'length', curryN( 1, 'count' ) );

self::macro( 'take', curryN( 2, function ( $n, $array ) {
			return array_slice( $array, 0, $n );
		} ) );

self::macro( 'takeLast', curryN( 2, function ( $n, $array ) {
			return array_slice( $array, - $n, $n );
		} ) );

self::macro( 'slice', curryN( 3, function ( $offset, $limit, $array ) {
			return array_slice( $array, $offset, $limit );
		} ) );

self::macro( 'drop', curryN( 2, self::slice( Fns::__, null ) ) );

self::macro( 'dropLast', curryN( 2, function ( $n, $array ) {
			$len = count( $array );

return self::take( $n < $len ? $len - $n : 0, $array );
		} ) );

self::macro( 'makePair', curryN( 2, function ( $a, $b ) {
			return [ $a, $b ];
		} ) );

self::macro( 'make', curryN( 1, function ( ...$args ) {
			return $args;
		} ) );

self::macro( 'insert', curryN( 3, function ( $index, $v, $array ) {
			$values = array_values( $array );

array_splice( $values, $index, 0, [ $v ] );

return $values;
		} ) );

self::macro( 'range', curryN( 2, 'range' ) );

self::macro( 'xprod', curryN( 2, function ( $a, $b ) {
			$result = [];
			foreach ( $a as $el1 ) {
				foreach ( $b as $el2 ) {
					$result[] = [ $el1, $el2 ];
				}
			}

return $result;
		} ) );

self::macro( 'prepend', Lst::insert( 0 ) );

self::macro( 'reverse', curryN( 1, 'array_reverse' ) );
	}

/**
	 * Curried function that keys the array by the given key
	 *
	 * keyBy :: string -> array -> array
	 *
	 * ```
	 * $data = [
	 *    [ 'x' => 'a', 'y' => 123 ],
	 *    [ 'x' => 'b', 'y' => 456 ],
	 * ];
	 *
	 * Lst::keyBy( 'x', $data );
	 * [
	 *    'a' => [ 'x' => 'a', 'y' => 123 ],
	 *    'b' => [ 'x' => 'b', 'y' => 456 ],
	 * ],
	 * ```
	 *
	 * @param string $key
	 * @param mixed[]  $array
	 *
	 * @return mixed[]|callable
	 */
	public static function keyBy( $key = null, $array = null ) {
		$keyBy = function ( $key, $array ) {
			$apply = Fns::converge( Lst::zipObj(), [ Lst::pluck( $key ), Fns::identity() ] );

return $apply( $array );
		};

return call_user_func_array( curryN( 2, $keyBy ), func_get_args() );
	}

/**
	 * Curried function that wraps each item in array with pair: [$key => $item1]
	 *
	 * keyWith :: string -> array -> array
	 *
	 * ```
	 * $data = [ 1, 2.3, 'some data', - 2, 'a' ];
	 *
	 * Lst::keyWith('myKey', $data);
	 * [ [ 'myKey' => 1 ], [ 'myKey' => 2.3 ], [ 'myKey' => 'some data' ], [ 'myKey' => - 2 ], [ 'myKey' => 'a' ] ]
	 * ```
	 *
	 * @param string $key
	 * @param mixed[] $array
	 *
	 * @return mixed[]|callable
	 */
	public static function keyWith( $key = null, $array = null ) {
		$keyWith = function ( $key, $array ) {
			return Fns::map( function ( $item ) use ( $key ) {
				return [ $key => $item ];
			}, $array );
		};

return call_user_func_array( curryN( 2, $keyWith ), func_get_args() );
	}

/**
	 * This method will return the values in the original collection that are not present in the given collection:
	 *
	 * @param array|Collection $array1
	 * @param array|Collection $array2
	 *
	 * @return callable|Collection|array
	 */
	public static function diff( $array1 = null, $array2 = null ) {
		$diff = function( $array1, $array2){
			if ( is_object( $array1)) {
				return $array1->diff($array2);
			} else {
				return array_diff( $array1, $array2 );
			}
		};
		return call_user_func_array( curryN(2, $diff), func_get_args());
	}

/**
	 * It returns array of $val elements repeated $times times.
	 *
	 * @param mixed $val
	 * @param int $times
	 *
	 * @return callable|array[mixed]
	 */
	public static function repeat( $val = null, $times = null ) {
		$repeat = flip( partial( 'array_fill', 0 ) );

return call_user_func_array( curryN( 2, $repeat ), func_get_args() );
	}

/**
	 * @param array|Collection $param
	 *
	 * @return callable|int
	 */
	public static function sum( $param = null ) {
		$sum = function ( $param ) {
			return is_object( $param ) ? $param->sum() : array_sum( $param );
		};

return call_user_func_array( curryN( 1, $sum ), func_get_args() );
	}
}

Lst::init();

Batal