S.isAsyncParse -> S.isAsync

Author: DZakh

IDEAS.md

@@ -44,6 +44,7 @@ let trimContract: S.contract<string => string> = S.contract(s => {
 - Add S.bigint
 - Add S.removeTypeValidation
 - Add S.unwrap
+- S.isAsyncParse -> S.isAsync
 
 ## v10
 

packages/tests/src/core/S_isAsyncParse_test.res renamed to packages/tests/src/core/S_isAsync_test.res

@@ -2,28 +2,28 @@ open Ava
 open RescriptCore
 
 test("Returns false for schema with NoOperation", t => {
-  t->Assert.is(S.unknown->S.isAsyncParse, false, ())
+  t->Assert.is(S.unknown->S.isAsync, false, ())
 })
 
 test("Returns false for sync schema", t => {
-  t->Assert.is(S.string->S.isAsyncParse, false, ())
+  t->Assert.is(S.string->S.isAsync, false, ())
 })
 
 test("Returns true for async schema", t => {
   let schema = S.string->S.transform(_ => {asyncParser: i => () => Promise.resolve(i)})
 
-  t->Assert.is(schema->S.isAsyncParse, true, ())
+  t->Assert.is(schema->S.isAsync, true, ())
 })
 
 test("Returns true for async schema after running a serializer", t => {
   let schema =
     S.string->S.transform(_ => {asyncParser: i => () => Promise.resolve(i), serializer: i => i})
   t->Assert.deepEqual("abc"->S.serializeWith(schema), Ok(%raw(`"abc"`)), ())
-  t->Assert.is(schema->S.isAsyncParse, true, ())
+  t->Assert.is(schema->S.isAsync, true, ())
 })
 
 test("Returns true for schema with nested async", t => {
   let schema = S.tuple1(S.string->S.transform(_ => {asyncParser: i => () => Promise.resolve(i)}))
 
-  t->Assert.is(schema->S.isAsyncParse, true, ())
+  t->Assert.is(schema->S.isAsync, true, ())
 })

packages/tests/src/utils/U.bs.mjs

@@ -96,7 +96,7 @@ function assertCompiledCode(t, schema, op, code, message) {
 
     }
     compiledCode = (schema.serializeOrThrow.toString());
-  } else if (S$RescriptSchema.isAsyncParse(schema)) {
+  } else if (S$RescriptSchema.isAsync(schema)) {
     S$RescriptSchema.parseAsyncWith(undefined, schema);
     compiledCode = (schema.a.toString());
   } else {
@@ -116,7 +116,7 @@ function assertCompiledCodeIsNoop(t, schema, op, message) {
 
     }
     compiledCode = (schema.serializeOrThrow.toString());
-  } else if (S$RescriptSchema.isAsyncParse(schema)) {
+  } else if (S$RescriptSchema.isAsync(schema)) {
     S$RescriptSchema.parseAsyncWith(undefined, schema);
     compiledCode = (schema.a.toString());
   } else {

packages/tests/src/utils/U.res

@@ -80,7 +80,7 @@ let assertCompiledCode = (
 ) => {
   let compiledCode = switch op {
   | #Parse =>
-    if schema->S.isAsyncParse {
+    if schema->S.isAsync {
       let _ = %raw(`undefined`)->S.parseAsyncWith(schema)
       %raw(`schema.a.toString()`)
     } else {
@@ -113,7 +113,7 @@ let assertCompiledCode = (
 let assertCompiledCodeIsNoop = (t, ~schema, ~op: [#Parse | #Serialize], ~message=?) => {
   let compiledCode = switch op {
   | #Parse =>
-    if schema->S.isAsyncParse {
+    if schema->S.isAsync {
       let _ = %raw(`undefined`)->S.parseAsyncWith(schema)
       %raw(`schema.a.toString()`)
     } else {

src/S.bs.mjs

@@ -102,6 +102,8 @@ var assertOrRaiseWith = S_Core$RescriptSchema.assertOrRaiseWith;
 
 var isAsyncParse = S_Core$RescriptSchema.isAsyncParse;
 
+var isAsync = S_Core$RescriptSchema.isAsync;
+
 var recursive = S_Core$RescriptSchema.recursive;
 
 var classify = S_Core$RescriptSchema.classify;
@@ -235,6 +237,7 @@ export {
   serializeToJsonStringOrRaiseWith ,
   assertOrRaiseWith ,
   isAsyncParse ,
+  isAsync ,
   recursive ,
   classify ,
   setName ,

src/S.resi

@@ -234,7 +234,9 @@ let serializeToJsonStringOrRaiseWith: ('value, t<'value>, ~space: int=?) => stri
 
 let assertOrRaiseWith: ('any, t<'value>) => unit
 
+@deprecated("It'll be removed in v9. Use S.isAsync instead")
 let isAsyncParse: t<'value> => bool
+let isAsync: t<'value> => bool
 
 let recursive: (t<'value> => t<'value>) => t<'value>
 

src/S_Core.bs.mjs

@@ -686,7 +686,7 @@ function parse(any) {
   return parseInternal(any);
 }
 
-function isAsyncParse(schema) {
+function isAsync(schema) {
   var v = schema.i;
   if (typeof v === "boolean") {
     return v;
@@ -3126,6 +3126,8 @@ var parseOrRaiseWith = parseAnyOrRaiseWith;
 
 var parseAsyncWith = parseAnyAsyncWith;
 
+var isAsyncParse = isAsync;
+
 var Schema = {};
 
 var schema$7 = factory$7;
@@ -3229,6 +3231,7 @@ export {
   serializeToJsonStringOrRaiseWith ,
   assertOrRaiseWith ,
   isAsyncParse ,
+  isAsync ,
   recursive ,
   classify ,
   setName ,

src/S_Core.res

@@ -1199,8 +1199,7 @@ module Literal = {
   }
 }
 
-// TODO: Rename to isAsync
-let isAsyncParse = schema => {
+let isAsync = schema => {
   let schema = schema->toUnknown
   switch schema.isAsyncSchema {
   | Unknown =>
@@ -1228,6 +1227,7 @@ let isAsyncParse = schema => {
   | Value(v) => v
   }
 }
+let isAsyncParse = isAsync
 
 let \"~experimantalReverse" = schema => {
   schema.reverse()

src/S_Core.resi

@@ -235,6 +235,7 @@ let serializeToJsonStringOrRaiseWith: ('value, t<'value>, ~space: int=?) => stri
 let assertOrRaiseWith: ('any, t<'value>) => unit
 
 let isAsyncParse: t<'value> => bool
+let isAsync: t<'value> => bool
 
 let recursive: (t<'value> => t<'value>) => t<'value>