Fix iterator / iterable typedefs, add generator typedefs

compiler/gentype/TranslateTypeExprFromTypes.ml

@@ -149,15 +149,155 @@ let translate_constr ~config ~params_translation ~(path : Path.t) ~type_env =
     {dependencies = []; type_ = ident ("Intl." ^ intl_module)}
   | (["Stdlib"; "Error"; "t"] | ["Stdlib"; "JsError"; "t"]), [] ->
     {dependencies = []; type_ = ident "Error"}
-  | ["Stdlib"; "Iterator"; "t"], [param_translation] ->
+  | (["Stdlib"; "Iterable"; "t"] | ["iterable"]), [param_translation] ->
     {
       dependencies = param_translation.dependencies;
-      type_ = ident ~type_args:[param_translation.type_] "Iterator";
+      type_ = ident ~type_args:[param_translation.type_] "Iterable";
     }
-  | ["Stdlib"; "AsyncIterator"; "t"], [param_translation] ->
+  | ( ["Stdlib"; "Iterator"; "t"],
+      [yield_translation; return_translation; next_translation] ) ->
+    {
+      dependencies =
+        List.concat
+          [
+            yield_translation.dependencies;
+            return_translation.dependencies;
+            next_translation.dependencies;
+          ];
+      type_ =
+        ident
+          ~type_args:
+            [
+              yield_translation.type_;
+              return_translation.type_;
+              next_translation.type_;
+            ]
+          "Iterator";
+    }
+  | ( ["Stdlib"; "IteratorObject"; "t"],
+      [yield_translation; return_translation; next_translation] ) ->
+    {
+      dependencies =
+        List.concat
+          [
+            yield_translation.dependencies;
+            return_translation.dependencies;
+            next_translation.dependencies;
+          ];
+      type_ =
+        ident
+          ~type_args:
+            [
+              yield_translation.type_;
+              return_translation.type_;
+              next_translation.type_;
+            ]
+          "IteratorObject";
+    }
+  | ( ["Stdlib"; "IterableIterator"; "t"],
+      [yield_translation; return_translation; next_translation] ) ->
+    {
+      dependencies =
+        List.concat
+          [
+            yield_translation.dependencies;
+            return_translation.dependencies;
+            next_translation.dependencies;
+          ];
+      type_ =
+        ident
+          ~type_args:
+            [
+              yield_translation.type_;
+              return_translation.type_;
+              next_translation.type_;
+            ]
+          "IterableIterator";
+    }
+  | ( ["Stdlib"; "Generator"; "t"],
+      [yield_translation; return_translation; next_translation] ) ->
+    {
+      dependencies =
+        List.concat
+          [
+            yield_translation.dependencies;
+            return_translation.dependencies;
+            next_translation.dependencies;
+          ];
+      type_ =
+        ident
+          ~type_args:
+            [
+              yield_translation.type_;
+              return_translation.type_;
+              next_translation.type_;
+            ]
+          "Generator";
+    }
+  | ["Stdlib"; "AsyncIterable"; "t"], [param_translation] ->
     {
       dependencies = param_translation.dependencies;
-      type_ = ident ~type_args:[param_translation.type_] "AsyncIterator";
+      type_ = ident ~type_args:[param_translation.type_] "AsyncIterable";
+    }
+  | ( ["Stdlib"; "AsyncIterator"; "t"],
+      [yield_translation; return_translation; next_translation] ) ->
+    {
+      dependencies =
+        List.concat
+          [
+            yield_translation.dependencies;
+            return_translation.dependencies;
+            next_translation.dependencies;
+          ];
+      type_ =
+        ident
+          ~type_args:
+            [
+              yield_translation.type_;
+              return_translation.type_;
+              next_translation.type_;
+            ]
+          "AsyncIterator";
+    }
+  | ( ["Stdlib"; "AsyncIterableIterator"; "t"],
+      [yield_translation; return_translation; next_translation] ) ->
+    {
+      dependencies =
+        List.concat
+          [
+            yield_translation.dependencies;
+            return_translation.dependencies;
+            next_translation.dependencies;
+          ];
+      type_ =
+        ident
+          ~type_args:
+            [
+              yield_translation.type_;
+              return_translation.type_;
+              next_translation.type_;
+            ]
+          "AsyncIterableIterator";
+    }
+  | ( ["Stdlib"; "AsyncGenerator"; "t"],
+      [yield_translation; return_translation; next_translation] ) ->
+    {
+      dependencies =
+        List.concat
+          [
+            yield_translation.dependencies;
+            return_translation.dependencies;
+            next_translation.dependencies;
+          ];
+      type_ =
+        ident
+          ~type_args:
+            [
+              yield_translation.type_;
+              return_translation.type_;
+              next_translation.type_;
+            ]
+          "AsyncGenerator";
     }
   | ["Stdlib"; "Ordering"; "t"], [] -> {dependencies = []; type_ = number_t}
   | ["unit"], [] -> {dependencies = []; type_ = unit_t}

compiler/ml/predef.ml

@@ -43,6 +43,8 @@ and ident_exn = ident_create "exn"
 
 and ident_array = ident_create "array"
 
+and ident_iterable = ident_create "iterable"
+
 and ident_list = ident_create "list"
 
 and ident_option = ident_create "option"
@@ -86,6 +88,8 @@ and path_exn = Pident ident_exn
 
 and path_array = Pident ident_array
 
+and path_iterable = Pident ident_iterable
+
 and path_list = Pident ident_list
 
 and path_option = Pident ident_option
@@ -118,6 +122,8 @@ and type_exn = newgenty (Tconstr (path_exn, [], ref Mnil))
 
 and type_array t = newgenty (Tconstr (path_array, [t], ref Mnil))
 
+and type_iterable t = newgenty (Tconstr (path_iterable, [t], ref Mnil))
+
 and type_list t = newgenty (Tconstr (path_list, [t], ref Mnil))
 
 and type_option t = newgenty (Tconstr (path_option, [t], ref Mnil))
@@ -245,6 +251,14 @@ let common_initial_env add_type add_extension empty_env =
       type_arity = 1;
       type_variance = [Variance.full];
     }
+  and decl_iterable =
+    let tvar = newgenvar () in
+    {
+      decl_abstr with
+      type_params = [tvar];
+      type_arity = 1;
+      type_variance = [Variance.covariant];
+    }
   and decl_list =
     let tvar = newgenvar () in
     {
@@ -369,6 +383,7 @@ let common_initial_env add_type add_extension empty_env =
   |> add_type ident_result decl_result
   |> add_type ident_promise decl_promise
   |> add_type ident_array decl_array
+  |> add_type ident_iterable decl_iterable
   |> add_type ident_list decl_list
   |> add_type ident_dict decl_dict
   |> add_type ident_unknown decl_unknown

compiler/ml/predef.mli

@@ -25,6 +25,7 @@ val type_bool : type_expr
 val type_unit : type_expr
 val type_exn : type_expr
 val type_array : type_expr -> type_expr
+val type_iterable : type_expr -> type_expr
 val type_list : type_expr -> type_expr
 val type_option : type_expr -> type_expr
 val type_result : type_expr -> type_expr -> type_expr
@@ -41,6 +42,7 @@ val path_bool : Path.t
 val path_unit : Path.t
 val path_exn : Path.t
 val path_array : Path.t
+val path_iterable : Path.t
 val path_list : Path.t
 val path_option : Path.t
 val path_result : Path.t

packages/@rescript/runtime/Stdlib.res

@@ -31,8 +31,15 @@ module String = Stdlib_String
 module Symbol = Stdlib_Symbol
 module Type = Stdlib_Type
 
+module Iterable = Stdlib_Iterable
 module Iterator = Stdlib_Iterator
+module IteratorObject = Stdlib_IteratorObject
+module IterableIterator = Stdlib_IterableIterator
+module Generator = Stdlib_Generator
+module AsyncIterable = Stdlib_AsyncIterable
 module AsyncIterator = Stdlib_AsyncIterator
+module AsyncIterableIterator = Stdlib_AsyncIterableIterator
+module AsyncGenerator = Stdlib_AsyncGenerator
 module Map = Stdlib_Map
 module WeakMap = Stdlib_WeakMap
 module Set = Stdlib_Set

packages/@rescript/runtime/Stdlib_Array.res

@@ -8,7 +8,10 @@ external setUnsafe: (array<'a>, int, 'a) => unit = "%array_unsafe_set"
 
 external unsafe_get: (array<'a>, int) => 'a = "%array_unsafe_get"
 
-@val external fromIterator: Stdlib_Iterator.t<'a> => array<'a> = "Array.from"
+external asIterable: array<'a> => Stdlib_Iterable.t<'a> = "%identity"
+
+@val
+external fromIterable: Stdlib_Iterable.t<'a> => array<'a> = "Array.from"
 @val external fromArrayLike: arrayLike<'a> => array<'a> = "Array.from"
 @val
 external fromArrayLikeWithMap: (arrayLike<'a>, 'a => 'b) => array<'b> = "Array.from"
@@ -406,7 +409,7 @@ let last = a => a->get(a->length - 1)
 external ignore: array<'a> => unit = "%ignore"
 
 @send
-external entries: array<'a> => Stdlib_Iterator.t<(int, 'a)> = "entries"
+external entries: array<'a> => Stdlib_IteratorObject.t<(int, 'a), unit, unknown> = "entries"
 
 @send
-external values: array<'a> => Stdlib_Iterator.t<'a> = "values"
+external values: array<'a> => Stdlib_IteratorObject.t<'a, unit, unknown> = "values"

packages/@rescript/runtime/Stdlib_Array.resi

@@ -11,18 +11,27 @@ type t<'a> = array<'a>
 type arrayLike<'a>
 
 /**
-`fromIterator(iterator)` creates an array from the provided `iterator`
+`asIterable(array)` views `array` as an `Iterable.t`.
+
+This is useful when passing an array to APIs that consume iterables, such as
+`Array.from` or `for...of` in JavaScript.
+*/
+external asIterable: array<'a> => Stdlib_Iterable.t<'a> = "%identity"
+
+/**
+`fromIterable(iterable)` creates an array from the provided `iterable`
 
 ## Examples
 
 ```rescript
 Map.fromArray([("foo", 1), ("bar", 2)])
 ->Map.values
-->Array.fromIterator == [1, 2]
+->IteratorObject.asIterable
+->Array.fromIterable == [1, 2]
 ```
 */
 @val
-external fromIterator: Stdlib_Iterator.t<'a> => array<'a> = "Array.from"
+external fromIterable: Stdlib_Iterable.t<'a> => array<'a> = "Array.from"
 
 /**
 `fromArrayLike(source)` converts an array-like value (anything with indexed items and a `length`) into a regular array.
@@ -1661,13 +1670,12 @@ See [Array.prototype.entries](https://developer.mozilla.org/en-US/docs/Web/JavaS
 
 ```rescript
 let array = [5, 6, 7]
-let iterator: Iterator.t<(int, int)> = array->Array.entries
-iterator->Iterator.next == {done: false, value: Some((0, 5))}
-iterator->Iterator.next == {done: false, value: Some((1, 6))}
+let iterator: IteratorObject.t<(int, int), unit, unknown> = array->Array.entries
+iterator->IteratorObject.toArray == [(0, 5), (1, 6), (2, 7)]
 ```
 */
 @send
-external entries: array<'a> => Stdlib_Iterator.t<(int, 'a)> = "entries"
+external entries: array<'a> => Stdlib_IteratorObject.t<(int, 'a), unit, unknown> = "entries"
 
 /**
 `values(array)` returns a new array iterator object that contains the values for each index in the array.
@@ -1678,10 +1686,9 @@ See [Array.prototype.values](https://developer.mozilla.org/en-US/docs/Web/JavaSc
 
 ```rescript
 let array = [5, 6, 7]
-let iterator: Iterator.t<int> = array->Array.values
-iterator->Iterator.next == {done: false, value: Some(5)}
-iterator->Iterator.next == {done: false, value: Some(6)}
+let iterator: IteratorObject.t<int, unit, unknown> = array->Array.values
+iterator->IteratorObject.toArray == [5, 6, 7]
 ```
  */
 @send
-external values: array<'a> => Stdlib_Iterator.t<'a> = "values"
+external values: array<'a> => Stdlib_IteratorObject.t<'a, unit, unknown> = "values"

packages/@rescript/runtime/Stdlib_AsyncGenerator.res

@@ -0,0 +1,36 @@
+type t<'yield, 'return, 'next> = Stdlib_AsyncIterable.t<'yield>
+
+external asAsyncIterable: t<'yield, 'return, 'next> => Stdlib_AsyncIterable.t<'yield> = "%identity"
+external asAsyncIterableIterator: t<'yield, 'return, 'next> => Stdlib_AsyncIterableIterator.t<
+  'yield,
+  'return,
+  'next,
+> = "%identity"
+external asAsyncIterator: t<'yield, 'return, 'next> => Stdlib_AsyncIterator.t<
+  'yield,
+  'return,
+  'next,
+> = "%identity"
+
+let next = generator => generator->asAsyncIterator->Stdlib_AsyncIterator.next
+
+let nextValue = (generator, value) =>
+  generator->asAsyncIterator->Stdlib_AsyncIterator.nextValue(value)
+
+@send
+external returnValueRaw: (
+  t<'yield, 'return, 'next>,
+  'return,
+) => promise<Stdlib_AsyncIterator.rawResult<'yield, 'return>> = "return"
+
+let returnValue = async (generator, value) =>
+  Stdlib_AsyncIterator.normalizeResult(await generator->returnValueRaw(value))
+
+@send
+external throwErrorRaw: (
+  t<'yield, 'return, 'next>,
+  exn,
+) => promise<Stdlib_AsyncIterator.rawResult<'yield, 'return>> = "throw"
+
+let throwError = async (generator, error) =>
+  Stdlib_AsyncIterator.normalizeResult(await generator->throwErrorRaw(error))