clojure.core.logic — mschuene/core.logic 0.8.11.1

!= clj

(!= u v)

Disequality constraint. Ensures that u and v will never unify. u and v can be complex terms.

!=c clj

(!=c p)

*locals* clj

*logic-dbs* clj

-conjo clj

(-conjo coll args out)

-featurec clj

(-featurec x fs)

-fixc clj

(-fixc x f reifier)

(-fixc x f runnable reifier)

-fnm clj macro

(-fnm fn-gen t as & cs)

-inc clj macro

(-inc & rest)

-nafc clj

(-nafc c args)

-predc clj

(-predc x p)

(-predc x p pform)

-reify clj

(-reify s v)

(-reify s v r)

-reify* clj

(-reify* s v)

-run clj macro

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

== clj

(== u v)

A goal that attempts to unify terms u and v.

add-attr clj

(add-attr s x attr attrv)

add-dom clj

(add-dom s x dom domv)

(add-dom s x dom domv seenset)

add-var clj

(add-var cs x c)

addcg clj

(addcg c)

all clj macro

(all)

(all & goals)

Like fresh but does does not create logic variables.

and* clj

(and* goals)

A function version of all, which takes a list of goals and succeeds only fi they all succeed.

annotate clj

(annotate k v)

answer-cache clj

(answer-cache)

appendo clj

(appendo x y z)

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

assoc-dom clj

(assoc-dom x k v)

assoc-meta clj

(assoc-meta x k v)

bind* clj macro

(bind* a g)

(bind* a g & g-rest)

bindable? clj

(bindable? x)

build clj

(build s u)

cgoal clj

(cgoal c)

choice clj

(choice a f)

composeg clj

(composeg)

(composeg g0 g1)

composeg* clj macro

(composeg* g0)

(composeg* g0 & gs)

conda clj macro

(conda & clauses)

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

conde clj 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 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.

conjo clj

(conjo coll & args)

A constraint version of conj

conso clj

(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. If ground d must be bound to a proper tail.

constrain-tree clj

(constrain-tree t fc)

copy-term clj

(copy-term u v)

Copies a term u into v. Non-relational.

defna clj macro

(defna & rest)

Define a soft cut goal. See conda.

defnc clj macro

(defnc name args & body)

defne clj macro

(defne & rest)

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

defnm clj macro

(defnm t n & rest)

defnu clj macro

(defnu & rest)

Define a committed choice goal. See condu.

dissoc-dom clj

(dissoc-dom x k)

dissoc-meta clj

(dissoc-meta x k)

distincto clj

(distincto l)

A relation which guarantees no element of l will unify with another element of l.

distribute clj

(distribute v* strategy)

disunify clj

(disunify s u v)

(disunify s u v cs)

empty-f clj

empty-s clj

emptyo clj

(emptyo a)

A relation where a is the empty list

enforce-constraints clj

(enforce-constraints x)

enforceable-constrained clj

(enforceable-constrained a)

entailed? clj

(entailed? c c' a)

entangle clj

(entangle s x y)

env-locals clj

(env-locals & syms)

everyg clj

(everyg g coll)

A pseudo-relation that takes a coll and ensures that the goal g succeeds on every element of the collection.

ext clj

(ext s u v)

ext-run-csg clj

(ext-run-csg u v)

fail clj

(fail a)

A goal that always fails.

featurec clj

(featurec x fs)

Ensure that a map contains at least the key-value pairs in the map fs. fs must be partially instantiated - that is, it may contain values which are logic variables to support feature extraction.

firsto clj

(firsto l a)

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

fix-constraints clj

(fix-constraints a)

A goal to run the constraints in cq until it is empty. Of course running a constraint may grow cq so this function finds the fixpoint.

fixc clj

(fixc x f reifier)

(fixc x f runnable reifier)

fk clj

fna clj macro

(fna & rest)

Define an anonymous soft cut goal. See conda.

fnc clj macro

(fnc args & body)

Define an anonymous constraint that can be used with the unifier:

(let [oddc (fnc [x] (odd? x))]

 (unifier {:a '?a} {:a 1} :when {'?a oddc})
   ;;=> {:a 1}

 (unifier {:a '?a} {:a 2} :when {'?a oddc})
   ;;=> nil

)

Note, the constraint will not run until all arguments are fully ground.

Use defnc to define a constraint and assign a toplevel var.

fne clj macro

(fne & rest)

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

fnm clj macro

(fnm t as tabled? & cs)

fnu clj macro

(fnu & rest)

Define an anonymous committed choice goal. See condu.

force-ans clj

(force-ans x)

fresh clj macro

(fresh [& lvars] & goals)

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

get-attr clj

(get-attr s x attr)

get-dom clj

(get-dom s x dom)

get-dom-fd clj

(get-dom-fd a x)

ground-term? clj

(ground-term? x s)

ientailed? clj

(ientailed? c)

ifa* clj macro

(ifa*)

(ifa* [e & gs] & grest)

ifu* clj macro

(ifu*)

(ifu* [e & gs] & grest)

is clj macro

(is u v op)

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

lcons clj

(lcons a d)

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

lcons? clj

(lcons? x)

let-dom clj macro

(let-dom a vars & body)

llist clj 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 macro

(log & s)

Goal for println

lvar clj

(lvar)

(lvar name)

(lvar name unique)

lvar? clj

(lvar? x)

lvaro clj macro

(lvaro v)

A goal that succeeds if the argument is fresh. v must be a logic variable. Non-relational.

lvars clj

(lvars n)

make-cs clj

(make-cs)

make-suspended-stream clj

(make-suspended-stream cache ansv* f)

master clj

(master argv cache)

Take the argument to the goal and check that we don't have an alpha equivalent cached answer term in the cache. If it doesn't already exist in the cache add the new answer term.

matcha clj macro

(matcha xs & cs)

Define a soft cut pattern match. See conda.

matche clj macro

(matche xs & cs)

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

matchu clj macro

(matchu xs & cs)

Define a committed choice goal. See condu.

member1o clj

(member1o x l)

Like membero but uses to disequality further constraining the results. For example, if x and l are ground and x occurs multiple times in l, member1o will succeed only once.

membero clj

(membero x l)

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

merge-doms clj

(merge-doms s x doms)

merge-with-root clj

(merge-with-root s x root)

mplus* clj macro

(mplus* e)

(mplus* e & e-rest)

nafc clj

(nafc c & args)

EXPERIMENTAL: negation as failure constraint. All arguments to the goal c must be ground. If some argument is not ground the execution of this constraint will be delayed.

nilo clj

(nilo a)

A relation where a is nil

nonlvaro clj macro

(nonlvaro v)

A goal that succeeds if the argument is not fresh. v must be a logic variable. Non-relational.

normalize-store clj

occurs-check clj

(occurs-check s u v)

onceo clj

(onceo g)

or* clj

(or* goals)

A function version of conde, which takes a list of goals and tries them as if via conde. Note that or* only does disjunction, ie (or* [a b c]) is the same as (conde [a] [b] [c]). If you need something like (conde [a b] [c]), you can use and*, or all: (or* [(and* a b) c]).

pair clj

partial-map clj

(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.

partial-map? clj

(partial-map? x)

permuteo clj

(permuteo xl yl)

A relation that will permute xl into the yl. May not terminate if xl is not ground.

pred clj macro

(pred v f)

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

predc clj

(predc x p)

(predc x p pform)

project clj macro

(project [& vars] & goals)

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

recover-vars clj

(recover-vars p)

recover-vars-from-term clj

(recover-vars-from-term x)

reify-constraints clj

(reify-constraints v r a)

reify-lvar-name clj

(reify-lvar-name s)

reifyg clj

(reifyg x)

rem-attr clj

(rem-attr s x attr)

rem-dom clj

(rem-dom s x dom)

(rem-dom s x dom seenset)

rembero clj

(rembero x l o)

A relation between l and o where x is removed from l exactly one time.

remcg clj

(remcg c)

resto clj

(resto l d)

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

run clj macro

(run n bindings & goals)

Executes goals until a maximum of n results are found.

run* clj macro

(run* bindings & goals)

Executes goals until results are exhausted.

run-constraint clj

(run-constraint c)

run-constraints clj

(run-constraints xcs)

run-constraints* clj

(run-constraints* xs cs ws)

run-db clj 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 macro

(run-db* db bindings & goals)

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

run-nc clj macro

(run-nc n bindings & goals)

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

run-nc* clj macro

(run-nc* & goals)

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

runcg clj

(runcg c)

s# clj

seqc clj

(seqc v)

solutions clj

(solutions s g)

(solutions s q g)

sort-by-member-count clj

(sort-by-member-count a)

sort-by-strategy clj

(sort-by-strategy v x a)

stopcg clj

(stopcg c)

subst-val clj

(subst-val x)

(subst-val x doms)

(subst-val x doms _meta)

(subst-val x doms eset _meta)

subst-val? clj

(subst-val? x)

subst? clj

(subst? x)

succeed clj

(succeed a)

A goal that always succeeds.

suspended-stream? clj

(suspended-stream? x)

sync-eset clj

(sync-eset s v seenset f)

tabled clj macro

(tabled args & grest)

Macro for defining a tabled goal. Prefer ^:tabled with the defne/a/u forms over using this directly.

tabled-s clj

(tabled-s)

(tabled-s oc)

(tabled-s oc meta)

to-s clj

(to-s v)

to-stream clj

(to-stream aseq)

to-subst-val clj

(to-subst-val v)

trace-lvar clj

(trace-lvar a lvar)

trace-lvars clj macro

(trace-lvars title & lvars)

Goal for tracing the values of logic variables.

trace-s clj macro

(trace-s)

Goal that prints the current substitution

tramp clj

(tramp f)

tree-term? clj

(tree-term? x)

treec clj

(treec x fc reifier)

u# clj

uai clj macro

(uai & args)

umi clj macro

(umi & args)

unbound-names clj

unbound-rands clj

(unbound-rands a c)

unify clj

(unify s u v)

unify-with-map* clj

(unify-with-map* u v s)

unify-with-pmap* clj

(unify-with-pmap* u v s)

unify-with-sequential* clj

(unify-with-sequential* u v s)

update-dom clj

(update-dom s x dom f)

(update-dom s x dom f seenset)

update-eset clj

(update-eset s doms eset)

update-pvars! clj

(update-pvars! x vars)

updatecg clj

(updatecg c)

var-rands clj

(var-rands a c)

verify-all-bound clj

(verify-all-bound a constrained)

waiting-stream-check clj

(waiting-stream-check w success-cont failure-cont)

Take a waiting stream, a success continuation, and a failure continuation. If we don't find any ready suspended streams, invoke the failure continuation. If we find a ready suspended stream calculate the remainder of the waiting stream. If we've reached the fixpoint just call the thunk of the suspended stream, otherwise call mplus on the result of the thunk and the remainder of the waiting stream. Pass this result to the success contination.

waiting-stream? clj

(waiting-stream? x)

walk* clj

(walk* s v)

walk-record-term clj

(walk-record-term v f)