Make apply lazy (#1317)

Fixes #1300

Author: chrisrink10

.github/workflows/run-clojure-test-suite.yml

@@ -19,7 +19,6 @@ jobs:
         with:
           path: clojure-test-suite
           repository: basilisp-lang/clojure-test-suite
-          ref: feature/support-basilisp
       - uses: actions/setup-python@v5
         with:
           python-version: '3.13'

src/basilisp/core.lpy

@@ -23,7 +23,7 @@
 (def ^{:doc      "Create a list from the arguments."
        :arglists '([& args])}
   list
-  (fn* list [& args] (if args args '())))
+  (fn* list [& args] (if args (basilisp.lang.list/list args) '())))
 
 (def
   ^{:doc      "If ``seq`` is a Seq, return the first element from ``seq``. If ``seq``
@@ -209,11 +209,17 @@
   (fn iterator-seq [it]
     (basilisp.lang.runtime/to-iterator-seq it)))
 
-
 (def ^{:doc      "Apply function ``f`` to the arguments provided.
 
                   The last argument must always be coercible to a Seq. Intermediate
-                  arguments are not modified."
+                  arguments are not modified. The Seq in the last argument may be
+                  infinite if the called function ``f`` is lazy.
+
+                  .. warning::
+
+                     Applying arguments to Python functions (rather than Basilisp
+                     functions) will consume the argument Seq eagerly. Infinite
+                     Seqs are **not** supported for Python functions."
        :arglists '([f & args])}
   apply
   (fn apply [f & args]
@@ -231,7 +237,7 @@
        :arglists '([& seqs])}
   concat
   (fn concat [& seqs]
-    (apply basilisp.lang.runtime/concat seqs)))
+    (basilisp.lang.runtime/concat-from-seq seqs)))
 
 (def
   ^{:doc      "Create a hash map from pairs of input arguments."
@@ -2840,11 +2846,13 @@
       (cons (f (first coll)) (map f (rest coll))))))
   ([f coll & colls]
    (lazy-seq
-    (when-let [coll (seq coll)]
-      (let [colls (map seq colls)]
-        (when (every? identity colls)
-          (cons (apply f (first coll) (map first colls))
-                (apply map f (rest coll) (map rest colls)))))))))
+    (let [step-elems (fn step-elems [colls]
+                       (lazy-seq
+                        (let [colls (map seq colls)]
+                          (when (every? identity colls)
+                            (cons (map first colls)
+                                  (step-elems (map rest colls)))))))]
+      (map #(apply f %) (step-elems (cons coll colls)))))))
 
 (def ^{:doc "Return a vector of ``(f elem)`` for elements in ``coll``\\. More than one
              collection may be supplied. If more than one collection is supplied, the
@@ -2878,10 +2886,8 @@
   "Return a lazy sequence of the concatenated results of mapping ``f`` over ``colls``\\."
   ([f]
    (comp (map f) cat))
-  ([f coll]
-   (apply concat (map f coll)))
-  ([f coll & colls]
-   (apply concat (apply map f coll colls))))
+  ([f & colls]
+   (apply concat (apply map f colls))))
 
 (defn filter
   "Return a lazy sequence of elements from ``coll`` where ``(pred elem)`` returns a

src/basilisp/lang/compiler/generator.py

@@ -799,6 +799,7 @@ def _var_ns_as_python_sym(name: str) -> str:
 _ATTRIB_FIELD_FN_NAME = _load_attr(f"{_ATTR_ALIAS}.field")
 _BASILISP_LOAD_CONSTANT_NAME = _load_attr(f"{_RUNTIME_ALIAS}._load_constant")
 _COERCE_SEQ_FN_NAME = _load_attr(f"{_RUNTIME_ALIAS}.to_seq")
+_UNWRAP_REST_ARGS_FN_NAME = _load_attr(f"{_RUNTIME_ALIAS}._unwrap_rest_args")
 _BASILISP_FN_FN_NAME = _load_attr(f"{_RUNTIME_ALIAS}._basilisp_fn")
 _FN_WITH_ATTRS_FN_NAME = _load_attr(f"{_RUNTIME_ALIAS}._with_attrs")
 _BASILISP_TYPE_FN_NAME = _load_attr(f"{_RUNTIME_ALIAS}._basilisp_type")
@@ -1707,7 +1708,7 @@ def __fn_args_to_py_ast(
                     value=ast.IfExp(
                         test=ast.Name(id=arg_name, ctx=ast.Load()),
                         body=ast.Call(
-                            func=_NEW_LIST_FN_NAME,
+                            func=_UNWRAP_REST_ARGS_FN_NAME,
                             args=[ast.Name(id=arg_name, ctx=ast.Load())],
                             keywords=[],
                         ),
@@ -1738,6 +1739,8 @@ def __fn_args_to_py_ast(
 def __fn_decorator(
     arities: Iterable[int],
     has_rest_arg: bool = False,
+    *,
+    max_fixed_arity: int,
 ) -> ast.Call:
     return ast.Call(
         func=_BASILISP_FN_FN_NAME,
@@ -1767,7 +1770,8 @@ def __fn_decorator(
                     ),
                     ctx=ast.Load(),
                 ),
-            )
+            ),
+            ast.keyword(arg="max_fixed_arity", value=ast.Constant(max_fixed_arity)),
         ],
     )
 
@@ -1875,6 +1879,7 @@ def __single_arity_fn_to_py_ast(  # pylint: disable=too-many-locals
                                         __fn_decorator(
                                             (len(fn_args),),
                                             has_rest_arg=method.is_variadic,
+                                            max_fixed_arity=node.max_fixed_arity,
                                         )
                                     ],
                                     (
@@ -1905,10 +1910,11 @@ def __multi_arity_dispatch_fn(  # pylint: disable=too-many-arguments,too-many-lo
     ctx: GeneratorContext,
     name: str,
     arity_map: Mapping[int, str],
+    *,
     return_tags: Iterable[Node | None],
     default_name: str | None = None,
     rest_arity_fixed_arity: int | None = None,
-    max_fixed_arity: int | None = None,
+    max_fixed_arity: int,
     meta_node: MetaNode | None = None,
     is_async: bool = False,
 ) -> GeneratedPyAST[ast.expr]:
@@ -2085,6 +2091,7 @@ def fn(*args):
                                         )
                                     ),
                                     has_rest_arg=default_name is not None,
+                                    max_fixed_arity=max_fixed_arity,
                                 )
                             ],
                         )
@@ -3688,7 +3695,7 @@ def _const_val_to_py_ast(
     `_const_node_to_py_ast`."""
     try:
         serialized = pickle.dumps(form)
-    except (pickle.PicklingError, RecursionError) as e:
+    except (pickle.PicklingError, RecursionError) as e:  # pragma: no cover
         # For types without custom "constant" handling code, we defer to pickle
         # to generate a representation that can be reloaded from the generated
         # byte code. There are a few cases where that may not be possible for one