@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/Reasoner-BxYhx9s7.d.mts

@@ -0,0 +1,94 @@
+import { i as Formula, l as Statement, r as Document, s as N3Term } from "./Model-DaMmxurZ.mjs";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+declare namespace Reasoner_d_exports {
+  export { Options, ReasonerError, Result, Rule, query, reason, rules };
+}
+declare const ReasonerError_base: Schema.Class<ReasonerError, Schema.TaggedStruct<"N3ReasonerError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * Reasoning failed: an inconsistency was derived or a limit was exceeded.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+declare class ReasonerError extends ReasonerError_base {}
+/**
+ * @since 0.1.0
+ * @category models
+ */
+interface Options {
+  /** Maximum number of forward-chaining rounds (default 1000). */
+  readonly maxRounds?: number | undefined;
+  /** Maximum number of statements in the closure (default 1 000 000). */
+  readonly maxStatements?: number | undefined;
+  /** Whether to evaluate builtins (default `true`). */
+  readonly builtins?: boolean | undefined;
+}
+/**
+ * A rule extracted from a formula.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Rule {
+  readonly premise: ReadonlyArray<Statement>;
+  readonly conclusion: N3Term;
+  /** The statement the rule was read from. */
+  readonly source: Statement;
+}
+/**
+ * The result of reasoning.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Result {
+  /** The input statements together with everything inferred. */
+  readonly closure: Formula;
+  /** Only the newly inferred statements. */
+  readonly inferred: Formula;
+  /** The number of rounds until the fixpoint was reached. */
+  readonly rounds: number;
+}
+/**
+ * Extracts the rules (`=>` and `<=` statements between formulas) of a
+ * formula's top level.
+ *
+ * @since 0.1.0
+ * @category rules
+ */
+declare const rules: (formula: Formula) => ReadonlyArray<Rule>;
+/**
+ * Computes the deductive closure of a formula under its rules.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from 'effect'
+ * import { N3, Reasoner } from '@thomasfosterau/effect-rdf/n3'
+ *
+ * const program = Effect.gen(function* () {
+ *   const doc = yield* N3.parse(`@prefix : <http://example.org/> .
+ *     :socrates a :Man .
+ *     { ?x a :Man } => { ?x a :Mortal } .`)
+ *   const { inferred } = yield* Reasoner.reason(doc.formula)
+ *   return N3.serializeDocument(inferred) // :socrates a :Mortal .
+ * })
+ * ```
+ *
+ * @since 0.1.0
+ * @category reasoning
+ */
+declare const reason: (formula: Formula | Document, options?: Options) => Effect.Effect<Result, ReasonerError>;
+/**
+ * Answers a query: all bindings of the variables (and blank nodes) of
+ * `pattern` under which every statement of `pattern` holds in `formula`
+ * (builtins are evaluated).
+ *
+ * @since 0.1.0
+ * @category reasoning
+ */
+declare const query: (formula: Formula, pattern: Formula) => ReadonlyArray<ReadonlyMap<string, N3Term>>;
+export { Rule as a, rules as c, Result as i, ReasonerError as n, query as o, Reasoner_d_exports as r, reason as s, Options as t };
+//# sourceMappingURL=Reasoner-BxYhx9s7.d.mts.map