cljs.core.logic — org.clojure/core.logic 1.0.1

*locals* clj

*logic-dbs* cljs

-fnm clj/s macro

(-fnm fn-gen t as & cs)

-inc clj/s macro

(-inc & rest)

-run clj/s macro

(-run opts [x :as bindings] & goals)

== clj/s macro

(== u v)

A goal that attempts to unify terms u and v.

all clj/s macro

(all)

(all & goals)

Like fresh but does does not create logic variables.

all-blank? clj

(all-blank? p)

appendo cljs

A relation where x, y, and z are proper collections, such that z is y appended to x

assq cljs

(assq k xs)

Similar to Scheme assq, xs must be a List of Pairs

bind* clj/s macro

(bind* a g)

(bind* a g & g-rest)

bind-conde-clause clj

(bind-conde-clause a)

bind-conde-clauses clj

(bind-conde-clauses a clauses)

binding-map cljs

(binding-map u w)

(binding-map u w & ts)

Return the binding map that unifies terms u and w. Will prep the terms.

binding-map* cljs

(binding-map* u w)

(binding-map* u w & ts)

Return the binding map that unifies terms u and w. u and w should prepped terms.

Choice cljs

choice cljs

(choice a f)

cond-clauses clj

(cond-clauses a)

conda clj/s macro

(conda & clauses)

Soft cut. Once the head of a clause has succeeded all other clauses will be ignored. Non-relational.

conde clj/s macro

(conde & clauses)

Logical disjunction of the clauses. The first goal in a clause is considered the head of that clause. Interleaves the execution of the clauses.

condu clj/s macro

(condu & clauses)

Committed choice. Once the head (first goal) of a clause has succeeded, remaining goals of the clause will only be run once. Non-relational.

conso cljs

(conso a d l)

A relation where l is a collection, such that a is the first of l and d is the rest of l

defna clj/s macro

(defna & rest)

Define a soft cut goal. See conda.

defne clj/s macro

(defne & rest)

Define a goal fn. Supports pattern matching. All patterns will be tried. See conde.

defnm clj/s macro

(defnm t n & rest)

defnu clj/s macro

(defnu & rest)

Define a committed choice goal. See condu.

empty-s cljs

emptyo cljs

(emptyo a)

A relation where a is the empty list

env-locals clj

(env-locals & syms)

ex clj

(ex vs t a)

(ex vs t a exprs)

ex* clj

(ex* [[p a :as pa] & par] exprs seen)

extract-vars clj

(extract-vars p)

(extract-vars p seen)

Fail cljs

fail cljs

(fail a)

A goal that always fails.

failed? cljs

(failed? x)

firsto cljs

(firsto l a)

A relation where l is a collection, such that a is the first of l

fna clj/s macro

(fna & rest)

Define an anonymous soft cut goal. See conda.

fne clj/s macro

(fne & rest)

Define an anonymous goal fn. Supports pattern matching. All patterns will be tried. See conde.

fnm clj/s macro

(fnm t as tabled? & cs)

fnu clj/s macro

(fnu & rest)

Define an anonymous committed choice goal. See condu.

fresh clj/s macro

(fresh [& lvars] & goals)

Creates fresh variables. Goals occuring within form a logical conjunction.

fresh-expr? clj

(fresh-expr? cs)

handle-clause clj

(handle-clause as)

handle-clauses clj

(handle-clauses t as cs)

IBind cljs protocol

-bind cljs

(-bind this g)

IBuildTerm cljs protocol

-build-term cljs

(-build-term u s)

ifa* clj/s macro

(ifa*)

(ifa* [e & gs] & grest)

ifu* clj/s macro

(ifu*)

(ifu* [e & gs] & grest)

IIfA cljs protocol

-ifa cljs

(-ifa b gs c)

IIfU cljs protocol

-ifu cljs

(-ifu b gs c)

IMPlus cljs protocol

-mplus cljs

(-mplus a f)

Inc cljs

IOccursCheckTerm cljs protocol

-occurs-check-term cljs

(-occurs-check-term v x s)

IReifyTerm cljs protocol

-reify-term cljs

(-reify-term v s)

is clj/s macro

(is u v op)

Set the value of a var to value of another var with the operation applied. Non-relational.

ISubstitutions cljs protocol

-reify* cljs

(-reify* this v)

-ext-no-check cljs

(-ext-no-check this u v)

-ext cljs

(-ext this u v)

-walk cljs

(-walk this v)

-unify cljs

(-unify this u v)

-walk* cljs

(-walk* this v)

-reify cljs

(-reify this v)

-occurs-check cljs

(-occurs-check this u v)

-reify-lvar-name cljs

(-reify-lvar-name _)

ITake cljs protocol

-take* cljs

(-take* a)

IUnifyTerms cljs protocol

-unify-terms cljs

(-unify-terms u v s)

IUnifyWithLSeq cljs protocol

-unify-with-lseq cljs

(-unify-with-lseq v u s)

IUnifyWithLVar cljs protocol

-unify-with-lvar cljs

(-unify-with-lvar v u s)

IUnifyWithMap cljs protocol

-unify-with-map cljs

(-unify-with-map v u s)

IUnifyWithNil cljs protocol

-unify-with-nil cljs

(-unify-with-nil v u s)

IUnifyWithObject cljs protocol

-unify-with-object cljs

(-unify-with-object v u s)

IUnifyWithPMap cljs protocol

unify-with-pmap cljs

(unify-with-pmap pmap u s)

IUnifyWithSequential cljs protocol

-unify-with-seq cljs

(-unify-with-seq v u s)

IWalkTerm cljs protocol

-walk-term cljs

(-walk-term v s)

lcons cljs

(lcons a d)

Constructs a sequence a with an improper tail d if d is a logic variable.

LCons cljs

lcons-p? clj

(lcons-p? p)

lcons-pr-seq cljs

(lcons-pr-seq x)

lcons? cljs

(lcons? x)

LConsSeq cljs protocol

-lfirst cljs

(-lfirst this)

-lnext cljs

(-lnext this)

llist clj/s macro

(llist f s)

(llist f s & rest)

Constructs a sequence from 2 or more arguments, with the last argument as the tail. The tail is improper if the last argument is a logic variable.

log clj/s macro

(log & s)

Goal for println

lvar cljs

(lvar)

(lvar name)

LVar cljs

lvar-bind clj

(lvar-bind sym)

lvar-binds clj

(lvar-binds syms)

lvar-sym-counter cljs

lvar-sym? clj

(lvar-sym? s)

lvar? cljs

(lvar? x)

lvaro clj/s macro

(lvaro v)

Goal to test whether a logic var is ground. Non-relational.

make-s cljs

(make-s s)

(make-s s c)

matcha clj/s macro

(matcha xs & cs)

Define a soft cut pattern match. See conda.

matche clj/s macro

(matche xs & cs)

Pattern matching macro. All patterns will be tried. See conde.

matchu clj/s macro

(matchu xs & cs)

Define a committed choice goal. See condu.

membero cljs

A relation where l is a collection, such that l contains x

mplus cljs

(mplus a f)

mplus* clj/s macro

(mplus* e)

(mplus* e & e-rest)

name-with-attributes clj

(name-with-attributes name macro-args)

To be used in macro definitions. Handles optional docstrings and attribute maps for a name to be defined in a list of macro arguments. If the first macro argument is a string it is added as a docstring to name and removed from the macro argument list. If afterwards the first macro argument is a map, its entries are added to the name's metadata map and the map is removed from the macro argument list. The return value is a vector containing the name with its extended metadata map and the list of unprocessed macro arguments.

nilo cljs

(nilo a)

A relation where a is nil

nonlvaro clj/s macro

(nonlvaro v)

Goal to test whether a logic var is ground. Non-relational.

not-found cljs

p->llist clj

(p->llist p)

pair cljs

(pair lhs rhs)

Pair cljs

partial-map cljs

(partial-map m)

Given map m, returns partial map that unifies with maps even if it doesn't share all of the keys of that map. Only the keys of the partial map will be unified:

(m/run* [q] (m/fresh [pm x] (m/== pm (partial-map {:a x})) (m/== pm {:a 1 :b 2}) (m/== pm q))) ;;=> ({:a 1})

PMap cljs

pred clj/s macro

(pred v f)

Check a predicate against the value logic var. Non-relational.

prefix cljs

(prefix s <s)

prep cljs

(prep expr)

Prep a quoted expression. All symbols preceded by ? will be replaced with logic vars.

project clj/s macro

(project [& vars] & goals)

Extract the values bound to the specified logic vars. Non-relational.

project-binding clj

(project-binding s)

project-bindings clj

(project-bindings vars s)

resto cljs

(resto l d)

A relation where l is a collection, such that d is the rest of l

run clj/s macro

(run n bindings & goals)

Executes goals until a maximum of n results are found.

run* clj/s macro

(run* bindings & goals)

Executes goals until results are exhausted.

run-db clj/s macro

(run-db n db bindings & goals)

Executes goals until a maximum of n results are found. Uses a specified logic database.

run-db* clj/s macro

(run-db* db bindings & goals)

Executes goals until results are exhausted. Uses a specified logic database.

run-nc clj/s macro

(run-nc n bindings & goals)

Executes goals until a maximum of n results are found. Does not occurs-check.

run-nc* clj/s macro

(run-nc* & goals)

Executes goals until results are exhausted. Does not occurs-check.

s# cljs

subst? cljs

(subst? x)

Substitutions cljs

succeed cljs

(succeed a)

A goal that always succeeds.

take* cljs

(take* x)

to-s cljs

(to-s v)

to-stream cljs

(to-stream aseq)

trace-lvar clj

(trace-lvar a lvar)

trace-lvars clj/s macro

(trace-lvars title & lvars)

Goal for tracing the values of logic variables.

trace-s clj/s macro

(trace-s)

Goal that prints the current substitution

u# cljs

unifier cljs

(unifier u w)

(unifier u w & ts)

Unify the terms u and w. Will prep the terms.

unifier* cljs

(unifier* u w)

(unifier* u w & ts)

Unify the terms u and w.

unify cljs

(unify s u v)

unify-with-map* cljs

(unify-with-map* v u s)

walk-term-map* cljs

(walk-term-map* v s)

warn clj

(warn & msg)