Yaltik/hy
2
0
Fork 0
Code Pull Requests Releases Activity

Remove uses of let from /hy

Browse Source
This commit is contained in:
Kodi Arfer 2017-02-03 17:03:06 -08:00
parent 36507b0678
commit 99638ba2df
6 changed files with 120 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
hy/contrib/botsbuildbots.hy
View File

@ -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."))))

10
hy/contrib/loop.hy
View File

@ -58,13 +58,13 @@
(defmacro/g! fnr [signature &rest body]
(let [new-body (recursive-replace 'recur g!recur-fn body)]
(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)))
~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)]
(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))))
(~g!recur-fn ~@initargs)))

29
hy/core/language.hy
View File

@ -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)]
(setv iters (tee coll))
(map first (apply zip [(get iters 0)
(drop n (get iters 1))]))))
(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]
(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))
new_symbol)
(defn calling-module-name [&optional [n 1]]
"Get the name of the module calling `n` levels up the stack from the
@ -335,15 +334,15 @@
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)]
(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)))
(assoc m k v))
m)
merge2 (fn [m1 m2]
(reduce merge-entry (.items m2) (or m1 {})))]
(defn merge2 [m1 m2]
(reduce merge-entry (.items m2) (or m1 {})))
(reduce merge2 maps))))
(defn neg? [n]
@ -421,8 +420,8 @@
"Return every nth member of coll
raises ValueError for (not (pos? n))"
(if (pos? n)
(let [citer (iter coll)
skip (dec n)]
(do
(setv citer (iter coll) skip (dec n))
(for* [val citer]
(yield val)
(for* [_ (range skip)]

36
hy/core/macros.hy
View File

@ -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
(.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 []]
gensyms [])
(for* [sym syms]
(.extend gensyms `[~sym (gensym (cut '~sym 2))]))
(.extend gensyms [sym `(gensym ~(cut sym 2))]))
`(defmacro ~name [~@args]
(let ~gensyms
~@body))))
(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)]
(setv retval (gensym))
`(when (= --name-- "__main__")
(import sys)
(setv ~retval (apply ~mainfn sys.argv))
(setv ~retval (apply (fn [~@args] ~@body) sys.argv))
(if (integer? ~retval)
(sys.exit ~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))

30
hy/core/shadow.hy
View File

@ -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)
(if
(= (len args) 1)
(operator.pos (get args 0))
(reduce operator.add args)))))
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)
(if
(= (len args) 1)
(- (get args 0))
(reduce operator.sub args)))))
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)
(if
(= (len args) 1)
(operator.truediv 1 (get args 0))
(reduce operator.truediv args)))))
args
(reduce operator.truediv args)
(raise (TypeError "Need at least 1 argument to divide"))))
(defn comp-op [op args]

53
hy/extra/anaphoric.hy
View File

@ -26,7 +26,8 @@
(defmacro ap-if [test-form then-form &optional else-form]
`(let [it ~test-form]
`(do
(setv it ~test-form)
(if it ~then-form ~else-form)))
@ -38,18 +39,20 @@
(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)]
(setv v (gensym 'v) f (gensym 'f))
`((fn []
(defn ~f [it] ~form)
(for [~v ~lst]
(yield (~f ~v))))))
@ -57,19 +60,23 @@
(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]