😮 Мы снимали этот подкаст на международной IT-конференции «Стачка»! В этом году она пройдёт 10-11 апреля в Ульяновске и 3-4 октября в Петербурге.

A set of core PHP functions rewritten to throw exceptions instead of returning false when an error is encountered.

// вместо 
$contents = @file_get_contents($file);

if ($contents === false) {
    throw new RuntimeException("File {$file} is not readable");
}

// пишем
$contents = Safe\file_get_contents($file);

$contents = exceptionallyCall('file_get_contents', $file);

/**
 * @template T
 * @param callable(): (T|false) $function
 * @return T
 * @throws \ErrorException
 */
function exceptionally(
    callable $function,
    int $errorLevels = E_ALL & ~E_DEPRECATED & ~E_USER_DEPRECATED,
): mixed {}

// PHP < 8.6
$contents = exceptionally(static fn () => file_get_contents($file));

// PHP >= 8.6 с partial function application
$contents = exceptionally(file_get_contents($file, ...));

composer require thesis/exceptionally

namespace Encoding;

enum Base64
{
    case Standard;
    case UrlSafe;
    case Imap;
}

enum PaddingMode
{
    case VariantControlled;
    case StripPadding;
    case PreservePadding;
}

enum DecodingMode
{
    case Forgiving;
    case Strict;
}

enum TimingMode
{
    case Variable;
    case Constant;
}

/**
 * @throws UnableToEncodeException
 */
function base64_encode(
    string $data,
    Base64 $variant = Base64::Standard,
    PaddingMode $paddingMode = PaddingMode::VariantControlled,
    TimingMode $timingMode = TimingMode::Variable,
): string;

/**
 * @throws UnableToDecodeException
 */
function base64_decode(
    string $data,
    Base64 $variant = Base64::Standard,
    DecodingMode $decodingMode = DecodingMode::Strict,
    TimingMode $timingMode = TimingMode::Variable,
): string;

Hi Valentin,

We are still working on it with Tim Düsterhus doing the full implementation.

Best regards

use Psr\Log\LoggerInterface as Logger;
use Monolog\Logger as Monolog;
use Typhoon\Type;

/**
 * @template T
 */
interface Ref
{
    /**
     * @template S, где S — супертип для T
     * @param Type<S> $super
     * @return self<S>
     */
    public function as(Type $super): self;
}

/**
 * @param Ref<Monolog> $ref
 * @return Ref<Logger>
 */
function upcastLogger(Ref $ref): Ref
{
    return $ref->as(Type\objectT(Logger::class));
}

/**
 * @template S super T
 * @param Type<S> $super
 * @return self<S>
 */
public function as(Type $super): self;

/**
 * @param list<ReflectionParameter> $parameters
 */
function make(array $parameters): Something {}

$trimReflection = new ReflectionFunction(trim(...));

make(array_reverse($trimReflection->getParameters()));

function make(ReflectionFunctionAbstract $function): Something
{
    $parameters = $function->getParameters();

    // ...
}

final class MessedReflectionFunction extends ReflectionFunction
{
    public function getParameters(): array
    {
        return array_reverse(parent::getParameters());
    }
}

make(new MessedReflectionFunction(trim(...)));