PHP RFC: Generic Types and Functions best php traiing trivandrum

-

PHP RFC: Generic Types and Functions


Introduction

Proposal

Generic Types

class Entry<KeyType, ValueType>
{
    protected $key;
    protected $value;
 
    public function __construct(KeyType $key, ValueType $value)
    {
        $this->key   = $key;
        $this->value = $value;
    }
 
    public function getKey(): KeyType
    {
        return $this->key;
    }
 
    public function getValue(): ValueType
    {
        return $this->value;
    }
}
$entry = new Entry<int,string>(1, 'test');
$entry = new Entry(1, 'test');
var_dump(get_class($entry)); // => (string) "Entry"

Extending a Generic Type

class StringEntry extends Entry<int,string>
{}

Type-hinting and Type-checking Generic Types

function write(Entry<int, string> $entry)
{
    // ...
}
 
write(new Entry<int, string>(1, 'test'));
write(new Entry<int, int>(1, 2)); // throws a TypeError

Nested Type Arguments

class Container<ContentType>
{
    private $content;
 
    public function getContent(): ContentType
    {
        return $this->content;
    }
 
    public function setContent(ContentType $content): void
    {
        $this->content = $content;
    }
}
 
$container = new Container<Entry<int,string>>();
 
$container->setContent(new Entry<int,string>(1, 'test'));
var_dump($container->getContent() instanceof Entry<int,string>); // => (bool) true
 
$container->setContent(new Entry<int,int>(1, 1)); // throws a TypeError

Upper Bounds

interface Boxable
{
    // ...
}
 
class Box<T is Boxable>
{
    // ...
}
 
class Hat implements Boxable
{
    // ...
}
 
$box = new Box<Hat>(); // ok
$box = new Box<string>(); // throws a
Note that the choice of the keyword is to indicate upper bounds is based on the rejection of perhaps more obvious alternatives - repurposing the extends or implements keywords would be misleading, since they would work precisely the same way; worse, permitting both keywords would render consumer code invalid if an upper bound type provided by a library is refactored between class and interface. Repurposing instanceof would also be misleading, since the upper bound is checking the type-hint, not an instance. Furthermore, we don't want this to collide with possible future mixed scalar types, such as number or scalar, neither of which make sense in conjunction with either extends or implements. (If a reserved is keyword is undesirable for other reasons, a simple : is likely a better alternative than overloading the meaning of an existing keyword.)
Bounds Checking
interface Machine {}
 
class Computer implements Machine {}
 
class SuperComputer extends Computer {}
 
class MachineBuilder<T is Machine> {}
 
class ComputerBuilder<T is Computer> extends MachineBuilder<Computer> {} // (A)
 
class SuperComputerBuilder extends ComputerBuilder<SuperComputer> {} // (B)

Traits

trait Factory<D is Drink, F is Flavor>
{
    public function make(F $flavor) : D {
        return new D();
    }
}
 
class Maker
{
    use Factory<Tea, Sugar> {
        make as makeTea;
    }
    use Factory<Coffee, Milk> {
        make as makeCoffee;
    }
}
 
$maker = new Maker();
$maker->makeTea(new Sugar(4));
$maker->makeCoffee(new Milk(1));
trait Container<T>
{
    private $value;
 
    public function get() : T
    {
        return $this->value;
    }
 
    public function set(T $value)
    {
        $this->value = $value;
    }
}
 
class Box<T>
{
    use Container<T>;
}
 
$box = new Box<Hat>();
$box->set(new Hat());
var_dump($box->get()); // => Hat#2

Generic Functions and Methods

declare(strict_types=1)
 
class Box<T>
{
    public function __construct(T $content)
    {
        // ...
    }
}
 
function create_box<T>(T $content): Box<T>
{
    var_dump(func_type_args()); // => array("Hat")
 
    return new Box<T>($content);
}
 
$box = create_box(new Hat());
$box = create_box<string>(new Hat()); // throws TypeError

Generic Methods

interface Greetable
{
    public function getName();
}
 
class Greeter
{
    public function greet<T is Greetable>(T $subject)
    {
        $subject = $object->getName();
 
        return "Hello, {$name}!";
    }
}
 
class AdvancedGreeter extends Greeter
{
    public function greet<T is Greetable>(T $subject)
    {
        return parent::greet($subject) . " - have a great day!";
    }
}

Generic Constructors

class Hello<T1>
{
    public function __construct<T1,T2>()
    {
        // ...
    }
}

Generic Closures

Type Checking

class Box<T> {}
 
class HeadGear {}
 
class Hat extends HeadGear {}
 
interface Feline {}
 
class Cat implements Feline {}
 
$hat_box = new Box<Hat>();
$cat_box = new Box<Cat>();
 
var_dump($hat_box instanceof Box); // => (bool) true
var_dump($cat_box instanceof Box); // => (bool) true
var_dump($cat_box instanceof Box<Cat>); // => (bool) true
var_dump($cat_box instanceof Box<Hat>); // => (bool) false
var_dump($cat_box instanceof Box<Feline>); // => (bool) true
var_dump($hat_box instanceof Box<HeadGear>); // => (bool) true

Bounded Polymorphism

Multiple Constraints

class A<T> where T is T1, T is T2 {
    // ...
}

Autoloading

Reflection

Reification

Static Type-checking With ''instanceof''
New Pseudo-types

Backward Incompatible Changes

Proposed PHP Version(s)

Proposed Voting Choices

Patches and Tests

References

rfc/generics.txt · Last modified: 2017/09/22 13:28 (external edit)
Location: Nandanam TC-11/415-3, Navodaya Gardens, ,Nalanchira(po), Nalanchira Rd, Parottukonam, Thiruvananthapuram, Kerala 695015, India

Comments

Post a Comment

Popular posts from this blog

A Tailwind CSS Preset for Laravel 5.5

-
Image
A Tailwind CSS Preset for Laravel 5.5 Laravel News Podcast host, Michael Dyrynda, quickly released a Tailwind CSS preset for Laravel 5.5 shortly after the  first release  of the open-source version of this excellent utility-first CSS library: View image on Twitter Michael Dyrynda   @michaeldyrynda  Took a run at making a basic  @ tailwindcss   scaffolding preset for  @ laravelphp   https:// github.com/michaeldyrynda /laravel-preset-tailwind  … 6:12 PM - Nov 1, 2017   11 11 Replies     28 28 Retweets     136 136 likes Twitter Ads info and privacy To install the preset and start using it in Laravel, you can use the  php artisan preset  command: composer require laravel-frontend-presets/tailwindcss php artisan preset tailwindcss npm install npm run dev If you want to include auth views, run this preset instead: php artisan preset tailwindcss-a...
Read more

Short and safe array iteration

-
Short and safe array iteration One reason to follow development mailing lists is you sometimes pick up on some very neat tricks. Here's one that I spotted on the PHP Internals list recently to simplify array iteration in PHP 7. PHP's largely loose, dynamic typing has plenty of both pros and cons. One con in particular is that you don't always know for sure if a value you're trying to use has been set yet, or is non-null. PHP will dutifully whine at you if you try to use a null value, sometimes fatally. (Yet another reason to structure your code to avoid nulls, period.) One place this comes up in particular is in  foreach()  loops, especially when working with nested array structures. (PHP lacks a struct type, but makes anonymous hash maps so easy that they get used as the uber data type, for better or worse.) Consider the following: <?php foreach ( $definition [ 'keys' ] as  $id  =>  $val ) {    // ... } ?> This not-at-all uncommo...
Read more

PHPStorm's performance

-
PHPStorm's performance Java VM options PHPStorm is made in Java. If you ever played Minecraft, you know you could allocate extra RAM by adding flags to your startup command. You can also do this in PHPStorm, it's even built into the UI. Go to  help > Edit Custom VM Options . You can play around with the settings here. I for one changed the maximum amount of RAM allocated to PHPStorm, and added two graphics options (at the end of the file). -Xms500m -Xmx1500m -Dawt.useSystemAAFontSettings=lcd -Dawt.java2d.opengl=true # Only for people on Mac, it makes Java use an optimised graphics engine. -Dapple.awt.graphics.UseQuartz=true Custom properties PHPStorm also has a file to set custom properties:  help > Edit Custom Properties . Adding one option here changed the way PHPStorm renders text: it will show text immediately, instead of analysing it first. The downside is that you can sometimes see a flash of unstyled text. It feels much smoother though. editor.zer...
Read more