From 99638ba2df39f6c2db8b05d0504289b487daa354 Mon Sep 17 00:00:00 2001 From: Kodi Arfer Date: Fri, 3 Feb 2017 17:03:06 -0800 Subject: [PATCH] Remove uses of `let` from /hy --- hy/contrib/botsbuildbots.hy | 6 ++-- hy/contrib/loop.hy | 24 +++++++-------- hy/core/language.hy | 61 ++++++++++++++++++------------------- hy/core/macros.hy | 48 ++++++++++++++--------------- hy/core/shadow.hy | 36 +++++++++++----------- hy/extra/anaphoric.hy | 59 +++++++++++++++++++---------------- 6 files changed, 120 insertions(+), 114 deletions(-) diff --git a/hy/contrib/botsbuildbots.hy b/hy/contrib/botsbuildbots.hy index fcea8c6..1e96b66 100644 --- a/hy/contrib/botsbuildbots.hy +++ b/hy/contrib/botsbuildbots.hy @@ -26,8 +26,8 @@ (do (import [requests]) - (let [r (requests.get - "https://raw.githubusercontent.com/hylang/hy/master/AUTHORS")] - (repeat r.text))) + (setv r (requests.get + "https://raw.githubusercontent.com/hylang/hy/master/AUTHORS")) + (repeat r.text)) (except [e ImportError] (repeat "Botsbuildbots requires `requests' to function.")))) diff --git a/hy/contrib/loop.hy b/hy/contrib/loop.hy index d114140..40217d6 100644 --- a/hy/contrib/loop.hy +++ b/hy/contrib/loop.hy @@ -58,13 +58,13 @@ (defmacro/g! fnr [signature &rest body] - (let [new-body (recursive-replace 'recur g!recur-fn body)] - `(do - (import [hy.contrib.loop [--trampoline--]]) - (with-decorator - --trampoline-- - (def ~g!recur-fn (fn [~@signature] ~@new-body))) - ~g!recur-fn))) + (setv new-body (recursive-replace 'recur g!recur-fn body)) + `(do + (import [hy.contrib.loop [--trampoline--]]) + (with-decorator + --trampoline-- + (def ~g!recur-fn (fn [~@signature] ~@new-body))) + ~g!recur-fn)) (defmacro defnr [name lambda-list &rest body] @@ -86,8 +86,8 @@ ;; If recur is used in a non-tail-call position, None is returned, which ;; causes chaos. Fixing this to detect if recur is in a tail-call position ;; and erroring if not is a giant TODO. - (let [fnargs (map (fn [x] (first x)) bindings) - initargs (map second bindings)] - `(do (require hy.contrib.loop) - (hy.contrib.loop.defnr ~g!recur-fn [~@fnargs] ~@body) - (~g!recur-fn ~@initargs)))) + (setv fnargs (map (fn [x] (first x)) bindings) + initargs (map second bindings)) + `(do (require hy.contrib.loop) + (hy.contrib.loop.defnr ~g!recur-fn [~@fnargs] ~@body) + (~g!recur-fn ~@initargs))) diff --git a/hy/core/language.hy b/hy/core/language.hy index 5628e3f..54f24d8 100644 --- a/hy/core/language.hy +++ b/hy/core/language.hy @@ -103,13 +103,12 @@ (defn distinct [coll] "Return a generator from the original collection with duplicates removed" - (let [seen (set) - citer (iter coll)] + (setv seen (set) citer (iter coll)) (for* [val citer] (if (not_in val seen) (do (yield val) - (.add seen val)))))) + (.add seen val))))) (if-python2 (def @@ -178,9 +177,9 @@ (defn drop-last [n coll] "Return a sequence of all but the last n elements in coll." - (let [iters (tee coll)] - (map first (apply zip [(get iters 0) - (drop n (get iters 1))])))) + (setv iters (tee coll)) + (map first (apply zip [(get iters 0) + (drop n (get iters 1))]))) (defn empty? [coll] "Return True if `coll` is empty" @@ -229,14 +228,14 @@ (setv _gensym_lock (Lock)) (defn gensym [&optional [g "G"]] - (let [new_symbol None] - (global _gensym_counter) - (global _gensym_lock) - (.acquire _gensym_lock) - (try (do (setv _gensym_counter (inc _gensym_counter)) - (setv new_symbol (HySymbol (.format ":{0}_{1}" g _gensym_counter)))) - (finally (.release _gensym_lock))) - new_symbol)) + (setv new_symbol None) + (global _gensym_counter) + (global _gensym_lock) + (.acquire _gensym_lock) + (try (do (setv _gensym_counter (inc _gensym_counter)) + (setv new_symbol (HySymbol (.format ":{0}_{1}" g _gensym_counter)))) + (finally (.release _gensym_lock))) + new_symbol) (defn calling-module-name [&optional [n 1]] "Get the name of the module calling `n` levels up the stack from the @@ -335,16 +334,16 @@ from the latter (left-to-right) will be combined with the mapping in the result by calling (f val-in-result val-in-latter)." (if (any maps) - (let [merge-entry (fn [m e] - (let [k (get e 0) - v (get e 1)] - (if (in k m) - (assoc m k (f (get m k) v)) - (assoc m k v))) - m) - merge2 (fn [m1 m2] - (reduce merge-entry (.items m2) (or m1 {})))] - (reduce merge2 maps)))) + (do + (defn merge-entry [m e] + (setv k (get e 0) v (get e 1)) + (if (in k m) + (assoc m k (f (get m k) v)) + (assoc m k v)) + m) + (defn merge2 [m1 m2] + (reduce merge-entry (.items m2) (or m1 {}))) + (reduce merge2 maps)))) (defn neg? [n] "Return true if n is < 0" @@ -421,13 +420,13 @@ "Return every nth member of coll raises ValueError for (not (pos? n))" (if (pos? n) - (let [citer (iter coll) - skip (dec n)] - (for* [val citer] - (yield val) - (for* [_ (range skip)] - (next citer)))) - (raise (ValueError "n must be positive")))) + (do + (setv citer (iter coll) skip (dec n)) + (for* [val citer] + (yield val) + (for* [_ (range skip)] + (next citer)))) + (raise (ValueError "n must be positive")))) (defn zero? [n] "Return true if n is 0" diff --git a/hy/core/macros.hy b/hy/core/macros.hy index b41b45a..7046296 100644 --- a/hy/core/macros.hy +++ b/hy/core/macros.hy @@ -125,8 +125,8 @@ [(empty? args) `(do ~@body ~@belse)] [(= (len args) 2) `(for* [~@args] (do ~@body) ~@belse)] [True - (let [alist (cut args 0 None 2)] - `(for* [(, ~@alist) (genexpr (, ~@alist) [~@args])] (do ~@body) ~@belse))])) + (setv alist (cut args 0 None 2)) + `(for* [(, ~@alist) (genexpr (, ~@alist) [~@args])] (do ~@body) ~@belse)])) (defmacro -> [head &rest rest] @@ -151,7 +151,8 @@ (if (isinstance expression HyExpression) `(~(first expression) ~f ~@(rest expression)) `(~expression ~f))) - `(let [~f ~form] + `(do + (setv ~f ~form) ~@(map build-form expressions) ~f)) @@ -203,23 +204,24 @@ (defmacro with-gensyms [args &rest body] (setv syms []) (for* [arg args] - (.extend syms `[~arg (gensym '~arg)])) - `(let ~syms - ~@body)) + (.extend syms [arg `(gensym '~arg)])) + `(do + (setv ~@syms) + ~@body)) (defmacro defmacro/g! [name args &rest body] - (let [syms (list + (setv syms (list (distinct (filter (fn [x] (and (hasattr x "startswith") (.startswith x "g!"))) (flatten body)))) - gensyms []] - (for* [sym syms] - (.extend gensyms `[~sym (gensym (cut '~sym 2))])) - `(defmacro ~name [~@args] - (let ~gensyms - ~@body)))) + gensyms []) + (for* [sym syms] + (.extend gensyms [sym `(gensym ~(cut sym 2))])) + `(defmacro ~name [~@args] + (setv ~@gensyms) + ~@body)) (defmacro defmacro! [name args &rest body] "Like defmacro/g! plus automatic once-only evaluation for o! @@ -251,17 +253,15 @@ (defmacro defmain [args &rest body] "Write a function named \"main\" and do the if __main__ dance" - (let [retval (gensym) - mainfn `(fn [~@args] - ~@body)] - `(when (= --name-- "__main__") - (import sys) - (setv ~retval (apply ~mainfn sys.argv)) - (if (integer? ~retval) - (sys.exit ~retval))))) + (setv retval (gensym)) + `(when (= --name-- "__main__") + (import sys) + (setv ~retval (apply (fn [~@args] ~@body) sys.argv)) + (if (integer? ~retval) + (sys.exit ~retval)))) (defreader @ [expr] - (let [decorators (cut expr None -1) - fndef (get expr -1)] - `(with-decorator ~@decorators ~fndef))) + (setv decorators (cut expr None -1) + fndef (get expr -1)) + `(with-decorator ~@decorators ~fndef)) diff --git a/hy/core/shadow.hy b/hy/core/shadow.hy index 5008973..d216b17 100644 --- a/hy/core/shadow.hy +++ b/hy/core/shadow.hy @@ -26,22 +26,22 @@ (defn + [&rest args] "Shadow + operator for when we need to import / map it against something" - (let [count (len args)] - (if (zero? count) - (raise (TypeError "Need at least 1 argument to add/concatenate")) - (if (= count 1) - (operator.pos (get args 0)) - (reduce operator.add args))))) + (if + (= (len args) 1) + (operator.pos (get args 0)) + args + (reduce operator.add args) + (raise (TypeError "Need at least 1 argument to add/concatenate")))) (defn - [&rest args] "Shadow - operator for when we need to import / map it against something" - (let [count (len args)] - (if (= count 0) - (raise (TypeError "Need at least 1 argument to subtract")) - (if (= count 1) - (- (get args 0)) - (reduce operator.sub args))))) + (if + (= (len args) 1) + (- (get args 0)) + args + (reduce operator.sub args) + (raise (TypeError "Need at least 1 argument to subtract")))) (defn * [&rest args] @@ -53,12 +53,12 @@ (defn / [&rest args] "Shadow / operator for when we need to import / map it against something" - (let [count (len args)] - (if (= count 0) - (raise (TypeError "Need at least 1 argument to divide")) - (if (= count 1) - (operator.truediv 1 (get args 0)) - (reduce operator.truediv args))))) + (if + (= (len args) 1) + (operator.truediv 1 (get args 0)) + args + (reduce operator.truediv args) + (raise (TypeError "Need at least 1 argument to divide")))) (defn comp-op [op args] diff --git a/hy/extra/anaphoric.hy b/hy/extra/anaphoric.hy index aaee36b..ac5c80e 100644 --- a/hy/extra/anaphoric.hy +++ b/hy/extra/anaphoric.hy @@ -26,8 +26,9 @@ (defmacro ap-if [test-form then-form &optional else-form] - `(let [it ~test-form] - (if it ~then-form ~else-form))) + `(do + (setv it ~test-form) + (if it ~then-form ~else-form))) (defmacro ap-each [lst &rest body] @@ -38,38 +39,44 @@ (defmacro ap-each-while [lst form &rest body] "Evaluate the body form for each element in the list while the predicate form evaluates to True." - `(let [p (lambda [it] ~form)] + (setv p (gensym)) + `(do + (defn ~p [it] ~form) (for [it ~lst] - (if (p it) + (if (~p it) ~@body (break))))) (defmacro ap-map [form lst] "Yield elements evaluated in the form for each element in the list." - (let [v (gensym 'v) - f (gensym 'f)] - `(let [~f (lambda [it] ~form)] - (for [~v ~lst] - (yield (~f ~v)))))) + (setv v (gensym 'v) f (gensym 'f)) + `((fn [] + (defn ~f [it] ~form) + (for [~v ~lst] + (yield (~f ~v)))))) (defmacro ap-map-when [predfn rep lst] "Yield elements evaluated for each element in the list when the predicate function returns True." - `(let [f (lambda [it] ~rep)] + (setv f (gensym)) + `((fn [] + (defn ~f [it] ~rep) (for [it ~lst] (if (~predfn it) - (yield (f it)) - (yield it))))) + (yield (~f it)) + (yield it)))))) (defmacro ap-filter [form lst] "Yield elements returned when the predicate form evaluates to True." - `(let [pred (lambda [it] ~form)] + (setv pred (gensym)) + `((fn [] + (defn ~pred [it] ~form) (for [val ~lst] - (if (pred val) - (yield val))))) + (if (~pred val) + (yield val)))))) (defmacro ap-reject [form lst] @@ -80,14 +87,15 @@ (defmacro ap-dotimes [n &rest body] "Execute body for side effects `n' times, with it bound from 0 to n-1" (unless (numeric? n) - (raise (TypeError (.format "{0!r} is not a number" n)))) + (raise (TypeError (.format "{!r} is not a number" n)))) `(ap-each (range ~n) ~@body)) (defmacro ap-first [predfn lst] "Yield the first element that passes `predfn`" (with-gensyms [n] - `(let [~n None] + `(do + (setv ~n None) (ap-each ~lst (when ~predfn (setv ~n it) (break))) ~n))) @@ -95,7 +103,8 @@ (defmacro ap-last [predfn lst] "Yield the last element that passes `predfn`" (with-gensyms [n] - `(let [~n None] + `(do + (setv ~n None) (ap-each ~lst (none? ~n) (when ~predfn (setv ~n it))) @@ -104,20 +113,18 @@ (defmacro ap-reduce [form lst &optional [initial-value None]] "Anaphoric form of reduce, `acc' and `it' can be used for a form" - (if (none? initial-value) - `(let [acc (car ~lst)] - (ap-each (cdr ~lst) (setv acc ~form)) - acc) - `(let [acc ~initial-value] - (ap-each ~lst (setv acc ~form)) - acc))) + `(do + (setv acc ~(if (none? initial-value) `(car ~lst) initial-value)) + (ap-each ~(if (none? initial-value) `(cdr ~lst) lst) + (setv acc ~form)) + acc)) (defmacro ap-pipe [var &rest forms] "Pushes a value through several forms. (Anaphoric version of -> and ->>)" (if (empty? forms) var - `(ap-pipe (let [it ~var] ~(first forms)) ~@(rest forms)))) + `(ap-pipe (do (setv it ~var) ~(first forms)) ~@(rest forms)))) (defmacro ap-compose [&rest forms]