Add TypeSpec\varray() and TypeSpec\darray(), tests

Author: fredemmott

src/TypeSpec.hack

@@ -59,6 +59,13 @@ function constvector<Tv>(TypeSpec<Tv> $inner): TypeSpec<\ConstVector<Tv>> {
   return new __Private\VectorSpec(\ConstVector::class, $inner);
 }
 
+function darray<Tk as arraykey, Tv>(
+  TypeSpec<Tk> $tsk,
+  TypeSpec<Tv> $tsv,
+): TypeSpec<darray<Tk, Tv>> {
+  return new __Private\DictLikeArraySpec('darray', $tsk, $tsv);
+}
+
 function dict<Tk as arraykey, Tv>(
   TypeSpec<Tk> $tsk,
   TypeSpec<Tv> $tsv,
@@ -70,12 +77,13 @@ function dict_like_array<Tk as arraykey, Tv>(
   TypeSpec<Tk> $tsk,
   TypeSpec<Tv> $tsv,
 ): TypeSpec<array<Tk, Tv>> {
-  return new __Private\DictLikeArraySpec($tsk, $tsv);
+  return new __Private\DictLikeArraySpec('array', $tsk, $tsv);
 }
 
-function enum<Tinner as arraykey, T as /* HH_IGNORE_ERROR[2053] */ \HH\BuiltinEnum<Tinner>>(
-  classname<T> $what,
-): TypeSpec<T> {
+function enum<
+  Tinner as arraykey,
+  T as /* HH_IGNORE_ERROR[2053] */ \HH\BuiltinEnum<Tinner>,
+>(classname<T> $what): TypeSpec<T> {
   return new __Private\EnumSpec($what);
 }
 
@@ -147,15 +155,18 @@ function untyped_array(): TypeSpec<array> {
   return new __Private\UntypedArraySpec();
 }
 
-function vec_like_array<Tv>(TypeSpec<Tv> $tsv): TypeSpec<array<Tv>> {
-  return new __Private\VecLikeArraySpec($tsv);
+function varray<Tv>(TypeSpec<Tv> $tsv): TypeSpec<varray<Tv>> {
+  return new __Private\VecLikeArraySpec('varray', $tsv);
 }
 
-
 function vec<Tv>(TypeSpec<Tv> $inner): TypeSpec<vec<Tv>> {
   return new __Private\VecSpec($inner);
 }
 
+function vec_like_array<Tv>(TypeSpec<Tv> $tsv): TypeSpec<array<Tv>> {
+  return new __Private\VecLikeArraySpec('array', $tsv);
+}
+
 function vector<Tv>(TypeSpec<Tv> $inner): TypeSpec<Vector<Tv>> {
   return new __Private\VectorSpec(Vector::class, $inner);
 }

src/TypeSpec/__Private/DictLikeArraySpec.hack

@@ -19,6 +19,7 @@ final class DictLikeArraySpec<Tk as arraykey, Tv>
   extends TypeSpec<array<Tk, Tv>> {
 
   public function __construct(
+    private string $name,
     private TypeSpec<Tk> $tsk,
     private TypeSpec<Tv> $tsv,
   ) {
@@ -29,13 +30,13 @@ final class DictLikeArraySpec<Tk as arraykey, Tv>
     if (!$value is KeyedTraversable<_, _>) {
       throw TypeCoercionException::withValue(
         $this->getTrace(),
-        'array<Tk, Tv>',
+        $this->name.'<Tk, Tv>',
         $value,
       );
     }
 
-    $kt = $this->getTrace()->withFrame('array<Tk, _>');
-    $vt = $this->getTrace()->withFrame('array<_, Tv>');
+    $kt = $this->getTrace()->withFrame($this->name.'<Tk, _>');
+    $vt = $this->getTrace()->withFrame($this->name.'<_, Tv>');
 
     return Dict\pull_with_key(
       $value,
@@ -50,13 +51,13 @@ final class DictLikeArraySpec<Tk as arraykey, Tv>
     if (!\is_array($value)) {
       throw IncorrectTypeException::withValue(
         $this->getTrace(),
-        'array<Tk, Tv>',
+        $this->name.'<Tk, Tv>',
         $value,
       );
     }
 
-    $kt = $this->getTrace()->withFrame('array<Tk, _>');
-    $vt = $this->getTrace()->withFrame('array<_, Tv>');
+    $kt = $this->getTrace()->withFrame($this->name.'<Tk, _>');
+    $vt = $this->getTrace()->withFrame($this->name.'<_, Tv>');
 
     return Dict\pull_with_key(
       $value,
@@ -69,7 +70,8 @@ final class DictLikeArraySpec<Tk as arraykey, Tv>
   <<__Override>>
   public function toString(): string {
     return Str\format(
-      'array<%s, %s>',
+      '%s<%s, %s>',
+      $this->name,
       $this->tsk->toString(),
       $this->tsv->toString(),
     );

src/TypeSpec/__Private/VecLikeArraySpec.hack

@@ -15,14 +15,20 @@ use type Facebook\TypeSpec\TypeSpec;
 use namespace HH\Lib\Vec;
 
 final class VecLikeArraySpec<T> extends TypeSpec<array<T>> {
-  public function __construct(private TypeSpec<T> $inner) {
+  public function __construct(
+    private string $name,
+    private TypeSpec<T> $inner,
+  ) {
   }
 
   <<__Override>>
   public function coerceType(mixed $value): array<T> {
     if (!$value is Traversable<_>) {
-      throw
-        TypeCoercionException::withValue($this->getTrace(), 'array<T>', $value);
+      throw TypeCoercionException::withValue(
+        $this->getTrace(),
+        $this->name.'<T>',
+        $value,
+      );
     }
 
     return Vec\map($value, $inner ==> $this->inner->coerceType($inner))
@@ -34,7 +40,7 @@ final class VecLikeArraySpec<T> extends TypeSpec<array<T>> {
     if (!\is_array($value)) {
       throw IncorrectTypeException::withValue(
         $this->getTrace(),
-        'array<T>',
+        $this->name.'<T>',
         $value,
       );
     }
@@ -53,12 +59,15 @@ final class VecLikeArraySpec<T> extends TypeSpec<array<T>> {
         $counter->next();
         $i = $counter->current();
         if ($k !== $i) {
-          throw
-            IncorrectTypeException::withValue($this->getTrace(), 'key '.$i, $k);
+          throw IncorrectTypeException::withValue(
+            $this->getTrace(),
+            'key '.$i,
+            $k,
+          );
         }
         return $this
           ->inner
-          ->withTrace($this->getTrace()->withFrame('array['.$i.']'))
+          ->withTrace($this->getTrace()->withFrame($this->name.'['.$i.']'))
           ->assertType($inner);
       },
     )
@@ -67,6 +76,6 @@ final class VecLikeArraySpec<T> extends TypeSpec<array<T>> {
 
   <<__Override>>
   public function toString(): string {
-    return 'array<'.$this->inner->toString().'>';
+    return $this->name.'<'.$this->inner->toString().'>';
   }
 }

src/TypeSpec/__Private/from_type_structure.hack

@@ -75,10 +75,11 @@ function from_type_structure<T>(TypeStructure<T> $ts): TypeSpec<T> {
           return new UntypedArraySpec();
         case 1:
           /* HH_IGNORE_ERROR[4110] */
-          return new VecLikeArraySpec(from_type_structure($generics[0]));
+          return new VecLikeArraySpec('array', from_type_structure($generics[0]));
         case 2:
           /* HH_IGNORE_ERROR[4110] */
           return new DictLikeArraySpec(
+            'array',
             from_type_structure($generics[0]),
             from_type_structure($generics[1]),
           );

tests/DArraySpecTest.hack

@@ -0,0 +1,90 @@
+/*
+ *  Copyright (c) 2016, Fred Emmott
+ *  Copyright (c) 2017-present, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the MIT license found in the
+ *  LICENSE file in the root directory of this source tree.
+ *
+ */
+
+namespace Facebook\TypeAssert;
+
+use namespace Facebook\TypeSpec;
+use type Facebook\TypeSpec\TypeSpec;
+use function Facebook\FBExpect\expect;
+
+final class DArraySpecTest extends TypeSpecTest<darray<arraykey, mixed>> {
+  <<__Override>>
+  public function getTypeSpec(): TypeSpec<darray<arraykey, int>> {
+    return TypeSpec\darray(TypeSpec\arraykey(), TypeSpec\int());
+  }
+
+  <<__Override>>
+  public function getValidCoercions(): vec<(mixed, darray<arraykey, int>)> {
+    return vec[
+      tuple(Map {'foo' => 123}, darray['foo' => 123]),
+      tuple(ImmMap {'foo' => 123}, darray['foo' => 123]),
+      tuple(dict['foo' => 123], darray['foo' => 123]),
+      tuple(dict[], darray[]),
+      tuple(vec[123], darray[0 => 123]),
+      tuple(vec['123'], darray[0 => 123]),
+      tuple(keyset['123'], darray['123' => 123]),
+      tuple(keyset[123], darray[123 => 123]),
+      tuple(varray[123], darray[0 => 123]),
+      tuple(darray["123" => 123], darray['123' => 123]),
+    ];
+  }
+
+  <<__Override>>
+  public function getInvalidCoercions(): vec<(mixed)> {
+    return vec[
+      tuple(false),
+      tuple(123),
+      tuple(Map {'foo' => 'bar'}),
+    ];
+  }
+
+  <<__Override>>
+  public function getToStringExamples(
+  ): vec<(TypeSpec<darray<arraykey, mixed>>, string)> {
+    return vec[
+      tuple(
+        TypeSpec\darray(TypeSpec\string(), TypeSpec\int()),
+        'darray<string, int>',
+      ),
+      tuple(
+        TypeSpec\darray(TypeSpec\int(), TypeSpec\string()),
+        'darray<int, string>',
+      ),
+      tuple(
+        TypeSpec\dict_like_array(TypeSpec\string(), TypeSpec\int()),
+        'array<string, int>',
+      ),
+      tuple(
+        TypeSpec\dict_like_array(TypeSpec\int(), TypeSpec\string()),
+        'array<int, string>',
+      ),
+
+    ];
+  }
+
+  public function testDictLikeArrayIsDArray(): void {
+    $dict_like_array = (
+      (): array<string, int> ==> TypeSpec\dict_like_array(
+        TypeSpec\string(),
+        TypeSpec\int(),
+      )->assertType(darray['foo' => 123])
+    )();
+    expect($dict_like_array)->toEqual(darray['foo' => 123]);
+    $darray_asserted = (
+      (): darray<string, int> ==> TypeSpec\darray(
+        TypeSpec\string(),
+        TypeSpec\int(),
+      )->assertType($dict_like_array)
+    )();
+    expect($darray_asserted)->toEqual($dict_like_array);
+    $darray_verbatim = ((): darray<string, int> ==> $dict_like_array)();
+    expect($darray_verbatim)->toEqual($dict_like_array);
+  }
+}

tests/VArraySpecTest.hack

@@ -0,0 +1,73 @@
+/*
+ *  Copyright (c) 2016, Fred Emmott
+ *  Copyright (c) 2017-present, Facebook, Inc.
+ *  All rights reserved.
+ *
+ *  This source code is licensed under the MIT license found in the
+ *  LICENSE file in the root directory of this source tree.
+ *
+ */
+
+namespace Facebook\TypeAssert;
+
+use namespace Facebook\TypeSpec;
+use type Facebook\TypeSpec\TypeSpec;
+use function Facebook\FBExpect\expect;
+
+final class VArraySpecTest extends TypeSpecTest<varray<mixed>> {
+  <<__Override>>
+  public function getTypeSpec(): TypeSpec<varray<int>> {
+    return TypeSpec\varray(TypeSpec\int());
+  }
+
+  <<__Override>>
+  public function getValidCoercions(): vec<(mixed, varray<int>)> {
+    return vec[
+      tuple(vec[], varray[]),
+      tuple(vec['123'], varray[123]),
+      tuple(varray['123'], varray[123]),
+      tuple(varray[123], varray[123]),
+      tuple(dict['foo' => '456'], varray[456]),
+      tuple(Vector {123}, varray[123]),
+      tuple(darray['foo' => 123], varray[123]),
+      tuple(keyset['123'], varray[123]),
+    ];
+  }
+
+  <<__Override>>
+  public function getInvalidCoercions(): vec<(mixed)> {
+    return vec[
+      tuple(false),
+      tuple(123),
+      tuple(varray['foo']),
+      tuple(vec['foo']),
+      tuple(keyset['foo']),
+    ];
+  }
+
+  <<__Override>>
+  public function getToStringExamples(
+  ): vec<(TypeSpec<varray<mixed>>, string)> {
+    return vec[
+      tuple(TypeSpec\varray(TypeSpec\string()), 'varray<string>'),
+      tuple(TypeSpec\varray(TypeSpec\int()), 'varray<int>'),
+      tuple(TypeSpec\vec_like_array(TypeSpec\string()), 'array<string>'),
+      tuple(TypeSpec\vec_like_array(TypeSpec\int()), 'array<int>'),
+    ];
+  }
+
+  public function testVecLikeArrayIsVArray(): void {
+    $vec_like_array = (
+      (): array<int> ==>
+        TypeSpec\vec_like_array(TypeSpec\int())->assertType(varray[123])
+    )();
+    expect($vec_like_array)->toEqual(varray[123]);
+    $varray_asserted = (
+      (): varray<int> ==>
+        TypeSpec\varray(TypeSpec\int())->assertType($vec_like_array)
+    )();
+    expect($varray_asserted)->toEqual($vec_like_array);
+    $varray_verbatim = ((): varray<int> ==> $vec_like_array)();
+    expect($varray_verbatim)->toEqual($vec_like_array);
+  }
+}