flanders.core — threatgrid/flanders 0.1.19

any clj/s

any-bool clj/s

any-inst clj/s

any-int clj/s

any-keyword clj/s

any-num clj/s

any-str clj/s

any-str-seq clj/s

any-string-seq clj/s

anything clj/s

(anything & {:as opts})

bool clj/s

(bool & {:keys [equals] :as opts})

conditional clj/s

(conditional & pred+types)

def-entity-type clj/s macro

(def-entity-type name description & map-entries)

def-enum-type clj/s macro

(def-enum-type name values & opts)

def-eq clj/s macro

(def-eq name value & opts)

def-map-type clj/s macro

(def-map-type name map-entries & {:as opts})

either clj/s

(either & {:keys [choices] :as opts})

Build an EitherType with the keyword arguments opts.

(either :choices [(int) (str)]) ;; => #flanders.types.EitherType{:choices [,,,]}

This function requires the value of the :choices key be a sequence of at least length 1.

(either :choices [(int) (str)]) ;; => AssertionError Assert failed: either expects at least one choice

entry clj/s

(entry k t & {:keys [required?] :or {required? true} :as opts})

enum clj/s

(enum values & {:keys [open?] :or {open? false} :as opts})

eq clj/s

(eq value & {:keys [description reference comment usage name]})

inst clj/s

(inst & {:as opts})

int clj/s

(int & {:keys [equals] :as opts})

key clj/s

(key equals & {:as opts})

keyword clj/s

(keyword & {:keys [equals] :as opts})

map clj/s

(map entries & {:as opts})

Make a MapType containing the given entries. Note that nothing is done to enforce uniqueness of the entries keys. Duplicate keys are handled at the discretion of the fn that is walking the DDL tree, though it should be assumed that later duplicates replace earlier ones (as when merging maps).

map-of clj/s

(map-of {:as opts} & entry-lists)

Build a MapType with a map of options followed by lists of entries. Useful when composing lists of required-entries, optional-entries, and predefined entries.

num clj/s

(num & {:keys [equals] :as opts})

optional-entries clj/s

(optional-entries & entries)

required-entries clj/s

(required-entries & entries)

seq-of clj/s

(seq-of t & {:as opts})

set-of clj/s

(set-of t & {:as opts})

str clj/s

(str & {:keys [equals] :as opts})