diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..bc3a0ab
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) sji <sji@sj-i.dev>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..491405b
--- /dev/null
+++ b/README.md
@@ -0,0 +1,83 @@
+# Typist
+
+Typist is a PHP library enforcing types of local variables.  
+It internally uses references to typed properties introduced in PHP 7.4.
+
+## Installation
+
+```
+composer require sj-i/typist
+```
+
+## Supported Versions
+
+- PHP 7.4 or later
+
+# Usage
+## Basic Usage
+
+```
+use Typist\Typist;
+
+// type enforcements are valid during the lifetime of this `$_`
+$_ = [
+    Typist::int($typed_int, 1),
+    Typist::string($typed_string, 'str'),
+    Typist::bool($typed_bool, false),
+    Typist::float($typed_float, 0.1),
+    Typist::class(\DateTimeInterface::class, $typed_object, new \DateTime()),
+];
+
+assert($typed_int === 1);
+assert($typed_string === 'str');
+assert($typed_bool === false);
+assert($typed_float === 0.1);
+assert($typed_object instanceof \DateTime);
+
+// modifications with valid types are OK
+$typed_int = 2;
+$typed_string = 'trs';
+$typed_bool = true;
+$typed_float = -0.1;
+$typed_object = new DateTimeImmutable();
+
+// any statements below raises TypeError
+$typed_int = 'a';
+$typed_string = 1;
+$typed_bool = 'a';
+$typed_float = 'a';
+$typed_object = 'a';
+```
+
+## Nullable Types
+
+```
+use Typist\Typist;
+
+$_ = [
+    Typist::nullable()::int($typed_int1, 1),
+    Typist::nullable()::int($typed_int2, null),
+    Typist::nullable()::string($typed_string1, 'str'),
+    Typist::nullable()::string($typed_string2, null),
+    Typist::nullable()::bool($typed_bool1, false),
+    Typist::nullable()::bool($typed_bool2, null),
+    Typist::nullable()::float($typed_float1, 0.1),
+    Typist::nullable()::float($typed_float2, null),
+    Typist::nullable()::class(\DateTimeInterface::class, $typed_object1, new \DateTime()),
+    Typist::nullable()::class(\DateTimeInterface::class, $typed_object2, null),
+];
+```
+
+or if you use PHP8, `()` can be omitted.
+
+```
+use Typist\Typist;
+
+$_ = [
+    Typist::nullable::int($typed_int2, null),
+    Typist::nullable::string($typed_string2, null),
+    Typist::nullable::bool($typed_bool2, null),
+    Typist::nullable::float($typed_float2, null),
+    Typist::nullable::class(\DateTimeInterface::class, $typed_object2, null),
+];
+```
diff --git a/composer.json b/composer.json
new file mode 100644
index 0000000..25fb520
--- /dev/null
+++ b/composer.json
@@ -0,0 +1,34 @@
+{
+  "name": "sj-i/typist",
+  "description": "Enforcing types of local variables",
+  "type": "library",
+  "keywords": [
+    "type-safety"
+  ],
+  "minimum-stability": "stable",
+  "license": "MIT",
+  "authors": [
+    {
+      "name": "sji",
+      "homepage": "https://twitter.com/sji_ch"
+    }
+  ],
+  "require": {
+    "php": "^7.4 || ^8.0"
+  },
+  "require-dev": {
+    "phpunit/phpunit": "^8.0 || ^9.0",
+    "vimeo/psalm": "^3.12",
+    "squizlabs/php_codesniffer": "^3.5"
+  },
+  "autoload": {
+    "psr-4": {
+      "Typist\\": "src/Typist"
+    }
+  },
+  "autoload-dev": {
+    "psr-4": {
+      "Typist\\": "tests/Typist"
+    }
+  }
+}
diff --git a/phpcs.xml b/phpcs.xml
new file mode 100644
index 0000000..e247a9c
--- /dev/null
+++ b/phpcs.xml
@@ -0,0 +1,5 @@
+<?xml version="1.0"?>
+<ruleset name="Typist">
+    <arg name="extensions" value="php" />
+    <rule ref="PSR12" />
+</ruleset>
diff --git a/psalm.xml b/psalm.xml
new file mode 100644
index 0000000..af1211c
--- /dev/null
+++ b/psalm.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0"?>
+<psalm
+        errorLevel="1"
+        resolveFromConfigFile="true"
+        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+        xmlns="https://getpsalm.org/schema/config"
+        xsi:schemaLocation="https://getpsalm.org/schema/config vendor/vimeo/psalm/config.xsd"
+>
+    <projectFiles>
+        <directory name="src"/>
+        <ignoreFiles>
+            <directory name="vendor"/>
+        </ignoreFiles>
+    </projectFiles>
+</psalm>
diff --git a/src/Typist/BoolEnforcer.php b/src/Typist/BoolEnforcer.php
new file mode 100644
index 0000000..3eda9f4
--- /dev/null
+++ b/src/Typist/BoolEnforcer.php
@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * This file is part of the sj-i/typist package.
+ *
+ * (c) sji <sji@sj-i.dev>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Typist;
+
+final class BoolEnforcer
+{
+    private bool $value;
+
+    /**
+     * @internal
+     */
+    public function __construct(bool &$value)
+    {
+        $this->value = &$value;
+    }
+}
diff --git a/src/Typist/ClassEnforcer.php b/src/Typist/ClassEnforcer.php
new file mode 100644
index 0000000..82e8781
--- /dev/null
+++ b/src/Typist/ClassEnforcer.php
@@ -0,0 +1,67 @@
+<?php
+
+/**
+ * This file is part of the sj-i/typist package.
+ *
+ * (c) sji <sji@sj-i.dev>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Typist;
+
+use ReflectionClass;
+
+/**
+ * @template T
+ */
+final class ClassEnforcer
+{
+    /** @var class-string[] */
+    private static array $registered_classes = [];
+
+    private GeneratedClassEnforcerInterface $enforcer;
+
+    /**
+     * @internal
+     * @param class-string<T> $passed_class_name
+     * @param T $value
+     * @throws \ReflectionException
+     */
+    public function __construct(string $passed_class_name, &$value)
+    {
+        $class = new ReflectionClass($passed_class_name);
+
+        $namespace = $class->getNamespaceName();
+        $class_name = $class->getShortName();
+        $fully_qualified_class_name = ($namespace === '' ? '\\' : $namespace) . $class_name;
+
+        $enforcer_name = $class_name . 'Enforcer';
+        $enforcer_namespace = rtrim(implode('\\', [__NAMESPACE__ , $namespace]), '\\');
+        $enforcer_interface_name = GeneratedClassEnforcerInterface::class;
+
+        if (!isset(self::$registered_classes[$fully_qualified_class_name])) {
+            $code = <<<TEMPLATE
+            declare(strict_types=1);
+            namespace {$enforcer_namespace};
+            class {$enforcer_name} implements \\{$enforcer_interface_name}
+            {
+                private {$fully_qualified_class_name} \$value;
+                public function __construct({$fully_qualified_class_name} &\$value)
+                {
+                    \$this->value = &\$value;
+                }
+            }
+            TEMPLATE;
+            eval($code);
+            self::$registered_classes[$fully_qualified_class_name] = true;
+        }
+
+        /** @var class-string<GeneratedClassEnforcerInterface> $enforcer_fqn */
+        $enforcer_fqn = implode('\\', [$enforcer_namespace, $enforcer_name]);
+        $this->enforcer = new $enforcer_fqn($value);
+    }
+}
diff --git a/src/Typist/FloatEnforcer.php b/src/Typist/FloatEnforcer.php
new file mode 100644
index 0000000..485a1f0
--- /dev/null
+++ b/src/Typist/FloatEnforcer.php
@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * This file is part of the sj-i/typist package.
+ *
+ * (c) sji <sji@sj-i.dev>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Typist;
+
+final class FloatEnforcer
+{
+    private float $value;
+
+    /**
+     * @internal
+     */
+    public function __construct(float &$value)
+    {
+        $this->value = &$value;
+    }
+}
diff --git a/src/Typist/GeneratedClassEnforcerInterface.php b/src/Typist/GeneratedClassEnforcerInterface.php
new file mode 100644
index 0000000..27e9f90
--- /dev/null
+++ b/src/Typist/GeneratedClassEnforcerInterface.php
@@ -0,0 +1,21 @@
+<?php
+
+/**
+ * This file is part of the sj-i/typist package.
+ *
+ * (c) sji <sji@sj-i.dev>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Typist;
+
+/**
+ * @internal
+ */
+interface GeneratedClassEnforcerInterface
+{
+}
diff --git a/src/Typist/IntEnforcer.php b/src/Typist/IntEnforcer.php
new file mode 100644
index 0000000..3cb9b33
--- /dev/null
+++ b/src/Typist/IntEnforcer.php
@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * This file is part of the sj-i/typist package.
+ *
+ * (c) sji <sji@sj-i.dev>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Typist;
+
+final class IntEnforcer
+{
+    private int $value;
+
+    /**
+     * @internal
+     */
+    public function __construct(int &$value)
+    {
+        $this->value = &$value;
+    }
+}
diff --git a/src/Typist/NullableBoolEnforcer.php b/src/Typist/NullableBoolEnforcer.php
new file mode 100644
index 0000000..d0ae861
--- /dev/null
+++ b/src/Typist/NullableBoolEnforcer.php
@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * This file is part of the sj-i/typist package.
+ *
+ * (c) sji <sji@sj-i.dev>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Typist;
+
+final class NullableBoolEnforcer
+{
+    private ?bool $value;
+
+    /**
+     * @internal
+     */
+    public function __construct(?bool &$value)
+    {
+        $this->value = &$value;
+    }
+}
diff --git a/src/Typist/NullableClassEnforcer.php b/src/Typist/NullableClassEnforcer.php
new file mode 100644
index 0000000..e9cdd60
--- /dev/null
+++ b/src/Typist/NullableClassEnforcer.php
@@ -0,0 +1,67 @@
+<?php
+
+/**
+ * This file is part of the sj-i/typist package.
+ *
+ * (c) sji <sji@sj-i.dev>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Typist;
+
+use ReflectionClass;
+
+/**
+ * @template T
+ */
+final class NullableClassEnforcer
+{
+    /** @var class-string[] */
+    private static array $registered_classes = [];
+
+    private GeneratedClassEnforcerInterface $enforcer;
+
+    /**
+     * @internal
+     * @param class-string<T> $passed_class_name
+     * @param T|null $value
+     * @throws \ReflectionException
+     */
+    public function __construct(string $passed_class_name, &$value)
+    {
+        $class = new ReflectionClass($passed_class_name);
+
+        $namespace = $class->getNamespaceName();
+        $class_name = $class->getShortName();
+        $fully_qualified_class_name = ($namespace === '' ? '\\' : $namespace) . $class_name;
+
+        $enforcer_name = 'Nullable' . $class_name . 'Enforcer';
+        $enforcer_namespace = rtrim(implode('\\', [__NAMESPACE__ , $namespace]), '\\');
+        $enforcer_interface_name = GeneratedClassEnforcerInterface::class;
+
+        if (!isset(self::$registered_classes[$fully_qualified_class_name])) {
+            $code = <<<TEMPLATE
+            declare(strict_types=1);
+            namespace {$enforcer_namespace};
+            class {$enforcer_name} implements \\{$enforcer_interface_name}
+            {
+                private ?{$fully_qualified_class_name} \$value;
+                public function __construct(?{$fully_qualified_class_name} &\$value)
+                {
+                    \$this->value = &\$value;
+                }
+            }
+            TEMPLATE;
+            eval($code);
+            self::$registered_classes[$fully_qualified_class_name] = true;
+        }
+
+        /** @var class-string<GeneratedClassEnforcerInterface> $enforcer_fqn */
+        $enforcer_fqn = implode('\\', [$enforcer_namespace, $enforcer_name]);
+        $this->enforcer = new $enforcer_fqn($value);
+    }
+}
diff --git a/src/Typist/NullableFloatEnforcer.php b/src/Typist/NullableFloatEnforcer.php
new file mode 100644
index 0000000..9babf9a
--- /dev/null
+++ b/src/Typist/NullableFloatEnforcer.php
@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * This file is part of the sj-i/typist package.
+ *
+ * (c) sji <sji@sj-i.dev>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Typist;
+
+final class NullableFloatEnforcer
+{
+    private ?float $value;
+
+    /**
+     * @internal
+     */
+    public function __construct(?float &$value)
+    {
+        $this->value = &$value;
+    }
+}
diff --git a/src/Typist/NullableIntEnforcer.php b/src/Typist/NullableIntEnforcer.php
new file mode 100644
index 0000000..11fa748
--- /dev/null
+++ b/src/Typist/NullableIntEnforcer.php
@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * This file is part of the sj-i/typist package.
+ *
+ * (c) sji <sji@sj-i.dev>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Typist;
+
+final class NullableIntEnforcer
+{
+    private ?int $value;
+
+    /**
+     * @internal
+     */
+    public function __construct(?int &$value)
+    {
+        $this->value = &$value;
+    }
+}
diff --git a/src/Typist/NullableStringEnforcer.php b/src/Typist/NullableStringEnforcer.php
new file mode 100644
index 0000000..21b2f60
--- /dev/null
+++ b/src/Typist/NullableStringEnforcer.php
@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * This file is part of the sj-i/typist package.
+ *
+ * (c) sji <sji@sj-i.dev>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Typist;
+
+final class NullableStringEnforcer
+{
+    private ?string $value;
+
+    /**
+     * @internal
+     */
+    public function __construct(?string &$value)
+    {
+        $this->value = &$value;
+    }
+}
diff --git a/src/Typist/NullableTypeEnforcer.php b/src/Typist/NullableTypeEnforcer.php
new file mode 100644
index 0000000..490cfa8
--- /dev/null
+++ b/src/Typist/NullableTypeEnforcer.php
@@ -0,0 +1,70 @@
+<?php
+
+/**
+ * This file is part of the sj-i/typist package.
+ *
+ * (c) sji <sji@sj-i.dev>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Typist;
+
+final class NullableTypeEnforcer
+{
+    private function __construct()
+    {
+    }
+
+    /**
+     * @param-out int|null $value_holder
+     */
+    public static function int(?int &$value_holder, ?int $value): NullableIntEnforcer
+    {
+        $value_holder = $value;
+        return new NullableIntEnforcer($value_holder);
+    }
+
+    /**
+     * @param-out string|null $value_holder
+     */
+    public static function string(?string &$value_holder, ?string $value): NullableStringEnforcer
+    {
+        $value_holder = $value;
+        return new NullableStringEnforcer($value_holder);
+    }
+
+    /**
+     * @param-out bool|null $value_holder
+     */
+    public static function bool(?bool &$value_holder, ?bool $value): NullableBoolEnforcer
+    {
+        $value_holder = $value;
+        return new NullableBoolEnforcer($value_holder);
+    }
+
+    /**
+     * @param-out float|null $value_holder
+     */
+    public static function float(?float &$value_holder, ?float $value): NullableFloatEnforcer
+    {
+        $value_holder = $value;
+        return new NullableFloatEnforcer($value_holder);
+    }
+
+    /**
+     * @template T
+     * @param class-string<T> $class_name
+     * @param T|null $value_holder
+     * @param T|null $value
+     * @return NullableClassEnforcer
+     */
+    public static function class(string $class_name, &$value_holder, $value): NullableClassEnforcer
+    {
+        $value_holder = $value;
+        return new NullableClassEnforcer($class_name, $value_holder);
+    }
+}
diff --git a/src/Typist/StringEnforcer.php b/src/Typist/StringEnforcer.php
new file mode 100644
index 0000000..6d44fb4
--- /dev/null
+++ b/src/Typist/StringEnforcer.php
@@ -0,0 +1,27 @@
+<?php
+
+/**
+ * This file is part of the sj-i/typist package.
+ *
+ * (c) sji <sji@sj-i.dev>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Typist;
+
+final class StringEnforcer
+{
+    private string $value;
+
+    /**
+     * @internal
+     */
+    public function __construct(string &$value)
+    {
+        $this->value = &$value;
+    }
+}
diff --git a/src/Typist/Typist.php b/src/Typist/Typist.php
new file mode 100644
index 0000000..f71f31b
--- /dev/null
+++ b/src/Typist/Typist.php
@@ -0,0 +1,87 @@
+<?php
+
+/**
+ * This file is part of the sj-i/typist package.
+ *
+ * (c) sji <sji@sj-i.dev>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Typist;
+
+/**
+ * @psalm-immutable
+ */
+final class Typist
+{
+    // phpcs:ignore Generic.NamingConventions.UpperCaseConstantName.ClassConstantNotUpperCase
+    public const nullable = NullableTypeEnforcer::class;
+
+    private function __construct()
+    {
+    }
+
+    /**
+     * @param-out int $value_holder
+     */
+    public static function int(?int &$value_holder, int $value): IntEnforcer
+    {
+        $value_holder = $value;
+        return new IntEnforcer($value_holder);
+    }
+
+    /**
+     * @param-out string $value_holder
+     */
+    public static function string(?string &$value_holder, string $value): StringEnforcer
+    {
+        $value_holder = $value;
+        return new StringEnforcer($value_holder);
+    }
+
+    /**
+     * @param-out bool $value_holder
+     */
+    public static function bool(?bool &$value_holder, bool $value): BoolEnforcer
+    {
+        $value_holder = $value;
+        return new BoolEnforcer($value_holder);
+    }
+
+    /**
+     * @param-out float $value_holder
+     */
+    public static function float(?float &$value_holder, float $value): FloatEnforcer
+    {
+        $value_holder = $value;
+        return new FloatEnforcer($value_holder);
+    }
+
+    /**
+     * @template T
+     * @param class-string<T> $class_name
+     * @param T|null $value_holder
+     * @param T $value
+     * @param-out T $value_holder
+     * @return ClassEnforcer
+     * @throws \ReflectionException
+     */
+    public static function class(string $class_name, &$value_holder, $value): ClassEnforcer
+    {
+        $value_holder = $value;
+        return new ClassEnforcer($class_name, $value_holder);
+    }
+
+    /**
+     * @return NullableTypeEnforcer|string
+     * @psalm-return class-string<NullableTypeEnforcer>
+     */
+    public static function nullable(): string
+    {
+        return NullableTypeEnforcer::class;
+    }
+}
diff --git a/tests/Typist/TypistTest.php b/tests/Typist/TypistTest.php
new file mode 100644
index 0000000..65b5b79
--- /dev/null
+++ b/tests/Typist/TypistTest.php
@@ -0,0 +1,173 @@
+<?php
+
+/**
+ * This file is part of the sj-i/typist package.
+ *
+ * (c) sji <sji@sj-i.dev>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+declare(strict_types=1);
+
+namespace Typist;
+
+use PHPUnit\Framework\TestCase;
+use Throwable;
+use TypeError;
+
+class TypistTest extends TestCase
+{
+    public function testInt(): void
+    {
+        $_ = [
+            Typist::int($typed_value, 1),
+        ];
+        $this->assertSame(1, $typed_value);
+        $typed_value = 2;
+        $this->assertTypeError(function () use (&$typed_value) {
+            $typed_value = 'aaa';
+        });
+        $this->assertTypeError(function () use (&$typed_value) {
+            $typed_value = null;
+        });
+    }
+
+    public function testString(): void
+    {
+        $_ = [
+            Typist::string($typed_value, 'a'),
+        ];
+        $this->assertSame('a', $typed_value);
+        $typed_value = 'b';
+        $this->assertTypeError(function () use (&$typed_value) {
+            $typed_value = 1;
+        });
+        $this->assertTypeError(function () use (&$typed_value) {
+            $typed_value = null;
+        });
+    }
+
+    public function testBool(): void
+    {
+        $_ = [
+            Typist::bool($typed_value, false),
+        ];
+        $this->assertSame(false, $typed_value);
+        $typed_value = true;
+        $this->assertTypeError(function () use (&$typed_value) {
+            $typed_value = 1;
+        });
+        $this->assertTypeError(function () use (&$typed_value) {
+            $typed_value = null;
+        });
+    }
+
+    public function testFloat(): void
+    {
+        $_ = [
+            Typist::float($typed_value, 1.1),
+        ];
+        $this->assertSame(1.1, $typed_value);
+        $typed_value = -1.1;
+        $typed_value = 1;
+        $this->assertTypeError(function () use (&$typed_value) {
+            $typed_value = 'a';
+        });
+        $this->assertTypeError(function () use (&$typed_value) {
+            $typed_value = null;
+        });
+    }
+
+    public function testClass(): void
+    {
+        $_ = [
+            Typist::class(\DateTimeInterface::class, $typed_value, new \DateTimeImmutable()),
+        ];
+        $this->assertInstanceOf(\DateTimeImmutable::class, $typed_value);
+        $typed_value = new \DateTime();
+        $this->assertTypeError(function () use (&$typed_value) {
+            $typed_value = 'a';
+        });
+        $this->assertTypeError(function () use (&$typed_value) {
+            $typed_value = null;
+        });
+    }
+
+    public function testNullableInt(): void
+    {
+        $_ = [
+            Typist::nullable()::int($typed_value, 1),
+        ];
+        $this->assertSame(1, $typed_value);
+        $typed_value = 2;
+        $typed_value = null;
+        $this->expectException(TypeError::class);
+        $typed_value = 'aaa';
+    }
+
+    public function testNullableString(): void
+    {
+        $_ = [
+            Typist::nullable()::string($typed_value, 'a'),
+        ];
+        $this->assertSame('a', $typed_value);
+        $typed_value = 'b';
+        $typed_value = null;
+        $this->expectException(TypeError::class);
+        $typed_value = 1;
+    }
+
+    public function testNullableBool(): void
+    {
+        $_ = [
+            Typist::nullable()::bool($typed_value, false),
+        ];
+        $this->assertSame(false, $typed_value);
+        $typed_value = true;
+        $typed_value = null;
+        $this->expectException(TypeError::class);
+        $typed_value = 1;
+    }
+
+    public function testNullableFloat(): void
+    {
+        $_ = [
+            Typist::nullable()::float($typed_value, 1.1),
+        ];
+        $this->assertSame(1.1, $typed_value);
+        $typed_value = 1;
+        $typed_value = -1.1;
+        $typed_value = null;
+        $this->expectException(TypeError::class);
+        $typed_value = '';
+    }
+
+    public function testNullableClass(): void
+    {
+        $_ = [
+            Typist::nullable()::class(
+                \DateTimeInterface::class,
+                $typed_value,
+                new \DateTimeImmutable()
+            ),
+        ];
+        $this->assertInstanceOf(\DateTimeImmutable::class, $typed_value);
+        $typed_value = new \DateTime();
+        $typed_value = null;
+        $this->assertTypeError(function () use (&$typed_value) {
+            $typed_value = 'a';
+        });
+    }
+
+    private function assertTypeError(callable $func): void
+    {
+        try {
+            $func();
+        } catch (Throwable $e) {
+        }
+        $this->assertTrue(isset($e));
+        $this->assertInstanceOf(TypeError::class, $e);
+    }
+}