exupery-core-types 0.2.0 → 0.3.1

package/dist/Array.d.ts

@@ -20,7 +20,7 @@ export interface Array<T> {
      * This method is only to be used by resources
      *
      */
-    __get_length(): number;
+    __get_number_of_elements(): number;
     /**
      * This method is only to be used by resources
      *

package/dist/Circular_Dependency.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A circular dependency is a function without parameters returning the specified type
+ * it makes it possible to do the evaluation only when the function is called
+ * useful for lazy evaluation
+ */
+export type Circular_Dependency<T> = {
+    'get circular dependent': () => T;
+};

package/dist/Dictionary.d.ts

@@ -19,7 +19,7 @@ export interface Dictionary<T> {
      * This method is only to be used by resources
      * iterates over all entries in a sorted manner
      */
-    to_array(compare: Compare_Function<T>): Array<Key_Value_Pair<T>>;
+    deprecated_to_array(compare: Compare_Function<T>): Array<Key_Value_Pair<T>>;
     /**
      * This method is only to be used by resources
      * returns an {@link Optional_Value } of type T reflecting wether the entry existed or not
@@ -27,7 +27,5 @@ export interface Dictionary<T> {
      * @param key
      */
     __get_entry(key: string): Optional_Value<T>;
-    __add_entry_if_not_exists(key: string, value: T): Dictionary<T>;
-    __add_entry_overwrite_if_exists(key: string, value: T): Dictionary<T>;
-    __remove_entry_if_exists(key: string): Dictionary<T>;
+    __get_number_of_entries(): number;
 }

package/dist/Guaranteed_Procedure.d.ts

@@ -0,0 +1,4 @@
+export type Guaranteed_Procedure<Parameters, Resources> = ($: Parameters, $r: Resources) => Guaranteed_Procedure_Promise;
+export type Guaranteed_Procedure_Promise = {
+    __start: (on_finished: () => void) => void;
+};

package/dist/Guaranteed_Procedure.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Guaranteed_Query.d.ts

@@ -0,0 +1,20 @@
+export type Guaranteed_Query<Parameters, Result, Resources> = ($: Parameters, $r: Resources) => Guaranteed_Query_Promise<Result>;
+/**
+ * A value that will asynchronously become available.
+ * Similar to the concept of a promise, but with a smaller API.
+ */
+export type Guaranteed_Query_Promise<Result> = {
+    map<NT>(handle_value: ($: Result) => NT): Guaranteed_Query_Promise<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: ($: Result) => Guaranteed_Query_Promise<NT>): Guaranteed_Query_Promise<NT>;
+    /**
+     * This method is only to be used by resources
+     */
+    __start(on_finished: ($: Result) => void): void;
+};
+export type Basic_Guaranteed_Query_Promise<Result> = {
+    __start: (on_finished: (result: Result) => void) => void;
+};

package/dist/Guaranteed_Query.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Lookup.d.ts

@@ -1,11 +1,10 @@
 import { Optional_Value } from "./Optional_Value";
 /**
  * A lookup is similar to a Dictionary, but much more basic.
- * There are only operations to retrieve entries
+ * There is only 1 operation: __get_entry.
  */
 export interface Lookup<T> {
     /**
-     * This method is only to be used by resources
      * returns an {@link Optional_Value } of type T reflecting wether the entry existed or not
      *
      * @param key

package/dist/Refiner.d.ts

@@ -0,0 +1,13 @@
+export interface Refinement_Result<T, E> {
+    /**
+     * @param set what to do when the value was set, returns the new type
+     * @param not_set  what to do when the value was not set, returns the new type
+     */
+    process(success: ($: T) => void, exception: ($: E) => void): void;
+    map<NT, NE>(handle_value: ($: T) => NT, handle_exception: ($: E) => NE): Refinement_Result<NT, NE>;
+    map_result<NT>(handle_value: ($: T) => NT): Refinement_Result<NT, E>;
+    transform<NT>(handle_value: ($: T) => NT, handle_exception: ($: E) => NT): NT;
+    with_result<NT>(handle_value: ($: T) => Refinement_Result<NT, E>): Refinement_Result<NT, E>;
+}
+export type Refiner_With_Parameters<In, Parameters, Out, Error> = ($: In, $p: Parameters) => Refinement_Result<Out, Error>;
+export type Refiner_Without_Parameters<In, Out, Error> = ($: In) => Refinement_Result<Out, Error>;

package/dist/Refiner.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Transformer.d.ts

@@ -0,0 +1,2 @@
+export type Transformer_With_Parameters<In, Parameters, Out> = ($: In, $p: Parameters) => Out;
+export type Transformer_Without_Parameters<In, Out> = ($: In) => Out;

package/dist/Transformer.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Unguaranteed_Procedure.d.ts

@@ -0,0 +1,5 @@
+export type Unguaranteed_Procedure<Parameters, Error, Resources> = ($: Parameters, $r: Resources) => Unguaranteed_Procedure_Promise<Error>;
+export type Unguaranteed_Procedure_Promise<Error> = {
+    __start: (on_success: () => void, on_error: (error: Error) => void) => void;
+    map_error<NE>(handle_error: (error: Error) => NE): Unguaranteed_Procedure_Promise<NE>;
+};

package/dist/Unguaranteed_Procedure.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Unguaranteed_Query.d.ts

@@ -0,0 +1,13 @@
+import { Guaranteed_Query_Promise } from "./Guaranteed_Query";
+export type Unguaranteed_Query<Parameters, Result, Error, Resources> = ($: Parameters, $r: Resources) => Unguaranteed_Query_Promise<Result, Error>;
+export type Unguaranteed_Query_Promise<Result, Error> = {
+    map_<NT>(handle_value: ($: Result) => NT): Unguaranteed_Query_Promise<NT, Error>;
+    map_exception_<NE>(handle_exception: ($: Error) => NE): Unguaranteed_Query_Promise<Result, NE>;
+    then<NT>(handle_value: ($: Result) => Guaranteed_Query_Promise<NT>): Unguaranteed_Query_Promise<NT, Error>;
+    then_unguaranteed<NT>(handle_value: ($: Result) => Unguaranteed_Query_Promise<NT, Error>): Unguaranteed_Query_Promise<NT, Error>;
+    catch_(handle_exception: ($: Error) => Guaranteed_Query_Promise<Result>): Guaranteed_Query_Promise<Result>;
+    __start(on_success: ($: Result) => void, on_error: ($: Error) => void): void;
+};
+export type Basic_Unguaranteed_Query_Promise<Result, Error> = {
+    __start: (on_success: (result: Result) => void, on_error: (error: Error) => void) => void;
+};

package/dist/Unguaranteed_Query.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.d.ts

@@ -1,5 +1,9 @@
 export * from "./Array";
-export * from "./Computed_Value";
+export * from "./Circular_Dependency";
 export * from "./Dictionary";
 export * from "./Lookup";
 export * from "./Optional_Value";
+export * from "./Guaranteed_Procedure";
+export * from "./Unguaranteed_Procedure";
+export * from "./Guaranteed_Query";
+export * from "./Unguaranteed_Query";

package/dist/index.js

@@ -15,7 +15,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./Array"), exports);
-__exportStar(require("./Computed_Value"), exports);
+__exportStar(require("./Circular_Dependency"), exports);
 __exportStar(require("./Dictionary"), exports);
 __exportStar(require("./Lookup"), exports);
 __exportStar(require("./Optional_Value"), exports);
+__exportStar(require("./Guaranteed_Procedure"), exports);
+__exportStar(require("./Unguaranteed_Procedure"), exports);
+__exportStar(require("./Guaranteed_Query"), exports);
+__exportStar(require("./Unguaranteed_Query"), exports);

package/package.json

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

package/dist/Computed_Value.d.ts

@@ -1,8 +0,0 @@
-/**
- * A computed value is a function without paramters returning the specified type
- * it makes it possible to do the evaluation only when the function is called
- * useful for lazy evaluation or when side effects are needed
- */
-export type Computed_Value<T> = {
-    'compute': () => T;
-};