feat(algorithms): adding identity, recombine to Functional ; min, max and size to List

Author: SuperFola

Functional.ark

@@ -33,12 +33,35 @@
 
 # @brief Flip the arguments of a function
 # @param _f the function
-# @param _a the first argument
-# @details Returns a function taking 1 argument: the second argument of the function to flip
+# @details Returns a function taking 2 arguments a and b, calling (f b a) 
 # =begin
 # (let foo (fun (a b) (- a b)))
-# ((flip foo 14) 12) # will call (foo 12 14) instead of (foo 14 12)
+# ((flip foo) 14 12) # will call (foo 12 14) instead of (foo 14 12)
 # =end
 # @author https://github.com/rstefanic
-(let flip (fun (_f _a)
-  (fun (_b &_f &_a) (_f _b _a))))
+(let flip (fun (_f)
+  (fun (_a _b &_f) (_f _b _a))))
+
+# @brief No-op, return the value as-is
+# @param _x the value
+# =begin
+# (let maybeAbs (if shouldNormalizeNegatives math:abs identity))
+# (let data (list:map nums maybeAbs))
+# =end
+# @author https://github.com/SuperFola
+(let identity (fun (_x) _x))
+
+# @brief Generic form for functions that need to reuse their arguments
+# @param _f function called with two arguments
+# @param _g first unary function
+# @param _h second unary function
+# @details Returns a function taking one argument x, calling (f (g x) (h x))
+# =begin
+# (let mean (recombine (fun (a b) (/ a b)) list:sum list:size))
+# (print (mean [0 1 1 2 3 5 8 13]))  # 4.125
+# =end
+# @author https://github.com/SuperFola
+(let recombine (fun (_f _g _h)
+  (fun (_x &_f &_g &_h)
+    (_f (_g _x) (_h _x)))))
+

List.ark

@@ -48,6 +48,14 @@
 # @author https://github.com/SuperFola
 (let fill (fun (_val _count) (builtin__list:fill _val _count)))
 
+# @brief Function to call the `len` operator on a list
+# @param _L list to get the size of
+# =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
@@ -62,7 +70,7 @@
 # @brief Iterate over a given list and run a given function on every element.
 # @param _L the list to iterate over
 # @param _func the function to call on each element
-# @details The original list is left unmodified.
+# @details The original list is not modified.
 # =begin
 # (import std.List)
 # (let collection [1 2 5 12])
@@ -81,7 +89,7 @@
 
 # @brief Iterate over a given list and multiply all the elements with the others.
 # @param _L the list to iterate over
-# @details The original list is left unmodified.
+# @details The original list is not modified.
 # =begin
 # (import std.List)
 # (let collection [1 2 5 12])
@@ -99,7 +107,7 @@
 
 # @brief Iterate over a given list and sum all the elements.
 # @param _L the list to iterate over
-# @details The original list is left unmodified.
+# @details The original list is not modified.
 # =begin
 # (import std.List)
 # (let collection [1 2 5 12])
@@ -115,12 +123,46 @@
     (set _index (+ 1 _index)) })
   _output }))
 
+# @brief Find the minimum in a list of numbers
+# @param _L list of numbers
+# @details The original list is not modified.
+# =begin
+# (let value (list:min [0 1 2 3 5 8]))  # 0
+# =end
+# @author https://github.com/SuperFola
+(let min (fun (_L) {
+  (mut _index 0)
+  (mut _output nil)
+
+  (while (< _index (len _L)) {
+    (if (or (nil? _output) (< (@ _L _index) _output))
+        (set _output (@ _L _index)))
+    (set _index (+ 1 _index)) })
+  _output }))
+
+# @brief Find the maximum in a list of numbers
+# @param _L list of numbers
+# @details The original list is not modified.
+# =begin
+# (let value (list:min [0 1 2 3 5 8]))  # 8
+# =end
+# @author https://github.com/SuperFola
+(let max (fun (_L) {
+  (mut _index 0)
+  (mut _output nil)
+
+  (while (< _index (len _L)) {
+    (if (or (nil? _output) (> (@ _L _index) _output))
+        (set _output (@ _L _index)))
+    (set _index (+ 1 _index)) })
+  _output }))
+
 (import std.Math :min :max)
 
 # @brief Drop the first n elements of a list
 # @param _L the list to work on
 # @param _n the number of elements to drop
-# @details The original list is left unmodified.
+# @details The original list is not modified.
 # =begin
 # (let cool-stuff [1 2 3 4 5 6 7 8 9])
 # (print (drop cool-stuff 4))  # [5 6 7 8 9]
@@ -143,7 +185,7 @@
 # @brief Drop the first elements of a list, while they match a given predicate
 # @param _L the list to work on
 # @param _f the predicate
-# @details The original list is left unmodified.
+# @details The original list is not modified.
 # =begin
 # (let cool-stuff [1 2 3 4 5 6 7 8 9])
 # (print (dropWhile cool-stuff (fun (a) (< a 4))))  # [4 5 6 7 8 9]
@@ -164,7 +206,7 @@
 # @brief Keep elements in a given list if they follow a predicate
 # @param _L the list to work on
 # @param _f the predicate
-# @details The original list is left unmodified.
+# @details The original list is not modified.
 # =begin
 # (import std.Math)
 # (print (filter [1 2 3 4 5 6 7 8 9] math:even))  # [2 4 6 8]
@@ -182,7 +224,7 @@
 # @brief Apply a given function to each element of a list
 # @param _L the list to work on
 # @param _f the function to apply to each element
-# @details The original list is left unmodified.
+# @details The original list is not modified.
 # =begin
 # (print (map [1 2 3 4 5 6 7 8 9] (fun (e) (* e e))))  # [1 4 9 25 36 49 64 81]
 # =end
@@ -199,7 +241,7 @@
 # @brief Apply a function to the elements of a list to reduce it
 # @param _L the list to work on
 # @param _f the function to apply
-# @details The original list is left unmodified.
+# @details The original list is not modified.
 # =begin
 # (let cool [1 2 3 4 5 6 7 8 9])
 # (print (reduce cool (fun (a b) (+ a b))))  # 45
@@ -216,7 +258,7 @@
 
 # @brief Flatten a list
 # @param _L the list to work on
-# @details The original list is left unmodified.
+# @details The original list is not modified.
 # =begin
 # (let cool [[1 2 3] [4] 5 6 [7 8] 9])
 # (print (flatten cool))  # [1 2 3 4 5 6 7 8 9]
@@ -238,7 +280,7 @@
 # @brief Apply a given function to each element of a list and then flatten it
 # @param _L the list to work on
 # @param _f the function to apply to each element
-# @details The original list is left unmodified.
+# @details The original list is not modified.
 # =begin
 # (let cool [1 2 3 4])
 # (print (flatMap cool (fun (a) [a a])))  # [1 1 2 2 3 3 4 4]
@@ -260,7 +302,7 @@
 # @brief Take the first n elements of
 # @param _L the list to work on
 # @param _n the number of elements to take
-# @details The original list is left unmodified.
+# @details The original list is not modified.
 # =begin
 # (print (take [1 2 3 4 5 6 7 8 9] 4))  # [1 2 3 4]
 # =end
@@ -278,7 +320,7 @@
 # @brief Take the first n elements of a list, given a predicate
 # @param _L the list to work on
 # @param _f the predicate
-# @details The original list is left unmodified.
+# @details The original list is not modified.
 # =begin
 # (print (takeWhile [1 2 3 4 5 6 7 8 9 10] (fun (a) (< a 4))))  # [1 2 3]
 # =end
@@ -299,7 +341,7 @@
 # @brief Partition a list in two, given a predicate
 # @param _L the list to work on
 # @param _f the predicate, accepting the value and its index
-# @details The original list is left unmodified.
+# @details The original list is not modified.
 # =begin
 # (let a [1 2 3])
 # (print (list:partition a (fun (c i) (= 0 (mod c 2)))))  # [[2] [1 3]]
@@ -321,7 +363,7 @@
 
 # @brief Unzip a list of [[a b] [c d]...] into [[a c ...] [b d ...]]
 # @param _L the list to work on
-# @details The original list is left unmodified.
+# @details The original list is not modified.
 # =begin
 # (let zipped [[1 5] [2 6] [3 7] [4 8]])
 # (print (unzip zipped))  # [[1 2 3 4] [5 6 7 8]]
@@ -343,7 +385,7 @@
 # @brief Zip two lists into one: [1 2 3 4] and [5 6 7 8] will give [[1 5] [2 6] [3 7] [4 8]]
 # @param _a the first list to work on
 # @param _b the second list to work on
-# @details The original lists are left unmodified.
+# @details The original lists are not modified.
 # =begin
 # (let a [1 2 3 4])
 # (let b [5 6 7 8])
@@ -362,7 +404,7 @@
 
 # @brief Zip a list elements with their index. [5 6 7 8] will give [[0 5] [1 6] [2 7] [3 8]]
 # @param _L the list to iterate over
-# @details The original list is left unmodified.
+# @details The original list is not modified.
 # =begin
 # (let a [5 6 7 8])
 # (print (zipWithIndex a))  # [[0 5] [1 6] [2 7] [3 8]]
@@ -381,7 +423,7 @@
 # @param _L the list to work on
 # @param _init an init value
 # @param _f a function to apply to the list
-# @details The original list is left unmodified.
+# @details The original list is not modified.
 # =begin
 # (let a [1 2 3 4])
 # (print (foldLeft a 0 (fun (a b) (+ a b))))  # 10
@@ -512,7 +554,7 @@
   _output }))
 
 # @brief Insert an element (or expand a list) at a given position inside a list
-# @details Original list is left unmodified
+# @details The original list is not modified
 # @param _L list to insert element(s) in
 # @param _index where to insert
 # @param _value value to insert

tests/functional-tests.ark

@@ -1,13 +1,47 @@
 (import std.Functional:*)
 (import std.Testing)
+(import std.List)
 
 (let foo (fun (x) (+ x 3)))
 (let egg (fun (y) (* y 2)))
 (let bar (fun (x y) (- x y)))
 
 (test:suite functional {
-    (test:eq ((compose foo egg) 5) (foo (egg 5)))
-    (test:eq ((compose egg egg) 5) (egg (egg 5)))
-    # no need to test left and right because they were already tested by the exceptions tests (throw, return)
-    (test:eq ((flip bar 5) 6) (bar 6 5))
-    (test:eq ((flip bar 6) 5) (bar 5 6))})
+    (test:case "compose" {
+        (test:eq ((compose foo egg) 5) (foo (egg 5)))
+        (test:eq ((compose egg egg) 5) (egg (egg 5))) })
+
+    (test:case "left & right" {
+        (let err (left 5))
+        (err
+            (fun (x) (test:expect true))
+            (fun (x) (test:expect false)))
+
+        (let ok (right 6))
+        (ok
+            (fun (x) (test:expect false))
+            (fun (x) (test:expect true))) })
+
+    (test:case "flip" {
+        (test:eq ((flip bar) 5 6) (bar 6 5))
+        (test:eq ((flip bar) 6 5) (bar 5 6)) })
+
+    (test:case "identity" {
+        (test:eq (identity nil) nil)
+        (test:eq (identity []) [])
+        (test:eq (identity "hello") "hello") })
+
+    (test:case "recombine" {
+        (let mean (recombine
+            (fun (a b) (/ a b))
+            list:sum
+            list:size))
+        (test:eq (mean [0 1 1 2 3 5 8 13]) 4.125)
+        (test:eq (mean [0]) 0)
+
+        (let minMax (recombine
+            (fun (a b) [a b])
+            list:min
+            list:max))
+        (test:eq (minMax [1 1 2 3 5 8 13]) [1 13]) })})
+

tests/list-tests.ark

@@ -22,6 +22,9 @@
 
     (test:eq (builtin__list:setAt a 0 5) (list:setAt a 0 5))
 
+    (test:eq (list:size []) 0)
+    (test:eq (list:size [1 2 3]) 3)
+
     (list:forEach a (fun (e) {
         # just assert we have something, basically it's just a while + @
         (test:neq e nil)}))
@@ -32,6 +35,14 @@
     (test:eq (list:sum b) (+ 4 5 6))
     (test:eq (list:sum []) 0)
 
+    (test:eq (list:min []) nil)
+    (test:eq (list:min b) 4)
+    (test:eq (list:min [-1]) -1)
+
+    (test:eq (list:max []) nil)
+    (test:eq (list:max b) 6)
+    (test:eq (list:max [-1]) -1)
+
     (test:eq (list:drop a 0) [1 2 3])
     (test:eq (list:drop a 1) [2 3])
     (test:eq (list:drop a 2) [3])