diff options
Diffstat (limited to 'doc/0.1.0/cljlib.md')
| -rw-r--r-- | doc/0.1.0/cljlib.md | 674 |
1 files changed, 674 insertions, 0 deletions
diff --git a/doc/0.1.0/cljlib.md b/doc/0.1.0/cljlib.md new file mode 100644 index 0000000..1226591 --- /dev/null +++ b/doc/0.1.0/cljlib.md @@ -0,0 +1,674 @@ +# Cljlib.fnl +Fennel-cljlib - functions from Clojure's core.clj implemented on top of Fennel. + +Documentation for version: 0.1.0 + +## `add` +Function signature: + +``` +(add + ([a]) + ([a b]) + ([a b c]) + ([a b c d]) + ([a b c d & rest])) +``` + +Sum arbitrary amount of numbers. + +## `apply` +Function signature: + +``` +(apply + ([f args]) + ([f a args]) + ([f a b args]) + ([f a b c args]) + ([f a b c d & args])) +``` + +Apply `f` to the argument list formed by prepending intervening +arguments to `args`. + +## `assoc` +Function signature: + +``` +(assoc + ([tbl k v]) + ([tbl k v & kvs])) +``` + +Associate key `k` with value `v` in `tbl`. + +## `boolean?` +Function signature: + +``` +(boolean? [x]) +``` + +Test if `x` is a Boolean + +## `butlast` +Function signature: + +``` +(butlast [col]) +``` + +Returns everything but the last element of a table as a new + table. Calls `seq` on its argument. + +## `comp` +Function signature: + +``` +(comp + ([f]) + ([f g]) + ([f g & fs])) +``` + +Compose functions. + +## `complement` +Function signature: + +``` +(complement [f]) +``` + +Takes a function `f` and returns the function that takes the same +amount of arguments as `f`, has the same effect, and returns the +oppisite truth value. + +## `concat` +Function signature: + +``` +(concat + ([x]) + ([x y]) + ([x y & xs])) +``` + +Concatenate tables. + +## `conj` +Function signature: + +``` +(conj + ([tbl]) + ([tbl x]) + ([tbl x & xs])) +``` + +Insert `x` as a last element of indexed table `tbl`. Modifies `tbl` + +## `cons` +Function signature: + +``` +(cons [x tbl]) +``` + +Insert `x` to `tbl` at the front. Modifies `tbl`. + +## `constantly` +Function signature: + +``` +(constantly [x]) +``` + +Returns a function that takes any number of arguments and returns `x`. + +## `dec` +Function signature: + +``` +(dec [x]) +``` + +Decrease number by one + +## `div` +Function signature: + +``` +(div + ([a]) + ([a b]) + ([a b c]) + ([a b c d]) + ([a b c d & rest])) +``` + +Divide arbitrary amount of numbers. + +## `double?` +Function signature: + +``` +(double? [x]) +``` + +Test if `x` is a number with floating point data. + +## `empty?` +Function signature: + +``` +(empty? [x]) +``` + +Check if collection is empty. + +## `eq` +Function signature: + +``` +(eq + ([x]) + ([x y]) + ([x y & xs])) +``` + +Deep compare values. + +## `even?` +Function signature: + +``` +(even? [x]) +``` + +Test if value is even. + +## `every?` +Function signature: + +``` +(every? [pred tbl]) +``` + +Test if every item in `tbl` satisfies the `pred`. + +## `false?` +Function signature: + +``` +(false? [x]) +``` + +Test if `x` is `false` + +## `filter` +Function signature: + +``` +(filter [pred col]) +``` + +Returns a sequential table of the items in `col` for which `pred` + returns logical true. + +## `first` +Function signature: + +``` +(first [col]) +``` + +Return first element of a table. Calls `seq` on its argument. + +## `ge` +Function signature: + +``` +(ge + ([x]) + ([x y]) + ([x y & more])) +``` + +Returns true if nums are in monotonically non-increasing order + +## `get` +Function signature: + +``` +(get + ([tbl key]) + ([tbl key not-found])) +``` + +Get value from the table by accessing it with a `key`. +Accepts additional `not-found` as a marker to return if value wasn't +found in the table. + +## `get-in` +Function signature: + +``` +(get-in + ([tbl keys]) + ([tbl keys not-found])) +``` + +Get value from nested set of tables by providing key sequence. +Accepts additional `not-found` as a marker to return if value wasn't +found in the table. + +## `get-method` +Function signature: + +``` +(get-method [multifn dispatch-val]) +``` + +Given a multimethod and a dispatch value, returns the dispatch `fn` +that would apply to that value, or `nil` if none apply and no default. + +## `gt` +Function signature: + +``` +(gt + ([x]) + ([x y]) + ([x y & more])) +``` + +Returns true if nums are in monotonically increasing order + +## `hash-map` +Function signature: + +``` +(hash-map + ([& kvs])) +``` + +Create associative table from keys and values + +## `identity` +Function signature: + +``` +(identity [x]) +``` + +Returns its argument. + +## `inc` +Function signature: + +``` +(inc [x]) +``` + +Increase number by one + +## `int?` +Function signature: + +``` +(int? [x]) +``` + +Test if `x` is a number without floating point data. + +## `kvseq` +Function signature: + +``` +(kvseq [tbl]) +``` + +Transforms any table kind to key-value sequence. + +## `last` +Function signature: + +``` +(last [col]) +``` + +Returns the last element of a table. Calls `seq` on its argument. + +## `le` +Function signature: + +``` +(le + ([x]) + ([x y]) + ([x y & more])) +``` + +Returns true if nums are in monotonically non-decreasing order + +## `lt` +Function signature: + +``` +(lt + ([x]) + ([x y]) + ([x y & more])) +``` + +Returns true if nums are in monotonically decreasing order + +## `map?` +Function signature: + +``` +(map? [tbl]) +``` + +Check whether `tbl` is an associative table. + +## `mapv` +Function signature: + +``` +(mapv + ([f col]) + ([f col1 col2]) + ([f col1 col2 col3]) + ([f col1 col2 col3 & cols])) +``` + +Maps function `f` over one or more collections. + +Accepts arbitrary amount of tables, calls `seq` on each of it. +Function `f` must take the same amount of parameters as the amount of +tables passed to `mapv`. Applies `f` over first value of each +table. Then applies `f` to second value of each table. Continues until +any of the tables is exhausted. All remaining values are +ignored. Returns a table of results. + +## `memoize` +Function signature: + +``` +(memoize [f]) +``` + +Returns a memoized version of a referentially transparent function. +The memoized version of the function keeps a cache of the mapping from +arguments to results and, when calls with the same arguments are +repeated often, has higher performance at the expense of higher memory +use. + +## `methods` +Function signature: + +``` +(methods [multifn]) +``` + +Given a multimethod, returns a map of dispatch values -> dispatch fns + +## `mul` +Function signature: + +``` +(mul + ([a]) + ([a b]) + ([a b c]) + ([a b c d]) + ([a b c d & rest])) +``` + +Multiply arbitrary amount of numbers. + +## `neg-int?` +Function signature: + +``` +(neg-int? [x]) +``` + +Test if `x` is a negetive integer. + +## `neg?` +Function signature: + +``` +(neg? [x]) +``` + +Test if `x` is less than zero. + +## `nil?` +Function signature: + +``` +(nil? + ([x])) +``` + +Test if value is nil. + +## `not-any?` +Function signature: + +``` +(not-any? pred tbl) +``` + +Test if no item in `tbl` satisfy the `pred`. + +## `not-empty` +Function signature: + +``` +(not-empty [x]) +``` + +If `x` is empty, returns `nil`, otherwise `x`. + +## `odd?` +Function signature: + +``` +(odd? [x]) +``` + +Test if value is odd. + +## `pos-int?` +Function signature: + +``` +(pos-int? [x]) +``` + +Test if `x` is a positive integer. + +## `pos?` +Function signature: + +``` +(pos? [x]) +``` + +Test if `x` is greater than zero. + +## `range` +Function signature: + +``` +(range + ([upper]) + ([lower upper]) + ([lower upper step])) +``` + +return range of of numbers from `lower` to `upper` with optional `step`. + +## `reduce` +Function signature: + +``` +(reduce + ([f col]) + ([f val col])) +``` + +Reduce collection `col` using function `f` and optional initial value `val`. + +`f` should be a function of 2 arguments. If val is not supplied, +returns the result of applying f to the first 2 items in coll, then +applying f to that result and the 3rd item, etc. If coll contains no +items, f must accept no arguments as well, and reduce returns the +result of calling f with no arguments. If coll has only 1 item, it is +returned and f is not called. If val is supplied, returns the result +of applying f to val and the first item in coll, then applying f to +that result and the 2nd item, etc. If coll contains no items, returns +val and f is not called. Calls `seq` on `col`. + +## `reduce-kv` +Function signature: + +``` +(reduce-kv [f val col]) +``` + +Reduces an associative table using function `f` and initial value `val`. + +`f` should be a function of 3 arguments. Returns the result of +applying `f` to `val`, the first key and the first value in `coll`, +then applying `f` to that result and the 2nd key and value, etc. If +`coll` contains no entries, returns `val` and `f` is not called. Note +that reduce-kv is supported on sequential tables and strings, where +the keys will be the ordinals. + +## `remove-all-methods` +Function signature: + +``` +(remove-all-methods [multifn]) +``` + +Removes all of the methods of multimethod + +## `remove-method` +Function signature: + +``` +(remove-method [multifn dispatch-val]) +``` + +Remove method from `multifn` for given `dispatch-val`. + +## `rest` +Function signature: + +``` +(rest [seq]) +``` + +Returns table of all elements of a table but the first one. Calls + `seq` on its argument. + +## `reverse` +Function signature: + +``` +(reverse [tbl]) +``` + +Returns table with same items as in `tbl` but in reverse order. + +## `seq` +Function signature: + +``` +(seq [col]) +``` + +Create sequential table. +Transforms original table to sequential table of key value pairs +stored as sequential tables in linear time. If `col` is an +associative table, returns `[[key1 value1] ... [keyN valueN]]` table. +If `col` is sequential table, returns its shallow copy. + +## `seq?` +Function signature: + +``` +(seq? [tbl]) +``` + +Check whether `tbl` is an sequential table. + +## `some` +Function signature: + +``` +(some [pred tbl]) +``` + +Test if any item in `tbl` satisfies the `pred`. + +## `string?` +Function signature: + +``` +(string? [x]) +``` + +Test if `x` is a string. + +## `sub` +Function signature: + +``` +(sub + ([a]) + ([a b]) + ([a b c]) + ([a b c d]) + ([a b c d & rest])) +``` + +Subtract arbitrary amount of numbers. + +## `true?` +Function signature: + +``` +(true? [x]) +``` + +Test if `x` is `true` + +## `vector` +Function signature: + +``` +(vector [& args]) +``` + +Constructs sequential table out of it's arguments. + +## `zero?` +Function signature: + +``` +(zero? [x]) +``` + +Test if value is zero. + + +<!-- Generated with Fenneldoc 0.0.1-->
\ No newline at end of file |