exupery-core-async 0.1.25 → 0.1.26

package/dist/Guaranteed_Procedure_Context.d.ts

@@ -0,0 +1,4 @@
+export interface Guaranteed_Procedure_Context {
+    execute(handle: ($i: Guaranteed_Procedure_Context) => Guaranteed_Procedure_Context): Guaranteed_Procedure_Context;
+    __start(on_finished: () => void): void;
+}

package/dist/Guaranteed_Query_Result.d.ts

@@ -0,0 +1,20 @@
+import { Guaranteed_Procedure_Context } from "./Guaranteed_Procedure_Context";
+import { Ungaranteed_Procedure_Context } from "./Unguaranteed_Procedure_Context";
+/**
+ * A value that will asynchronously become available.
+ * Similar to the concept of a promise, but with a smaller API.
+ */
+export interface Guaranteed_Query_Result<T> {
+    map<NT>(handle_value: ($: T) => NT): Guaranteed_Query_Result<NT>;
+    /**
+     * maps the current async value into a new async value
+     * @param handle_value callback that transforms the actual value into a new Async_Value
+     */
+    then<NT>(handle_value: ($: T) => Guaranteed_Query_Result<NT>): Guaranteed_Query_Result<NT>;
+    process_guaranteed(handle_value: ($i: Guaranteed_Procedure_Context, $: T) => Guaranteed_Procedure_Context): Guaranteed_Procedure_Context;
+    process_unguaranteed<E>(handle_value: ($i: Ungaranteed_Procedure_Context<E>, $: T) => Ungaranteed_Procedure_Context<E>): Ungaranteed_Procedure_Context<E>;
+    /**
+     * This method is only to be used by resources
+     */
+    __start(on_value: ($: T) => void): void;
+}

package/dist/Unguaranteed_Procedure_Context.d.ts

@@ -0,0 +1,24 @@
+import * as _et from 'exupery-core-types';
+import { Guaranteed_Procedure_Context } from "./Guaranteed_Procedure_Context";
+export interface Ungaranteed_Procedure_Context<E> {
+    /**
+     *
+     * executes a command when an exception has occurred,
+     * but stays in the ungaranteed context
+     *
+     * this is useful when you want to do some cleanup
+     * or logging in case of an exception,
+     * but still want to propagate the exception further
+     *
+     * note that this is different from `catch`,
+     * which would switch to the guaranteed context
+     */
+    process_exception_deprecated<NE>(handle: ($i: Guaranteed_Procedure_Context, $: E) => Guaranteed_Procedure_Context, map: ($: E) => NE): Ungaranteed_Procedure_Context<NE>;
+    throw_exception<E>($: E): Ungaranteed_Procedure_Context<E>;
+    catch(handle_exception: ($i: Guaranteed_Procedure_Context, $: E) => Guaranteed_Procedure_Context): Guaranteed_Procedure_Context;
+    execute_unguaranteed(handle: ($i: Ungaranteed_Procedure_Context<E>) => Ungaranteed_Procedure_Context<E>): Ungaranteed_Procedure_Context<E>;
+    execute(handle: ($i: Guaranteed_Procedure_Context) => Guaranteed_Procedure_Context): Ungaranteed_Procedure_Context<E>;
+    execute_dictionary_unguaranteed<E2>($: _et.Dictionary<Ungaranteed_Procedure_Context<E2>>, aggregate_exceptions: ($: _et.Dictionary<E2>) => E): Ungaranteed_Procedure_Context<E>;
+    execute_multiple_unguaranteed<E2>($: _et.Array<Ungaranteed_Procedure_Context<E2>>, aggregate_exceptions: ($: _et.Array<E2>) => E): Ungaranteed_Procedure_Context<E>;
+    __start(on_success: () => void, on_exception: ($: E) => void): void;
+}

package/dist/{Unsafe_Query_Result.d.ts → Unguaranteed_Query_Result.d.ts}

@@ -1,11 +1,11 @@
-import { Safe_Procedure_Context } from "./Safe_Procedure_Context";
-import { Safe_Query_Result } from "./Safe_Query_Result";
-import { Unsafe_Procedure_Context } from "./Unsafe_Procedure_Context";
-export interface Unsafe_Query_Result<T, E> {
-    map<NT>(handle_value: ($: T) => NT): Unsafe_Query_Result<NT, E>;
-    map_exception<NE>(handle_exception: ($: E) => NE): Unsafe_Query_Result<T, NE>;
-    then<NT>(handle_value: ($: T) => Unsafe_Query_Result<NT, E>): Unsafe_Query_Result<NT, E>;
-    catch(handle_exception: ($: E) => Safe_Query_Result<T>): Safe_Query_Result<T>;
+import { Guaranteed_Procedure_Context } from "./Guaranteed_Procedure_Context";
+import { Guaranteed_Query_Result } from "./Guaranteed_Query_Result";
+import { Ungaranteed_Procedure_Context } from "./Unguaranteed_Procedure_Context";
+export interface Unguaranteed_Query_Result<T, E> {
+    map<NT>(handle_value: ($: T) => NT): Unguaranteed_Query_Result<NT, E>;
+    map_exception<NE>(handle_exception: ($: E) => NE): Unguaranteed_Query_Result<T, NE>;
+    then<NT>(handle_value: ($: T) => Unguaranteed_Query_Result<NT, E>): Unguaranteed_Query_Result<NT, E>;
+    catch(handle_exception: ($: E) => Guaranteed_Query_Result<T>): Guaranteed_Query_Result<T>;
     /**
      * processes the queried data by executing a command.
      *
@@ -19,6 +19,6 @@ export interface Unsafe_Query_Result<T, E> {
      * @param map_exception the handler that will map the exception of the query into a new exception value of the command's exception type
      *
      */
-    process<NE>(handle_exception: ($i: Safe_Procedure_Context, $: E) => Safe_Procedure_Context, map_exception: ($: E) => NE, handle_value: ($i: Unsafe_Procedure_Context<NE>, $: T) => Unsafe_Procedure_Context<NE>): Unsafe_Procedure_Context<NE>;
+    process<NE>(handle_exception: ($i: Guaranteed_Procedure_Context, $: E) => Guaranteed_Procedure_Context, map_exception: ($: E) => NE, handle_value: ($i: Ungaranteed_Procedure_Context<NE>, $: T) => Ungaranteed_Procedure_Context<NE>): Ungaranteed_Procedure_Context<NE>;
     __start(on_value: ($: T) => void, on_exception: ($: E) => void): void;
 }

package/dist/index.d.ts

@@ -1,31 +1,31 @@
-export * from "./Safe_Procedure_Context";
-export * from "./Unsafe_Procedure_Context";
-export * from "./Safe_Query_Result";
-export * from "./Unsafe_Query_Result";
-export * from "./merge_2_safe_query_results";
-export * from "./run_safe_query";
-export * from "./run_unsafe_query";
-export * from "./initialize_safe_procedure_context";
-export * from "./initialize_unsafe_procedure_context";
-import { Safe_Procedure_Context } from "./Safe_Procedure_Context";
-import { Unsafe_Procedure_Context } from "./Unsafe_Procedure_Context";
-import { Safe_Query_Result } from "./Safe_Query_Result";
-import { Unsafe_Query_Result } from "./Unsafe_Query_Result";
+export * from "./Guaranteed_Procedure_Context";
+export * from "./Unguaranteed_Procedure_Context";
+export * from "./Guaranteed_Query_Result";
+export * from "./Unguaranteed_Query_Result";
+export * from "./merge_2_guaranteed_query_results";
+export * from "./run_guaranteed_query";
+export * from "./run_unguaranteed_query";
+export * from "./initialize_guaranteed_procedure_context";
+export * from "./initialize_unguaranteed_procedure_context";
+import { Guaranteed_Procedure_Context } from "./Guaranteed_Procedure_Context";
+import { Ungaranteed_Procedure_Context } from "./Unguaranteed_Procedure_Context";
+import { Guaranteed_Query_Result } from "./Guaranteed_Query_Result";
+import { Unguaranteed_Query_Result } from "./Unguaranteed_Query_Result";
 export declare const query: {
-    safe: {
-        'create result': <T>($: T) => Safe_Query_Result<T>;
+    guaranteed: {
+        'create result': <T>($: T) => Guaranteed_Query_Result<T>;
     };
-    unsafe: {
-        'create result': <T, E>($: T) => Unsafe_Query_Result<T, E>;
-        'raise exception': <T, E>($: E) => Unsafe_Query_Result<T, E>;
+    unguaranteed: {
+        'create result': <T, E>($: T) => Unguaranteed_Query_Result<T, E>;
+        'raise exception': <T, E>($: E) => Unguaranteed_Query_Result<T, E>;
     };
 };
 export declare const command: {
-    safe: {
-        initialize: () => Safe_Procedure_Context;
+    guaranteed: {
+        initialize: () => Guaranteed_Procedure_Context;
     };
-    unsafe: {
-        initialize: <E>() => Unsafe_Procedure_Context<E>;
-        'raise exception': <E>($: E) => Unsafe_Procedure_Context<E>;
+    unguaranteed: {
+        initialize: <E>() => Ungaranteed_Procedure_Context<E>;
+        'raise exception': <E>($: E) => Ungaranteed_Procedure_Context<E>;
     };
 };

package/dist/index.js

@@ -15,39 +15,39 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.command = exports.query = void 0;
-__exportStar(require("./Safe_Procedure_Context"), exports);
-__exportStar(require("./Unsafe_Procedure_Context"), exports);
-__exportStar(require("./Safe_Query_Result"), exports);
-__exportStar(require("./Unsafe_Query_Result"), exports);
-__exportStar(require("./merge_2_safe_query_results"), exports);
-__exportStar(require("./run_safe_query"), exports);
-__exportStar(require("./run_unsafe_query"), exports);
-__exportStar(require("./initialize_safe_procedure_context"), exports);
-__exportStar(require("./initialize_unsafe_procedure_context"), exports);
-const initialize_safe_procedure_context_1 = require("./initialize_safe_procedure_context");
-const initialize_unsafe_procedure_context_1 = require("./initialize_unsafe_procedure_context");
-const run_safe_query_1 = require("./run_safe_query");
-const run_unsafe_query_1 = require("./run_unsafe_query");
+__exportStar(require("./Guaranteed_Procedure_Context"), exports);
+__exportStar(require("./Unguaranteed_Procedure_Context"), exports);
+__exportStar(require("./Guaranteed_Query_Result"), exports);
+__exportStar(require("./Unguaranteed_Query_Result"), exports);
+__exportStar(require("./merge_2_guaranteed_query_results"), exports);
+__exportStar(require("./run_guaranteed_query"), exports);
+__exportStar(require("./run_unguaranteed_query"), exports);
+__exportStar(require("./initialize_guaranteed_procedure_context"), exports);
+__exportStar(require("./initialize_unguaranteed_procedure_context"), exports);
+const initialize_guaranteed_procedure_context_1 = require("./initialize_guaranteed_procedure_context");
+const initialize_unguaranteed_procedure_context_1 = require("./initialize_unguaranteed_procedure_context");
+const run_guaranteed_query_1 = require("./run_guaranteed_query");
+const run_unguaranteed_query_1 = require("./run_unguaranteed_query");
 exports.query = {
-    'safe': {
+    'guaranteed': {
         'create result': ($) => {
-            return (0, run_safe_query_1.__run_safe_query)({
+            return (0, run_guaranteed_query_1.__run_guaranteed_query)({
                 'execute': (on_value) => {
                     on_value($);
                 }
             });
         }
     },
-    'unsafe': {
+    'unguaranteed': {
         'create result': ($) => {
-            return (0, run_unsafe_query_1.__run_unsafe_query)({
+            return (0, run_unguaranteed_query_1.__run_unguaranteed_query)({
                 'execute': (on_value) => {
                     on_value($);
                 }
             });
         },
         'raise exception': ($) => {
-            return (0, run_unsafe_query_1.__run_unsafe_query)({
+            return (0, run_unguaranteed_query_1.__run_unguaranteed_query)({
                 'execute': (on_value, on_exception) => {
                     on_exception($);
                 }
@@ -56,13 +56,13 @@ exports.query = {
     },
 };
 exports.command = {
-    'safe': {
-        'initialize': initialize_safe_procedure_context_1.initialize_safe_procedure_context
+    'guaranteed': {
+        'initialize': initialize_guaranteed_procedure_context_1.initialize_guaranteed_procedure_context
     },
-    'unsafe': {
-        'initialize': initialize_unsafe_procedure_context_1.initialize_unsafe_procedure_context,
+    'unguaranteed': {
+        'initialize': initialize_unguaranteed_procedure_context_1.initialize_unguaranteed_procedure_context,
         'raise exception': ($) => {
-            return (0, initialize_unsafe_procedure_context_1.__execute_unsafe_action)({
+            return (0, initialize_unguaranteed_procedure_context_1.__execute_unguaranteed_action)({
                 'execute': (on_success, on_exception) => {
                     on_exception($);
                 }

package/dist/initialize_guaranteed_procedure_context.d.ts

@@ -0,0 +1,12 @@
+import { Guaranteed_Procedure_Context } from "./Guaranteed_Procedure_Context";
+type Executer = {
+    'execute': (on_finished: () => void) => void;
+};
+/**
+ * returns an {@link Async_Value }
+ * @param executer the function that produces the eventual value
+ * @returns
+ */
+export declare function __execute_guaranteed_action(executer: Executer): Guaranteed_Procedure_Context;
+export declare const initialize_guaranteed_procedure_context: () => Guaranteed_Procedure_Context;
+export {};

package/dist/{initialize_safe_procedure_context.js → initialize_guaranteed_procedure_context.js}

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initialize_safe_procedure_context = void 0;
-exports.__execute_safe_action = __execute_safe_action;
-class Safe_Command_Result_Class {
+exports.initialize_guaranteed_procedure_context = void 0;
+exports.__execute_guaranteed_action = __execute_guaranteed_action;
+class Guaranteed_Procedure_Context_Class {
     constructor(executer) {
         this.executer = executer;
     }
     execute(handle) {
-        return __execute_safe_action({
+        return __execute_guaranteed_action({
             'execute': (on_finished) => {
                 this.executer.execute(() => {
-                    handle((0, exports.initialize_safe_procedure_context)()).__start(on_finished);
+                    handle((0, exports.initialize_guaranteed_procedure_context)()).__start(on_finished);
                 });
             }
         });
@@ -24,14 +24,14 @@ class Safe_Command_Result_Class {
  * @param executer the function that produces the eventual value
  * @returns
  */
-function __execute_safe_action(executer) {
-    return new Safe_Command_Result_Class(executer);
+function __execute_guaranteed_action(executer) {
+    return new Guaranteed_Procedure_Context_Class(executer);
 }
-const initialize_safe_procedure_context = () => {
-    return new Safe_Command_Result_Class({
+const initialize_guaranteed_procedure_context = () => {
+    return new Guaranteed_Procedure_Context_Class({
         'execute': (on_finished) => {
             on_finished(); //nothing to do, call on_finished immediately
         }
     });
 };
-exports.initialize_safe_procedure_context = initialize_safe_procedure_context;
+exports.initialize_guaranteed_procedure_context = initialize_guaranteed_procedure_context;

package/dist/{initialize_unsafe_procedure_context.d.ts → initialize_unguaranteed_procedure_context.d.ts}

@@ -1,4 +1,4 @@
-import { Unsafe_Procedure_Context } from "./Unsafe_Procedure_Context";
+import { Ungaranteed_Procedure_Context } from "./Unguaranteed_Procedure_Context";
 /**
  * this function contains the body in which the async value or exception is executed
  * after the execution, either the on_value or on_exception callback will be called
@@ -13,6 +13,6 @@ type Executer<E> = {
  * @param executer the function that produces the eventual value
  * @returns
  */
-export declare function __execute_unsafe_action<E>(executer: Executer<E>): Unsafe_Procedure_Context<E>;
-export declare const initialize_unsafe_procedure_context: <E>() => Unsafe_Procedure_Context<E>;
+export declare function __execute_unguaranteed_action<E>(executer: Executer<E>): Ungaranteed_Procedure_Context<E>;
+export declare const initialize_unguaranteed_procedure_context: <E>() => Ungaranteed_Procedure_Context<E>;
 export {};

package/dist/{initialize_unsafe_procedure_context.js → initialize_unguaranteed_procedure_context.js}

@@ -23,35 +23,35 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initialize_unsafe_procedure_context = void 0;
-exports.__execute_unsafe_action = __execute_unsafe_action;
+exports.initialize_unguaranteed_procedure_context = void 0;
+exports.__execute_unguaranteed_action = __execute_unguaranteed_action;
 const _ei = __importStar(require("exupery-core-internals"));
-const initialize_safe_procedure_context_1 = require("./initialize_safe_procedure_context");
+const initialize_guaranteed_procedure_context_1 = require("./initialize_guaranteed_procedure_context");
 const create_asynchronous_processes_monitor_1 = require("./create_asynchronous_processes_monitor");
-class Unsafe_Command_Result_Class {
+class Unguaranteed_Command_Result_Class {
     constructor(executer) {
         this.executer = executer;
     }
-    process_exception(handle, map) {
-        return new Unsafe_Command_Result_Class({
+    process_exception_deprecated(handle, map) {
+        return new Unguaranteed_Command_Result_Class({
             'execute': (new_on_success, new_on_exception) => {
                 this.executer.execute(new_on_success, ($) => {
-                    handle((0, initialize_safe_procedure_context_1.initialize_safe_procedure_context)(), $).__start(() => new_on_exception(map($)));
+                    handle((0, initialize_guaranteed_procedure_context_1.initialize_guaranteed_procedure_context)(), $).__start(() => new_on_exception(map($)));
                 });
             }
         });
     }
     catch(handle_exception) {
-        return (0, initialize_safe_procedure_context_1.__execute_safe_action)({
+        return (0, initialize_guaranteed_procedure_context_1.__execute_guaranteed_action)({
             'execute': (new_on_success) => {
                 this.executer.execute(new_on_success, ($) => {
-                    handle_exception((0, initialize_safe_procedure_context_1.initialize_safe_procedure_context)(), $).__start(new_on_success);
+                    handle_exception((0, initialize_guaranteed_procedure_context_1.initialize_guaranteed_procedure_context)(), $).__start(new_on_success);
                 });
             }
         });
     }
     throw_exception($) {
-        return __execute_unsafe_action({
+        return __execute_unguaranteed_action({
             'execute': (on_finished, on_exception) => {
                 this.executer.execute(() => {
                     on_exception($);
@@ -59,27 +59,27 @@ class Unsafe_Command_Result_Class {
             }
         });
     }
-    execute_unsafe(handle) {
-        return new Unsafe_Command_Result_Class({
+    execute_unguaranteed(handle) {
+        return new Unguaranteed_Command_Result_Class({
             'execute': (new_on_success, new_on_exception) => {
                 this.executer.execute(() => {
-                    handle((0, exports.initialize_unsafe_procedure_context)()).__start(new_on_success, new_on_exception);
+                    handle((0, exports.initialize_unguaranteed_procedure_context)()).__start(new_on_success, new_on_exception);
                 }, new_on_exception);
             }
         });
     }
     execute(handle) {
-        return new Unsafe_Command_Result_Class({
+        return new Unguaranteed_Command_Result_Class({
             'execute': (new_on_success, new_on_exception) => {
                 this.executer.execute(() => {
-                    handle((0, initialize_safe_procedure_context_1.initialize_safe_procedure_context)()).__start(new_on_success);
+                    handle((0, initialize_guaranteed_procedure_context_1.initialize_guaranteed_procedure_context)()).__start(new_on_success);
                 }, new_on_exception);
             }
         });
     }
-    execute_dictionary_unsafe($, aggregate_exceptions) {
+    execute_dictionary_unguaranteed($, aggregate_exceptions) {
         let exceptions = {};
-        return __execute_unsafe_action({
+        return __execute_unguaranteed_action({
             'execute': (on_success, on_exception) => {
                 (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((monitor) => {
                     $.map(($, key) => {
@@ -102,9 +102,9 @@ class Unsafe_Command_Result_Class {
             }
         });
     }
-    execute_multiple_unsafe($, aggregate_exceptions) {
+    execute_multiple_unguaranteed($, aggregate_exceptions) {
         let exceptions = [];
-        return __execute_unsafe_action({
+        return __execute_unguaranteed_action({
             'execute': (on_success, on_exception) => {
                 (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((monitor) => {
                     $.map(($) => {
@@ -136,14 +136,14 @@ class Unsafe_Command_Result_Class {
  * @param executer the function that produces the eventual value
  * @returns
  */
-function __execute_unsafe_action(executer) {
-    return new Unsafe_Command_Result_Class(executer);
+function __execute_unguaranteed_action(executer) {
+    return new Unguaranteed_Command_Result_Class(executer);
 }
-const initialize_unsafe_procedure_context = () => {
-    return new Unsafe_Command_Result_Class({
+const initialize_unguaranteed_procedure_context = () => {
+    return new Unguaranteed_Command_Result_Class({
         'execute': (on_success, on_exception) => {
             on_success(); //nothing to do, call on_finished immediately
         }
     });
 };
-exports.initialize_unsafe_procedure_context = initialize_unsafe_procedure_context;
+exports.initialize_unguaranteed_procedure_context = initialize_unguaranteed_procedure_context;

package/dist/merge_2_guaranteed_query_results.d.ts

@@ -0,0 +1,6 @@
+import { Guaranteed_Query_Result } from "./Guaranteed_Query_Result";
+export type Sync_Tuple_2<T1, T2> = {
+    readonly 'first': T1;
+    readonly 'second': T2;
+};
+export declare function merge_2_unguaranteed_query_results<T1, T2>(first: Guaranteed_Query_Result<T1>, second: Guaranteed_Query_Result<T2>): Guaranteed_Query_Result<Sync_Tuple_2<T1, T2>>;

package/dist/{merge_2_safe_query_results.js → merge_2_guaranteed_query_results.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.merge_2_safe_query_results = merge_2_safe_query_results;
-const run_safe_query_1 = require("./run_safe_query");
-function merge_2_safe_query_results(first, second) {
-    return (0, run_safe_query_1.__run_safe_query)({
+exports.merge_2_unguaranteed_query_results = merge_2_unguaranteed_query_results;
+const run_guaranteed_query_1 = require("./run_guaranteed_query");
+function merge_2_unguaranteed_query_results(first, second) {
+    return (0, run_guaranteed_query_1.__run_guaranteed_query)({
         'execute': (on_value) => {
             let element_1_is_set = false;
             let element_2_is_set = false;

package/dist/{run_safe_query.d.ts → run_guaranteed_query.d.ts}

@@ -1,4 +1,4 @@
-import { Safe_Query_Result } from "./Safe_Query_Result";
+import { Guaranteed_Query_Result } from "./Guaranteed_Query_Result";
 type Executer<T> = {
     'execute': (on_value: ($: T) => void) => void;
 };
@@ -7,5 +7,5 @@ type Executer<T> = {
  * @param executer the function that produces the eventual value
  * @returns
  */
-export declare function __run_safe_query<T>(executer: Executer<T>): Safe_Query_Result<T>;
+export declare function __run_guaranteed_query<T>(executer: Executer<T>): Guaranteed_Query_Result<T>;
 export {};

package/dist/{run_safe_query.js → run_guaranteed_query.js}

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__run_safe_query = __run_safe_query;
-const initialize_safe_procedure_context_1 = require("./initialize_safe_procedure_context");
-const initialize_unsafe_procedure_context_1 = require("./initialize_unsafe_procedure_context");
-class Safe_Query_Result_Class {
+exports.__run_guaranteed_query = __run_guaranteed_query;
+const initialize_guaranteed_procedure_context_1 = require("./initialize_guaranteed_procedure_context");
+const initialize_unguaranteed_procedure_context_1 = require("./initialize_unguaranteed_procedure_context");
+class Guaranteed_Query_Result_Class {
     constructor(executer) {
         this.executer = executer;
     }
     map(handle_value) {
-        return __run_safe_query({
+        return __run_guaranteed_query({
             'execute': (on_value) => {
                 this.executer.execute((value) => {
                     on_value(handle_value(value));
@@ -17,7 +17,7 @@ class Safe_Query_Result_Class {
         });
     }
     then(handle_value) {
-        return __run_safe_query({
+        return __run_guaranteed_query({
             'execute': (on_value) => {
                 this.executer.execute((value) => {
                     handle_value(value).__start(on_value);
@@ -25,20 +25,20 @@ class Safe_Query_Result_Class {
             }
         });
     }
-    process_safe(handle_value) {
-        return (0, initialize_safe_procedure_context_1.__execute_safe_action)({
+    process_guaranteed(handle_value) {
+        return (0, initialize_guaranteed_procedure_context_1.__execute_guaranteed_action)({
             'execute': (on_success) => {
                 this.executer.execute((value) => {
-                    handle_value((0, initialize_safe_procedure_context_1.initialize_safe_procedure_context)(), value).__start(on_success);
+                    handle_value((0, initialize_guaranteed_procedure_context_1.initialize_guaranteed_procedure_context)(), value).__start(on_success);
                 });
             }
         });
     }
-    process_unsafe(handle_value) {
-        return (0, initialize_unsafe_procedure_context_1.__execute_unsafe_action)({
+    process_unguaranteed(handle_value) {
+        return (0, initialize_unguaranteed_procedure_context_1.__execute_unguaranteed_action)({
             'execute': (on_success, on_exception) => {
                 this.executer.execute((value) => {
-                    handle_value((0, initialize_unsafe_procedure_context_1.initialize_unsafe_procedure_context)(), value).__start(on_success, on_exception);
+                    handle_value((0, initialize_unguaranteed_procedure_context_1.initialize_unguaranteed_procedure_context)(), value).__start(on_success, on_exception);
                 });
             }
         });
@@ -52,6 +52,6 @@ class Safe_Query_Result_Class {
  * @param executer the function that produces the eventual value
  * @returns
  */
-function __run_safe_query(executer) {
-    return new Safe_Query_Result_Class(executer);
+function __run_guaranteed_query(executer) {
+    return new Guaranteed_Query_Result_Class(executer);
 }

package/dist/{run_unsafe_query.d.ts → run_unguaranteed_query.d.ts}

@@ -1,4 +1,4 @@
-import { Unsafe_Query_Result } from "./Unsafe_Query_Result";
+import { Unguaranteed_Query_Result } from "./Unguaranteed_Query_Result";
 /**
  * this function contains the body in which the async value or exception is executed
  * after the execution, either the on_value or on_exception callback will be called
@@ -13,5 +13,5 @@ type Executer<T, E> = {
  * @param executer the function that produces the eventual value
  * @returns
  */
-export declare function __run_unsafe_query<T, E>(executer: Executer<T, E>): Unsafe_Query_Result<T, E>;
+export declare function __run_unguaranteed_query<T, E>(executer: Executer<T, E>): Unguaranteed_Query_Result<T, E>;
 export {};

package/dist/{run_unsafe_query.js → run_unguaranteed_query.js}

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__run_unsafe_query = __run_unsafe_query;
-const run_safe_query_1 = require("./run_safe_query");
-const initialize_safe_procedure_context_1 = require("./initialize_safe_procedure_context");
-const initialize_unsafe_procedure_context_1 = require("./initialize_unsafe_procedure_context");
-class Unsafe_Query_Result_Class {
+exports.__run_unguaranteed_query = __run_unguaranteed_query;
+const run_guaranteed_query_1 = require("./run_guaranteed_query");
+const initialize_guaranteed_procedure_context_1 = require("./initialize_guaranteed_procedure_context");
+const initialize_unguaranteed_procedure_context_1 = require("./initialize_unguaranteed_procedure_context");
+class Unguaranteed_Query_Result_Class {
     constructor(executer) {
         this.executer = executer;
     }
     map(handle_value) {
-        return new Unsafe_Query_Result_Class({
+        return new Unguaranteed_Query_Result_Class({
             'execute': (on_value, on_exception) => {
                 this.executer.execute(($) => {
                     on_value(handle_value($));
@@ -18,7 +18,7 @@ class Unsafe_Query_Result_Class {
         });
     }
     then(handle_value) {
-        return new Unsafe_Query_Result_Class({
+        return new Unguaranteed_Query_Result_Class({
             'execute': (new_on_value, new_on_exception) => {
                 this.executer.execute(($) => {
                     handle_value($).__start(new_on_value, new_on_exception);
@@ -27,7 +27,7 @@ class Unsafe_Query_Result_Class {
         });
     }
     map_exception(handle_exception) {
-        return new Unsafe_Query_Result_Class({
+        return new Unguaranteed_Query_Result_Class({
             'execute': (on_value, on_exception) => {
                 this.executer.execute(on_value, ($) => {
                     on_exception(handle_exception($));
@@ -36,7 +36,7 @@ class Unsafe_Query_Result_Class {
         });
     }
     catch(handle_exception) {
-        return (0, run_safe_query_1.__run_safe_query)({
+        return (0, run_guaranteed_query_1.__run_guaranteed_query)({
             'execute': (on_value) => {
                 this.executer.execute(on_value, ($) => {
                     handle_exception($).__start(on_value);
@@ -45,12 +45,12 @@ class Unsafe_Query_Result_Class {
         });
     }
     process(handle_exception, map_exception, handle_value) {
-        return (0, initialize_unsafe_procedure_context_1.__execute_unsafe_action)({
+        return (0, initialize_unguaranteed_procedure_context_1.__execute_unguaranteed_action)({
             'execute': (on_success, on_exception) => {
                 this.executer.execute((value) => {
-                    handle_value((0, initialize_unsafe_procedure_context_1.initialize_unsafe_procedure_context)(), value).__start(on_success, on_exception);
+                    handle_value((0, initialize_unguaranteed_procedure_context_1.initialize_unguaranteed_procedure_context)(), value).__start(on_success, on_exception);
                 }, (exception) => {
-                    handle_exception((0, initialize_safe_procedure_context_1.initialize_safe_procedure_context)(), exception).__start(() => on_exception(map_exception(exception)));
+                    handle_exception((0, initialize_guaranteed_procedure_context_1.initialize_guaranteed_procedure_context)(), exception).__start(() => on_exception(map_exception(exception)));
                 });
             }
         });
@@ -64,6 +64,6 @@ class Unsafe_Query_Result_Class {
  * @param executer the function that produces the eventual value
  * @returns
  */
-function __run_unsafe_query(executer) {
-    return new Unsafe_Query_Result_Class(executer);
+function __run_unguaranteed_query(executer) {
+    return new Unguaranteed_Query_Result_Class(executer);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exupery-core-async",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "license": "Apache-2.0",
   "author": "Corno",
   "description": "async types for Exupery",

package/dist/Safe_Procedure_Context.d.ts

@@ -1,4 +0,0 @@
-export interface Safe_Procedure_Context {
-    execute(handle: ($i: Safe_Procedure_Context) => Safe_Procedure_Context): Safe_Procedure_Context;
-    __start(on_finished: () => void): void;
-}

package/dist/Safe_Query_Result.d.ts

@@ -1,20 +0,0 @@
-import { Safe_Procedure_Context } from "./Safe_Procedure_Context";
-import { Unsafe_Procedure_Context } from "./Unsafe_Procedure_Context";
-/**
- * A value that will asynchronously become available.
- * Similar to the concept of a promise, but with a smaller API.
- */
-export interface Safe_Query_Result<T> {
-    map<NT>(handle_value: ($: T) => NT): Safe_Query_Result<NT>;
-    /**
-     * maps the current async value into a new async value
-     * @param handle_value callback that transforms the actual value into a new Async_Value
-     */
-    then<NT>(handle_value: ($: T) => Safe_Query_Result<NT>): Safe_Query_Result<NT>;
-    process_safe(handle_value: ($i: Safe_Procedure_Context, $: T) => Safe_Procedure_Context): Safe_Procedure_Context;
-    process_unsafe<E>(handle_value: ($i: Unsafe_Procedure_Context<E>, $: T) => Unsafe_Procedure_Context<E>): Unsafe_Procedure_Context<E>;
-    /**
-     * This method is only to be used by resources
-     */
-    __start(on_value: ($: T) => void): void;
-}

package/dist/Unsafe_Procedure_Context.d.ts

@@ -1,24 +0,0 @@
-import * as _et from 'exupery-core-types';
-import { Safe_Procedure_Context } from "./Safe_Procedure_Context";
-export interface Unsafe_Procedure_Context<E> {
-    /**
-     *
-     * executes a command when an exception has occurred,
-     * but stays in the unsafe context
-     *
-     * this is useful when you want to do some cleanup
-     * or logging in case of an exception,
-     * but still want to propagate the exception further
-     *
-     * note that this is different from `catch`,
-     * which would switch to the safe context
-     */
-    process_exception<NE>(handle: ($i: Safe_Procedure_Context, $: E) => Safe_Procedure_Context, map: ($: E) => NE): Unsafe_Procedure_Context<NE>;
-    throw_exception<E>($: E): Unsafe_Procedure_Context<E>;
-    catch(handle_exception: ($i: Safe_Procedure_Context, $: E) => Safe_Procedure_Context): Safe_Procedure_Context;
-    execute_unsafe(handle: ($i: Unsafe_Procedure_Context<E>) => Unsafe_Procedure_Context<E>): Unsafe_Procedure_Context<E>;
-    execute(handle: ($i: Safe_Procedure_Context) => Safe_Procedure_Context): Unsafe_Procedure_Context<E>;
-    execute_dictionary_unsafe<E2>($: _et.Dictionary<Unsafe_Procedure_Context<E2>>, aggregate_exceptions: ($: _et.Dictionary<E2>) => E): Unsafe_Procedure_Context<E>;
-    execute_multiple_unsafe<E2>($: _et.Array<Unsafe_Procedure_Context<E2>>, aggregate_exceptions: ($: _et.Array<E2>) => E): Unsafe_Procedure_Context<E>;
-    __start(on_success: () => void, on_exception: ($: E) => void): void;
-}

package/dist/initialize_safe_procedure_context.d.ts

@@ -1,12 +0,0 @@
-import { Safe_Procedure_Context } from "./Safe_Procedure_Context";
-type Executer = {
-    'execute': (on_finished: () => void) => void;
-};
-/**
- * returns an {@link Async_Value }
- * @param executer the function that produces the eventual value
- * @returns
- */
-export declare function __execute_safe_action(executer: Executer): Safe_Procedure_Context;
-export declare const initialize_safe_procedure_context: () => Safe_Procedure_Context;
-export {};

package/dist/merge_2_safe_query_results.d.ts

@@ -1,6 +0,0 @@
-import { Safe_Query_Result } from "./Safe_Query_Result";
-export type Sync_Tuple_2<T1, T2> = {
-    readonly 'first': T1;
-    readonly 'second': T2;
-};
-export declare function merge_2_safe_query_results<T1, T2>(first: Safe_Query_Result<T1>, second: Safe_Query_Result<T2>): Safe_Query_Result<Sync_Tuple_2<T1, T2>>;