;; -*- mode: fennel; -*- vi:ft=fennel
;; Configuration file for Fenneldoc v0.1.9
;; https://gitlab.com/andreyorst/fenneldoc

{:fennel-path {}
 :function-signatures true
 :ignored-args-patterns ["[a-z]"
                         "%.%.%."
                         "[xkf]s"
                         "kvs"
                         "col[0-9]"
                         "cols?"
                         "rest"
                         "more"
                         "keys"
                         "tbl"
                         "_"
                         "%+"
                         "cs"
                         "sep"
                         "coll"
                         "Set"
                         "s[0-9]+"
                         "ss"
                         "args"]
 :inline-references "link"
 :insert-comment true
 :insert-copyright true
 :insert-license true
 :insert-version true
 :mode "checkdoc"
 :modules-info
 {:cljlib.fnl
  {:description "Fennel-cljlib - functions from Clojure's core.clj implemented on top of Fennel.

This library contains a set of functions providing functions that behave similarly to Clojure's equivalents.
The library itself apart from macros has nothing Fennel-specific, so it should work on Lua, e.g.:

``` lua
Lua 5.3.5  Copyright (C) 1994-2018 Lua.org, PUC-Rio
> clj = require\"cljlib\"
> table.concat(clj.mapv(function (x) return x * x end, {1, 2, 3}), \" \")
-- 1 4 9
```

This example is mapping an anonymous `function' over a table, producing a new table, and concatenating it with `\" \"`.

However, this library also provides a Fennel-specific set of [macros](./macros.md), which provides additional facilities like `defn' or `defmulti' which extends the language allowing writing code that looks and works mostly like Clojure.

Each function in this library is created with `defn', which is a special macro for creating multi-arity functions.
So when you see a function signature like `(foo [x])`, this means that this is function `foo', which accepts exactly one argument `x'.
On the contrary, functions created with `fn' will produce a `(foo x)` signature (`x' is not inside brackets).

Functions, which signatures look like `(foo ([x]) ([x y]) ([x y & zs]))`, it is a multi-arity function, which accepts either one, two, or three or more arguments.
Each `([...])` represents a different body of a function which is chosen by checking the amount of arguments passed to the function.
See [Clojure's doc section on multi-arity functions](https://clojure.org/guides/learn/functions#_multi_arity_functions).

## Compatibility

This library is mainly developed with Lua 5.4 and tested against Lua 5.2, 5.3, 5.4, and LuaJIT 2.1.0-beta3.
Note, that in Lua 5.2 and LuaJIT equality semantics are a bit different from Lua 5.3 and Lua 5.4.
The main difference is that when comparing two tables, they must have exactly the same `__eq` metamethods, so comparing hash sets with hash sets will work, but comparing sets with other tables works only in Lua5.3+.
Another difference is that Lua 5.2 and LuaJIT don't have an inbuilt UTF-8 library, therefore `seq' function will not work for non-ASCII strings."
   :doc-order ["ns"
               "in-ns"
               "def"
               "fn*"
               "defn"
               "defn-"
               "time"
               "if-let"
               "when-let"
               "if-some"
               "when-some"
               "defmulti"
               "defmethod"
               "cond"
               "loop"
               "try"
               "lazy-seq"
               "lazy-cat"
               "apply"
               "add"
               "sub"
               "mul"
               "div"
               "le"
               "lt"
               "ge"
               "gt"
               "inc"
               "dec"
               "eq"
               "map?"
               "vector?"
               "multifn?"
               "set?"
               "nil?"
               "zero?"
               "pos?"
               "neg?"
               "even?"
               "odd?"
               "string?"
               "boolean?"
               "true?"
               "false?"
               "int?"
               "pos-int?"
               "neg-int?"
               "double?"
               "empty?"
               "not-empty"
               "vector"
               "seq"
               "first"
               "rest"
               "last"
               "butlast"
               "conj"
               "disj"
               "cons"
               "concat"
               "reduce"
               "reduced"
               "reduce-kv"
               "mapv"
               "filter"
               "every?"
               "some"
               "not-any?"
               "range"
               "reverse"
               "take"
               "nthrest"
               "partition"
               "identity"
               "comp"
               "complement"
               "constantly"
               "memoize"
               "assoc"
               "hash-map"
               "get"
               "get-in"
               "keys"
               "vals"
               "find"
               "dissoc"
               "remove-method"
               "remove-all-methods"
               "methods"
               "get-method"
               "hash-set"]
   :name "cljlib"}}
 :order "alphabetic"
 :out-dir "./doc"
 :project-copyright "Copyright (C) 2020-2021 Andrey Listopadov"
 :project-license "[MIT](https://gitlab.com/andreyorst/fennel-cljlib/-/raw/master/LICENSE)"
 :project-version "v1.1.1"
 :sandbox false
 :test-requirements {:cljlib.fnl "(require-macros (doto :cljlib require))
                                  (require-macros (doto :fennel-test.fennel-test require))"}
 :toc true}