chore: remove deprecated math:even, math:odd, dict:contains, dict:size, list:size

Author: SuperFola

Dict.ark

@@ -33,17 +33,6 @@
 # @author https://github.com/SuperFola
 (let contains? (fun (_D _key) (builtin__dict:contains _D _key)))
 
-# @brief Checks if the dictionary has a given key
-# @deprecated Use `dict:contains?`
-# @param _D dictionary
-# =begin
-# (let data (dict "key" "value"))
-# (print (dict:contains data "key"))  # true
-# (print (dict:contains data "test"))  # false
-# =end
-# @author https://github.com/SuperFola
-(let contains contains?)
-
 # @brief Get a value from a given dictionary using a key, or a default value if it doesn't exist
 # @param _D dictionary
 # @param _key key to get
@@ -55,7 +44,7 @@
 # =end
 # @author https://github.com/SuperFola
 (let getOrElse (fun (_D _key _default)
-  (if (contains _D _key)
+  (if (contains? _D _key)
     (get _D _key)
     _default)))
 
@@ -71,7 +60,7 @@
 # =end
 # @author https://github.com/SuperFola
 (let updateOrDefault (fun (_D _key _f _default)
-  (if (contains _D _key)
+  (if (contains? _D _key)
     (add _D _key (_f (get _D _key)))
     (add _D _key _default))))
 
@@ -97,16 +86,6 @@
 # @author https://github.com/SuperFola
 (let keys (fun (_D) (builtin__dict:keys _D)))
 
-# @brief Computes the number of (key, value) pairs in a given dictionary
-# @param _D dictionary
-# @deprecated Use the builtin `len` instead
-# =begin
-# (let data (dict "key" "value"))
-# (print (dict:size data))  # 1
-# =end
-# @author https://github.com/SuperFola
-(let size (fun (_D) (builtin__dict:size _D)))
-
 # @brief Returns a list of the values of a dictionary
 # @param _D dictionary
 # =begin

List.ark

@@ -59,15 +59,6 @@
 # @author https://github.com/SuperFola
 (let fill (fun (_count _val) (builtin__list:fill _count _val)))
 
-# @brief Function to call the `len` operator on a list
-# @param _L list to get the size of
-# @deprecated Use the builtin `len` instead
-# =begin
-# (print (list:size [1 2 3 4]))  # 4
-# =end
-# @author https://github.com/SuperFola
-(let size (fun (_L) (len _L)))
-
 # @brief Modify a given list and return a new one
 # @details The original list is not modified
 # @param list the list to modify

Math.ark

@@ -171,23 +171,11 @@
 # @author https://github.com/rstefanic
 (let even? (fun (_n) (= 0 (mod _n 2))))
 
-# @brief Return true if the number is even, false otherwise
-# @deprecated Use `math:even?`
-# @param _n the number
-# @author https://github.com/rstefanic
-(let even even?)
-
 # @brief Return true if the number is odd, false otherwise
 # @param _n the number
 # @author https://github.com/rstefanic
 (let odd? (fun (_n) (= 1 (abs (mod _n 2)))))
 
-# @brief Return true if the number is odd, false otherwise
-# @deprecated Use `math:odd?`
-# @param _n the number
-# @author https://github.com/rstefanic
-(let odd odd?)
-
 # @brief Get the minimum between two numbers
 # @param _a the first number
 # @param _b the second number

tests/dict-tests.ark

@@ -63,14 +63,11 @@
     (test:expect (not (dict:contains? d "hello")))
     (test:expect (not (dict:contains? d d))) })
 
-  (test:case "size" {
-    (test:eq (dict:size d) 6)
-    (test:eq (dict:size d) (len d))
-    (test:eq (dict:size (dict)) 0)
-    (test:eq (dict:size (dict)) (len (dict)))
-    (test:eq (dict:size d3) 1)
-    (test:eq (dict:size d3) (len d3))
-    (test:eq (dict:size d4) 1) })
+  (test:case "len" {
+    (test:eq (len d) 6)
+    (test:eq (len (dict)) 0)
+    (test:eq (len d3) 1)
+    (test:eq (len d4) 1) })
 
   (test:case "keys" {
     (test:eq (dict:keys d) ["key" 5 true false foo closure])
@@ -104,14 +101,14 @@
     (test:eq (dict:get d5 "count") 2) })
 
   (test:case "remove" {
-    (test:eq (dict:size d) 7)
+    (test:eq (len d) 7)
     (dict:remove d "test")
     (test:eq (dict:get d "test") nil)
-    (test:eq (dict:size d) 6) })
+    (test:eq (len d) 6) })
 
   (test:case "map" {
     (let mapped (dict:map d2 map_to_str))
-    (test:eq (dict:size d2) (dict:size mapped))
+    (test:eq (len d2) (len mapped))
     (test:eq (dict:get d2 "a") 1)
     (test:eq (dict:get d2 "b") 2)
     (test:eq (dict:get d2 "c") 3)
@@ -120,11 +117,11 @@
     (test:eq (dict:get mapped "c") "3")
 
     (let mapped2 (dict:map (dict) (fun (k v) v)))
-    (test:eq (dict:size mapped2) 0) })
+    (test:eq (len mapped2) 0) })
 
   (test:case "map!" {
     (dict:map! mapped map_to_num)
-    (test:eq (dict:size d2) (dict:size mapped))
+    (test:eq (len d2) (len mapped))
     (test:eq (dict:get d2 "a") 1)
     (test:eq (dict:get d2 "b") 2)
     (test:eq (dict:get d2 "c") 3)
@@ -133,7 +130,7 @@
     (test:eq (dict:get mapped "c") 3)
 
     (dict:map! empty map_to_num)
-    (test:eq (dict:size empty) 0) })
+    (test:eq (len empty) 0) })
 
   (test:case "forEach" {
     (dict:forEach empty (fun (k v)
@@ -144,17 +141,17 @@
   (test:case "copy" {
     (let d2_copy (dict:copy d2))
     (dict:add d2_copy "d" 4)
-    (test:eq (dict:size d2_copy) 4)
-    (test:eq (dict:size d2) 3) })
+    (test:eq (len d2_copy) 4)
+    (test:eq (len d2) 3) })
 
   (test:case "filter" {
     (let filtered (dict:filter d filter_str_keys))
-    (test:eq (dict:size d) 6)
-    (test:eq (dict:size filtered) 1)
+    (test:eq (len d) 6)
+    (test:eq (len filtered) 1)
     (test:eq (dict:get filtered "key") 2)
 
     (let empty_filtered (dict:filter empty filter_str_keys))
-    (test:eq (dict:size empty_filtered) 0) })
+    (test:eq (len empty_filtered) 0) })
 
   (test:case "asJson" {
       (test:eq (dict:asJson empty) "{}")
@@ -164,19 +161,19 @@
 
   (test:case "filter!" {
     (dict:filter! d2 filter_odd)
-    (test:eq (dict:size d2) 2)
+    (test:eq (len d2) 2)
     (test:expect (dict:contains? d2 "a"))
     (test:expect (not (dict:contains? d2 "b")))
     (test:expect (dict:contains? d2 "c"))
     (test:eq (dict:get d2 "a") 1)
     (test:eq (dict:get d2 "c") 3)
 
     (dict:filter! empty filter_odd)
-    (test:eq (dict:size empty_filtered) 0) })
+    (test:eq (len empty_filtered) 0) })
 
   (test:case "update!" {
     (dict:update! d d2)
-    (test:eq (dict:size d) 8)
+    (test:eq (len d) 8)
     (test:eq (dict:get d "a") 1)
     (test:eq (dict:get d "c") 3)
     (test:eq (dict:get d "key") 2)
@@ -186,13 +183,13 @@
     (test:eq (dict:get d foo) "yes")
     (test:eq (dict:get d closure) foo)
 
-    (test:eq (dict:size d2) 2)
+    (test:eq (len d2) 2)
     (dict:add d2 "a" 5)
     (test:eq (dict:get d "a") 1)
     (test:eq (dict:get d2 "a") 5)
 
     (dict:update! d2 empty)
-    (test:eq (dict:size d2) 2)
+    (test:eq (len d2) 2)
     (test:eq (dict:get d2 "a") 5)
     (test:eq (dict:get d2 "c") 3)
-    (test:eq (dict:size empty) 0) }) })
+    (test:eq (len empty) 0) }) })

tests/functional-tests.ark

@@ -35,7 +35,7 @@
     (let mean (recombine
       (fun (a b) (/ a b))
       list:sum
-      list:size))
+      len))
     (test:eq (mean [0 1 1 2 3 5 8 13]) 4.125)
     (test:eq (mean [0]) 0)
 

tests/list-tests.ark

@@ -29,9 +29,9 @@
     (test:expect (not (list:contains? [1 2 3] "1")))
     (test:expect (list:contains? ["1" "2" "3"] "1")) })
 
-  (test:case "size" {
-    (test:eq (list:size []) 0)
-    (test:eq (list:size [1 2 3]) 3) })
+  (test:case "len" {
+    (test:eq (len []) 0)
+    (test:eq (len [1 2 3]) 3) })
 
   (test:case "forEach" {
     (list:forEach a (fun (e) {

tests/math-tests.ark

@@ -42,8 +42,8 @@
     (test:expect (math:even? 2))
     (test:expect (math:even? 0))
     (test:expect (math:even? -2))
-    (test:expect (not (math:even 1)))
-    (test:expect (not (math:even -1))) })
+    (test:expect (not (math:even? 1)))
+    (test:expect (not (math:even? -1))) })
 
   (test:case "odd?" {
     (test:expect (math:odd? 1))