Add "any" to convert operation names and add S.convertAnyAsyncWith

Author: DZakh

src/S.bs.mjs

@@ -86,11 +86,13 @@ var parseAsyncWith = S_Core$RescriptSchema.parseAsyncWith;
 
 var parseAnyAsyncWith = S_Core$RescriptSchema.parseAnyAsyncWith;
 
-var convertWith = S_Core$RescriptSchema.convertWith;
+var convertAnyWith = S_Core$RescriptSchema.convertAnyWith;
 
-var convertToJsonWith = S_Core$RescriptSchema.convertToJsonWith;
+var convertAnyToJsonWith = S_Core$RescriptSchema.convertAnyToJsonWith;
 
-var convertToJsonStringWith = S_Core$RescriptSchema.convertToJsonStringWith;
+var convertAnyToJsonStringWith = S_Core$RescriptSchema.convertAnyToJsonStringWith;
+
+var convertAnyAsyncWith = S_Core$RescriptSchema.convertAnyAsyncWith;
 
 var serializeWith = S_Core$RescriptSchema.serializeWith;
 
@@ -235,9 +237,10 @@ export {
   parseAnyOrRaiseWith ,
   parseAsyncWith ,
   parseAnyAsyncWith ,
-  convertWith ,
-  convertToJsonWith ,
-  convertToJsonStringWith ,
+  convertAnyWith ,
+  convertAnyToJsonWith ,
+  convertAnyToJsonStringWith ,
+  convertAnyAsyncWith ,
   serializeWith ,
   serializeToUnknownWith ,
   serializeToJsonStringWith ,

src/S.resi

@@ -224,9 +224,10 @@ let parseAsyncWith: (Js.Json.t, t<'value>) => promise<result<'value, error>>
 
 let parseAnyAsyncWith: ('any, t<'value>) => promise<result<'value, error>>
 
-let convertWith: ('any, t<'value>) => result<'value, error>
-let convertToJsonWith: ('any, t<'value>) => result<Js.Json.t, error>
-let convertToJsonStringWith: ('any, t<'value>) => result<string, error>
+let convertAnyWith: ('any, t<'value>) => result<'value, error>
+let convertAnyToJsonWith: ('any, t<'value>) => result<Js.Json.t, error>
+let convertAnyToJsonStringWith: ('any, t<'value>) => result<string, error>
+let convertAnyAsyncWith: ('any, t<'value>) => promise<result<'value, error>>
 
 let serializeWith: ('value, t<'value>) => result<Js.Json.t, error>
 

src/S_Core.bs.mjs

@@ -727,19 +727,25 @@ function $tildeexperimentalReverse(schema) {
   return schema.r();
 }
 
-function parseAnyOrRaiseWith(any, schema) {
-  return schema.parseOrThrow(any);
+function asyncPrepareOk(value) {
+  return {
+          TAG: "Ok",
+          _0: value
+        };
 }
 
-function assertOrRaiseWith(any, schema) {
-  schema.assert(any);
+function asyncPrepareError(jsExn) {
+  return {
+          TAG: "Error",
+          _0: getOrRethrow(jsExn)
+        };
 }
 
-function parseAnyWith(any, schema) {
+function convertAnyWith(any, schema) {
   try {
     return {
             TAG: "Ok",
-            _0: schema.parseOrThrow(any)
+            _0: (schema[0] ? undefined : (schema[0] = compile(schema.b, schema, 0), undefined), schema[0](any))
           };
   }
   catch (raw_exn){
@@ -751,11 +757,11 @@ function parseAnyWith(any, schema) {
   }
 }
 
-function convertWith(any, schema) {
+function convertAnyToJsonWith(any, schema) {
   try {
     return {
             TAG: "Ok",
-            _0: (schema[0] ? undefined : (schema[0] = compile(schema.b, schema, 0), undefined), schema[0](any))
+            _0: (schema[8] ? undefined : (schema[8] = compile(schema.b, schema, 8), undefined), schema[8](any))
           };
   }
   catch (raw_exn){
@@ -767,11 +773,11 @@ function convertWith(any, schema) {
   }
 }
 
-function convertToJsonWith(any, schema) {
+function convertAnyToJsonStringWith(any, schema) {
   try {
     return {
             TAG: "Ok",
-            _0: (schema[8] ? undefined : (schema[8] = compile(schema.b, schema, 8), undefined), schema[8](any))
+            _0: (schema[16] ? undefined : (schema[16] = compile(schema.b, schema, 16), undefined), schema[16](any))
           };
   }
   catch (raw_exn){
@@ -783,11 +789,32 @@ function convertToJsonWith(any, schema) {
   }
 }
 
-function convertToJsonStringWith(any, schema) {
+function convertAnyAsyncWith(any, schema) {
+  try {
+    return (schema[2] ? undefined : (schema[2] = compile(schema.b, schema, 2), undefined), schema[2](any)).then(asyncPrepareOk, asyncPrepareError);
+  }
+  catch (raw_exn){
+    var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
+    return Promise.resolve({
+                TAG: "Error",
+                _0: getOrRethrow(exn)
+              });
+  }
+}
+
+function parseAnyOrRaiseWith(any, schema) {
+  return schema.parseOrThrow(any);
+}
+
+function assertOrRaiseWith(any, schema) {
+  schema.assert(any);
+}
+
+function parseAnyWith(any, schema) {
   try {
     return {
             TAG: "Ok",
-            _0: (schema[16] ? undefined : (schema[16] = compile(schema.b, schema, 16), undefined), schema[16](any))
+            _0: schema.parseOrThrow(any)
           };
   }
   catch (raw_exn){
@@ -799,23 +826,9 @@ function convertToJsonStringWith(any, schema) {
   }
 }
 
-function asyncPrepareOk(value) {
-  return {
-          TAG: "Ok",
-          _0: value
-        };
-}
-
-function asyncPrepareError(jsExn) {
-  return {
-          TAG: "Error",
-          _0: getOrRethrow(jsExn)
-        };
-}
-
 function parseAnyAsyncWith(any, schema) {
   try {
-    return schema.a(any).then(asyncPrepareOk, asyncPrepareError);
+    return (schema[3] ? undefined : (schema[3] = compile(schema.b, schema, 3), undefined), schema[3](any)).then(asyncPrepareOk, asyncPrepareError);
   }
   catch (raw_exn){
     var exn = Caml_js_exceptions.internalToOCamlException(raw_exn);
@@ -924,13 +937,6 @@ function initialParseOrRaise(unknown) {
   return operation(unknown);
 }
 
-function initialParseAsyncOrRaise(unknown) {
-  var schema = this;
-  var operation = compile(schema.b, schema, 3);
-  schema.a = operation;
-  return operation(unknown);
-}
-
 function initialAssertOrRaise(unknown) {
   var schema = this;
   var operation = compile(schema.b, schema, 5);
@@ -1006,7 +1012,6 @@ function makeReverseSchema(name, tagged, metadataMap, builder, maybeTypeFilter)
           f: maybeTypeFilter,
           i: 0,
           m: metadataMap,
-          a: initialParseAsyncOrRaise,
           parseOrThrow: initialParseOrRaise,
           parse: jsParse,
           parseAsync: jsParseAsync,
@@ -1034,7 +1039,6 @@ function makeSchema(name, tagged, metadataMap, builder, maybeTypeFilter, reverse
           f: maybeTypeFilter,
           i: 0,
           m: metadataMap,
-          a: initialParseAsyncOrRaise,
           parseOrThrow: initialParseOrRaise,
           parse: jsParse,
           parseAsync: jsParseAsync,
@@ -1720,7 +1724,6 @@ function factory$3(definer) {
           d: definer,
           c: ctx,
           m: empty,
-          a: initialParseAsyncOrRaise,
           parseOrThrow: initialParseOrRaise,
           parse: jsParse,
           parseAsync: jsParseAsync,
@@ -1877,7 +1880,6 @@ function setUnknownKeys(schema, unknownKeys) {
             d: schema.d,
             c: schema.c,
             m: schema.m,
-            a: initialParseAsyncOrRaise,
             parseOrThrow: initialParseOrRaise,
             parse: jsParse,
             parseAsync: jsParseAsync,
@@ -3114,7 +3116,6 @@ function setGlobalConfig(override) {
   if (prevDisableNanNumberCheck !== globalConfig.n) {
     schema$5.assert = initialAssertOrRaise;
     schema$5.parseOrThrow = initialParseOrRaise;
-    schema$5.a = initialParseAsyncOrRaise;
     return ;
   }
 
@@ -3280,9 +3281,10 @@ export {
   parseAnyOrRaiseWith ,
   parseAsyncWith ,
   parseAnyAsyncWith ,
-  convertWith ,
-  convertToJsonWith ,
-  convertToJsonStringWith ,
+  convertAnyWith ,
+  convertAnyToJsonWith ,
+  convertAnyToJsonStringWith ,
+  convertAnyAsyncWith ,
   serializeWith ,
   serializeToUnknownWith ,
   serializeToJsonStringWith ,

src/S_Core.res

@@ -249,9 +249,6 @@ type rec t<'value> = {
   mutable definerCtx?: char,
   @as("m")
   metadataMap: dict<unknown>,
-  @as("a")
-  mutable // FIXME: Remove
-  parseAsyncOrRaise: unknown => promise<unknown>,
   @as("parseOrThrow")
   mutable parseOrRaise: unknown => unknown,
   @as("parse")
@@ -1292,59 +1289,67 @@ let useSyncOperation = (schema, operation, input) => {
   }
 }
 
-@inline
-let parseAnyOrRaiseWith = (any, schema) => {
-  schema.parseOrRaise(any->castAnyToUnknown)->castUnknownToAny
-}
+let asyncPrepareOk = value => Ok(value->castUnknownToAny)
 
-let assertOrRaiseWith = (any, schema) => {
-  schema.assertOrRaise(any->castAnyToUnknown)
+let asyncPrepareError = jsExn => {
+  jsExn->(Obj.magic: Js.Exn.t => exn)->InternalError.getOrRethrow->Error
 }
 
-let parseAnyWith = (any, schema) => {
+@inline
+let useAsyncOperation = (schema, operation, input) => {
   try {
-    parseAnyOrRaiseWith(any->castAnyToUnknown, schema)->castUnknownToAny->Ok
+    schema
+    ->callMemoizedOperation(operation->Operation.addFlag(Operation.Flag.async), input)
+    ->Stdlib.Promise.thenResolveWithCatch(asyncPrepareOk, asyncPrepareError)
   } catch {
-  | exn => exn->InternalError.getOrRethrow->Error
+  | exn => exn->InternalError.getOrRethrow->Error->Stdlib.Promise.resolve
   }
 }
 
-let parseWith: (Js.Json.t, t<'value>) => result<'value, error> = parseAnyWith
-
-let parseOrRaiseWith: (Js.Json.t, t<'value>) => 'value = parseAnyOrRaiseWith
-
-let convertWith = (any, schema) => {
+let convertAnyWith = (any, schema) => {
   schema->useSyncOperation(Operation.make(), any)
 }
 
-let convertToJsonWith = (any, schema) => {
+let convertAnyToJsonWith = (any, schema) => {
   schema->useSyncOperation(Operation.make()->Operation.addFlag(Operation.Flag.jsonableOutput), any)
 }
 
-let convertToJsonStringWith = (any, schema) => {
+let convertAnyToJsonStringWith = (any, schema) => {
   schema->useSyncOperation(
     Operation.make()->Operation.addFlag(Operation.Flag.jsonStringOutput),
     any,
   )
 }
 
-let asyncPrepareOk = value => Ok(value->castUnknownToAny)
+let convertAnyAsyncWith = (any, schema) => {
+  schema->useAsyncOperation(Operation.make(), any)
+}
 
-let asyncPrepareError = jsExn => {
-  jsExn->(Obj.magic: Js.Exn.t => exn)->InternalError.getOrRethrow->Error
+@inline
+let parseAnyOrRaiseWith = (any, schema) => {
+  schema.parseOrRaise(any->castAnyToUnknown)->castUnknownToAny
 }
 
-let parseAnyAsyncWith = (any, schema) => {
+let assertOrRaiseWith = (any, schema) => {
+  schema.assertOrRaise(any->castAnyToUnknown)
+}
+
+let parseAnyWith = (any, schema) => {
   try {
-    schema.parseAsyncOrRaise(any->castAnyToUnknown)->Stdlib.Promise.thenResolveWithCatch(
-      asyncPrepareOk,
-      asyncPrepareError,
-    )
+    parseAnyOrRaiseWith(any->castAnyToUnknown, schema)->castUnknownToAny->Ok
   } catch {
-  | exn => exn->InternalError.getOrRethrow->Error->Stdlib.Promise.resolve
+  | exn => exn->InternalError.getOrRethrow->Error
   }
 }
 
+let parseWith: (Js.Json.t, t<'value>) => result<'value, error> = parseAnyWith
+
+let parseOrRaiseWith: (Js.Json.t, t<'value>) => 'value = parseAnyOrRaiseWith
+
+let parseAnyAsyncWith = (any, schema) => {
+  schema->useAsyncOperation(Operation.make()->Operation.addFlag(Operation.Flag.typeValidation), any)
+}
+
 let parseAsyncWith = parseAnyAsyncWith
 
 let serializeOrRaiseWith = (value, schema) => {
@@ -1416,18 +1421,6 @@ let initialParseOrRaise = unknown => {
   operation(unknown)
 }
 
-let initialParseAsyncOrRaise = unknown => {
-  let schema = %raw(`this`)
-  let operation = schema.builder->Builder.compile(
-    ~schema,
-    ~operation=Operation.make()
-    ->Operation.addFlag(Operation.Flag.typeValidation)
-    ->Operation.addFlag(Operation.Flag.async),
-  )
-  schema.parseAsyncOrRaise = operation
-  operation(unknown)
-}
-
 let initialAssertOrRaise = unknown => {
   let schema = %raw(`this`)
   let operation = schema.builder->Builder.compile(
@@ -1501,7 +1494,6 @@ let makeReverseSchema = (~name, ~tagged, ~metadataMap, ~builder, ~maybeTypeFilte
   name,
   metadataMap,
   parseOrRaise: initialParseOrRaise,
-  parseAsyncOrRaise: initialParseAsyncOrRaise,
   serializeToUnknownOrRaise: initialSerializeToUnknownOrRaise,
   serializeOrRaise: initialSerializeOrRaise,
   assertOrRaise: initialAssertOrRaise,
@@ -1519,7 +1511,6 @@ let makeSchema = (~name, ~tagged, ~metadataMap, ~builder, ~maybeTypeFilter, ~rev
   name,
   metadataMap,
   parseOrRaise: initialParseOrRaise,
-  parseAsyncOrRaise: initialParseAsyncOrRaise,
   serializeToUnknownOrRaise: initialSerializeToUnknownOrRaise,
   serializeOrRaise: initialSerializeOrRaise,
   assertOrRaise: initialAssertOrRaise,
@@ -2757,7 +2748,6 @@ module Object = {
         definer: definer->Obj.magic,
         definerCtx: ctx->Obj.magic,
         parseOrRaise: initialParseOrRaise,
-        parseAsyncOrRaise: initialParseAsyncOrRaise,
         serializeToUnknownOrRaise: initialSerializeToUnknownOrRaise,
         serializeOrRaise: initialSerializeOrRaise,
         assertOrRaise: initialAssertOrRaise,
@@ -2786,7 +2776,6 @@ module Object = {
         definer: ?schema.definer,
         definerCtx: ?schema.definerCtx,
         parseOrRaise: initialParseOrRaise,
-        parseAsyncOrRaise: initialParseAsyncOrRaise,
         serializeToUnknownOrRaise: initialSerializeToUnknownOrRaise,
         serializeOrRaise: initialSerializeOrRaise,
         assertOrRaise: initialAssertOrRaise,
@@ -4253,8 +4242,7 @@ let setGlobalConfig = override => {
   }
   if prevDisableNanNumberCheck != globalConfig.disableNanNumberCheck {
     float.assertOrRaise = initialAssertOrRaise
-    float.parseOrRaise = initialParseOrRaise
-    float.parseAsyncOrRaise = initialParseAsyncOrRaise
+    float.parseOrRaise = initialParseOrRaise // FIXME: Reset all memoid operations by flag
   }
 }