Previous: , Up: Top   [Index]

19 Index of the guile-log api


Jump to:   *   ,   -   ;   <   =   _                    
A   B   C   D   E   F   G   I   L   M   N   O   P   Q   R   S   T   U   V   W   Z  
Index Entry  Section

*current-stack*: umatch
*equal?: kanren
*gp-var-tr*: guile-log
*kanren-assq*: guile-log

,,: prolog-microkanren

-i>: prolog-microkanren

;;: prolog-microkanren

</.>: guile-log
<//>: guile-log
<<case-lambda>>: guile-log
<<define->>: guile-log
<<define>>: guile-log
<<lambda>>: guile-log
<=: continuations
<=: return-values
<==>: guile-log
<=>: guile-log
<abort>: dynamics
<and!!>: guile-log
<and!>: guile-log
<and-i>: guile-log
<and>: guile-log
<append-dynamic>: dynamic-functions
<apply>: guile-log
<ask>: guile-log
<attvar-raw?>: attributes
<attvar?>: attributes
<call>: guile-log
<car>: guile-log
<case-lambda>: guile-log
<catch>: dynamics
<cc>: guile-log
<cdr>: guile-log
<clear>: guile-log
<code>: guile-log
<collect-2>: acumulators/generators
<collect-step-2>: acumulators/generators
<collect-step>: acumulators/generators
<collect>: acumulators/generators
<cond>: guile-log
<cons>: guile-log
<continue>: guile-log
<cut>: guile-log
<def->: guile-log
<def>: guile-log
<define-guile-log-rule>: guile-log
<define>: guile-log
<del-attr>: attributes
<dynamic-compile>: dynamic-functions
<dynwind>: guile-log
<eval>: guile-log
<fail>: guile-log
<fix-fold-step>: guile-log
<fix-fold>: guile-log
<fold-step>: guile-log
<fold>: guile-log
<format>: guile-log
<funcall>: guile-log
<get-attr>: attributes
<guard-dynamic-functions>: dynamic-functions
<hvar>: guile-log
<if-some>: guile-log
<if>: guile-log
<lambda-dyn>: dynamic-functions
<lambda>: guile-log
<let*>: guile-log
<let-with-guard>: guile-log
<let-with-lr-guard>: guile-log
<let>: guile-log
<letrec>: guile-log
<letrec>: guile-log
<logical++>: guile-log
<logical-->: guile-log
<match>: guile-log
<max-2>: acumulators/generators
<max-step-2>: acumulators/generators
<max-step>: acumulators/generators
<max>: acumulators/generators
<min-2>: acumulators/generators
<min-step-2>: acumulators/generators
<min-step>: acumulators/generators
<min>: acumulators/generators
<next>: guile-log
<not>: guile-log
<or-i>: guile-log
<or-union>: guile-log
<or>: guile-log
<peek-fail>: guile-log
<pp-dyn>: guile-log
<pp>: guile-log
<prod-2>: acumulators/generators
<prod-step-2>: acumulators/generators
<prod-step>: acumulators/generators
<prod>: acumulators/generators
<prompt>: dynamics
<push-dynamic>: dynamic-functions
<put-attr>: attributes
<r=>: guile-log
<raw-attvar>: attributes
<recur>: guile-log
<remove-dynamic>: dynamic-functions
<ret>: guile-log
<return>: guile-log
<run>: guile-log
<scm>: guile-log
<soland-2>: acumulators/generators
<soland-step-2>: acumulators/generators
<soland-step>: acumulators/generators
<soland>: acumulators/generators
<solor-2>: acumulators/generators
<solor-step-2>: acumulators/generators
<solor-step>: acumulators/generators
<solor>: acumulators/generators
<stall>: guile-log
<state-ref>: guile-log
<state-set!>: guile-log
<succeeds>: guile-log
<sum-2>: acumulators/generators
<sum-step-2>: acumulators/generators
<sum-step>: acumulators/generators
<sum>: acumulators/generators
<tail-code>: guile-log
<take>: guile-log
<update>: guile-log
<values>: guile-log
<var>: guile-log
<when>: guile-log
<with-cc>: guile-log
<with-cut>: guile-log
<with-dynamic-functions>: dynamic-functions
<with-fail>: guile-log
<with-guile-log>: guile-log
<with-s>: guile-log
<zip>: guile-log

=/=: minikanren
==: kanren
==: minikanren
=>: return-values

_: kanren

: return-values

: return-values

: sets

∖∖: sets

: sets

: sets

: sets

: sets

: sets

abort_to_pompt: prolog continuations
absento: minikanren
add-operator: expressions
all: kanren
all!: kanren
all!!: kanren
all-interleave: kanren
always_state_guard_dynamic_object: dynamic-features
amaxall: prolog sequencing
amaxalln: prolog sequencing
amaxof: prolog sequencing
amaxofn: prolog sequencing
amaxofp: prolog sequencing
amaxofpn: prolog sequencing
amaxofs: prolog sequencing
amaxofsn: prolog sequencing
amaxstp: prolog sequencing
amaxstpn: prolog sequencing
aminall: prolog sequencing
aminalln: prolog sequencing
aminof: prolog sequencing
aminofn: prolog sequencing
aminofp: prolog sequencing
aminofpn: prolog sequencing
aminofs: prolog sequencing
aminofsn: prolog sequencing
aminstp: prolog sequencing
aminstpn: prolog sequencing
and-interleave: guile-log
and_i: prolog interleaving
any: kanren
any-interleave: kanren
any-union: kanren
associate-getter-setter: persistance
attvar: prolog attributes
auto: prolog coroutines

backtrack_dynamic_object: dynamic-features
bagof: prolog sequencing
bmaxall: prolog sequencing
bmaxalln: prolog sequencing
bmaxof: prolog sequencing
bmaxofn: prolog sequencing
bmaxofp: prolog sequencing
bmaxofpn: prolog sequencing
bmaxofs: prolog sequencing
bmaxofsn: prolog sequencing
bmaxstp: prolog sequencing
bmaxstpn: prolog sequencing
bminall: prolog sequencing
bminalln: prolog sequencing
bminof: prolog sequencing
bminofn: prolog sequencing
bminofp: prolog sequencing
bminofpn: prolog sequencing
bminofs: prolog sequencing
bminofsn: prolog sequencing
bminstp: prolog sequencing
bminstpn: prolog sequencing
booleano: minikanren

c: sets
call_k: prolog continuations
canonize: prolog canonical
case: guile-log
CC: guile-log
cc: continuations
cc: return-values
ccc: return-values
cell: prolog delay
cellit: prolog delay
close_error_false: closures
close_error_true: closures
closure_code_ref: closures
closure_is_closed: closures
closure_p: closures
closure_state_ref: closures
compile-prolog-file: running
compile-prolog-string: running
cond: guile-log
conda: minikanren
conde: minikanren
condu: minikanren
copy_dynamic_object: dynamic-features
countall: prolog sequencing
countalln: prolog sequencing
countof: prolog sequencing
countofn: prolog sequencing
countofs: prolog sequencing
countofsn: prolog sequencing
countstp: prolog sequencing
countstpn: prolog sequencing
current-pot: prolog-microkanren
CUT: guile-log

define-and-log: guile-log
define-dynamic: dynamic-functions
define-fluid-object: persistance
define-guile-log: guile-log
define-guile-log-parser: stream ideom
define-named-object: persistance
define-shallow-object: persistance
delay: prolog delay
del_attr: prolog attributes
do[]: scheme
Ds: parser combinators
dynwind: prolog-dynwind

engine_create: engines
engin_next: engines
error_at_closed_p_handle: closures
error_on_namespace_switch: modules
extend-relation: kanren
extend-relation-with-recur-limit: kanren
extended: extended matching

f*: parser combinators
f+: parser combinators
f-and: parser combinators
f-and!: parser combinators
f-and!!: parser combinators
f-append: parser combinators
f-cons: parser combinators
f-cons*: parser combinators
f-eof: parser combinators
f-false: parser combinators
f-id: parser combinators
f-list: parser combinators
f-nl: parser combinators
f-nl!: parser combinators
f-nl-pr: parser combinators
f-not: parser combinators
f-not!: parser combinators
f-not*: parser combinators
f-not-pr: parser combinators
f-or: parser combinators
f-or!: parser combinators
f-out: parser combinators
f-reg: parser combinators
f-reg!: parser combinators
f-reg-pr: parser combinators
f-seq: parser combinators
f-seq!: parser combinators
f-seq!!: parser combinators
f-tag: parser combinators
f-tag!: parser combinators
f-tag-pr: parser combinators
f-true: parser combinators
fact: kanren
fail: kanren
fails: kanren
fail_on_namespace_switch: modules
ff*: parser combinators
ff+: parser combinators
ff?: parser combinators
findall: prolog sequencing
fluid_guard_dynamic_object: dynamic-features
fn: parser combinators
foldall: prolog sequencing
foldalln: prolog sequencing
foldof: prolog sequencing
foldofn: prolog sequencing
foldofs: prolog sequencing
foldofsn: prolog sequencing
foldstp: prolog sequencing
foldstpn: prolog sequencing
freeze: prolog coroutines
freezeBig: prolog coroutines
freezeId: prolog coroutines
fresh: minikanren
frozen: prolog coroutines
functorize: functors

generalized: types-and-classes
get_attr: prolog attributes
get_message: fibers
get_namespace_switch_handle: modules
get_prolog_conversion_handle: dynamic-features
get_prolog_flags_handle: dynamic-features
get_prolog_operators_handle: dynamic-features
gp->scm: umatch
gp-budy: umatch
gp-car: umatch
gp-cdr: umatch
gp-clear: umatch
gp-cons!: umatch
gp-copy: umatch
gp-dynwind: umatch
gp-fluid-set: umatch
gp-get-stack: umatch
gp-lookup: umatch
gp-m-unify!: umatch
gp-make-stack: umatch
gp-make-var: umatch
gp-newframe: umatch
gp-pair?: umatch
gp-print: umatch
gp-printer: umatch
gp-restore-state: umatch
gp-restore-wind: umatch
gp-set!: umatch
gp-stack-set: umatch
gp-store-state: umatch
gp-undo-safe-variable-guard: umatch
gp-undo-safe-variable-lguard: umatch
gp-undo-safe-variable-rguard: umatch
gp-unify!: umatch
gp-unify-raw!: umatch
gp-unwind: umatch
gp-var!: umatch
gp-var-number: umatch
gp-var-ref: umatch
gp-var-set!: umatch
gp-var?: umatch

if: guile-log
if-only: kanren
if-some: kanren
insert: prolog delay
interleave: guile-log
interleave-union: guile-log
intersect-relation: kanren

lastall: prolog sequencing
lastalln: prolog sequencing
lastof: prolog sequencing
laststpn: prolog sequencing
leave-logical: umatch
let-gls: kanren
let-lv: kanren
let-with-guard: guile-log
let-with-lr-guard: guile-log
let<>: guile-log
Level: debugging
lift-to-relations: kanren
list-of-pre: prolog-microkanren
list-of-tail: prolog-microkanren
load-persists: persistance
log-code-macro: guile-log
lookup: types-and-classes

machine-base*: prolog-microkanren
make-opdata: expressions
make-persister: persistance
make-shallow: persistance
make_channel: fibers
make_vhash: prolog hash
maxall: prolog sequencing
maxalln: prolog sequencing
maxof: prolog sequencing
maxofn: prolog sequencing
maxofs: prolog sequencing
maxofsn: prolog sequencing
maxstp: prolog sequencing
maxstpn: prolog sequencing
memo: memoizing
memo: prolog-tabling
memo-rec: memoizing
minall: prolog sequencing
minalln: prolog sequencing
minof: prolog sequencing
minofn: prolog sequencing
minofs: prolog sequencing
minofsn: prolog sequencing
minstp: prolog sequencing
minstpn: prolog sequencing
mk: sets
mk-operator-expression: expressions
mk-token: parser combinators

n: sets
namespace_white_list_handle: modules
namespace_white_list_ref: modules
namespace_white_list_set: modules
not_backtrack_dynamic_object: dynamic-features
numbero: minikanren

o: sets
ok_on_namespece_switch: modules
once: minikanren
once_i: prolog-microkanren
or_i: prolog interleaving
or_union: prolog interleaving

P: guile-log
p-freeze: parser combinators
parse: parser combinators
parse<>: guile-log
partially-eval-sgl: kanren
persist-ref: persistance
persist-set!: persistance
postpone: postpone
postpone-frame: postpone
postpone_frame: prolog postpone
postpone_frame: prolog-tabling
pot-machine-base: prolog-microkanren
predicate: kanren
prodall: prolog sequencing
prodalln: prolog sequencing
prodof: prolog sequencing
prodofn: prolog sequencing
prodofs: prolog sequencing
prodofsn: prolog sequencing
prodstp: prolog sequencing
prodstpn: prolog sequencing
project: kanren
project: minikanren
project/no-check: kanren
prolog-run: running
push-setup: umatch
put_attr: prolog attributes
put_message: fibers

que-setup: umatch
query: kanren

raw_attvar: prolog attributes
rec: memoizing
rec-00: memoizing
rec-action: memoizing
rec-action00: memoizing
rec-lam: memoizing
rec-lam-00: memoizing
rec-lam-once: memoizing
rec-once: memoizing
rec=: memoizing
rec==: memoizing
recursive: memoizing
recursive_canonize: prolog canonical
reify: kanren
relation: kanren
rem-operator: expressions
reset-char-conversion: running
reset-flags: running
reset-operator-map: running
reset-prolog: running
reverse-lookup: types-and-classes
re_prompt: prolog continuations
run: minikanren
run*: minikanren

S: guile-log
save-persists: persistance
scm[]: scheme
setof: prolog sequencing
sets_to_theory: types-and-classes
setup-parser: parser tooling
set_dynamic_object: dynamic-features
set_no_whitelist: modules
sfail: kanren
sleep: fibers
solution: kanren
solve: kanren
spawn_fiber: fibers
stall: interpreter
state_guard_dynamic_object: dynamic-features
state_guard_dynamic_object_zip: dynamic-features
succeed: kanren
succeeds: kanren
sumall: prolog sequencing
sumalln: prolog sequencing
sumof: prolog sequencing
sumofn: prolog sequencing
sumofs: prolog sequencing
sumofsn: prolog sequencing
sumstp: prolog sequencing
sumstpn: prolog sequencing
symbolo: minikanren

table: prolog-tabling
table_i: prolog-tabling
table_rec: prolog-tabling
tok-ws*: parser combinators
tok-ws+: parser combinators
tr: guile-log
Trace: debugging
trace: debugging
trace-level: debugging
trace-vars: kanren

u: sets
umatch: umatch
update: prolog zip
use-logical: umatch
usr_ref: interpreter
usr_set: interpreter
usr_zip: prolog zip

var?: kanren
vhashp: prolog hash
vhash_cons: prolog hash
vhash_fo_each: prolog hash
vhash_ref: prolog hash
voset-addition: implementations
voset-complement: implementations
voset-difference: implementations
voset-equal?: implementations
voset-intersection: implementations
voset-subset<: implementations
voset-subset<=: implementations
voset-union: implementations
vosetq-addition: implementations
vosetq-complement: implementations
vosetq-difference: implementations
vosetq-equal?: implementations
vosetq-intersection: implementations
vosetq-subset<: implementations
vosetq-subset<=: implementations
vosetq-union: implementations
vosetv-addition: implementations
vosetv-complement: implementations
vosetv-difference: implementations
vosetv-equal?: implementations
vosetv-intersection: implementations
vosetv-subset<: implementations
vosetv-subset<=: implementations
vosetv-union: implementations
vosetx-addition: implementations
vosetx-complement: implementations
vosetx-difference: implementations
vosetx-equal?: implementations
vosetx-intersection: implementations
vosetx-subset<: implementations
vosetx-subset<=: implementations
vosetx-union: implementations
vset->assoc: implementations
vset->kvlist): implementations
vset->list: implementations
vset-addition: implementations
vset-complement: implementations
vset-difference: implementations
vset-empty: implementations
vset-equal?: implementations
vset-fold: implementations
vset-for-each: implementations
vset-intersection: implementations
vset-map: implementations
vset-subset<: implementations
vset-subset<=: implementations
vset-union: implementations
vset-world: implementations
vsetq->assoc: implementations
vsetq->kvlist): implementations
vsetq->list: implementations
vsetq-addition: implementations
vsetq-complement: implementations
vsetq-difference: implementations
vsetq-empty: implementations
vsetq-equal?: implementations
vsetq-fold: implementations
vsetq-for-each: implementations
vsetq-intersection: implementations
vsetq-map: implementations
vsetq-subset<: implementations
vsetq-subset<=: implementations
vsetq-union: implementations
vsetq-world: implementations
vsetv->assoc: implementations
vsetv->kvlist): implementations
vsetv->list: implementations
vsetv-addition: implementations
vsetv-complement: implementations
vsetv-difference: implementations
vsetv-empty: implementations
vsetv-equal?: implementations
vsetv-fold: implementations
vsetv-for-each: implementations
vsetv-intersection: implementations
vsetv-map: implementations
vsetv-subset<: implementations
vsetv-subset<=: implementations
vsetv-union: implementations
vsetv-world: implementations
vsetx->assoc: implementations
vsetx->kvlist): implementations
vsetx->list: implementations
vsetx-addition: implementations
vsetx-complement: implementations
vsetx-difference: implementations
vsetx-empty: implementations
vsetx-equal?: implementations
vsetx-fold: implementations
vsetx-for-each: implementations
vsetx-intersection: implementations
vsetx-map: implementations
vsetx-subset<: implementations
vsetx-subset<=: implementations
vsetx-union: implementations
vsetx-world: implementations

when: prolog coroutines
whenBig: prolog coroutines
with-gp-vars: umatch
with[]: scheme
with_always_state_guard_dynamic_object: dynamic-features
with_backtrack_dynamic_object: dynamic-features
with_coroutine: prolog coroutines
with_fibers: fibers
with_fluid_guard_dynamic_object: dynamic-features
with_fluid_guard_dynamic_object_once: dynamic-features
with_not_backtrack_dynamic_object: dynamic-features
with_prompt: prolog continuations
with_state_guard_dynamic_object: dynamic-features
with_state_guard_dynamic_object_zip: dynamic-features
wosetx-addition: implementations
wosetx-complement: implementations
wosetx-difference: implementations
wosetx-equal?: implementations
wosetx-intersection: implementations
wosetx-subset<: implementations
wosetx-subset<=: implementations
wosetx-union: implementations
wsetx->assoc: implementations
wsetx->kvlist): implementations
wsetx->list: implementations
wsetx-addition: implementations
wsetx-complement: implementations
wsetx-difference: implementations
wsetx-empty: implementations
wsetx-equal?: implementations
wsetx-fold: implementations
wsetx-for-each: implementations
wsetx-intersection: implementations
wsetx-map: implementations
wsetx-subset<: implementations
wsetx-subset<=: implementations
wsetx-union: implementations
wsetx-world: implementations

zip: prolog zip

Jump to:   *   ,   -   ;   <   =   _                    
A   B   C   D   E   F   G   I   L   M   N   O   P   Q   R   S   T   U   V   W   Z  

Previous: , Up: Top   [Index]