dag_unify.core — dag_unify 1.6.7

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.

copy clj/s

(copy input)

create-shared-values clj/s

(create-shared-values serialized)

deref-map clj/s

(deref-map input)

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)

get-in clj/s

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

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

has-path clj/s

(has-path path paths)

isomorphic? clj/s

(isomorphic? a b)

label-of clj/s

(label-of parent)

mapfn clj/s

merge clj/s

merge-with-keys clj/s

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

nonfail clj/s

(nonfail maps)

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.

pprint clj/s

(pprint input)

ref= clj/s

(ref= map path1 path2)

ref? clj/s

(ref? val)

resolve clj/s

(resolve arg)

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

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.

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)