clj-foundation.data — coconutpalm/clj-foundation 0.10.0

Convert data between various forms; provide useful guard functions. For example:

• any? - Return coll if any element in coll satisfies predicate
• replace-nil - If value is not nil, return it, otherwise return replacement
• keywordize - Turn string or named value into an idiomatic Clojure :keyword
• ->SNAKE_CASE - Turn string or named value into a string in SNAKE_CASE form
• Various functions for parsing and processing XML

->uppercase-with-spaces clj

(->uppercase-with-spaces value)

Inputs: [value :- (types s/Str Named)] Returns: s/Str

Convert - or _ to ' ' and captialize string.

any? clj

(any? predicate coll)

Returns coll if any element in coll satisfies predicate.

constant-seq clj

(constant-seq c)

Return an infinite lazy seq of cs

dasherize clj

(dasherize match value)

Replace all instance of match with '-' in value.

extract-root-xml-element clj

(extract-root-xml-element root-element xml)

Extract root xml element from the given XML document.

getter clj

(getter property-name)

Inputs: [property-name :- s/Str] Returns: s/Str

identity->nil clj

(identity->nil value)

(identity->nil value identity-p)

Inputs: ([value :- s/Any identity-p :- (=> s/Bool [s/Any])] [value :- s/Any]) Returns: s/Any

Synopsis: (identity->nil []) --> nil (identity->nil "") --> nil (identity->nil 1 #{1}) --> nil ; e.g.: Under multiplication (identity->nil "none" #{"nil" "none" " "}) --> nil

If value is empty (for its type's natural definition of empty), returns nil. Otherwise returns value.

• Non-numeric values are empty iff (empty? value).
• Numbers default to zero as their identity value.
• The identity predicate may optionally be overridden in the second parameter.

keywordize clj

(keywordize name)

Return dasherized keyword from camelCase underscore_names, namespaced/names, etc. See the unit tests for the complete set of supported cases.

Ex. camelCase -> :camel-case some_name -> :some-name customer.firstName -> :customer.first-name

nothing->identity clj

(nothing->identity identity-value value)

Inputs: [identity-value :- s/Any value :- s/Any] Returns: s/Any

Takes nil or Nothing to the specified identity value for the type and computation in context, otherwise returns value. An identity value can be applied to a value of the given type under the operation in context without affecting the result. For example 0 is the identity value for rational numbers under addition. The empty string is the identity value for strings under concatination.

Note that Nothing is already an identity value for maps and seqs. This function is only useful for types where the Nothing type is ill-behaved (e.g.: Strings, Numbers, ...) for a given operation.

Another name for this concept is the monadic zero for the type/operation.

parse-xml clj

(parse-xml xml)

Parse XML from a String

remove-header-row clj

(remove-header-row data)

When processing CSV, frequently we want to throw out the header row.

replace-if clj

(replace-if value predicate)

(replace-if value predicate replacement)

Inputs: ([value :- s/Any predicate :- (=> s/Any [s/Any])] [value :- s/Any predicate :- (=> s/Any [s/Any]) replacement :- s/Any]) Returns: s/Any

In the binary form, replace value with the result of running predicate against value if that result is truthy. In the terniary form, replace value with replacement if the result of running predicate against value is truthy.

An idiomatic way to use this function is to pass a set of disallowed values as predicate, and a replacement value as replacement.

replace-nil clj

(replace-nil maybe-nil replacement)

Inputs: [maybe-nil :- s/Any replacement :- s/Any] Returns: s/Any

Accepts a value that cannot be nil; if it is not nil it returns it, else it returns its replacement.

set-map-entries clj

(set-map-entries m entries new-value)

Inputs: [m :- #:s{Keyword s/Any} entries :- [s/Keyword] new-value :- s/Any] Returns: #:s{Any s/Any}

Returns a new copy of m where for all [k v] => if k is in entries, v is set to new-value.

something-or clj

(something-or value f)

Inputs: [value :- s/Any f :- (=> s/Any [s/Any])] Returns: s/Any

If value is not Nothing return value, else run f and return its result.

string->keyword clj

(string->keyword name)

(string->keyword name naming-exceptions)

Inputs: ([name :- s/Str naming-exceptions :- #{s/Str}] [name :- s/Str]) Returns: s/Keyword

Convert string name to a keyword respecting naming-exceptions. Ex. some_name -> :some-name

string-list->keywords clj

(string-list->keywords list)

(string-list->keywords list naming-exceptions)

Convert a list of strings to a list of keywords

undasherize clj

(undasherize replacement value)

Inputs: [replacement :- s/Str value :- (types s/Str Named)] Returns: s/Str

Replace all instances of '-' or '_' with replacement

value-or clj

(value-or value f)

Inputs: [value :- s/Any f :- (=> s/Any [s/Any])] Returns: s/Any

If value is nil or an instance of Nothing, run f and return its result. Else, return value.

xml-element->kv-pair clj

(xml-element->kv-pair element)

Return key-value pair where key is the tag name, and value is content of the xml element.

xml-elements->map clj

(xml-elements->map elements)

Return a map of key-value pairs from the given xml elements.