Yaltik/hy
2
0
Fork 0
Code Pull Requests Releases Activity
a201e9f6a8
hy/tests/native_tests/core.hy

707 lines
23 KiB
Hy
Raw Normal View History

Update copyright years
2019-02-07 14:57:35 +01:00
;; Copyright 2019 the authors.
Make all files comply with license-header policy
2017-04-27 23:16:57 +02:00
;; This file is part of Hy, which is free software licensed under the Expat
;; license. See the LICENSE.
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
;;;; some simple helpers
(defn assert-true [x]
(assert (= True x)))
(defn assert-false [x]
(assert (= False x)))
(defn assert-equal [x y]
(assert (= x y)))
Burninate the synonyms `true`, `false`, and `nil` Per the straw poll in #908, as an alternative to #1147. Now you must use `True`, `False`, and `None`, as in Python. Or just assign `true` to `True`, etc.; the old synonyms aren't reserved words anymore.
2016-11-24 03:35:17 +01:00
(defn assert-none [x]
(assert (is x None)))
Make nth return default value when out of bounds
2014-08-23 13:35:31 +02:00
Don't check the type of arguments to `inc`, `odd?`, etc. This allows them to be used with numeric types that aren't built in, such as NumPy arrays. Because Python uses duck typing, there's generally no way to know in advance whether a given value will accept a given operator. Of course, things like `(inc "hello")` will still raise a `TypeError`, because so does `(+ "hello" 1)`.
2016-10-11 23:04:50 +02:00
(defn assert-requires-num [f]
(for [x ["foo" [] None]]
Assertion-testing style edit
2016-10-12 00:48:40 +02:00
(try (f x)
(except [TypeError] True)
(else (assert False)))))
Don't check the type of arguments to `inc`, `odd?`, etc. This allows them to be used with numeric types that aren't built in, such as NumPy arrays. Because Python uses duck typing, there's generally no way to know in advance whether a given value will accept a given operator. Of course, things like `(inc "hello")` will still raise a `TypeError`, because so does `(+ "hello" 1)`.
2016-10-11 23:04:50 +02:00
Adding a simple `coll?` function to the core * hy/core/language.hy: -Added a simple coll? function that checks whether the given argument is an iterable and not a string, - Also replaced the check in `flatten` by coll? * tests/native_tests/core.hy: Tests updated for checking coll?
2014-01-12 11:19:09 +01:00
(defn test-coll? []
"NATIVE: testing coll?"
(assert-true (coll? [1 2 3]))
(assert-true (coll? {"a" 1 "b" 2}))
(assert-true (coll? (range 10)))
(assert-false (coll? "abc"))
(assert-false (coll? 1)))
Reimplement butlast in terms of drop-last
2014-08-22 11:51:12 +02:00
(defn test-butlast []
"NATIVE: testing butlast function"
(assert-equal (list (butlast (range 10)))
[0 1 2 3 4 5 6 7 8])
(assert-equal (list (butlast [1]))
[])
(assert-equal (list (butlast []))
[])
; with an infinite sequence
(import itertools)
(assert-equal (list (take 5 (butlast (itertools.count 10))))
[10 11 12 13 14]))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(defn test-cycle []
"NATIVE: testing cycle"
Update: Updated most methods to replace While with For, and added tons of new tests for things like (cycle []) and lists with None's in them. thanks @olasd Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(assert-equal (list (cycle [])) [])
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(assert-equal (list (take 7 (cycle [1 2 3]))) [1 2 3 1 2 3 1])
Update: Updated most methods to replace While with For, and added tons of new tests for things like (cycle []) and lists with None's in them. thanks @olasd Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(assert-equal (list (take 2 (cycle [1 2 3]))) [1 2])
(assert-equal (list (take 4 (cycle [1 None 3]))) [1 None 3 1]))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(defn test-dec []
"NATIVE: testing the dec function"
(assert-equal 0 (dec 1))
(assert-equal -1 (dec 0))
Update: Updated most methods to replace While with For, and added tons of new tests for things like (cycle []) and lists with None's in them. thanks @olasd Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(assert-equal 0 (dec (dec 2)))
Don't check the type of arguments to `inc`, `odd?`, etc. This allows them to be used with numeric types that aren't built in, such as NumPy arrays. Because Python uses duck typing, there's generally no way to know in advance whether a given value will accept a given operator. Of course, things like `(inc "hello")` will still raise a `TypeError`, because so does `(+ "hello" 1)`.
2016-10-11 23:04:50 +02:00
(assert-requires-num dec))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
`setv` no longer creates variables with '.' in their names FIXES #577
2014-04-29 16:22:55 +02:00
(defn test-setv []
"NATIVE: testing setv mutation"
(setv x 1)
(setv y 1)
(assert-equal x y)
Make `setv` always return None
2017-03-23 23:11:55 +01:00
(setv y 12)
(setv x y)
`setv` no longer creates variables with '.' in their names FIXES #577
2014-04-29 16:22:55 +02:00
(assert-equal x 12)
(assert-equal y 12)
Make `setv` always return None
2017-03-23 23:11:55 +01:00
(setv y (fn [x] 9))
(setv x y)
`setv` no longer creates variables with '.' in their names FIXES #577
2014-04-29 16:22:55 +02:00
(assert-equal (x y) 9)
(assert-equal (y x) 9)
(try (do (setv a.b 1) (assert False))
remove catch in favor of except
2015-08-09 08:41:11 +02:00
(except [e [NameError]] (assert (in "name 'a' is not defined" (str e)))))
`setv` no longer creates variables with '.' in their names FIXES #577
2014-04-29 16:22:55 +02:00
(try (do (setv b.a (fn [x] x)) (assert False))
remove catch in favor of except
2015-08-09 08:41:11 +02:00
(except [e [NameError]] (assert (in "name 'b' is not defined" (str e)))))
`setv` no longer creates variables with '.' in their names FIXES #577
2014-04-29 16:22:55 +02:00
(import itertools)
(setv foopermutations (fn [x] (itertools.permutations x)))
(setv p (set [(, 1 3 2) (, 3 2 1) (, 2 1 3) (, 3 1 2) (, 1 2 3) (, 2 3 1)]))
(assert-equal (set (itertools.permutations [1 2 3])) p)
(assert-equal (set (foopermutations [3 1 2])) p)
(setv permutations- itertools.permutations)
(setv itertools.permutations (fn [x] 9))
(assert-equal (itertools.permutations p) 9)
(assert-equal (foopermutations foopermutations) 9)
(setv itertools.permutations permutations-)
(assert-equal (set (itertools.permutations [2 1 3])) p)
(assert-equal (set (foopermutations [2 3 1])) p))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(defn test-distinct []
"NATIVE: testing the distinct function"
(setv res (list (distinct [ 1 2 3 4 3 5 2 ])))
(assert-equal res [1 2 3 4 5])
;; distinct of an empty list should be []
(setv res (list (distinct [])))
(assert-equal res [])
;; now with an iter
(setv test_iter (iter [1 2 3 4 3 5 2]))
(setv res (list (distinct test_iter)))
Update: Updated most methods to replace While with For, and added tons of new tests for things like (cycle []) and lists with None's in them. thanks @olasd Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(assert-equal res [1 2 3 4 5])
; make sure we can handle None in the list
(setv res (list (distinct [1 2 3 2 5 None 3 4 None])))
(assert-equal res [1 2 3 5 None 4]))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(defn test-drop []
"NATIVE: testing drop function"
(setv res (list (drop 2 [1 2 3 4 5])))
Update: Updated most methods to replace While with For, and added tons of new tests for things like (cycle []) and lists with None's in them. thanks @olasd Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(assert-equal res [3 4 5])
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(setv res (list (drop 3 (iter [1 2 3 4 5]))))
Update: Updated most methods to replace While with For, and added tons of new tests for things like (cycle []) and lists with None's in them. thanks @olasd Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(assert-equal res [4 5])
(setv res (list (drop 3 (iter [1 2 3 None 4 5]))))
(assert-equal res [None 4 5])
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(setv res (list (drop 0 [1 2 3 4 5])))
(assert-equal res [1 2 3 4 5])
Reimplement some built-ins in terms of the standard library. As a result: * functions such as `nth` should work correctly on iterators; * `nth` will raise `IndexError` (in a fashion consistent with `get`) when the index is out of bounds; * `take`, etc. will raise `ValueError` instead of returning an ambiguous value if the index is negative; * `map`, `zip`, `range`, `input`, `filter` work the same way (Py3k one) on both Python 2 and 3 (see #523 and #331).
2014-04-29 16:01:14 +02:00
(try (do (list (drop -1 [1 2 3 4 5])) (assert False))
Burninate the synonyms `true`, `false`, and `nil` Per the straw poll in #908, as an alternative to #1147. Now you must use `True`, `False`, and `None`, as in Python. Or just assign `true` to `True`, etc.; the old synonyms aren't reserved words anymore.
2016-11-24 03:35:17 +01:00
(except [e [ValueError]] None))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(setv res (list (drop 6 (iter [1 2 3 4 5]))))
(assert-equal res [])
(setv res (list (take 5 (drop 2 (iterate inc 0)))))
(assert-equal res [2 3 4 5 6]))
Implement drop-last
2014-08-22 11:09:59 +02:00
(defn test-drop-last []
"NATIVE: testing drop-last function"
(assert-equal (list (drop-last 5 (range 10 20)))
[10 11 12 13 14])
(assert-equal (list (drop-last 0 (range 5)))
[0 1 2 3 4])
(assert-equal (list (drop-last 100 (range 100)))
[])
; with an infinite sequence
(import itertools)
(assert-equal (list (take 5 (drop-last 100 (itertools.count 10))))
[10 11 12 13 14]))
Second (smaller) set of native core functions This rounds out the first pass at a set of core functions, adding some that were not in the first PR. From here I'm working on a contrib.seq and contrib.io module to hold less obvious but maybe interesting native functions that can move to core if desired. This should also close out issure #150 asking for some core functions like these.
2013-07-29 18:40:48 +02:00
(defn test-drop-while []
"NATIVE: testing drop-while function"
(setv res (list (drop-while even? [2 4 7 8 9])))
(assert (= res [7 8 9]))
(setv res (list (drop-while pos? [2 4 7 8 9])))
(assert (= res []))
(setv res (list (drop-while numeric? [1 2 3 None "a"])))
(assert (= res [None "a"])))
(defn test-empty? []
"NATIVE: testing the empty? function"
(assert-true (empty? ""))
(assert-false (empty? "None"))
(assert-true (empty? (,)))
(assert-false (empty? (, None)))
(assert-true (empty? []))
(assert-false (empty? [None]))
(assert-true (empty? {}))
(assert-false (empty? {"a" None}))
(assert-true (empty? (set)))
(assert-false (empty? (set [None]))))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(defn test-even []
"NATIVE: testing the even? function"
(assert-true (even? -2))
(assert-false (even? 1))
Update: Updated most methods to replace While with For, and added tons of new tests for things like (cycle []) and lists with None's in them. thanks @olasd Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(assert-true (even? 0))
Don't check the type of arguments to `inc`, `odd?`, etc. This allows them to be used with numeric types that aren't built in, such as NumPy arrays. Because Python uses duck typing, there's generally no way to know in advance whether a given value will accept a given operator. Of course, things like `(inc "hello")` will still raise a `TypeError`, because so does `(+ "hello" 1)`.
2016-10-11 23:04:50 +02:00
(assert-requires-num even?))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
Implement every? and some
2014-02-11 09:42:56 +01:00
(defn test-every? []
"NATIVE: testing the every? function"
(assert-true (every? even? [2 4 6]))
(assert-false (every? even? [1 3 5]))
(assert-false (every? even? [2 4 5]))
(assert-true (every? even? [])))
Implement Python 2 `exec` The implementation of `hy.core.language.exec` draws code from the `exec_` function in commit f574c7be6ebc80041ef58ca29588f310248ebed4 of the library Six, which is copyright 2010–2017 Benjamin Peterson and licensed under the Expat license.
2017-07-25 19:28:42 +02:00
(setv globalvar 1)
(defn test-exec []
(setv localvar 1)
(setv code "
result['localvar in locals'] = 'localvar' in locals()
result['localvar in globals'] = 'localvar' in globals()
result['globalvar in locals'] = 'globalvar' in locals()
result['globalvar in globals'] = 'globalvar' in globals()
result['x in locals'] = 'x' in locals()
result['x in globals'] = 'x' in globals()
result['y in locals'] = 'y' in locals()
result['y in globals'] = 'y' in globals()")
(setv result {})
(exec code)
(assert-true (get result "localvar in locals"))
(assert-false (get result "localvar in globals"))
(assert-false (get result "globalvar in locals"))
(assert-true (get result "globalvar in globals"))
(assert-false (or
(get result "x in locals") (get result "x in globals")
(get result "y in locals") (get result "y in globals")))
(setv result {})
(exec code {"x" 1 "result" result})
(assert-false (or
(get result "localvar in locals") (get result "localvar in globals")
(get result "globalvar in locals") (get result "globalvar in globals")))
(assert-true (and
(get result "x in locals") (get result "x in globals")))
(assert-false (or
(get result "y in locals") (get result "y in globals")))
(setv result {})
(exec code {"x" 1 "result" result} {"y" 1})
(assert-false (or
(get result "localvar in locals") (get result "localvar in globals")
(get result "globalvar in locals") (get result "globalvar in globals")))
(assert-false (get result "x in locals"))
(assert-true (get result "x in globals"))
(assert-true (get result "y in locals"))
(assert-false (get result "y in globals")))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(defn test-filter []
"NATIVE: testing the filter function"
(setv res (list (filter pos? [ 1 2 3 -4 5])))
(assert-equal res [ 1 2 3 5 ])
;; test with iter
(setv res (list (filter pos? (iter [ 1 2 3 -4 5 -6]))))
(assert-equal res [ 1 2 3 5])
(setv res (list (filter neg? [ -1 -4 5 3 4])))
Update: Updated most methods to replace While with For, and added tons of new tests for things like (cycle []) and lists with None's in them. thanks @olasd Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(assert-false (= res [1 2]))
;; test with empty list
(setv res (list (filter neg? [])))
(assert-equal res [])
;; test with None in the list
(setv res (list (filter even? (filter numeric? [1 2 None 3 4 None 4 6]))))
(assert-equal res [2 4 4 6])
(setv res (list (filter none? [1 2 None 3 4 None 4 6])))
(assert-equal res [None None]))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
Adding automatic gensym macro Adding to the manual gensym for macros are 2 new macros, but very literal from the CL in letoverlambda. The first is the (with-gensyms ...) macro that can generate a small set of syms for a macro. Works something like: (defmacro adder2 [A B] (with-gensyms [a b] `(let [[~a ~A] [~b ~B]] (+ ~a ~b)))) and ~a and ~b will be replaced with (gensym "a") and (gensym "b") respectively. Then the final macro is a new defmacro that will automatically replace symbols prefaced with "g!" with a new gensym based on the rest of the symbol. So in this final version of 'nif': (defmacro/g! nif4 (expr pos zero neg) `(let [[~g!result ~expr]] (cond [(pos? ~g!result) ~pos] [(zero? ~g!result) ~zero] [(neg? ~g!result) ~neg]))) all uses of ~g!result will be replaced with (gensym "result").
2013-12-16 02:47:46 +01:00
(defn test-flatten []
"NATIVE: testing the flatten function"
(setv res (flatten [1 2 [3 4] 5]))
(assert-equal res [1 2 3 4 5])
(setv res (flatten ["foo" (, 1 2) [1 [2 3] 4] "bar"]))
(assert-equal res ["foo" 1 2 1 2 3 4 "bar"])
(setv res (flatten [1]))
(assert-equal res [1])
(setv res (flatten []))
(assert-equal res [])
(setv res (flatten (, 1)))
(assert-equal res [1])
;; test with None
(setv res (flatten (, 1 (, None 3))))
(assert-equal res [1 None 3])
(try (flatten "foo")
remove catch in favor of except
2015-08-09 08:41:11 +02:00
(except [e [TypeError]] (assert (in "not a collection" (str e)))))
Adding automatic gensym macro Adding to the manual gensym for macros are 2 new macros, but very literal from the CL in letoverlambda. The first is the (with-gensyms ...) macro that can generate a small set of syms for a macro. Works something like: (defmacro adder2 [A B] (with-gensyms [a b] `(let [[~a ~A] [~b ~B]] (+ ~a ~b)))) and ~a and ~b will be replaced with (gensym "a") and (gensym "b") respectively. Then the final macro is a new defmacro that will automatically replace symbols prefaced with "g!" with a new gensym based on the rest of the symbol. So in this final version of 'nif': (defmacro/g! nif4 (expr pos zero neg) `(let [[~g!result ~expr]] (cond [(pos? ~g!result) ~pos] [(zero? ~g!result) ~zero] [(neg? ~g!result) ~neg]))) all uses of ~g!result will be replaced with (gensym "result").
2013-12-16 02:47:46 +01:00
(try (flatten 12.34)
remove catch in favor of except
2015-08-09 08:41:11 +02:00
(except [e [TypeError]] (assert (in "not a collection" (str e))))))
Adding automatic gensym macro Adding to the manual gensym for macros are 2 new macros, but very literal from the CL in letoverlambda. The first is the (with-gensyms ...) macro that can generate a small set of syms for a macro. Works something like: (defmacro adder2 [A B] (with-gensyms [a b] `(let [[~a ~A] [~b ~B]] (+ ~a ~b)))) and ~a and ~b will be replaced with (gensym "a") and (gensym "b") respectively. Then the final macro is a new defmacro that will automatically replace symbols prefaced with "g!" with a new gensym based on the rest of the symbol. So in this final version of 'nif': (defmacro/g! nif4 (expr pos zero neg) `(let [[~g!result ~expr]] (cond [(pos? ~g!result) ~pos] [(zero? ~g!result) ~zero] [(neg? ~g!result) ~neg]))) all uses of ~g!result will be replaced with (gensym "result").
2013-12-16 02:47:46 +01:00
Second (smaller) set of native core functions This rounds out the first pass at a set of core functions, adding some that were not in the first PR. From here I'm working on a contrib.seq and contrib.io module to hold less obvious but maybe interesting native functions that can move to core if desired. This should also close out issure #150 asking for some core functions like these.
2013-07-29 18:40:48 +02:00
(defn test-float? []
"NATIVE: testing the float? function"
(assert-true (float? 4.2))
(assert-false (float? 0))
(assert-false (float? -3))
(assert-true (float? -3.2))
(assert-false (float? "foo")))
add `symbol?` function to `hy.core` `symbol?` will test if the input is an instance of HySymbol. It's useful when writing macros.
2015-01-29 16:17:52 +01:00
(defn test-symbol? []
"NATIVE: testing the symbol? function"
(assert-false (symbol? "hello"))
(assert-false (symbol? [1 2 3]))
(assert-false (symbol? '[a b c]))
(assert-true (symbol? 'im-symbol))
(assert-false (symbol? (name 'im-symbol))))
add `list?` function to `hy.core` `list?` will test if the argument is an instance of list.
2019-03-22 03:06:36 +01:00
(defn test-list? []
"NATIVE: testing the list? function"
(assert-false (list? "hello"))
(assert-true (list? [1 2 3])))
add `tuple?` function `hy.core` `tuple?` will test if the argument is an instance of tuple.
2019-04-09 05:07:25 +02:00
(defn test-tuple? []
"NATIVE: testing the tuple? function"
(assert-false (tuple? [4 5]))
(assert-true (tuple? (, 4 5))))
gensym in Hy Simple implementation of gensym in Hy. Returns a new HySymbol. Usable in macros like: (defmacro nif [expr pos zero neg] (let [[g (gensym)]] `(let [[~g ~expr]] (cond [(pos? ~g) ~pos] [(zero? ~g) ~zero] [(neg? ~g) ~neg])))) This addresses all the general comments about (gensym), and doesn't try to implement "auto-gensym" yet. But clearly the macro approach instead of the pre-processor approach (as described in the letoverlambda (http://letoverlambda.com/index.cl/guest/chap3.html#sec_5) is the way to go
2013-12-15 01:33:56 +01:00
(defn test-gensym []
"NATIVE: testing the gensym function"
Consolidate hy.models.* and tests/models/* into one file apiece They were a lot of similar, tiny files.
2017-02-17 04:43:00 +01:00
(import [hy.models [HySymbol]])
gensym in Hy Simple implementation of gensym in Hy. Returns a new HySymbol. Usable in macros like: (defmacro nif [expr pos zero neg] (let [[g (gensym)]] `(let [[~g ~expr]] (cond [(pos? ~g) ~pos] [(zero? ~g) ~zero] [(neg? ~g) ~neg])))) This addresses all the general comments about (gensym), and doesn't try to implement "auto-gensym" yet. But clearly the macro approach instead of the pre-processor approach (as described in the letoverlambda (http://letoverlambda.com/index.cl/guest/chap3.html#sec_5) is the way to go
2013-12-15 01:33:56 +01:00
(setv s1 (gensym))
(assert (isinstance s1 HySymbol))
Simplify gensym format
2019-04-21 17:45:58 +02:00
(assert (= 0 (.find s1 "_G\uffff")))
gensym in Hy Simple implementation of gensym in Hy. Returns a new HySymbol. Usable in macros like: (defmacro nif [expr pos zero neg] (let [[g (gensym)]] `(let [[~g ~expr]] (cond [(pos? ~g) ~pos] [(zero? ~g) ~zero] [(neg? ~g) ~neg])))) This addresses all the general comments about (gensym), and doesn't try to implement "auto-gensym" yet. But clearly the macro approach instead of the pre-processor approach (as described in the letoverlambda (http://letoverlambda.com/index.cl/guest/chap3.html#sec_5) is the way to go
2013-12-15 01:33:56 +01:00
(setv s2 (gensym "xx"))
(setv s3 (gensym "xx"))
Simplify gensym format
2019-04-21 17:45:58 +02:00
(assert (= 0 (.find s2 "_xx\uffff")))
gensym in Hy Simple implementation of gensym in Hy. Returns a new HySymbol. Usable in macros like: (defmacro nif [expr pos zero neg] (let [[g (gensym)]] `(let [[~g ~expr]] (cond [(pos? ~g) ~pos] [(zero? ~g) ~zero] [(neg? ~g) ~neg])))) This addresses all the general comments about (gensym), and doesn't try to implement "auto-gensym" yet. But clearly the macro approach instead of the pre-processor approach (as described in the letoverlambda (http://letoverlambda.com/index.cl/guest/chap3.html#sec_5) is the way to go
2013-12-15 01:33:56 +01:00
(assert (not (= s2 s3)))
Remove undocumented fns `integer` and `string`
2019-05-20 23:17:39 +02:00
(assert (not (= (str s2) (str s3)))))
gensym in Hy Simple implementation of gensym in Hy. Returns a new HySymbol. Usable in macros like: (defmacro nif [expr pos zero neg] (let [[g (gensym)]] `(let [[~g ~expr]] (cond [(pos? ~g) ~pos] [(zero? ~g) ~zero] [(neg? ~g) ~neg])))) This addresses all the general comments about (gensym), and doesn't try to implement "auto-gensym" yet. But clearly the macro approach instead of the pre-processor approach (as described in the letoverlambda (http://letoverlambda.com/index.cl/guest/chap3.html#sec_5) is the way to go
2013-12-15 01:33:56 +01:00
Adding a simple `identity' function * hy/core/language.hy: Adding a simple `identity` function that returns the argument supplied to it * docs/language/core.rst: Updated docs with identity function
2014-01-21 20:19:49 +01:00
(defn test-identity []
"NATIVE: testing the identity function"
(assert (= 4 (identity 4)))
(assert (= "hy" (identity "hy")))
(assert (= [1 2] (identity [1 2]))))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(defn test-inc []
"NATIVE: testing the inc function"
(assert-equal 3 (inc 2))
Update: Updated most methods to replace While with For, and added tons of new tests for things like (cycle []) and lists with None's in them. thanks @olasd Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(assert-equal 0 (inc -1))
Don't check the type of arguments to `inc`, `odd?`, etc. This allows them to be used with numeric types that aren't built in, such as NumPy arrays. Because Python uses duck typing, there's generally no way to know in advance whether a given value will accept a given operator. Of course, things like `(inc "hello")` will still raise a `TypeError`, because so does `(+ "hello" 1)`.
2016-10-11 23:04:50 +02:00
(assert-requires-num inc)
(defclass X [object]
Remove uses of `defclass` attribute lists
2019-07-02 18:02:03 +02:00
(defn __add__ [self other] (.format "__add__ got {}" other)))
Don't check the type of arguments to `inc`, `odd?`, etc. This allows them to be used with numeric types that aren't built in, such as NumPy arrays. Because Python uses duck typing, there's generally no way to know in advance whether a given value will accept a given operator. Of course, things like `(inc "hello")` will still raise a `TypeError`, because so does `(+ "hello" 1)`.
2016-10-11 23:04:50 +02:00
(assert-equal (inc (X)) "__add__ got 1"))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(defn test-instance []
"NATIVE: testing instance? function"
(defclass Foo [object])
(defclass Foo2 [object])
(defclass Foo3 [Foo])
(setv foo (Foo))
(setv foo3 (Foo3))
(assert-true (instance? Foo foo))
(assert-false (instance? Foo2 foo))
(assert-true (instance? Foo foo3))
(assert-true (instance? float 1.0))
Int conversion to long in py2.x Updated to current master Droped HyInt/HyLong commit
2013-08-21 01:09:03 +02:00
(assert-true (instance? int (int 3)))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(assert-true (instance? str (str "hello"))))
Second (smaller) set of native core functions This rounds out the first pass at a set of core functions, adding some that were not in the first PR. From here I'm working on a contrib.seq and contrib.io module to hold less obvious but maybe interesting native functions that can move to core if desired. This should also close out issure #150 asking for some core functions like these.
2013-07-29 18:40:48 +02:00
(defn test-integer? []
"NATIVE: testing the integer? function"
(assert-true (integer? 0))
(assert-true (integer? 3))
(assert-true (integer? -3))
Remove undocumented fns `integer` and `string`
2019-05-20 23:17:39 +02:00
(assert-true (integer? (int "-3")))
(assert-true (integer? (int 3)))
Second (smaller) set of native core functions This rounds out the first pass at a set of core functions, adding some that were not in the first PR. From here I'm working on a contrib.seq and contrib.io module to hold less obvious but maybe interesting native functions that can move to core if desired. This should also close out issure #150 asking for some core functions like these.
2013-07-29 18:40:48 +02:00
(assert-false (integer? 4.2))
(assert-false (integer? None))
(assert-false (integer? "foo")))
Add integer-char? to core
2014-01-28 23:28:41 +01:00
(defn test-integer-char? []
"NATIVE: testing the integer-char? function"
(assert-true (integer-char? "1"))
(assert-true (integer-char? "-1"))
Remove undocumented fns `integer` and `string`
2019-05-20 23:17:39 +02:00
(assert-true (integer-char? (str (int 300))))
Add integer-char? to core
2014-01-28 23:28:41 +01:00
(assert-false (integer-char? "foo"))
(assert-false (integer-char? None)))
Implement interleave and interpose
2014-08-17 04:53:57 +02:00
(defn test-interleave []
"NATIVE: testing the interleave function"
;; with more than 2 sequences
(assert-equal (list (take 9 (interleave (range 10)
(range 10 20)
(range 20 30))))
[0 10 20 1 11 21 2 12 22])
;; with sequences of different length
(assert-equal (list (interleave (range 1000000)
(range 0 -3 -1)))
[0 0 1 -1 2 -2])
;; with infinite sequences
(import itertools)
(assert-equal (list (take 10 (interleave (itertools.count)
(itertools.count 100))))
[0 100 1 101 2 102 3 103 4 104]))
(defn test-interpose []
"NATIVE: testing the interpose function"
;; with a list
(assert-equal (list (interpose "!" ["a" "b" "c"]))
["a" "!" "b" "!" "c"])
;; with an infinite sequence
(import itertools)
(assert-equal (list (take 7 (interpose -1 (itertools.count))))
[0 -1 1 -1 2 -1 3]))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(defn test-iterable []
"NATIVE: testing iterable? function"
;; should work for a string
(setv s (str "abcde"))
(assert-true (iterable? s))
;; should work for unicode
(setv u "hello")
(assert-true (iterable? u))
(assert-true (iterable? (iter u)))
;; should work for a list
(setv l [1 2 3 4])
(assert-true (iterable? l))
(assert-true (iterable? (iter l)))
;; should work for a dict
(setv d {:a 1 :b 2 :c 3})
(assert-true (iterable? d))
;; should work for a tuple?
(setv t (, 1 2 3 4))
(assert-true (iterable? t))
;; should work for a generator
(assert-true (iterable? (repeat 3)))
;; shouldn't work for an int
(assert-false (iterable? 5)))
(defn test-iterate []
"NATIVE: testing the iterate function"
(setv res (list (take 5 (iterate inc 5))))
(assert-equal res [5 6 7 8 9])
(setv res (list (take 3 (iterate (fn [x] (* x x)) 5))))
(assert-equal res [5 25 625])
(setv f (take 4 (iterate inc 5)))
(assert-equal (list f) [5 6 7 8]))
(defn test-iterator []
"NATIVE: testing iterator? function"
;; should not work for a list
(setv l [1 2 3 4])
(assert-false (iterator? l))
;; should work for an iter over a list
(setv i (iter [1 2 3 4]))
(assert-true (iterator? i))
;; should not work for a dict
(setv d {:a 1 :b 2 :c 3})
(assert-false (iterator? d))
;; should not work for a tuple?
(setv t (, 1 2 3 4))
(assert-false (iterator? t))
;; should work for a generator
(assert-true (iterator? (repeat 3)))
;; should not work for an int
(assert-false (iterator? 5)))
Added (last) function to core language
2015-03-18 16:23:43 +01:00
(defn test-last []
"NATIVE: testing the last function"
(assert-equal (last [1 2 3 4]) 4)
(assert-equal (last [5]) 5))
Re-implemented last function so that it also supports iterators. Added a test to reflect this.
2015-04-07 11:30:52 +02:00
(import itertools)
(assert-equal (last (take 5 (itertools.count 10))) 14)
Added (last) function to core language
2015-03-18 16:23:43 +01:00
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(defn test-neg []
"NATIVE: testing the neg? function"
(assert-true (neg? -2))
(assert-false (neg? 1))
Update: Updated most methods to replace While with For, and added tons of new tests for things like (cycle []) and lists with None's in them. thanks @olasd Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(assert-false (neg? 0))
Remove native tests of Python 2
2019-05-20 20:46:52 +02:00
(assert-requires-num neg?))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
Add zero? predicate to check if an object is zero
2013-09-02 11:28:21 +02:00
(defn test-zero []
"NATIVE: testing the zero? function"
(assert-false (zero? -2))
(assert-false (zero? 1))
Don't check the type of arguments to `inc`, `odd?`, etc. This allows them to be used with numeric types that aren't built in, such as NumPy arrays. Because Python uses duck typing, there's generally no way to know in advance whether a given value will accept a given operator. Of course, things like `(inc "hello")` will still raise a `TypeError`, because so does `(+ "hello" 1)`.
2016-10-11 23:04:50 +02:00
(assert-true (zero? 0)))
Add zero? predicate to check if an object is zero
2013-09-02 11:28:21 +02:00
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(defn test-none []
"NATIVE: testing for `is None`"
(assert-true (none? None))
(setv f None)
(assert-true (none? f))
(assert-false (none? 0))
(assert-false (none? "")))
(defn test-nth []
"NATIVE: testing the nth function"
(assert-equal 2 (nth [1 2 4 7] 1))
(assert-equal 7 (nth [1 2 4 7] 3))
Burninate the synonyms `true`, `false`, and `nil` Per the straw poll in #908, as an alternative to #1147. Now you must use `True`, `False`, and `None`, as in Python. Or just assign `true` to `True`, etc.; the old synonyms aren't reserved words anymore.
2016-11-24 03:35:17 +01:00
(assert-none (nth [1 2 4 7] 5))
Make nth return default value when out of bounds
2014-08-23 13:35:31 +02:00
(assert-equal (nth [1 2 4 7] 5 "some default value")
"some default value") ; with default specified
Reimplement some built-ins in terms of the standard library. As a result: * functions such as `nth` should work correctly on iterators; * `nth` will raise `IndexError` (in a fashion consistent with `get`) when the index is out of bounds; * `take`, etc. will raise `ValueError` instead of returning an ambiguous value if the index is negative; * `map`, `zip`, `range`, `input`, `filter` work the same way (Py3k one) on both Python 2 and 3 (see #523 and #331).
2014-04-29 16:01:14 +02:00
(try (do (nth [1 2 4 7] -1) (assert False))
Burninate the synonyms `true`, `false`, and `nil` Per the straw poll in #908, as an alternative to #1147. Now you must use `True`, `False`, and `None`, as in Python. Or just assign `true` to `True`, etc.; the old synonyms aren't reserved words anymore.
2016-11-24 03:35:17 +01:00
(except [e [ValueError]] None))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
;; now for iterators
(assert-equal 2 (nth (iter [1 2 4 7]) 1))
(assert-equal 7 (nth (iter [1 2 4 7]) 3))
Burninate the synonyms `true`, `false`, and `nil` Per the straw poll in #908, as an alternative to #1147. Now you must use `True`, `False`, and `None`, as in Python. Or just assign `true` to `True`, etc.; the old synonyms aren't reserved words anymore.
2016-11-24 03:35:17 +01:00
(assert-none (nth (iter [1 2 4 7]) 5))
Make nth return default value when out of bounds
2014-08-23 13:35:31 +02:00
(assert-equal (nth (iter [1 2 4 7]) 5 "some default value")
"some default value") ; with default specified
Reimplement some built-ins in terms of the standard library. As a result: * functions such as `nth` should work correctly on iterators; * `nth` will raise `IndexError` (in a fashion consistent with `get`) when the index is out of bounds; * `take`, etc. will raise `ValueError` instead of returning an ambiguous value if the index is negative; * `map`, `zip`, `range`, `input`, `filter` work the same way (Py3k one) on both Python 2 and 3 (see #523 and #331).
2014-04-29 16:01:14 +02:00
(try (do (nth (iter [1 2 4 7]) -1) (assert False))
Burninate the synonyms `true`, `false`, and `nil` Per the straw poll in #908, as an alternative to #1147. Now you must use `True`, `False`, and `None`, as in Python. Or just assign `true` to `True`, etc.; the old synonyms aren't reserved words anymore.
2016-11-24 03:35:17 +01:00
(except [e [ValueError]] None))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(assert-equal 5 (nth (take 3 (drop 2 [1 2 3 4 5 6])) 2)))
Second (smaller) set of native core functions This rounds out the first pass at a set of core functions, adding some that were not in the first PR. From here I'm working on a contrib.seq and contrib.io module to hold less obvious but maybe interesting native functions that can move to core if desired. This should also close out issure #150 asking for some core functions like these.
2013-07-29 18:40:48 +02:00
(defn test-numeric? []
"NATIVE: testing the numeric? function"
(assert-true (numeric? 1))
(assert-true (numeric? 3.4))
(assert-true (numeric? 0.0))
(assert-true (numeric? -1.45))
(assert-false (numeric? "Foo"))
(assert-false (numeric? None)))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(defn test-odd []
"NATIVE: testing the odd? function"
(assert-true (odd? -3))
(assert-true (odd? 1))
Update: Updated most methods to replace While with For, and added tons of new tests for things like (cycle []) and lists with None's in them. thanks @olasd Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(assert-false (odd? 0))
Don't check the type of arguments to `inc`, `odd?`, etc. This allows them to be used with numeric types that aren't built in, such as NumPy arrays. Because Python uses duck typing, there's generally no way to know in advance whether a given value will accept a given operator. Of course, things like `(inc "hello")` will still raise a `TypeError`, because so does `(+ "hello" 1)`.
2016-10-11 23:04:50 +02:00
(assert-requires-num odd?))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
Add: parse-args function Closes #1719.
2019-10-30 14:45:17 +01:00
(defn test-parse-args []
"NATIVE: testing the parse-args function"
(setv parsed-args (parse-args [["strings" :nargs "+" :help "Strings"]
["-n" "--numbers" :action "append" :type 'int :help "Numbers"]]
["a" "b" "-n" "1" "-n" "2"]
:description "Parse strings and numbers from args"))
(assert-equal parsed-args.strings ["a" "b"])
(assert-equal parsed-args.numbers [1 2]))
add partition form to core the 2 argument version of Clojure's partition. pre-expand ->> macro in partition Docstring for partition. add test-partition Document partition.
2015-08-05 22:59:05 +02:00
(defn test-partition []
"NATIVE: testing the partition function"
(setv ten (range 10))
enhance partition
2015-09-03 06:54:24 +02:00
;; no remainder
(assert-equal (list (partition ten 3))
add partition form to core the 2 argument version of Clojure's partition. pre-expand ->> macro in partition Docstring for partition. add test-partition Document partition.
2015-08-05 22:59:05 +02:00
[(, 0 1 2) (, 3 4 5) (, 6 7 8)])
enhance partition
2015-09-03 06:54:24 +02:00
;; pair by default
(assert-equal (list (partition ten))
add partition form to core the 2 argument version of Clojure's partition. pre-expand ->> macro in partition Docstring for partition. add test-partition Document partition.
2015-08-05 22:59:05 +02:00
[(, 0 1) (, 2 3) (, 4 5) (, 6 7) (, 8 9)])
enhance partition
2015-09-03 06:54:24 +02:00
;; length 1 is valid
(assert-equal (list (partition ten 1))
add partition form to core the 2 argument version of Clojure's partition. pre-expand ->> macro in partition Docstring for partition. add test-partition Document partition.
2015-08-05 22:59:05 +02:00
[(, 0) (, 1) (, 2) (, 3) (, 4) (, 5) (, 6) (, 7) (, 8) (, 9)])
Fix #1237: iterator-handling bug in `partition` Also, `partition` with n < 0 now raises an error.
2017-02-26 19:18:20 +01:00
;; length 0 returns an empty sequence
enhance partition
2015-09-03 06:54:24 +02:00
(assert-equal (list (partition ten 0)) [])
Fix #1237: iterator-handling bug in `partition` Also, `partition` with n < 0 now raises an error.
2017-02-26 19:18:20 +01:00
;; negative length raises ValueError
(try (do (partition ten -1) (assert False))
(except [ValueError]))
enhance partition
2015-09-03 06:54:24 +02:00
;; keep remainder with a fillvalue
(assert-equal (list (partition ten 3 :fillvalue "x"))
[(, 0 1 2) (, 3 4 5) (, 6 7 8) (, 9 "x" "x")])
;; skip elements with step > n
(assert-equal (list (partition ten 2 3))
[(, 0 1) (, 3 4) (, 6 7)])
;; overlap with step < n
(assert-equal (list (partition (range 5) 2 1))
Fix #1237: iterator-handling bug in `partition` Also, `partition` with n < 0 now raises an error.
2017-02-26 19:18:20 +01:00
[(, 0 1) (, 1 2) (, 2 3) (, 3 4)])
;; tee the input as necessary
;; https://github.com/hylang/hy/issues/1237
(assert-equal (list (take 4 (partition (cycle [1 2 3]) 3)))
[(, 1 2 3) (, 1 2 3) (, 1 2 3) (, 1 2 3)])
(assert-equal (list (partition (iter (range 10))))
[(, 0 1) (, 2 3) (, 4 5) (, 6 7) (, 8 9)]))
add partition form to core the 2 argument version of Clojure's partition. pre-expand ->> macro in partition Docstring for partition. add test-partition Document partition.
2015-08-05 22:59:05 +02:00
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(defn test-pos []
"NATIVE: testing the pos? function"
(assert-true (pos? 2))
(assert-false (pos? -1))
Update: Updated most methods to replace While with For, and added tons of new tests for things like (cycle []) and lists with None's in them. thanks @olasd Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(assert-false (pos? 0))
Remove native tests of Python 2
2019-05-20 20:46:52 +02:00
(assert-requires-num pos?))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(defn test-remove []
"NATIVE: testing the remove function"
(setv r (list (remove odd? [1 2 3 4 5 6 7])))
(assert-equal r [2 4 6])
(assert-equal (list (remove even? [1 2 3 4 5])) [1 3 5])
(assert-equal (list (remove neg? [1 2 3 4 5])) [1 2 3 4 5])
Update: Updated most methods to replace While with For, and added tons of new tests for things like (cycle []) and lists with None's in them. thanks @olasd Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(assert-equal (list (remove pos? [1 2 3 4 5])) [])
;; deal with embedded None
(assert-equal (list (remove (fn [x] (not (numeric? x))) [1 2 None 3 None 4])) [1 2 3 4]))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(defn test-repeat []
"NATIVE: testing repeat"
(setv r (repeat 10))
(assert-equal (list (take 5 r)) [10 10 10 10 10])
(assert-equal (list (take 4 r)) [10 10 10 10])
(setv r (repeat 10 3))
(assert-equal (list r) [10 10 10]))
(defn test-repeatedly []
"NATIVE: testing repeatedly"
(setv r (repeatedly (fn [] (inc 4))))
(assert-equal (list (take 5 r)) [5 5 5 5 5])
(assert-equal (list (take 4 r)) [5 5 5 5])
(assert-equal (list (take 6 r)) [5 5 5 5 5 5]))
Second (smaller) set of native core functions This rounds out the first pass at a set of core functions, adding some that were not in the first PR. From here I'm working on a contrib.seq and contrib.io module to hold less obvious but maybe interesting native functions that can move to core if desired. This should also close out issure #150 asking for some core functions like these.
2013-07-29 18:40:48 +02:00
(defn test-second []
"NATIVE: testing second"
(assert-equal 2 (second [1 2]))
(assert-equal 3 (second [2 3 4])))
Implement every? and some
2014-02-11 09:42:56 +01:00
(defn test-some []
"NATIVE: testing the some function"
(assert-true (some even? [2 4 6]))
Burninate the synonyms `true`, `false`, and `nil` Per the straw poll in #908, as an alternative to #1147. Now you must use `True`, `False`, and `None`, as in Python. Or just assign `true` to `True`, etc.; the old synonyms aren't reserved words anymore.
2016-11-24 03:35:17 +01:00
(assert-none (some even? [1 3 5]))
Fix 'some' (first logical true value or nil)
2014-09-04 11:29:38 +02:00
(assert-true (some even? [1 2 3]))
Burninate the synonyms `true`, `false`, and `nil` Per the straw poll in #908, as an alternative to #1147. Now you must use `True`, `False`, and `None`, as in Python. Or just assign `true` to `True`, etc.; the old synonyms aren't reserved words anymore.
2016-11-24 03:35:17 +01:00
(assert-none (some even? []))
Fix 'some' (first logical true value or nil)
2014-09-04 11:29:38 +02:00
; 0, "" (empty string) and [] (empty list) are all logical false
Burninate the synonyms `true`, `false`, and `nil` Per the straw poll in #908, as an alternative to #1147. Now you must use `True`, `False`, and `None`, as in Python. Or just assign `true` to `True`, etc.; the old synonyms aren't reserved words anymore.
2016-11-24 03:35:17 +01:00
(assert-none (some identity [0 "" []]))
Fix 'some' (first logical true value or nil)
2014-09-04 11:29:38 +02:00
; non-empty string is logical true
(assert-equal (some identity [0 "this string is non-empty" []])
"this string is non-empty")
Burninate the synonyms `true`, `false`, and `nil` Per the straw poll in #908, as an alternative to #1147. Now you must use `True`, `False`, and `None`, as in Python. Or just assign `true` to `True`, etc.; the old synonyms aren't reserved words anymore.
2016-11-24 03:35:17 +01:00
; None if collection is empty
(assert-none (some even? [])))
Implement every? and some
2014-02-11 09:42:56 +01:00
Second (smaller) set of native core functions This rounds out the first pass at a set of core functions, adding some that were not in the first PR. From here I'm working on a contrib.seq and contrib.io module to hold less obvious but maybe interesting native functions that can move to core if desired. This should also close out issure #150 asking for some core functions like these.
2013-07-29 18:40:48 +02:00
(defn test-string? []
"NATIVE: testing string?"
(assert-true (string? "foo"))
(assert-true (string? ""))
(assert-false (string? 5.3))
(assert-true (string? (str 5.3)))
(assert-false (string? None)))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(defn test-take []
"NATIVE: testing the take function"
(setv res (list (take 3 [1 2 3 4 5])))
(assert-equal res [1 2 3])
(setv res (list (take 4 (repeat "s"))))
(assert-equal res ["s" "s" "s" "s"])
(setv res (list (take 0 (repeat "s"))))
(assert-equal res [])
Reimplement some built-ins in terms of the standard library. As a result: * functions such as `nth` should work correctly on iterators; * `nth` will raise `IndexError` (in a fashion consistent with `get`) when the index is out of bounds; * `take`, etc. will raise `ValueError` instead of returning an ambiguous value if the index is negative; * `map`, `zip`, `range`, `input`, `filter` work the same way (Py3k one) on both Python 2 and 3 (see #523 and #331).
2014-04-29 16:01:14 +02:00
(try (do (list (take -1 (repeat "s"))) (assert False))
Burninate the synonyms `true`, `false`, and `nil` Per the straw poll in #908, as an alternative to #1147. Now you must use `True`, `False`, and `None`, as in Python. Or just assign `true` to `True`, etc.; the old synonyms aren't reserved words anymore.
2016-11-24 03:35:17 +01:00
(except [e [ValueError]] None))
Update: Updated most methods to replace While with For, and added tons of new tests for things like (cycle []) and lists with None's in them. thanks @olasd Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(setv res (list (take 6 [1 2 None 4])))
(assert-equal res [1 2 None 4]))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(defn test-take-nth []
"NATIVE: testing the take-nth function"
(setv res (list (take-nth 2 [1 2 3 4 5 6 7])))
(assert-equal res [1 3 5 7])
(setv res (list (take-nth 3 [1 2 3 4 5 6 7])))
(assert-equal res [1 4 7])
(setv res (list (take-nth 4 [1 2 3 4 5 6 7])))
(assert-equal res [1 5])
(setv res (list (take-nth 5 [1 2 3 4 5 6 7])))
(assert-equal res [1 6])
(setv res (list (take-nth 6 [1 2 3 4 5 6 7])))
(assert-equal res [1 7])
(setv res (list (take-nth 7 [1 2 3 4 5 6 7])))
(assert-equal res [1])
Update: Updated most methods to replace While with For, and added tons of new tests for things like (cycle []) and lists with None's in them. thanks @olasd Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
;; what if there are None's in list
(setv res (list (take-nth 2 [1 2 3 None 5 6])))
(assert-equal res [1 3 5])
(setv res (list (take-nth 3 [1 2 3 None 5 6])))
(assert-equal res [1 None])
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
;; using 0 should raise ValueError
Remove uses of `let` from various tests
2017-02-04 18:07:27 +01:00
(setv passed False)
(try
(setv res (list (take-nth 0 [1 2 3 4 5 6 7])))
(except [ValueError] (setv passed True)))
(assert passed))
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(defn test-take-while []
"NATIVE: testing the take-while function"
(setv res (list (take-while pos? [ 1 2 3 -4 5])))
Update: Updated most methods to replace While with For, and added tons of new tests for things like (cycle []) and lists with None's in them. thanks @olasd Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(assert-equal res [1 2 3])
Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(setv res (list (take-while neg? [ -1 -4 5 3 4])))
Update: Updated most methods to replace While with For, and added tons of new tests for things like (cycle []) and lists with None's in them. thanks @olasd Add set of new core functions Add set of new core functions to the stdlib. Moved the auto-import code from compile_expression to HySymbol so that "even?' in this style expression will be found and imported. (list (filter even? [1 2 3 4 5])) The core functions are documented in 2 sections, one for basic functions like (even?..) and (nth ...) and one for all the sequence functions. Update: This removes all the caching decorators, misnamed as 'lazy-seq' from the core. All sequence methods now just use yield to return a generator, so they are Python-lazy Further refinements of core functions Cleaned up the docs to use 'iterator' instead of 'generator' Fixed drop to just return the iterator instead of an extra yield loop. But also added a test to catch dropping too many.
2013-07-08 04:36:26 +02:00
(assert-false (= res [1 2]))
(setv res (list (take-while none? [None None 1 2 3])))
(assert-equal res [None None])
(setv res (list (take-while (fn [x] (not (none? x))) [1 2 3 4 None 5 6 None 7])))
(assert-equal res [1 2 3 4]))
Add zipwith
2014-02-20 03:27:49 +01:00
test for doto macro relates #567
2014-04-21 12:21:11 +02:00
(defn test-doto []
"NATIVE: testing doto macro"
(setv collection [])
(doto collection (.append 1) (.append 2) (.append 3))
Fixing `doto` to be API compatible with Clojure's `doto`
2014-04-21 21:35:56 +02:00
(assert-equal collection [1 2 3])
(setv res (doto (set) (.add 2) (.add 1)))
(assert-equal res (set [1 2]))
(setv res (doto [] (.append 1) (.append 2) .reverse))
(assert-equal res [2 1]))
test for doto macro relates #567
2014-04-21 12:21:11 +02:00
Add a keyword? function to detect keywords. Thanks to algernon for the function body; huge improvement.
2014-04-02 05:23:53 +02:00
(defn test-is-keyword []
"NATIVE: testing the keyword? function"
(assert (keyword? ':bar))
(assert (keyword? ':baz))
Remove some exceptions in keyword parsing
2019-07-24 17:21:11 +02:00
(setv x :bar)
(assert (keyword? x))
Add a keyword? function to detect keywords. Thanks to algernon for the function body; huge improvement.
2014-04-02 05:23:53 +02:00
(assert (not (keyword? "foo")))
(assert (not (keyword? ":foo")))
(assert (not (keyword? 1)))
Burninate the synonyms `true`, `false`, and `nil` Per the straw poll in #908, as an alternative to #1147. Now you must use `True`, `False`, and `None`, as in Python. Or just assign `true` to `True`, etc.; the old synonyms aren't reserved words anymore.
2016-11-24 03:35:17 +01:00
(assert (not (keyword? None))))
Fixes a long-standing bug in import under Python 3.3 and later. Our MetaImporter was being inserted at the end of sys.meta_path. For Python prior to 3.3, this was fine since sys.meta_path was empty by default. As of the completion of PEP 302 in Py3.3 and later, there are several importers registered by default. One of these was trying (and failing) to import simple Hy modules, resulting in a failure to import anything inside __init__.hy. This change simply inserts the Hy-specific importer at the front of the list. This was noted in issue #620 (great catch @algernon)
2014-12-07 19:02:48 +01:00
(defn test-import-init-hy []
"NATIVE: testing import of __init__.hy"
(import tests.resources.bin)
(assert (in "_null_fn_for_import_test" (dir tests.resources.bin))))
added remaining itertools Some names have been changed. Removed redundant zipwith. Made `first` and `last` more efficient.
2015-09-03 19:45:55 +02:00
(defn test-accumulate []
"NATIVE: testing the accumulate function"
(assert-equal (list (accumulate ["a" "b" "c"]))
["a" "ab" "abc"])
(assert-equal (list (accumulate [1 2 3 4 5]))
[1 3 6 10 15])
(assert-equal (list (accumulate [1 -2 -3 -4 -5] -))
[1 3 6 10 15]))
Add a module for getting reserved words (#1171) This is helpful for writing syntax highlighters (e.g., https://github.com/hylang/hy/pull/1170).
2016-12-12 09:11:42 +01:00
Add comp, constantly and complement (#1179) * Add comp, constantly and complement relates #1176 * Fix composition order in comp * comp without parameters returns identity * Doc edits for comp, complement, constantly * Test that `(comp)` returns `identity` exactly * Simplify the `reduce` call in `comp` * updated version of comp
2016-12-25 21:11:25 +01:00
(defn test-complement []
"NATIVE: test complement"
Remove def and standardize on setv
2018-01-05 21:51:00 +01:00
(setv helper (complement identity))
Remove trailing space
2016-12-25 22:56:24 +01:00
Add comp, constantly and complement (#1179) * Add comp, constantly and complement relates #1176 * Fix composition order in comp * comp without parameters returns identity * Doc edits for comp, complement, constantly * Test that `(comp)` returns `identity` exactly * Simplify the `reduce` call in `comp` * updated version of comp
2016-12-25 21:11:25 +01:00
(assert-true (helper False))
(assert-false (helper True)))
(defn test-constantly []
"NATIVE: test constantly"
Remove def and standardize on setv
2018-01-05 21:51:00 +01:00
(setv helper (constantly 42))
Add comp, constantly and complement (#1179) * Add comp, constantly and complement relates #1176 * Fix composition order in comp * comp without parameters returns identity * Doc edits for comp, complement, constantly * Test that `(comp)` returns `identity` exactly * Simplify the `reduce` call in `comp` * updated version of comp
2016-12-25 21:11:25 +01:00
(assert-true (= (helper) 42))
(assert-true (= (helper 1 2 3) 42))
(assert-true (= (helper 1 2 :foo 3) 42)))
(defn test-comp []
"NATIVE: test comp"
(assert-true ((comp odd? inc second) [1 2 3 4 5]))
(assert-true (= 1 ((comp first) [1 2 3])))
(assert-true ((comp even? inc +) 1 2 3 4 5))
(assert-true (= 5 ((comp) 5)))
(assert (is (comp) identity)))
Add test for juxt
2016-12-25 22:57:50 +01:00
(defn test-juxt []
"NATIVE: test juxt"
(assert-equal ((juxt min max sum) [1 2 3 4 5 6])
[1 6 21])
(assert-equal ((juxt identity) 42)
[42]))
tests for #_ and (comment ...)
2017-08-04 03:53:47 +02:00
(defn test-comment []
(assert-none (comment <h1>This is merely a comment.</h1>
<p> Move along. (Nothing to see here.)</p>)))
Fix missing import in `doc` macro expansion
2018-09-06 00:48:58 +02:00
(defn test-doc [capsys]
(doc doc)
(setv out_err (.readouterr capsys))
(assert (.startswith (.strip (first out_err))
Improve correspondence with Python errors and console behavior Compiler and command-line error messages now reflect their Python counterparts. E.g. where Python emits a `SyntaxError`, so does Hy; same for `TypeError`s. Multiple tests have been added that check the format and type of raised exceptions over varying command-line invocations (e.g. interactive and not). A new exception type for `require` errors was added so that they can be treated like normal run-time errors and not compiler errors. The Hy REPL has been further refactored to better match the class-structured API. Now, different error types are handled separately and leverage more base class-provided functionality. Closes hylang/hy#1486.
2018-10-13 06:25:43 +02:00
"Help on function doc in module hy.core.macros:"))
Fix missing import in `doc` macro expansion
2018-09-06 00:48:58 +02:00
(assert (empty? (second out_err))))
Copy Permalink