在clojure中构建表格

如果我想在向量副本的Clojure中构建一个表，我会写：

(take 2 (repeat [1 2 3]))

但是我如何扩展表函数的概念来构建如下内容：

输入1:[a^2 6 2]，其中a^2是某个输入函数，2是最小值，6是最大值，2是步长

产出1:[4,16,36]

输入2:[b^2 10-5-2]

输出2:[10064361640416]

这将输出一个4x3矩阵

输入3:[（+（*10i）j）[14][13]

其中（+（*10i）j）是10i+j（某些给定的输入函数），[14]是i的最小值和最大值，[13]是j的最小值和最大值

---

输出3:[[11 12 13][21 22 23][31 32 33][41 42 43]]

我想你可以用

地图
和
范围

(defn applier
  [f ini max step]
  (map f (range ini (+ max step) step)))

(applier #(* % %) 2 6 2)
=> (4 16 36)

这个fn可以解决您的第三个示例

(defn your-fn [[ra1 ra2] [rb1 rb2] the-fn]
   (vec (map (fn [i] (vec (map (fn [j] (the-fn i j)) (range rb1 (inc rb2))))) (range ra1 (inc ra2))))
   )
(your-fn [1 4] [1 3] (fn [i j] (+ (* 10 i) j)))

=> [[11 12 13] [21 22 23] [31 32 33] [41 42 43]]

但是我需要更多的规范细节（或者更多的用例）来使这种行为更通用，也许你可以解释一下你的问题。我认为第1-2个和第3个示例没有采用相同类型的参数和含义（步骤vs seq）。因此@Guillermo Winkler解决了部分问题，我的fn将介绍最后一个示例
您希望以嵌套方式为
使用的
：

(for [i (range 1 (inc 4))]
  (for [j (range 1 (inc 3))]
    (+ (* 10 i) j)))
;; '((11 12 13) (21 22 23) (31 32 33) (41 42 43))

编辑：通过示例实现展开

例如：

(defn build-seq [f lower upper step]
  (for [i (range lower (+ upper step) step)]
    (f i)))

(build-seq #(* % %) 2 6 2)
;; '(4 16 36)

(defn build-table [f [ilower iupper] [jlower jupper]]
  (for [i (range ilower (inc iupper))]
    (for [j (range jlower (inc jupper))]
      (f i j))))

(build-table #(+ (* 10 %) %2) [1 4] [1 3])
;; '((11 12 13) (21 22 23) (31 32 33) (41 42 43))

您的三个输入/输出示例没有显示一个变量和两个变量的一致签名；此外，
步骤
参数似乎是可选的。我怀疑是否存在一个可以保留示例语法的好API，但我可以尝试一些不同的方法（即使我确实认为简单的嵌入式
for
表单是更好的解决方案）：

（defn灵活范围[{：键[上下步]：或{下0}]
（让[[上台阶]（第二步）
（和上台阶）[（+上台阶）台阶]
步骤（如果（位置步骤）
[双/正无穷步]
[双/负无穷步]）
上部（如果（<下部上部）
[（包括上）1]
[（十二月上旬）-1]）
：else[双精度/正无穷大1]）]
（范围下限上限阶）））
（defn构建表
（[f[¶ms]]
（对于[i（灵活范围参数）]
(f)(i)
（[f[&iparams][&jparams]]
（适用于[i（灵活范围iParms）]
（适用于[j（灵活范围JP参数）]
(f i j(()))
（构建表#（*%%）[：下2:上6:步骤2]）
;; '(4 16 36)
（构建表#（+*10%）%2）[：下1:上4]
[：下1：上3]）
;; '((11 12 13) (21 22 23) (31 32 33) (41 42 43))
您能解释一下第三个示例在描述第一个输入时的意义吗？
(defn flexible-range [{:keys [lower upper step] :or {lower 0}}]
  (let [[upper step] (cond
                       (and upper step) [(+ upper step) step]
                       step  (if (pos? step)
                               [Double/POSITIVE_INFINITY step]
                               [Double/NEGATIVE-INFINITY step])
                       upper (if (< lower upper)
                               [(inc upper)  1]
                               [(dec upper) -1])
                       :else   [Double/POSITIVE_INFINITY 1])]
    (range lower upper step)))

(defn build-table
  ([f [& params]]
    (for [i (flexible-range params)]
      (f i)))
  ([f [& iparams] [& jparams]]
    (for [i (flexible-range iparams)]
      (for [j (flexible-range jparams)]
        (f i j)))))

(build-table #(* % %) [:lower 2 :upper 6 :step  2])
;; '(4 16 36)

(build-table #(+ (* 10 %) %2) [:lower 1 :upper 4]
                              [:lower 1 :upper 3])
;; '((11 12 13) (21 22 23) (31 32 33) (41 42 43))