dag_unify.core — dag_unify 1.6.4

*exclude-keys* clj/s

*local-keys* clj/s

add-indices clj/s

(add-indices elements values)

aliases-of clj/s

(aliases-of path reentrance-sets)

given path and a set of set of paths, for each subset s, if a member m1 of s is a prefix of path, concatenate each member other m2 of s to remainder(m2,path).

all-refs clj/s

(all-refs input)

annotate clj/s

(annotate fs & [firsts path x y path-sets])

assoc-in clj/s

(assoc-in m path v)

Similar to clojure.core/assoc-in, but uses unification so that existing values are unified rather than overwritten.

assoc-in! clj/s

(assoc-in! m path v)

Similar to assoc-in, but m's references (if any) are modified.

by-rows clj/s

(by-rows fs)

copy clj/s

(copy input)

count-refs-in-path clj/s

(count-refs-in-path path fs)

create-path-in clj/s

(create-path-in path value)

create a path starting at map through all keys in map: (create-path-in '(a b c d e) value) => {:a {:b {:c {:d {:e value}}}}})

create-shared-values clj/s

(create-shared-values serialized)

deref-map clj/s

(deref-map input)

deserialize clj/s

(deserialize serialized)

deserialize-with-remove clj/s

(deserialize-with-remove serialized pred)

dissoc-in clj/s

(dissoc-in structure path)

dissoc a path in a dag, as well as any other path in the dag to the same value.

dissoc-in-all-paths clj/s

(dissoc-in-all-paths value paths)

dissoc-in-map clj/s

(dissoc-in-map the-map path)

dissoc a nested path from the-map; e.g.: (dissoc-in {:a {:b 42, :c 43}} [:a :b]) => {:a {:c 43}}.

dissoc-path clj/s

(dissoc-path serialized path)

elements clj/s

(elements fs)

elements-of-row clj/s

(elements-of-row elements row)

exception clj/s

(exception error-string)

exists? clj/s

(exists? the-map path)

fail-path clj/s

(fail-path fs1 fs2)

fail-path-between clj/s

(fail-path-between fs1 fs2)

If unifying fs1 and fs2 leads to a fail somewhere, show the path to the fail. Otherwise return nil. Not efficient: use only for diagnostics.

fail-path-r clj/s

(fail-path-r fs & [fs-keys])

find the first failing path in a fs.

fail? clj/s

(fail? fs)

(fail? fs) <=> true if at least one of fs's path's value is :fail.

failr? clj/s

(failr? fs keys)

find-fail-in clj/s

(find-fail-in fs1 fs2 paths)

find-paths-to-value clj/s

(find-paths-to-value map value path)

find all paths in map which are equal to value, where value is (ref?)=true.

gather-annotations clj/s

(gather-annotations fs & [firsts path annotate])

get-in clj/s

(get-in in-map path & [not-found])

same as clojure.core (get-in), but references are resolved and followed.

get-remainders-for clj/s

(get-remainders-for aliases-of-path reentrance-set)

has-path clj/s

(has-path path paths)

height clj/s

(height fs & [firsts path])

index-of-ref clj/s

(index-of-ref path path-sets & [i])

is-first-ref? clj/s

(is-first-ref? path sets)

isomorphic? clj/s

(isomorphic? a b)

key-rank clj/s

(key-rank k keys)

label-of clj/s

(label-of parent)

mapfn clj/s

max-lengths clj/s

(max-lengths serialization)

merge-with-keys clj/s

(merge-with-keys arg1 arg2 keys-of-arg1)

nonfail clj/s

(nonfail maps)

padding clj/s

(padding value width)

path-to-ref-index clj/s

(path-to-ref-index serialized path n)

pathify clj/s

(pathify fs & [prefix])

Transform a map into a map of paths/value pairs, where paths are lists of keywords, and values are atomic values. e.g.: {:foo {:bar 42, :baz 99}} => { { (:foo :bar) 42}, {(:foo :baz) 99} } The idea is to map the key :foo to the (recursive) result of pathify on :foo's value.

paths clj/s

(paths fs)

pprint clj/s

(pprint input)

prefix? clj/s

(prefix? a b)

return true iff seq a is a prefix of seq b: (prefix? [:a ] [:a :b]) => true (prefix? [:a :b] [:a ]) => false (prefix? [:a :b] [:a :c]) => false

print-out clj/s

(print-out fs)

rank-within clj/s

(rank-within path fs)

recursive-dissoc clj/s

(recursive-dissoc a-map pred)

like dissoc, but works recursively. Only works on reference-free maps (contains no atoms).

ref-skel-map clj/s

(ref-skel-map input-map)

associate each reference in input-map with:

1. its skeleton
2. all paths to point to it.

ref= clj/s

(ref= map path1 path2)

ref? clj/s

(ref? val)

remainder clj/s

(remainder a b)

if seq a is a prefix of seq b, then return what is left of b besides the common prefix of a. if seq a is not a prefix, return nil.

remove-matching-keys clj/s

(remove-matching-keys fs pred)

remove-top-values clj/s

(remove-top-values fs)

Remove any <key,value> pair in the input fs if value=:top. Use case is logging where we don't care about uninformative key->value pairs where value is simply :top. Also strips refs for readability.

resolve clj/s

(resolve arg)

if arg is not a ref, return arg. if is a ref, return (resolve @arg)

ser-intermed clj/s

(ser-intermed input-map)

serialize clj/s

(serialize input-map)

simple-unify clj/s

simplify-ref clj/s

(simplify-ref arg)

if arg is a ref and @arg is not a ref, return arg. if @arg is also a ref, return (simplify-ref @arg). else, return arg.

skeletize clj/s

(skeletize input-val)

skels clj/s

(skels input-map refs)

create map from reference to their skeletons.

sort-by-max-lengths clj/s

(sort-by-max-lengths serialization)

sort-shortest-path-ascending-r clj/s

(sort-shortest-path-ascending-r serialization path-length-pairs)

strip-refs clj/s

(strip-refs map-with-refs)

unify clj/s

(unify & args)

like unify!, but non-destructively copy each argument before unifying.

unify! clj/s

(unify! val1)

(unify! val1 val2 & rest-args)

destructively merge arguments, where arguments are maps possibly containing references, so that sharing relationship in the arguments is preserved in the result

unifyc clj/s

(unifyc & args)

alias for (defn unify)

width clj/s

(width fs & [firsts path])

width-of-cell clj/s

(width-of-cell cell)

width-of-column clj/s

(width-of-column elements column)