, Error.t>, ~send) =>
+ result |> ReludeReact.Render.asyncResultByValueLazy(
+ _ =>
{React.string(state.title)}
{
- ReactEvent.Synthetic.preventDefault(e);
- send(ViewCreateForm);
+ ReactEvent.Synthetic.preventDefault(e)
+ send(ViewCreateForm)
}}>
{React.string("Create")}
{
- ReactEvent.Synthetic.preventDefault(e);
- send(NoOp);
+ ReactEvent.Synthetic.preventDefault(e)
+ send(NoOp)
}}>
{React.string("No-Op Action")}
-
-
;
- };
-};
+ {React.string("Animal create view")}
-
- | _ => {React.string("Invalid URL")}
- };
-};
\ No newline at end of file
diff --git a/examples/demo/Router.res b/examples/demo/Router.res
new file mode 100644
index 0000000..065cf8f
--- /dev/null
+++ b/examples/demo/Router.res
@@ -0,0 +1,12 @@
+@react.component
+let make = () => {
+ let url = RescriptReactRouter.useUrl()
+
+ switch url.path {
+ | list{} => {React.string("Animal create view")}
+
+ | _ => {React.string("Invalid URL")}
+ }
+}
diff --git a/examples/sandbox/SandboxApp.re b/examples/sandbox/SandboxApp.re
deleted file mode 100644
index b2b7d82..0000000
--- a/examples/sandbox/SandboxApp.re
+++ /dev/null
@@ -1,46 +0,0 @@
-//open Relude.Globals;
-
-type state = {count: int};
-
-let initialState = {count: 0};
-
-type action =
- | Inc
- | Dec;
-
-let reducer: ReludeReact.Reducer.reducer(action, state) =
- (state, action) =>
- switch (action) {
- | Inc =>
- // This seems to work as expected - a single log
- UpdateWithSideEffect({count: state.count + 1}, _ => Js.log("Inc"));
-
- | Dec =>
- Js.log("Dec"); // This logs "Dec" twice if you click the Decrement button first before doing anything else
- Update({count: state.count - 1});
- };
-
-[@react.component]
-let make = () => {
- let (state, send) = ReludeReact.Reducer.useReducer(reducer, initialState);
-
-
-
{React.string("Count: " ++ string_of_int(state.count))}
-
{
- Js.log("onClick Inc");
- send(Inc);
- }}>
- {React.string("Increment")}
-
-
{
- Js.log("onClick Dec");
- send(Dec);
- }}>
- {React.string("Decrement")}
-
-
= (state, action) =>
+ switch action {
+ | Inc =>
+ // This seems to work as expected - a single log
+ UpdateWithSideEffect({count: state.count + 1}, _ => Js.log("Inc"))
+
+ | Dec =>
+ Js.log("Dec") // This logs "Dec" twice if you click the Decrement button first before doing anything else
+ Update({count: state.count - 1})
+ }
+
+@react.component
+let make = () => {
+ let (state, send) = ReludeReact.Reducer.useReducer(reducer, initialState)
+
+
+
{React.string("Count: " ++ string_of_int(state.count))}
+
{
+ Js.log("onClick Inc")
+ send(Inc)
+ }}>
+ {React.string("Increment")}
+
+
{
+ Js.log("onClick Dec")
+ send(Dec)
+ }}>
+ {React.string("Decrement")}
+
+
>>,
+}
+
+@ocaml.doc("
+ * Accepts a reducer function that emits `update` commands. Any updates that include side
+ * effects (SideEffect, UpdateWithIO, etc.) will be handled by enqueuing the side effects
+ * for execution outside of the reducer in a controlled fashion. The side effects are expected
+ * to dispatch further reducer actions to cause state changes, etc. IO-based effects are expected
+ * to produce actions that will be dispatched automatically.
+ ")
+let useReducer = (reducer: reducer<'action, 'state>, initialState: 'state) => {
+ // This wraps the given reducer function with the ability to capture the side effects
+ // emitted by the various types of updates, and stick them in our mutable array of effects to run later
+ let reducerWithSideEffects = ({state, sideEffects} as stateAndSideEffects, action) => {
+ let update = reducer(state, action)
+
+ switch update {
+ | NoUpdate => stateAndSideEffects
+
+ | Update(state) => {...stateAndSideEffects, state: state}
+
+ | UpdateWithSideEffect(state, sideEffect) => {
+ state: state,
+ sideEffects: ref(
+ Belt.Array.concat(sideEffects.contents, [SideEffect.Uncancelable.lift(sideEffect)]),
+ ),
+ }
+
+ | UpdateWithCancelableSideEffect(state, cancelableSideEffect) => {
+ state: state,
+ sideEffects: ref(
+ Belt.Array.concat(
+ sideEffects.contents,
+ [SideEffect.Cancelable.lift(cancelableSideEffect)],
+ ),
+ ),
+ }
+
+ | SideEffect(uncancelableSideEffect) => {
+ ...stateAndSideEffects,
+ sideEffects: ref(
+ Belt.Array.concat(
+ stateAndSideEffects.sideEffects.contents,
+ [SideEffect.Uncancelable.lift(uncancelableSideEffect)],
+ ),
+ ),
+ }
+
+ | CancelableSideEffect(cancelableSideEffect) => {
+ ...stateAndSideEffects,
+ sideEffects: ref(
+ Belt.Array.concat(
+ stateAndSideEffects.sideEffects.contents,
+ [SideEffect.Cancelable.lift(cancelableSideEffect)],
+ ),
+ ),
+ }
+
+ | UpdateWithIO(state, ioAction) =>
+ // The IO must have an 'action type for both the success and error channels - this
+ // way we know that the errors have been properly handled and translated to the appropriate action.
+ // Run the IO to get the success and error actions, then just send them.
+ // TODO: we don't have cancelable IOs (yet?)
+ let sideEffect: SideEffect.t<'action, 'state> = context => {
+ ioAction |> Relude.IO.unsafeRunAsync(x =>
+ switch x {
+ | Ok(action) => context.send(action)
+ | Error(action) => context.send(action)
+ }
+ )
+ None
+ }
+ {
+ state: state,
+ sideEffects: ref(Belt.Array.concat(stateAndSideEffects.sideEffects.contents, [sideEffect])),
+ }
+
+ | IO(ioAction) =>
+ let sideEffect: SideEffect.t<'action, 'state> = context => {
+ ioAction |> Relude.IO.unsafeRunAsync(x =>
+ switch x {
+ | Ok(action) => context.send(action)
+ | Error(action) => context.send(action)
+ }
+ )
+ None
+ }
+ {
+ ...stateAndSideEffects,
+ sideEffects: ref(Belt.Array.concat(stateAndSideEffects.sideEffects.contents, [sideEffect])),
+ }
+ }
+ }
+
+ // Our new initial state is the caller's state, plus our initial empty array of effects to run
+ let initialStateWithSideEffects = {
+ state: initialState,
+ sideEffects: ref([]),
+ }
+
+ // Plug our new reducer function into the React user reducer. This reducer takes the `update`s from the caller's
+ // reducers and enqueues the side effects in a mutable array for processing below in a separate useEffect
+ let ({state, sideEffects}, send) = React.useReducer(
+ reducerWithSideEffects,
+ initialStateWithSideEffects,
+ )
+
+ // This registers the side effects that were emitted by the reducer in a react effect hook.
+ // When the hook runs, it will execute all the side effects and will
+ // pass along any cancelation functions (bundled in a single cancelation function) to react itself.
+ // Each time this runs, the side effects array is cleared. Also, we pass along the side effects array
+ // in the awesome array argument for react to monitor.
+ React.useEffect1(() =>
+ if Array.length(sideEffects.contents) > 0 {
+ let cancelers: array = Belt.Array.keepMap(
+ sideEffects.contents,
+ sideEffect => sideEffect({state: state, send: send}),
+ )
+
+ sideEffects := []
+
+ Array.length(cancelers) > 0 ? Some(() => cancelers->Belt.Array.forEach(func => func())) : None
+ } else {
+ None
+ }
+ , [sideEffects])
+
+ // Finally, we return our initial state, and the send function for use in the calling component
+ (state, send)
+}
diff --git a/src/ReludeReact_Render.re b/src/ReludeReact_Render.re
deleted file mode 100644
index 2a86c7e..0000000
--- a/src/ReludeReact_Render.re
+++ /dev/null
@@ -1,525 +0,0 @@
-/**
-Returns an element if the condition is true, otherwise React.null
-*/
-let ifTrue: (React.element, bool) => React.element =
- (element, condition) => if (condition) {element} else {React.null};
-
-/**
-Renders an element if the condition is true, otherwise React.null
-*/
-let ifTrueLazy: (unit => React.element, bool) => React.element =
- (element, condition) =>
- if (condition) {
- element();
- } else {
- React.null;
- };
-
-/**
-Returns an element if the condition is false, otherwise React.null
-*/
-let ifFalse: (React.element, bool) => React.element =
- (element, condition) =>
- if (!condition) {
- element;
- } else {
- React.null;
- };
-
-/**
-Renders an element if the condition is false, otherwise React.null
-*/
-let ifFalseLazy: (unit => React.element, bool) => React.element =
- (element, condition) =>
- if (!condition) {
- element();
- } else {
- React.null;
- };
-
-/**
-Renders an option with a None element or render fucntion for Some
- */
-let option:
- 'a.
- (React.element, 'a => React.element, option('a)) => React.element
- =
- (noneElement, someElement, opt) =>
- switch (opt) {
- | None => noneElement
- | Some(a) => someElement(a)
- };
-
-/**
-Renders an option with render functions for None and Some
- */
-let optionLazy:
- 'a.
- (unit => React.element, 'a => React.element, option('a)) => React.element
- =
- (noneElement, someElement, opt) =>
- switch (opt) {
- | None => noneElement()
- | Some(a) => someElement(a)
- };
-
-/**
-Renders an option with a render function for Some, otherwise React.null
- */
-let optionIfSome: 'a. ('a => React.element, option('a)) => React.element =
- (someElement, opt) =>
- switch (opt) {
- | None => React.null
- | Some(a) => someElement(a)
- };
-
-/**
-Renders an option with a render function for None, otherwise React.null
- */
-let optionIfNone: 'a. (React.element, option('a)) => React.element =
- (element, opt) =>
- switch (opt) {
- | None => element
- | Some(_) => React.null
- };
-
-/**
-Renders an option with a render function for None, otherwise React.null
- */
-let optionIfNoneLazy: 'a. (unit => React.element, option('a)) => React.element =
- (element, opt) =>
- switch (opt) {
- | None => element()
- | Some(_) => React.null
- };
-
-/**
-Renders a Belt.Result.t('a, 'e), with render functions for both channels
- */
-let result:
- 'a 'e.
- ('a => React.element, 'e => React.element, Belt.Result.t('a, 'e)) =>
- React.element
- =
- (okElement, errorElement, result) =>
- switch (result) {
- | Ok(a) => okElement(a)
- | Error(e) => errorElement(e)
- };
-
-/**
-Renders a Belt.Result.t('a, 'e), with a render function for the Ok channel, otherwise React.null
- */
-let resultIfOk:
- 'a 'e.
- ('a => React.element, Belt.Result.t('a, 'e)) => React.element
- =
- (okElement, result) =>
- switch (result) {
- | Ok(a) => okElement(a)
- | Error(_) => React.null
- };
-
-/**
-Renders a Belt.Result.t('a, 'e), with a render function for the Error channel, otherwise React.null
- */
-let resultIfError:
- 'a 'e.
- ('e => React.element, Belt.Result.t('a, 'e)) => React.element
- =
- (errorElement, result) =>
- switch (result) {
- | Ok(_) => React.null
- | Error(e) => errorElement(e)
- };
-
-/**
-Renders a Relude.AsyncData value by providing an element/render function for each case
-*/
-let asyncData:
- 'a.
- (
- React.element,
- React.element,
- 'a => React.element,
- 'a => React.element,
- Relude.AsyncData.t('a)
- ) =>
- React.element
- =
- (initElement, loadingElement, reloadingElement, completeElement, data) =>
- switch (data) {
- | Init => initElement
- | Loading => loadingElement
- | Reloading(a) => reloadingElement(a)
- | Complete(a) => completeElement(a)
- };
-
-/**
-Renders a Relude.AsyncData value by providing a render function for each case
-*/
-let asyncDataLazy:
- 'a.
- (
- unit => React.element,
- unit => React.element,
- 'a => React.element,
- 'a => React.element,
- Relude.AsyncData.t('a)
- ) =>
- React.element
- =
- (initElement, loadingElement, reloadingElement, completeElement, data) =>
- switch (data) {
- | Init => initElement()
- | Loading => loadingElement()
- | Reloading(a) => reloadingElement(a)
- | Complete(a) => completeElement(a)
- };
-
-/**
-Renders a Relude.AsyncData value by providing an element/render function for each type of same-type value
-*/
-let asyncDataByValue:
- 'a.
- (React.element, 'a => React.element, Relude.AsyncData.t('a)) =>
- React.element
- =
- (initOrLoadingElement, valueElement, data) =>
- switch (data) {
- | Init
- | Loading => initOrLoadingElement
- | Reloading(a)
- | Complete(a) => valueElement(a)
- };
-
-/**
-Renders a Relude.AsyncData value by providing a render function for each type of same-type value
-*/
-let asyncDataByValueLazy:
- 'a.
- (unit => React.element, 'a => React.element, Relude.AsyncData.t('a)) =>
- React.element
- =
- (initOrLoadingElement, valueElement, data) =>
- switch (data) {
- | Init
- | Loading => initOrLoadingElement()
- | Reloading(a)
- | Complete(a) => valueElement(a)
- };
-
-/**
-Renders a Relude.AsyncResult value by providing an element/render function for each case
-*/
-let asyncResult:
- 'a 'e.
- (
- React.element,
- React.element,
- 'a => React.element,
- 'e => React.element,
- 'a => React.element,
- 'e => React.element,
- Relude.AsyncResult.t('a, 'e)
- ) =>
- React.element
- =
- (
- initElement,
- loadingElement,
- reloadingOkElement,
- reloadingErrorElement,
- completeOkElement,
- completeErrorElement,
- result,
- ) =>
- switch (result) {
- | Init => initElement
- | Loading => loadingElement
- | Reloading(Ok(a)) => reloadingOkElement(a)
- | Reloading(Error(e)) => reloadingErrorElement(e)
- | Complete(Ok(a)) => completeOkElement(a)
- | Complete(Error(e)) => completeErrorElement(e)
- };
-
-/**
-Renders a Relude.AsyncResult value by providing a render function for each case
-*/
-let asyncResultLazy:
- 'a 'e.
- (
- unit => React.element,
- unit => React.element,
- 'a => React.element,
- 'e => React.element,
- 'a => React.element,
- 'e => React.element,
- Relude.AsyncResult.t('a, 'e)
- ) =>
- React.element
- =
- (
- initElement,
- loadingElement,
- reloadingOkElement,
- reloadingErrorElement,
- completeOkElement,
- completeErrorElement,
- result,
- ) =>
- switch (result) {
- | Init => initElement()
- | Loading => loadingElement()
- | Reloading(Ok(a)) => reloadingOkElement(a)
- | Reloading(Error(e)) => reloadingErrorElement(e)
- | Complete(Ok(a)) => completeOkElement(a)
- | Complete(Error(e)) => completeErrorElement(e)
- };
-
-/**
-Renders a Relude.AsyncResult value by providing an element/render function for each same-type value
-*/
-let asyncResultByValue:
- 'a 'e.
- (
- React.element,
- 'a => React.element,
- 'e => React.element,
- Relude.AsyncResult.t('a, 'e)
- ) =>
- React.element
- =
- (initOrLoadingElement, okElement, errorElement, result) =>
- switch (result) {
- | Init
- | Loading => initOrLoadingElement
- | Reloading(Ok(a))
- | Complete(Ok(a)) => okElement(a)
- | Reloading(Error(e))
- | Complete(Error(e)) => errorElement(e)
- };
-
-/**
-Renders a Relude.AsyncResult value by providing a render function for each same-type value
-*/
-let asyncResultByValueLazy:
- 'a 'e.
- (
- unit => React.element,
- 'a => React.element,
- 'e => React.element,
- Relude.AsyncResult.t('a, 'e)
- ) =>
- React.element
- =
- (initOrLoadingElement, okElement, errorElement, result) =>
- switch (result) {
- | Init
- | Loading => initOrLoadingElement()
- | Reloading(Ok(a))
- | Complete(Ok(a)) => okElement(a)
- | Reloading(Error(e))
- | Complete(Error(e)) => errorElement(e)
- };
-
-/**
-Renders a Relude.AsyncResult if it's in the Init state
-*/
-let asyncResultIfInit:
- 'a 'e.
- (React.element, Relude.AsyncResult.t('a, 'e)) => React.element
- =
- (element, result) =>
- switch (result) {
- | Init => element
- | Loading => React.null
- | Reloading(_) => React.null
- | Complete(_) => React.null
- };
-
-/**
-Renders a Relude.AsyncResult if it's in the Init state
-*/
-let asyncResultIfInitLazy:
- 'a 'e.
- (unit => React.element, Relude.AsyncResult.t('a, 'e)) => React.element
- =
- (element, result) =>
- switch (result) {
- | Init => element()
- | Loading => React.null
- | Reloading(_) => React.null
- | Complete(_) => React.null
- };
-
-/**
-Renders a Relude.AsyncResult if it's in the Loading state
-*/
-let asyncResultIfLoading:
- 'a 'e.
- (React.element, Relude.AsyncResult.t('a, 'e)) => React.element
- =
- (element, result) =>
- switch (result) {
- | Init => React.null
- | Loading => element
- | Reloading(_) => React.null
- | Complete(_) => React.null
- };
-
-/**
-Renders a Relude.AsyncResult if it's in the Loading state
-*/
-let asyncResultIfLoadingLazy:
- 'a 'e.
- (unit => React.element, Relude.AsyncResult.t('a, 'e)) => React.element
- =
- (element, result) =>
- switch (result) {
- | Init => React.null
- | Loading => element()
- | Reloading(_) => React.null
- | Complete(_) => React.null
- };
-
-/**
-Renders a Relude.AsyncResult if it's in the Reloading state
-*/
-let asyncResultIfReloading:
- 'a 'e.
- (Belt.Result.t('a, 'e) => React.element, Relude.AsyncResult.t('a, 'e)) =>
- React.element
- =
- (element, result) =>
- switch (result) {
- | Init => React.null
- | Loading => React.null
- | Reloading(r) => element(r)
- | Complete(_) => React.null
- };
-
-/**
-Renders a Relude.AsyncResult if it's in the Complete state
-*/
-let asyncResultIfComplete:
- 'a 'e.
- (Belt.Result.t('a, 'e) => React.element, Relude.AsyncResult.t('a, 'e)) =>
- React.element
- =
- (element, result) =>
- switch (result) {
- | Init => React.null
- | Loading => React.null
- | Reloading(_) => React.null
- | Complete(r) => element(r)
- };
-
-/**
-Renders a Relude.AsyncResult if there is no contained value (i.e. for Init or Loading states)
- */
-let asyncResultIfEmpty:
- 'a 'e.
- (React.element, Relude.AsyncResult.t('a, 'e)) => React.element
- =
- (element, result) =>
- switch (result) {
- | Init
- | Loading => element
- | _ => React.null
- };
-
-/**
-Renders a Relude.AsyncResult if there is no contained value (i.e. for Init or Loading states)
- */
-let asyncResultIfEmptyLazy:
- 'a 'e.
- (unit => React.element, Relude.AsyncResult.t('a, 'e)) => React.element
- =
- (element, result) =>
- switch (result) {
- | Init
- | Loading => element()
- | _ => React.null
- };
-
-/**
-Renders a Relude.AsyncResult if it's in a state that contains a Belt.Result value (i.e. Reloading or Complete)
- */
-let asyncResultIfNonEmpty:
- 'a 'e.
- (Belt.Result.t('a, 'e) => React.element, Relude.AsyncResult.t('a, 'e)) =>
- React.element
- =
- (element, result) =>
- switch (result) {
- | Complete(r)
- | Reloading(r) => element(r)
- | _ => React.null
- };
-
-/**
-Renders a Relude.AsyncResult if there is an `Ok` value (either Reloading or Complete)
- */
-let asyncResultIfOk:
- 'a 'e.
- ('a => React.element, Relude.AsyncResult.t('a, 'e)) => React.element
- =
- (element, result) =>
- switch (result) {
- | Reloading(Ok(a))
- | Complete(Ok(a)) => element(a)
- | _ => React.null
- };
-
-/**
-Renders a Relude.AsyncResult if there is an `Error` value (either Reloading or Complete)
- */
-let asyncResultIfError:
- 'a 'e.
- ('e => React.element, Relude.AsyncResult.t('a, 'e)) => React.element
- =
- (element, result) =>
- switch (result) {
- | Reloading(Error(e))
- | Complete(Error(e)) => element(e)
- | _ => React.null
- };
-
-/**
-Renders a Relude.AsyncResult if it's in a working (busy) state (e.g. Loading or Reloading).
- */
-let asyncResultIfBusy:
- 'a 'e.
- (
- option(Belt.Result.t('a, 'e)) => React.element,
- Relude.AsyncResult.t('a, 'e)
- ) =>
- React.element
- =
- (element, result) =>
- switch (result) {
- | Init => React.null
- | Loading => element(None)
- | Reloading(r) => element(Some(r))
- | Complete(_) => React.null
- };
-
-/**
-Renders a Relude.AsyncResult if it's in an idle state (e.g. Init or Complete)
- */
-let asyncResultIfIdle:
- 'a 'e.
- (
- option(Belt.Result.t('a, 'e)) => React.element,
- Relude.AsyncResult.t('a, 'e)
- ) =>
- React.element
- =
- (element, result) =>
- switch (result) {
- | Init => element(None)
- | Loading => React.null
- | Reloading(_) => React.null
- | Complete(r) => element(Some(r))
- };
\ No newline at end of file
diff --git a/src/ReludeReact_Render.res b/src/ReludeReact_Render.res
new file mode 100644
index 0000000..6850f5d
--- /dev/null
+++ b/src/ReludeReact_Render.res
@@ -0,0 +1,476 @@
+@ocaml.doc("
+Returns an element if the condition is true, otherwise React.null
+")
+let ifTrue: (React.element, bool) => React.element = (element, condition) =>
+ if condition {
+ element
+ } else {
+ React.null
+ }
+
+@ocaml.doc("
+Renders an element if the condition is true, otherwise React.null
+")
+let ifTrueLazy: (unit => React.element, bool) => React.element = (element, condition) =>
+ if condition {
+ element()
+ } else {
+ React.null
+ }
+
+@ocaml.doc("
+Returns an element if the condition is false, otherwise React.null
+")
+let ifFalse: (React.element, bool) => React.element = (element, condition) =>
+ if !condition {
+ element
+ } else {
+ React.null
+ }
+
+@ocaml.doc("
+Renders an element if the condition is false, otherwise React.null
+")
+let ifFalseLazy: (unit => React.element, bool) => React.element = (element, condition) =>
+ if !condition {
+ element()
+ } else {
+ React.null
+ }
+
+@ocaml.doc("
+Renders an option with a None element or render fucntion for Some
+ ")
+let option: 'a. (React.element, 'a => React.element, option<'a>) => React.element = (
+ noneElement,
+ someElement,
+ opt,
+) =>
+ switch opt {
+ | None => noneElement
+ | Some(a) => someElement(a)
+ }
+
+@ocaml.doc("
+Renders an option with render functions for None and Some
+ ")
+let optionLazy: 'a. (unit => React.element, 'a => React.element, option<'a>) => React.element = (
+ noneElement,
+ someElement,
+ opt,
+) =>
+ switch opt {
+ | None => noneElement()
+ | Some(a) => someElement(a)
+ }
+
+@ocaml.doc("
+Renders an option with a render function for Some, otherwise React.null
+ ")
+let optionIfSome: 'a. ('a => React.element, option<'a>) => React.element = (someElement, opt) =>
+ switch opt {
+ | None => React.null
+ | Some(a) => someElement(a)
+ }
+
+@ocaml.doc("
+Renders an option with a render function for None, otherwise React.null
+ ")
+let optionIfNone: 'a. (React.element, option<'a>) => React.element = (element, opt) =>
+ switch opt {
+ | None => element
+ | Some(_) => React.null
+ }
+
+@ocaml.doc("
+Renders an option with a render function for None, otherwise React.null
+ ")
+let optionIfNoneLazy: 'a. (unit => React.element, option<'a>) => React.element = (element, opt) =>
+ switch opt {
+ | None => element()
+ | Some(_) => React.null
+ }
+
+@ocaml.doc("
+Renders a Belt.Result.t('a, 'e), with render functions for both channels
+ ")
+let result: 'a 'e. (
+ 'a => React.element,
+ 'e => React.element,
+ Belt.Result.t<'a, 'e>,
+) => React.element = (okElement, errorElement, result) =>
+ switch result {
+ | Ok(a) => okElement(a)
+ | Error(e) => errorElement(e)
+ }
+
+@ocaml.doc("
+Renders a Belt.Result.t('a, 'e), with a render function for the Ok channel, otherwise React.null
+ ")
+let resultIfOk: 'a 'e. ('a => React.element, Belt.Result.t<'a, 'e>) => React.element = (
+ okElement,
+ result,
+) =>
+ switch result {
+ | Ok(a) => okElement(a)
+ | Error(_) => React.null
+ }
+
+@ocaml.doc("
+Renders a Belt.Result.t('a, 'e), with a render function for the Error channel, otherwise React.null
+ ")
+let resultIfError: 'a 'e. ('e => React.element, Belt.Result.t<'a, 'e>) => React.element = (
+ errorElement,
+ result,
+) =>
+ switch result {
+ | Ok(_) => React.null
+ | Error(e) => errorElement(e)
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncData value by providing an element/render function for each case
+")
+let asyncData: 'a. (
+ React.element,
+ React.element,
+ 'a => React.element,
+ 'a => React.element,
+ Relude.AsyncData.t<'a>,
+) => React.element = (initElement, loadingElement, reloadingElement, completeElement, data) =>
+ switch data {
+ | Init => initElement
+ | Loading => loadingElement
+ | Reloading(a) => reloadingElement(a)
+ | Complete(a) => completeElement(a)
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncData value by providing a render function for each case
+")
+let asyncDataLazy: 'a. (
+ unit => React.element,
+ unit => React.element,
+ 'a => React.element,
+ 'a => React.element,
+ Relude.AsyncData.t<'a>,
+) => React.element = (initElement, loadingElement, reloadingElement, completeElement, data) =>
+ switch data {
+ | Init => initElement()
+ | Loading => loadingElement()
+ | Reloading(a) => reloadingElement(a)
+ | Complete(a) => completeElement(a)
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncData value by providing an element/render function for each type of same-type value
+")
+let asyncDataByValue: 'a. (
+ React.element,
+ 'a => React.element,
+ Relude.AsyncData.t<'a>,
+) => React.element = (initOrLoadingElement, valueElement, data) =>
+ switch data {
+ | Init
+ | Loading => initOrLoadingElement
+ | Reloading(a)
+ | Complete(a) =>
+ valueElement(a)
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncData value by providing a render function for each type of same-type value
+")
+let asyncDataByValueLazy: 'a. (
+ unit => React.element,
+ 'a => React.element,
+ Relude.AsyncData.t<'a>,
+) => React.element = (initOrLoadingElement, valueElement, data) =>
+ switch data {
+ | Init
+ | Loading =>
+ initOrLoadingElement()
+ | Reloading(a)
+ | Complete(a) =>
+ valueElement(a)
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncResult value by providing an element/render function for each case
+")
+let asyncResult: 'a 'e. (
+ React.element,
+ React.element,
+ 'a => React.element,
+ 'e => React.element,
+ 'a => React.element,
+ 'e => React.element,
+ Relude.AsyncResult.t<'a, 'e>,
+) => React.element = (
+ initElement,
+ loadingElement,
+ reloadingOkElement,
+ reloadingErrorElement,
+ completeOkElement,
+ completeErrorElement,
+ result,
+) =>
+ switch result {
+ | Init => initElement
+ | Loading => loadingElement
+ | Reloading(Ok(a)) => reloadingOkElement(a)
+ | Reloading(Error(e)) => reloadingErrorElement(e)
+ | Complete(Ok(a)) => completeOkElement(a)
+ | Complete(Error(e)) => completeErrorElement(e)
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncResult value by providing a render function for each case
+")
+let asyncResultLazy: 'a 'e. (
+ unit => React.element,
+ unit => React.element,
+ 'a => React.element,
+ 'e => React.element,
+ 'a => React.element,
+ 'e => React.element,
+ Relude.AsyncResult.t<'a, 'e>,
+) => React.element = (
+ initElement,
+ loadingElement,
+ reloadingOkElement,
+ reloadingErrorElement,
+ completeOkElement,
+ completeErrorElement,
+ result,
+) =>
+ switch result {
+ | Init => initElement()
+ | Loading => loadingElement()
+ | Reloading(Ok(a)) => reloadingOkElement(a)
+ | Reloading(Error(e)) => reloadingErrorElement(e)
+ | Complete(Ok(a)) => completeOkElement(a)
+ | Complete(Error(e)) => completeErrorElement(e)
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncResult value by providing an element/render function for each same-type value
+")
+let asyncResultByValue: 'a 'e. (
+ React.element,
+ 'a => React.element,
+ 'e => React.element,
+ Relude.AsyncResult.t<'a, 'e>,
+) => React.element = (initOrLoadingElement, okElement, errorElement, result) =>
+ switch result {
+ | Init
+ | Loading => initOrLoadingElement
+ | Reloading(Ok(a))
+ | Complete(Ok(a)) =>
+ okElement(a)
+ | Reloading(Error(e))
+ | Complete(Error(e)) =>
+ errorElement(e)
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncResult value by providing a render function for each same-type value
+")
+let asyncResultByValueLazy: 'a 'e. (
+ unit => React.element,
+ 'a => React.element,
+ 'e => React.element,
+ Relude.AsyncResult.t<'a, 'e>,
+) => React.element = (initOrLoadingElement, okElement, errorElement, result) =>
+ switch result {
+ | Init
+ | Loading =>
+ initOrLoadingElement()
+ | Reloading(Ok(a))
+ | Complete(Ok(a)) =>
+ okElement(a)
+ | Reloading(Error(e))
+ | Complete(Error(e)) =>
+ errorElement(e)
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncResult if it's in the Init state
+")
+let asyncResultIfInit: 'a 'e. (React.element, Relude.AsyncResult.t<'a, 'e>) => React.element = (
+ element,
+ result,
+) =>
+ switch result {
+ | Init => element
+ | Loading => React.null
+ | Reloading(_) => React.null
+ | Complete(_) => React.null
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncResult if it's in the Init state
+")
+let asyncResultIfInitLazy: 'a 'e. (
+ unit => React.element,
+ Relude.AsyncResult.t<'a, 'e>,
+) => React.element = (element, result) =>
+ switch result {
+ | Init => element()
+ | Loading => React.null
+ | Reloading(_) => React.null
+ | Complete(_) => React.null
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncResult if it's in the Loading state
+")
+let asyncResultIfLoading: 'a 'e. (React.element, Relude.AsyncResult.t<'a, 'e>) => React.element = (
+ element,
+ result,
+) =>
+ switch result {
+ | Init => React.null
+ | Loading => element
+ | Reloading(_) => React.null
+ | Complete(_) => React.null
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncResult if it's in the Loading state
+")
+let asyncResultIfLoadingLazy: 'a 'e. (
+ unit => React.element,
+ Relude.AsyncResult.t<'a, 'e>,
+) => React.element = (element, result) =>
+ switch result {
+ | Init => React.null
+ | Loading => element()
+ | Reloading(_) => React.null
+ | Complete(_) => React.null
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncResult if it's in the Reloading state
+")
+let asyncResultIfReloading: 'a 'e. (
+ Belt.Result.t<'a, 'e> => React.element,
+ Relude.AsyncResult.t<'a, 'e>,
+) => React.element = (element, result) =>
+ switch result {
+ | Init => React.null
+ | Loading => React.null
+ | Reloading(r) => element(r)
+ | Complete(_) => React.null
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncResult if it's in the Complete state
+")
+let asyncResultIfComplete: 'a 'e. (
+ Belt.Result.t<'a, 'e> => React.element,
+ Relude.AsyncResult.t<'a, 'e>,
+) => React.element = (element, result) =>
+ switch result {
+ | Init => React.null
+ | Loading => React.null
+ | Reloading(_) => React.null
+ | Complete(r) => element(r)
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncResult if there is no contained value (i.e. for Init or Loading states)
+ ")
+let asyncResultIfEmpty: 'a 'e. (React.element, Relude.AsyncResult.t<'a, 'e>) => React.element = (
+ element,
+ result,
+) =>
+ switch result {
+ | Init
+ | Loading => element
+ | _ => React.null
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncResult if there is no contained value (i.e. for Init or Loading states)
+ ")
+let asyncResultIfEmptyLazy: 'a 'e. (
+ unit => React.element,
+ Relude.AsyncResult.t<'a, 'e>,
+) => React.element = (element, result) =>
+ switch result {
+ | Init
+ | Loading =>
+ element()
+ | _ => React.null
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncResult if it's in a state that contains a Belt.Result value (i.e. Reloading or Complete)
+ ")
+let asyncResultIfNonEmpty: 'a 'e. (
+ Belt.Result.t<'a, 'e> => React.element,
+ Relude.AsyncResult.t<'a, 'e>,
+) => React.element = (element, result) =>
+ switch result {
+ | Complete(r)
+ | Reloading(r) =>
+ element(r)
+ | _ => React.null
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncResult if there is an `Ok` value (either Reloading or Complete)
+ ")
+let asyncResultIfOk: 'a 'e. ('a => React.element, Relude.AsyncResult.t<'a, 'e>) => React.element = (
+ element,
+ result,
+) =>
+ switch result {
+ | Reloading(Ok(a))
+ | Complete(Ok(a)) =>
+ element(a)
+ | _ => React.null
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncResult if there is an `Error` value (either Reloading or Complete)
+ ")
+let asyncResultIfError: 'a 'e. (
+ 'e => React.element,
+ Relude.AsyncResult.t<'a, 'e>,
+) => React.element = (element, result) =>
+ switch result {
+ | Reloading(Error(e))
+ | Complete(Error(e)) =>
+ element(e)
+ | _ => React.null
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncResult if it's in a working (busy) state (e.g. Loading or Reloading).
+ ")
+let asyncResultIfBusy: 'a 'e. (
+ option> => React.element,
+ Relude.AsyncResult.t<'a, 'e>,
+) => React.element = (element, result) =>
+ switch result {
+ | Init => React.null
+ | Loading => element(None)
+ | Reloading(r) => element(Some(r))
+ | Complete(_) => React.null
+ }
+
+@ocaml.doc("
+Renders a Relude.AsyncResult if it's in an idle state (e.g. Init or Complete)
+ ")
+let asyncResultIfIdle: 'a 'e. (
+ option> => React.element,
+ Relude.AsyncResult.t<'a, 'e>,
+) => React.element = (element, result) =>
+ switch result {
+ | Init => element(None)
+ | Loading => React.null
+ | Reloading(_) => React.null
+ | Complete(r) => element(Some(r))
+ }
diff --git a/src/ReludeReact_SideEffect.re b/src/ReludeReact_SideEffect.res
similarity index 61%
rename from src/ReludeReact_SideEffect.re
rename to src/ReludeReact_SideEffect.res
index 99d3018..a92c849 100644
--- a/src/ReludeReact_SideEffect.re
+++ b/src/ReludeReact_SideEffect.res
@@ -1,65 +1,65 @@
-/**
+@ocaml.doc("
Side effects are given a context argument of the current state, and a dispatch function
for sending 0 or more additional actions for later processing.
-*/
-type context('action, 'state) = {
+")
+type context<'action, 'state> = {
state: 'state,
send: 'action => unit,
-};
+}
-/**
+@ocaml.doc("
A canceler function is a basic function with no arguments and no result, which can
be called to cancel a running or future side effect.
-*/
-type canceler = unit => unit;
+")
+type canceler = unit => unit
-/**
+@ocaml.doc("
A SideEffect.t is a function that takes a context (the current state, and an action dispatcher function),
performs a side effect with result type type unit and returns an optional canceler function.
The side effect should typically send one or more actions via the dispatcher `send` function,
in order to further affect the system.
-*/
-type t('action, 'state) = context('action, 'state) => option(canceler);
+")
+type t<'action, 'state> = context<'action, 'state> => option
-/**
+@ocaml.doc("
Alias for SideEffect.t
-*/
-type sideEffect('action, 'state) = t('action, 'state);
+")
+type sideEffect<'action, 'state> = t<'action, 'state>
module Uncancelable = {
- /**
+ @ocaml.doc("
An Uncancelable.t side effect is a side effect which cannot be canceled.
- */
- type t('action, 'state) = context('action, 'state) => unit;
+ ")
+ type t<'action, 'state> = context<'action, 'state> => unit
- /**
+ @ocaml.doc("
Lifts an uncancelable side effect to the more general SideEffect.t type
- */
- let lift: t('action, 'state) => sideEffect('action, 'state) =
- (uncancelable, context) => {
- uncancelable(context);
- None;
- };
+ ")
+ let lift: t<'action, 'state> => sideEffect<'action, 'state> = (uncancelable, context) => {
+ uncancelable(context)
+ None
+ }
module IO = {
- /**
+ @ocaml.doc("
An uncancellable side effect represented as a `Relude.IO` which succeeds with an `action` to
perform, and fails with a possibly different `action` to perform.
- */
- type t('action, 'state) = Relude.IO.t('action, 'action);
- };
-};
+ ")
+ type t<'action, 'state> = Relude.IO.t<'action, 'action>
+ }
+}
module Cancelable = {
- /**
+ @ocaml.doc("
A Cancelable.t is a side effect which can be canceled using the returned canceler function.
- */
- type t('action, 'state) = context('action, 'state) => canceler;
+ ")
+ type t<'action, 'state> = context<'action, 'state> => canceler
- /**
+ @ocaml.doc("
Lifts an cancelable side effect to the more general sideEffect type
- */
- let lift: t('action, 'state) => sideEffect('action, 'state) =
- (cancelable, context) => Some(cancelable(context));
+ ")
+ let lift: t<'action, 'state> => sideEffect<'action, 'state> = (cancelable, context) => Some(
+ cancelable(context),
+ )
// Note: we don't have cancelable IO yet
-};
\ No newline at end of file
+}