Macro file is required multiple times during compilation about hotpot.nvim HOT 20 CLOSED

      ["fnl/arglist"] = { "([f col])", "([f val col])" },
      ["fnl/docstring"] = "Reduce collection `col' using function `f' and optional initial value `val'.\n\n`f' should be a function of 2 arguments.  If val is not supplied,\nreturns the result of applying f to the first 2 items in coll, then\napplying f to that result and the 3rd item, etc.  If coll contains no\nitems, f must accept no arguments as well, and reduce returns the\nresult of calling f with no arguments.  If coll has only 1 item, it is\nreturned and f is not called.  If val is supplied, returns the result\nof applying f to val and the first item in coll, then applying f to\nthat result and the 2nd item, etc.  If coll contains no items, returns\nval and f is not called.  Calls `seq' on `col'.\n\nEarly termination is possible with the use of `reduced'\nfunction.\n\n# Examples\nReduce sequence of numbers with `add'\n\n``` fennel\n(reduce add [1 2 3 4])\n;; => 10\n(reduce add 10 [1 2 3 4])\n;; => 20\n```"
    },
    [<function 197>] = {
      ["fnl/arglist"] = { "[col]" },
      ["fnl/docstring"] = "Returns everything but the last element of a table as a new\n  table. Calls `seq' on its argument."
    },
    [<function 198>] = {
      ["fnl/arglist"] = { "([])", "([x])", "([x y])", "([x y & xs])" },
      ["fnl/docstring"] = "Concatenate tables."
    },
    [<function 199>] = {
      ["fnl/arglist"] = { "[binding test]", "then-branch", "else-branch" }
    },
    [<function 200>] = {
      ["fnl/arglist"] = { "[x]" },
      ["fnl/docstring"] = "If `x' is empty, returns `nil', otherwise `x'."
    },
    [<function 201>] = {
      ["fnl/arglist"] = { "[x]" },
      ["fnl/docstring"] = "Test if `x' is `true'"
    },
    [<function 202>] = {
      ["fnl/arglist"] = { "tbl", "key1", "..." },
      ["fnl/docstring"] = "Look up key1 in tbl table. If more args are provided, do a nested lookup."
    },
    [<function 203>] = {
      ["fnl/arglist"] = { "([])", "([a])", "([a b])", "([a b c])", "([a b c d])", "([a b c d & rest])" },
      ["fnl/docstring"] = "Sum arbitrary amount of numbers."
    },
    [<function 204>] = {
      ["fnl/arglist"] = { "[x]" },
      ["fnl/docstring"] = "Test if `x' is a Boolean"
    },
    [<function 205>] = {
      ["fnl/arglist"] = { "([x])", "([x y])", "([x y & xs])" },
      ["fnl/docstring"] = "Deep compare values.\n\n# Examples\n\n`eq' can compare both primitive types, tables, and user defined types\nthat have `__eq` metamethod.\n\n``` fennel\n(assert-is (eq 42 42))\n(assert-is (eq [1 2 3] [1 2 3]))\n(assert-is (eq (hash-set :a :b :c) (hash-set :a :b :c)))\n(assert-is (eq (hash-set :a :b :c) (ordered-set :c :b :a)))\n```\n\nDeep comparison is used for tables which use tables as keys:\n\n``` fennel\n(assert-is (eq {[1 2 3] {:a [1 2 3]} {:a 1} {:b 2}}\n               {{:a 1} {:b 2} [1 2 3] {:a [1 2 3]}}))\n(assert-is (eq {{{:a 1} {:b 1}} {{:c 3} {:d 4}} [[1] [2 [3]]] {:a 2}}\n               {[[1] [2 [3]]] {:a 2} {{:a 1} {:b 1}} {{:c 3} {:d 4}}}))\n```"
    },
    [<function 206>] = {
      ["fnl/arglist"] = { "a", "b", "..." },
      ["fnl/docstring"] = "Arithmetic operator; works the same as Lua but accepts more arguments."
    },
    [<function 207>] = {
      ["fnl/arglist"] = { "[x]" },
      ["fnl/docstring"] = "Test if `x' is a number without floating point data.\n\nNumber is rounded with `math.floor' and compared with original number."
    },
    [<function 208>] = {
      ["fnl/arglist"] = { "[x]" },
      ["fnl/docstring"] = "Test if `x' is a number with floating point data."
    },
    [<function 209>] = {
      ["fnl/arglist"] = { "[&", "args]" },
      ["fnl/docstring"] = "Constructs sequential table out of it's arguments.\n\nSets additional metadata for function `vector?' to work.\n\n# Examples\n\n``` fennel\n(local v (vector 1 2 3 4))\n(assert-eq v [1 2 3 4])\n```"
    },
    [<function 210>] = {
      ["fnl/arglist"] = { "[x]" },
      ["fnl/docstring"] = "Test if `x' is a positive integer."
    },
    [<function 211>] = {
      ["fnl/arglist"] = { "[x]" },
      ["fnl/docstring"] = "Test if `x' is a Boolean"
    },
    [<function 212>] = {
      ["fnl/arglist"] = { "\n  ([f col])", "\n  ([f col1 col2])", "\n  ([f col1 col2 col3])", "\n  ([f col1 col2 col3 & cols])" },
      ["fnl/docstring"] = "Maps function `f' over one or more collections.\n\nAccepts arbitrary amount of collections, calls `seq' on each of it.\nFunction `f' must take the same amount of arguments as the amount of\ntables, passed to `mapv'. Applies `f' over first value of each\ntable. Then applies `f' to second value of each table. Continues until\nany of the tables is exhausted. All remaining values are\nignored. Returns a sequential table of results.\n\n# Examples\nMap `string.upcase' over the string:\n\n``` fennel\n(mapv string.upper \"string\")\n;; => [\"S\" \"T\" \"R\" \"I\" \"N\" \"G\"]\n```\n\nMap `mul' over two tables:\n\n``` fennel\n(mapv mul [1 2 3 4] [1 0 -1])\n;; => [1 0 -3]\n```\n\nBasic `zipmap' implementation:\n\n``` fennel\n(import-macros {: into} :cljlib.init-macros)\n(fn zipmap [keys vals]\n  (into {} (mapv vector keys vals)))\n\n(zipmap [:a :b :c] [1 2 3 4])\n;; => {:a 1 :b 2 :c 3}\n```"
    },
    [<function 213>] = {
      ["fnl/arglist"] = { "([])", "([a])", "([a b])", "([a b c])", "([a b c d])", "([a b c d & rest])" },
      ["fnl/docstring"] = "Sum arbitrary amount of numbers."
    },
    [<function 214>] = {
      ["fnl/arglist"] = { "tbl", "method-name", "..." },
      ["fnl/docstring"] = "Call the named method on tbl with the provided args.\nMethod name doesn't have to be known at compile-time; if it is, use\n(tbl:method-name ...) instead."
    },
    [<function 215>] = {
      ["fnl/arglist"] = { "[pred", "tbl]" },
      ["fnl/docstring"] = "Test if every item in `tbl' satisfies the `pred'."
    },
    [<function 216>] = {
      ["fnl/arglist"] = { "[col]" },
      ["fnl/docstring"] = "Create sequential table.\n\nTransforms original table to sequential table of key value pairs\nstored as sequential tables in linear time.  If `col' is an\nassociative table, returns sequential table of vectors with key and\nvalue.  If `col' is sequential table, returns its shallow copy.  If\n`col' is string, return sequential table of its codepoints.\n\n# Examples\nSequential tables remain as is:\n\n``` fennel\n(seq [1 2 3 4])\n;; [1 2 3 4]\n```\n\nAssociative tables are transformed to format like this `[[key1 value1]\n... [keyN valueN]]` and order is non deterministic:\n\n``` fennel\n(seq {:a 1 :b 2 :c 3})\n;; [[:b 2] [:a 1] [:c 3]]\n```\n\nSee `into' macros for transforming this back to associative table.\nAdditionally you can use `conj' and `apply' with\n`hash-map':\n\n``` fennel\n(apply conj (hash-map) [:c 3] [[:a 1] [:b 2]])\n;; => {:a 1 :b 2 :c 3}\n```"
    },
    [<function 217>] = {
      ["fnl/arglist"] = { "([x])", "([x y])", "([x y & xs])" },
      ["fnl/docstring"] = "Deep compare values.\n\n# Examples\n\n`eq' can compare both primitive types, tables, and user defined types\nthat have `__eq` metamethod.\n\n``` fennel\n(assert-is (eq 42 42))\n(assert-is (eq [1 2 3] [1 2 3]))\n(assert-is (eq (hash-set :a :b :c) (hash-set :a :b :c)))\n(assert-is (eq (hash-set :a :b :c) (ordered-set :c :b :a)))\n```\n\nDeep comparison is used for tables which use tables as keys:\n\n``` fennel\n(assert-is (eq {[1 2 3] {:a [1 2 3]} {:a 1} {:b 2}}\n               {{:a 1} {:b 2} [1 2 3] {:a [1 2 3]}}))\n(assert-is (eq {{{:a 1} {:b 1}} {{:c 3} {:d 4}} [[1] [2 [3]]] {:a 2}}\n               {[[1] [2 [3]]] {:a 2} {{:a 1} {:b 1}} {{:c 3} {:d 4}}}))\n```"
    },
    [<function 218>] = {
      ["fnl/arglist"] = { "[multimethod]" },
      ["fnl/docstring"] = "Given a `multimethod', returns a map of dispatch values -> dispatch fns"
    },
    [<function 219>] = {
      ["fnl/arglist"] = { "[n", "col]" },
      ["fnl/docstring"] = "Returns a sequence of the first `n' items in `col', or all items if\nthere are fewer than `n'."
    },
    [<function 220>] = {
      ["fnl/arglist"] = { "\n  ([f args])", "\n  ([f a args])", "\n  ([f a b args])", "\n  ([f a b c args])", "\n  ([f a b c d & args])" },
      ["fnl/docstring"] = "Apply `f' to the argument list formed by prepending intervening\narguments to `args', and `f' must support variadic amount of\narguments.\n\n# Examples\nApplying `add' to different amount of arguments:\n\n``` fennel\n(assert-eq (apply add [1 2 3 4]) 10)\n(assert-eq (apply add 1 [2 3 4]) 10)\n(assert-eq (apply add 1 2 3 4 5 6 [7 8 9]) 45)\n```"
    },
    [<function 221>] = {
      ["fnl/arglist"] = { "attr-map?", "name", "expr" }
    },
    [<function 222>] = {
      ["fnl/arglist"] = { "[x]" },
      ["fnl/docstring"] = "Returns its argument."
    },
    [<function 223>] = {
      ["fnl/arglist"] = { "([])", "([x])" },
      ["fnl/docstring"] = "Test if `x' is nil."
    },
    [<function 224>] = {
      ["fnl/arglist"] = { "[f]" },
      ["fnl/docstring"] = "Takes a function `f' and returns the function that takes the same\namount of arguments as `f', has the same effect, and returns the\noppisite truth value."
    },
    [<function 225>] = {
      ["fnl/arglist"] = { "a", "b", "..." },
      ["fnl/docstring"] = "Comparison operator; works the same as Lua but accepts more arguments."
    },
    [<function 226>] = {
      ["fnl/arglist"] = { "[col]" },
      ["fnl/docstring"] = "Create sequential table.\n\nTransforms original table to sequential table of key value pairs\nstored as sequential tables in linear time.  If `col' is an\nassociative table, returns sequential table of vectors with key and\nvalue.  If `col' is sequential table, returns its shallow copy.  If\n`col' is string, return sequential table of its codepoints.\n\n# Examples\nSequential tables remain as is:\n\n``` fennel\n(seq [1 2 3 4])\n;; [1 2 3 4]\n```\n\nAssociative tables are transformed to format like this `[[key1 value1]\n... [keyN valueN]]` and order is non deterministic:\n\n``` fennel\n(seq {:a 1 :b 2 :c 3})\n;; [[:b 2] [:a 1] [:c 3]]\n```\n\nSee `into' macros for transforming this back to associative table.\nAdditionally you can use `conj' and `apply' with\n`hash-map':\n\n``` fennel\n(apply conj (hash-map) [:c 3] [[:a 1] [:b 2]])\n;; => {:a 1 :b 2 :c 3}\n```"
    },
    [<function 227>] = {
      ["fnl/arglist"] = { "([])", "([f])", "([f g])", "([f g & fs])" },
      ["fnl/docstring"] = "Compose functions."
    },
    [<function 228>] = {
      ["fnl/arglist"] = { "[binding test]", "&", "body" }
    },
    [<function 229>] = {
      ["fnl/arglist"] = { "binding1", "module-name1", "..." },
      ["fnl/docstring"] = "Binds a table of macros from each macro module according to a binding form.\n  Each binding form can be either a symbol or a k/v destructuring table.\n  Example:\n    (import-macros mymacros                 :my-macros    ; bind to symbol\n                   {:macro1 alias : macro2} :proj.macros) ; import by name"
    },
    [<function 230>] = {
      ["fnl/arglist"] = { "[col", "n]" },
      ["fnl/docstring"] = "Returns the nth rest of `col', `col' when `n' is 0.\n\n# Examples\n\n``` fennel\n(assert-eq (nthrest [1 2 3 4] 3) [4])\n(assert-eq (nthrest [1 2 3 4] 2) [3 4])\n(assert-eq (nthrest [1 2 3 4] 1) [2 3 4])\n(assert-eq (nthrest [1 2 3 4] 0) [1 2 3 4])\n```\n"
    },
    [<function 231>] = {
      ["fnl/arglist"] = { "[x]" },
      ["fnl/docstring"] = "Test if `x' is `false'"
    },
    [<function 232>] = {
      ["fnl/arglist"] = { "x1", "x2", "..." },
      ["fnl/docstring"] = "Bitwise OR of any number of arguments.\nOnly works in Lua 5.3+ or LuaJIT with the --use-bit-lib flag."
    },
    [<function 233>] = {
      ["fnl/arglist"] = { "[x]" },
      ["fnl/docstring"] = "Check if collection is empty."
    },
    [<function 234>] = {
      ["fnl/arglist"] = { "[col]" },
      ["fnl/docstring"] = "Transforms any table `col' to key-value sequence."
    },
    [<function 235>] = {
      ["fnl/arglist"] = { "[pred", "tbl]" },
      ["fnl/docstring"] = "Test if any item in `tbl' satisfies the `pred'."
    },
    [<function 236>] = {
      ["fnl/arglist"] = { "[n", "col]" },
      ["fnl/docstring"] = "Returns a sequence of the first `n' items in `col', or all items if\nthere are fewer than `n'."
    },
    [<function 237>] = {
      ["fnl/arglist"] = { "[key value (iterator)]", "..." },
      ["fnl/body-form?"] = true,
      ["fnl/docstring"] = "Runs the body once for each set of values provided by the given iterator.\nMost commonly used with ipairs for sequential tables or pairs for  undefined\norder, but can be used with any iterator."
    },
    [<function 238>] = {
      ["fnl/arglist"] = { "[tbl]" },
      ["fnl/docstring"] = "Returns table with same items as in `tbl' but in reverse order."
    },
    [<function 239>] = {
      ["fnl/arglist"] = { "([n col])", "([n step col])", "([n step pad col])" },
      ["fnl/docstring"] = "Returns a sequence of sequences of `n' items each, at offsets step\napart. If `step' is not supplied, defaults to `n', i.e. the partitions\ndo not overlap. If a `pad' collection is supplied, use its elements as\nnecessary to complete last partition up to `n' items. In case there\nare not enough padding elements, return a partition with less than `n'\nitems.\n\n# Examples\nPartition sequence into sub-sequences of size 3:\n\n``` fennel\n(assert-eq (partition 3 [1 2 3 4 5 6]) [[1 2 3] [4 5 6]])\n```\n\nWhen collection doesn't have enough elements, partition will not include those:\n\n``` fennel\n(assert-eq (partition 3 [1 2 3 4]) [[1 2 3]])\n```\n\nPartitions can overlap if step is supplied:\n\n``` fennel\n(assert-eq (partition 2 1 [1 2 3 4]) [[1 2] [2 3] [3 4]])\n```\n\nAdditional padding can be used to supply insufficient elements:\n\n``` fennel\n(assert-eq (partition 3 3 [3 2 1] [1 2 3 4]) [[1 2 3] [4 3 2]])\n```"
    },
    [<function 240>] = {
      ["fnl/arglist"] = { "val", "..." },
      ["fnl/docstring"] = "Thread-last macro.\n  Same as ->, except splices the value into the last position of each form\n  rather than the first."
    },
    [<function 241>] = {
      ["fnl/arglist"] = { "[f", "val", "tbl]" },
      ["fnl/docstring"] = "Reduces an associative table using function `f' and initial value `val'.\n\n`f' should be a function of 3 arguments.  Returns the result of\napplying `f' to `val', the first key and the first value in `tbl',\nthen applying `f' to that result and the 2nd key and value, etc.  If\n`tbl' contains no entries, returns `val' and `f' is not called.  Note\nthat reduce-kv is supported on sequential tables and strings, where\nthe keys will be the ordinals.\n\nEarly termination is possible with the use of `reduced'\nfunction.\n\n# Examples\nReduce associative table by adding values from all keys:\n\n``` fennel\n(local t {:a1 1\n          :b1 2\n          :a2 2\n          :b2 3})\n\n(reduce-kv #(+ $1 $3) 0 t)\n;; => 8\n```\n\nReduce table by adding values from keys that start with letter `a':\n\n``` fennel\n(local t {:a1 1\n          :b1 2\n          :a2 2\n          :b2 3})\n\n(reduce-kv (fn [res k v] (if (= (string.sub k 1 1) :a) (+ res v) res))\n           0 t)\n;; => 3\n```"
    },
    [<function 242>] = {
      ["fnl/arglist"] = { "([f col])", "([f val col])" },
      ["fnl/docstring"] = "Reduce collection `col' using function `f' and optional initial value `val'.\n\n`f' should be a function of 2 arguments.  If val is not supplied,\nreturns the result of applying f to the first 2 items in coll, then\napplying f to that result and the 3rd item, etc.  If coll contains no\nitems, f must accept no arguments as well, and reduce returns the\nresult of calling f with no arguments.  If coll has only 1 item, it is\nreturned and f is not called.  If val is supplied, returns the result\nof applying f to val and the first item in coll, then applying f to\nthat result and the 2nd item, etc.  If coll contains no items, returns\nval and f is not called.  Calls `seq' on `col'.\n\nEarly termination is possible with the use of `reduced'\nfunction.\n\n# Examples\nReduce sequence of numbers with `add'\n\n``` fennel\n(reduce add [1 2 3 4])\n;; => 10\n(reduce add 10 [1 2 3 4])\n;; => 20\n```"
    },
    [<function 243>] = {
      ["fnl/arglist"] = { "[index start stop step?]", "..." },
      ["fnl/body-form?"] = true,
      ["fnl/docstring"] = "Numeric loop construct.\nEvaluates body once for each value between start and stop (inclusive)."
    },
    <metatable> = {
      __index = {
        get = <function 244>,
        set = <function 245>,
        setall = <function 246>
      },
      __mode = "k"
    }
  }
}