PHP code example of miroshnikov / idles

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

miroshnikov / idles example snippets

concat(?iterable $array, $value): iterable

count(callable $predicate, ?iterable $collection): int

countBy(callable $iteratee, ?iterable $collection): array

drop(int $n, ?iterable $collection): iterable

dropRight(int $n, ?iterable $collection): iterable

findIndex(callable $predicate, ?iterable $collection): int

findLastIndex(callable $predicate, ?iterable $collection): int

flatten(?iterable $collection): iterable

flattenDeep(?iterable $collection): iterable

flattenDepth(int $depth, ?iterable $collection): iterable

fromPairs(?iterable $collection): array

head(?iterable $collecton)

indexOf($value, ?iterable $collection): int

intersection(?iterable $record1, ?iterable $record2): array

intersectionBy(callable $iteratee, ?iterable $record1, ?iterable $record2): array

intersectionWith(callable $comparator, ?iterable $record1, ?iterable $record2): array

join(string $separator, ?iterable $collection): string

last(?iterable $collecton)

nth(int $offset, ?iterable $collection)

remove(int $start, int $count, ?iterable $iterable): array

slice(int $start, int ?$end, ?iterable $collection): iterable

take(int $n, ?iterable $collection): iterable

takeRight(int $n, ?iterable $collection): array

uniq(?iterable $collection): array

uniqBy(callable $iteratee, ?iterable $collection): array

uniqWith(callable $predicate, ?iterable $collection): array

without(array $values, ?iterable $collection): iterable

zip(iterable $a, iterable $b): iterable

zipWith(callable $iteratee, iterable $a, iterable $b): iterable

all(?callable $predicate, ?iterable $collection): bool

any(callable $predicate, ?iterable $collection): bool

each(callable $iteratee, ?iterable $collection): iterable

filter(callable $predicate, ?iterable $collection): iterable

find(?callable $predicate, ?iterable $collection)

flatMap(callable $iteratee, ?iterable $collection): iterable

flatMapDeep(callable $iteratee, ?iterable $collection): iterable

flatMapDepth(callable $iteratee, int $depth, ?iterable $collection): iterable

groupBy(callable $iteratee, ?iterable $collection): array

indexBy(callable $iteratee, ?iterable $collection): iterable

map(callable $iteratee, ?iterable $collection)

orderBy(array $iteratees, array $orders, ?iterable $collection)

partition(callable $predicate, ?iterable $collection): array

reduce(callable $iteratee, $accumulator, ?iterable $collection)

resolve(array $resolvers, array $record): array

sort(array $comparator, ?iterable $collection): array

sortBy(array $comparators, ?iterable $collection): array

sortWith(array $comparators, ?iterable $collection): array

values(?iterable $collection): iterable

always($value)

applyTo($value, callable $interceptor)

ary(int $n, callable $fn): callable

ascend(callable $func, $a, $b): callable

attempt(callable $fn)

compose(callable ...$funcs): callable

curry(callable $f): callable

curryRight(callable $f): callable

descend(callable $func, $a, $b): callable

flip(callable $fn): callable

juxt(array $funcs): callable

memoize(callable $func): callable

negate(callable $predicate): callable

once(callable $fn): callable

partial(callable $fn, array $partials): callable

partialRight(callable $fn, array $partials): callable

pipe(callable ...$funcs): callable

tap(callable $interceptor, $value)

times(callable $iteratee, int $n): array

tryCatch(callable $tryer, callable $catcher, $value)

unary(callable $fn): callable

allPass(array $predicates): callable

anyPass(array $predicates): callable

both(callable $func1, callable $func2): callable

cond(array $pairs): callable

defaultTo($default)($value)

either(callable $func1, callable $func2): callable

ifElse(callable $predicate, callable $onTrue, callable $onFalse): callable

not($a): bool

unless(callable $predicate, callable $whenFalse, mixed $value)

when(callable $predicate, callable $whenTrue, mixed $value)

add(int|float $a, int|float $b): int|float

dec(int $number): int

divide(int|float $a, int|float $b): int|float

gt($a, $b): bool

gte($a, $b): bool

inc(int $number): int

lt($a, $b): bool

lte($a, $b): bool

modulo(int|float $a, int|float $b): int

multiply(int|float $a, int|float $b): int|float

round(int $precision, int|float $number): float

subtract(int|float $a, int|float $b): int|float

sum(?iterable $collection): int|float

sumBy(?callable $iteratee, ?iterable $collection): int|float

assignDeep(array $iterables): array

defaults(?iterable $record1, ?iterable $record2): array

evolve(array $transformations, ?iterable $record): array

extend(?iterable $source1, ?iterable $source2): array

has(string|int $key, ?iterable $record): bool

hasPath(string|int|array $path, ?iterable $record): bool

php
invert(?iterable $collection): array

php
keys(?iterable $record): iterable

php
merge(?iterable $source1, ?iterable $source2): array

php
mergeDeep(array $iterables): array

php
mergeLeft(?iterable $left, ?iterable $right): array

php
mergeWith(callable $customizer, ?iterable $left, ?iterable $right): array

php
modifyPath(array|string|int $path, callable $updater, ?iterable $record)

php
objOf(string $key, $value): array

php
omit(array $keys, ?iterable $collection): iterable

php
omitBy(callable $predicate, ?iterable $record): iterable

php
path(array|string $path, ?iterable $collection)

php
paths(array $paths, ?iterable $collection): array

php
pick(array $keys, ?iterable $collection): iterable

php
pickBy(callable $predicate, ?iterable $record): iterable

php
pluck(string|int $key, ?iterable $collection)

php
prop(string|int $key, ?iterable $record)

php
propEq(string|int $key, $value, ?iterable $record): bool

php
setPath($path, $value, ?iterable $record)

php
toPairs(?iterable $record): iterable

php
where(array $spec, ?iterable $record): bool

php
whereAny(array $spec, ?iterable $record): bool

php
whereEq(array $spec, ?iterable $test): bool

php
split(string $separator, string $s): array

php
words(string $pattern, string $string): array

php
collect(?iterable $iterable): array

php
equals($a, $b): bool

php
identity($value)

php
iterate(callable $f, $value): iterable

php
just($value): Optional

php
nothing(): Optional

php
now(): int

php
just(mixed $value): Optional

php
size(array|Countable|object|string|callable $value): int