first commit, moving the standard library in a separate repository

SuperFola · SuperFola · commit 79ee38554e06 · 2020-06-18T14:16:10.000+02:00
diff --git a/Functional/Compose.ark b/Functional/Compose.ark
@@ -0,0 +1,2 @@
+(let compose (fun (_f _g)
+    (fun (_y &_f &_g) (_f (_g _y)))))
diff --git a/Functional/Drop.ark b/Functional/Drop.ark
@@ -0,0 +1,9 @@
+(let drop (fun (_n _L) {
+    (mut _index _n)
+    (mut _output [])
+    (while (< _index (len _L)) {
+        (set _output (append _output (@ _L _index)))
+        (set _index (+ 1 _index))
+    })
+    _output
+}))
diff --git a/Functional/DropWhile.ark b/Functional/DropWhile.ark
@@ -0,0 +1,14 @@
+(let dropWhile (fun (_f _L) {
+    (mut _index 0)
+    (mut _output [])
+    (mut _continue true)
+
+    (while (and (< _index (len _L)) _continue) {
+        (if (_f (@ _L _index)) {
+                (set _index (+ 1 _index))
+                (set _output (append _output (@ _L _index)))
+            }
+            (set _continue false))
+    })
+    _output
+}))
diff --git a/Functional/Either.ark b/Functional/Either.ark
@@ -0,0 +1,8 @@
+{
+    (let left (fun (x)
+        (fun (_injl _injr &x) (_injl x))
+    ))
+    (let right (fun (y)
+        (fun (_injl _injr &y) (_injr y))
+    ))
+}
diff --git a/Functional/Exceptions.ark b/Functional/Exceptions.ark
@@ -0,0 +1,8 @@
+{
+    (import "Either.ark")
+    
+    (let throw left)
+    (let return right)
+    (let try (fun (either continue handle)
+        (either handle continue)))
+}
diff --git a/Functional/Filter.ark b/Functional/Filter.ark
@@ -0,0 +1,11 @@
+(let filter (fun (_f _L) {
+    (mut _index 0)
+    (mut _output [])
+    (while (< _index (len _L)) {
+        (if (_f (@ _L _index))
+            (set _output (append _output (@ _L _index)))
+            nil)
+        (set _index (+ 1 _index))
+    })
+    _output
+}))
diff --git a/Functional/Flip.ark b/Functional/Flip.ark
@@ -0,0 +1,2 @@
+(let flip (fun (_f _a)
+    (fun (_b &_f &_a) (_f _b _a))))
diff --git a/Functional/Functional.ark b/Functional/Functional.ark
@@ -0,0 +1,14 @@
+{
+    (import "Functional/Compose.ark")
+    (import "Functional/Drop.ark")
+    (import "Functional/DropWhile.ark")
+    (import "Functional/Either.ark")
+    (import "Functional/Filter.ark")
+    (import "Functional/Flip.ark")
+    (import "Functional/Map.ark")
+    (import "Functional/Reduce.ark")
+    (import "Functional/Take.ark")
+    (import "Functional/TakeWhile.ark")
+    (import "Functional/Unzip.ark")
+    (import "Functional/Zip.ark")
+}
diff --git a/Functional/Map.ark b/Functional/Map.ark
@@ -0,0 +1,9 @@
+(let map (fun (_f _L) {
+    (mut _index 0)
+    (mut _output [])
+    (while (< _index (len _L)) {
+        (set _output (append _output (_f (@ _L _index))))
+        (set _index (+ 1 _index))
+    })
+    _output
+}))
diff --git a/Functional/Reduce.ark b/Functional/Reduce.ark
@@ -0,0 +1,9 @@
+(let reduce (fun (function _L) {
+    (mut _index 1)
+    (mut _output (@ _L 0))
+    (while (< _index (len _L)) {
+        (set _output (function _output (@ _L _index)))
+        (set _index (+ 1 _index))
+    })
+    _output
+}))
diff --git a/Functional/Take.ark b/Functional/Take.ark
@@ -0,0 +1,9 @@
+(let take (fun (_n _L) {
+    (mut _index 0)
+    (mut _output [])
+    (while (and (< _index _n) (< _index (len _L))) {
+        (set _output (append _output (@ _L _index)))
+        (set _index (+ 1 _index))
+    })
+    _output
+}))
diff --git a/Functional/TakeWhile.ark b/Functional/TakeWhile.ark
@@ -0,0 +1,15 @@
+(let takeWhile (fun (_f _L) {
+    (mut _index 0)
+    (mut _output [])
+    (mut _continue true)
+
+    (while (and (< _index (len _L)) _continue) {
+        (if (_f (@ _L _index)) {
+                (set _output (append _output (@ _L _index)))
+                (set _index (+ 1 _index))
+            }
+            (set _continue false)
+        )
+    })
+    _output
+}))
diff --git a/Functional/Unzip.ark b/Functional/Unzip.ark
@@ -0,0 +1,13 @@
+(let unzip (fun (_L) {
+    (let _m (len _L))
+    (mut _list1 [])
+    (mut _list2 [])
+    (mut _index 0)
+    (while (< _index _m) {
+        (mut current (@ _L _index))
+        (set _list1 (append _list1 (@ current 0)))
+        (set _list2 (append _list2 (@ current 1)))
+        (set _index (+ 1 _index))
+    })
+    [_list1 _list2]
+}))
diff --git a/Functional/Zip.ark b/Functional/Zip.ark
@@ -0,0 +1,14 @@
+{
+    (import "Math/Min.ark")
+    
+    (let zip (fun (_a _b) {
+        (let _m (min (len _a) (len _b) ))
+        (mut _c [])
+        (mut _index 0)
+        (while (< _index _m) {
+            (set _c (append _c [(@ _a _index) (@ _b _index)]))
+            (set _index (+ 1 _index))
+        })
+        _c
+    }))
+}
diff --git a/List/ForEach.ark b/List/ForEach.ark
@@ -0,0 +1,8 @@
+(let forEach (fun (_L code) {
+    (mut _index 0)
+    (while (< _index (len _L)) {
+        (mut _element (@ _L _index))
+        (code _element)
+        (set _index (+ 1 _index))
+    })
+}))
diff --git a/List/Product.ark b/List/Product.ark
@@ -0,0 +1,9 @@
+(let product (fun (_L) {
+    (mut _index 0)
+    (mut _output 1)
+    (while (< _index (len _L)) {
+        (set _output (* _output (@ _L _index)))
+        (set _index (+ 1 _index))
+    })
+    _output
+}))
diff --git a/List/Sum.ark b/List/Sum.ark
@@ -0,0 +1,9 @@
+(let sum (fun (_L) {
+    (mut _index 0)
+    (mut _output 0)
+    (while (< _index (len _L)) {
+        (set _output (+ _output (@ _L _index)))
+        (set _index (+ 1 _index))
+    })
+    _output
+}))
diff --git a/Math/Abs.ark b/Math/Abs.ark
@@ -0,0 +1,5 @@
+(let abs (fun (_x)
+    (if (< _x 0)
+        (* -1 _x)
+        _x
+    )))
diff --git a/Math/Arithmetic.ark b/Math/Arithmetic.ark
@@ -0,0 +1,9 @@
+{
+    (import "Math/Abs.ark")
+    (import "Math/Even.ark")
+    (import "Math/Max.ark")
+    (import "Math/Min.ark")
+    (import "Math/Odd.ark")
+    (import "Math/Pow.ark")
+    (import "Math/Sqrt.ark")
+}
diff --git a/Math/Even.ark b/Math/Even.ark
@@ -0,0 +1,2 @@
+(let even (fun (_n)
+    (= 0 (mod _n 2))))
diff --git a/Math/Max.ark b/Math/Max.ark
@@ -0,0 +1,5 @@
+(let max (fun (_a _b)
+    (if (> _a _b)
+        _a
+        _b
+    )))
diff --git a/Math/Min.ark b/Math/Min.ark
@@ -0,0 +1,5 @@
+(let min (fun (_a _b)
+    (if (< _a _b)
+        _a
+        _b
+    )))
diff --git a/Math/Odd.ark b/Math/Odd.ark
@@ -0,0 +1,6 @@
+{
+    (import "Math/Abs.ark")
+    
+    (let odd (fun (_n)
+        (= 1 (abs (mod _n 2)))))
+}
diff --git a/Math/Pow.ark b/Math/Pow.ark
@@ -0,0 +1 @@
+(let pow (fun (x _a) (exp (* _a (ln x)))))
diff --git a/Math/Sqrt.ark b/Math/Sqrt.ark
@@ -0,0 +1 @@
+(let sqrt (fun (x) (exp (* 0.5 (ln x)))))
diff --git a/README.md b/README.md
@@ -0,0 +1,3 @@
+# ArkScript standard library
+
+TODO
diff --git a/Range.ark b/Range.ark
@@ -0,0 +1,32 @@
+{
+    (let range (fun (_a _b) {
+        (let asList (fun () {
+            # _a and _b are going to be captured by the caller
+            (mut _output [])
+            (mut a_ _a)
+            (while (< a_ _b) {
+                (set _output (append _output a_))
+                (set a_ (+ 1 a_))
+            })
+            _output
+        }))
+
+        (fun (&_a &_b &asList) {
+            (if (< _a _b) {
+                    (mut c _a)
+                    (set _a (+ _a 1))
+                    c
+                }
+                nil
+            )
+        })
+    }))
+
+    (let forEachR (fun (r _f) {
+        (mut val (r))
+        (while (= false (nil? val)) {
+            (_f val)
+            (set val (r))
+        })
+    }))
+}
diff --git a/String/Case.ark b/String/Case.ark
diff --git a/String/Reverse.ark b/String/Reverse.ark
diff --git a/String/Slice.ark b/String/Slice.ark
diff --git a/String/Split.ark b/String/Split.ark
diff --git a/Switch.ark b/Switch.ark

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+(let compose (fun (_f _g)`
	`2`	`+ (fun (_y &_f &_g) (_f (_g _y)))))`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+(let flip (fun (_f _a)`
	`2`	`+ (fun (_b &_f &_a) (_f _b _a))))`