baby.pat.vt — baby.pat/jessica-spano 0.1.0

! clj/s

!instant! clj/s

(!instant!)

*add clj/s multimethod

*change clj/s multimethod

*employ clj/s multimethod

*normalize-as clj/s multimethod

*rm clj/s multimethod

<- clj/s

(<- m path)

<-clone clj/s

(<-clone m subject xform)

<-count clj/s

(<-count m path)

<-keys clj/s

(<-keys m path)

<-overlay clj/s

(<-overlay m overlay underlay)

<-underlay clj/s

(<-underlay m underlay overlay)

<<- clj/s

(<<- m path)

<<-clone clj/s

(<<-clone m subject xform)

<<-count clj/s

(<<-count m path)

<<-keys clj/s

(<<-keys m path)

<<-overlay clj/s

(<<-overlay m path underlay)

<<-underlay clj/s

(<<-underlay m path overlay)

access clj/s

(access m {:keys [action supatom path function args] :as instructions})

Access an atom or map via an instructions map.

access-anything-with clj/s

(access-anything-with partial-instructions)

Takes partial instructions and returns a function that needs a map and further instructions.

access-this-with clj/s

(access-this-with m partial-instructions)

Takes partial instructions and returns a primed function like access

add clj/s

(add m items)

(add variant m items)

Adds items to m as normalized collections.

add-kw-ns clj/s

(add-kw-ns new-namespace thing)

Adds a provided namespace to the thing or things provided DWIM style.

add-normalized clj/s

(add-normalized safe-m items)

(add-normalized variant m items)

add-normalized-boilerplate clj/s

(add-normalized-boilerplate variant m items)

after? clj/s

(after? established in-question)

Is the first thing after the second?

all-valid-examples-of? clj/s

(all-valid-examples-of? things vt)

at-or-after? clj/s

(at-or-after? established in-question)

Is the first thing at or after the second?

at-or-before? clj/s

(at-or-before? established in-question)

Is the first thing at or before the second?

atom? clj/s

(atom? thing)

Is a thing an atom?

bang clj/s

(bang v)

(bang m v)

Provides a vector interface to access.

before? clj/s

(before? established in-question)

Is the first thing before the second?

between? clj/s

(between? basis-start basis-end in-question)

Given the start and end is the thing in question inside both?

call-fn-from-ident clj/s

(call-fn-from-ident m ident)

Calls a function located at the ident.

call-fn-from-ident-on-map clj/s

(call-fn-from-ident-on-map m ident)

Calls a function located at the ident on the map provided.

callable-fn-from-thing clj/s

(callable-fn-from-thing fq)

Given a keyword or a string returns a callable function that thing resolves to.

change clj/s

(change m path function)

(change m path function args)

Takes m, path, and then the args to '(swap! c update-in p ...)' or '(update-in c p ...)'.

contains-keys? clj/s

(contains-keys? m k)

(contains-keys? m k & ks)

Does a map contain all the provided keys?

default-change-wrapper clj/s

(default-change-wrapper variant map path function)

(default-change-wrapper variant map path function args)

duration-in-seconds clj/s

(duration-in-seconds time-start time-end)

Gives the duration of a time range in seconds. Useful for qualifying drilling activities based on sparse info.

employ clj/s

(employ m path)

(employ variant m path)

(employ variant m path & args)

ensure-safe-string clj/s

(ensure-safe-string kw-or-str)

entity-as-instance clj/s

(entity-as-instance entity)

Turn an entity into an instance.

entity-ident-or-idents? clj/s

(entity-ident-or-idents? thing)

Is this thing an ident or group of them?

entity-ident? clj/s

(entity-ident? thing)

Is a thing an entity id?

entity-idents? clj/s

(entity-idents? thing)

Is this thing a vector of entity ids?

follow-path clj/s

(follow-path m path)

Follows normalized entities to return the true value coords of path. Ripped from fulcro.a.n-s

follow-remove-normalized clj/s

(follow-remove-normalized m path)

Removes a path and all it's references from a normalized map.

id->default-value clj/s

(id->default-value m id)

Returns the value stored in the default position for an id. i.e. :a/cool returns the value at [:a/id :a/cool :a/a]

id-kw-for clj/s

(id-kw-for thing)

Catch all function that produces an idkw for a variety of types.

id-kw-for-map clj/s

(id-kw-for-map m)

Takes a map that presumably has a key with the name id and returns it's namespace qualified id key.

id-kw-for-path clj/s

(id-kw-for-path path)

DO I NEED THIS? WHAT USE IS THIS? HOW'D THIS GET HERE? WHERE IS KONDO?

id-of clj/s

(id-of m)

Takes a map with a namespaced id key and returns the value for the key named 'id'.

id-qkw? clj/s

(id-qkw? thing)

Is a thing a qualified id keyword?

ident->default-value clj/s

(ident->default-value m ident)

Returns the value stored in the default position for an ident.
i.e. [:a/id :a/cool] returns value at [:a/id :a/cool :a/a]

ident-for clj/s

(ident-for m)

Takes a map and returns the normalized ident for it based on the id.

in-bounds? clj/s

(in-bounds? basis-start basis-end in-question)

Given the start and end is the thing in question within both?

inside-of-prefix clj/s

(inside-of-prefix prefix)

Takes a prefix and returns a function that adds that prefix to a thing or things DWIM style.

instant->map clj/s

(instant->map t)

Takes an instant of time and breaks it down into units.

is-already-normalized? clj/s

(is-already-normalized? m)

Is the provided map already normalized?

map->instant clj/s

(map->instant {:time/keys [yyyy MM dd HH mm ss ms]})

Takes a map of time and returns an instant.

map-with? clj/s

(map-with? & qkws)

Does a map contain all these keys?

normalizable? clj/s

(normalizable? m)

Can the provided map be normalized?

not-after? clj/s

(not-after? established in-question)

Is the first thing not after the second?

not-before? clj/s

(not-before? established in-question)

Is the first thing not before the second?

now clj/s

plural clj/s

plural-datatype-name-of clj/s

(plural-datatype-name-of thing)

plural-keyword clj/s

pull-entry-by-key-name clj/s

(pull-entry-by-key-name key-name m)

Filters a map returning the entry matching the key-name

qid clj/s

(qid)

Utility to create a simply id that's a unique string. Placeholder.

rand-of clj/s

(rand-of)

(rand-of k)

Returns a random category member.
Can be provided category keyword ':nato-alphabet'

rand-str clj/s

(rand-str)

(rand-str len)

Creates a random string of 64 or supplied length upper and lower chars + numbers.

rando-counts-map clj/s

remove-normalized clj/s

(remove-normalized m path)

Removes a path from a normalized map.

return-as-function clj/s

(return-as-function m thing)

(return-as-function variant m thing)

Returns either the function given or the function stored at the path.

return-as-instance clj/s

(return-as-instance m thing)

(return-as-instance variant m thing)

If given a path, return the map entry, ortherwise return the map. A variant can be provided first to use a named method of employ.

return-map-and-ident clj/s

(return-map-and-ident m ident)

Given an atom or a map and another map or ident or id keyword returns m and ident. i.e. [{} [:a/id :a/cool]]

rm clj/s

(rm m path)

(rm variant m path)

Removes an ident from m.

rm-kw-ns clj/s

(rm-kw-ns thing)

Removes the namespace for a thing or things DWIM style.

safe-kws clj/s≠

clj

(safe-kws thing)

(safe-kws underscore-replacement thing)

cljs

(safe-kws thing)

safe-string->kw clj/s

(safe-string->kw n)

safe storage string -> useful kw

singular clj/s

singular-keyword clj/s

subtract clj/s

(subtract original & others)

Subtracts time by taking an inst, and number/unit pairs. i.e. 12 :minutes 43 :hours 4 :days, etc. Subtracts numbers via reduce.

sum clj/s

(sum original & others)

Adds time by taking an inst, and number/unit pairs. i.e. 12 :minutes 43 :hours 4 :days, etc. Adds numbers via reduce.

time-pair->seconds clj/s

(time-pair->seconds p)

(time-pair->seconds n u)

(time-pair->seconds n u & nus)

Turns a pair of number/unit i.e. 12 :minutes and converts it to seconds.

timestamp->instant clj/s

(timestamp->instant at)

Takes the milliseconds off the time string of a malformed database time string and makes it an inst.

type-of? clj/s

(type-of? thing string)

Does the type of a thing as a string include the string provided?

unqualified-keyword? clj/s

(unqualified-keyword? thing)

Is a thing a keyword with no namespace.

vt-dispatch clj/s

(vt-dispatch thing)

Takes a thing and returns it's value-type qualified keyword. This is a dumber case-based type dispatch.

walk-dissoc clj/s

(walk-dissoc m k & ks)

Walks a map returning it without the provided keys.

wrecklessly-dispatch-new-map clj/s

(wrecklessly-dispatch-new-map is-atom? m new-m)

A wrapper that helps make consistent return values for atoms and maps

wrecklessly-employ clj/s

(wrecklessly-employ m path)

Employ function that returns the value of a path in the map

wrecklessly-handle-possible-atoms clj/s

(wrecklessly-handle-possible-atoms thing)

A helpful function to help with atoms. Returns [is-atom? safe-thing]