feat: create modular range functions

prelude/__internal__/Byte.mad

@@ -1,15 +1,23 @@
 import type { Maybe } from "Maybe"
+
+import List from "List"
 import {} from "Scan"
 
+
+
 #iftarget js
 
 import { Just, Nothing } from "Maybe"
 
+
+
 _scanByte :: (Byte -> Maybe Byte) -> Maybe Byte -> String -> Maybe Byte
-_scanByte = (just, nothing, str) => (#- {
+_scanByte = (just, nothing, str) => (
+  #- {
   const n = parseInt(str)
   return isNaN(n) ? nothing : just(n)
-} -#)
+} -#
+)
 
 scanByte = _scanByte(Just, Nothing)
 
@@ -25,6 +33,21 @@ instance Scan Byte {
   scan = scanByte
 }
 
+/**
+ * Return a list of bytes within the given range. The start
+ * parameter is inclusive and the end parameter is exclusive.
+ *
+ * @since 0.23.1
+ * @example
+ * range(3, 3) // []
+ * range(3, 5) // [3, 4]
+ */
+range :: Byte -> Byte -> List Byte
+export range = (start, end) => {
+  s = toInteger(start)
+  return List.repeatWith((i) => fromInteger(i + s), toInteger(end) - s)
+}
+
 #iftarget js
 
 toInteger :: Byte -> Integer
@@ -68,5 +91,3 @@ fromFloat :: Float -> Byte
 export fromFloat = extern "madlib__number__floatToByte"
 
 #endif
-
-

prelude/__internal__/Float.mad

@@ -1,4 +1,6 @@
 import type { Maybe } from "Maybe"
+
+import List from "List"
 import {} from "Scan"
 
 
@@ -30,6 +32,21 @@ instance Scan Float {
   scan = scanFloat
 }
 
+/**
+ * Return a list of floats within the given range. The start
+ * parameter is inclusive and the end parameter is exclusive.
+ *
+ * @since 0.23.1
+ * @example
+ * range(3, 3) // []
+ * range(3, 5) // [3, 4]
+ */
+range :: Float -> Float -> List Float
+export range = (start, end) => {
+  s = toInteger(start)
+  return List.repeatWith((i) => fromInteger(i + s), toInteger(end) - s)
+}
+
 #iftarget js
 
 fromInteger :: Integer -> Float

prelude/__internal__/IO.mad

@@ -2,6 +2,7 @@ import type { Wish } from "Wish"
 import type { Error } from "__IOError__"
 
 import { equals, when } from "Function"
+import Integer from "Integer"
 import { mapWithIndex } from "List"
 import List from "List"
 import { cShow, pShow } from "Show"
@@ -428,5 +429,5 @@ export printColorPalette = () => List.forEach(
       putLine("")
     }
   },
-  List.range(0, 256),
+  Integer.range(0, 256),
 )

prelude/__internal__/Integer.mad

@@ -1,4 +1,6 @@
 import type { Maybe } from "Maybe"
+
+import List from "List"
 import {} from "Scan"
 
 
@@ -30,6 +32,18 @@ instance Scan Integer {
   scan = scanInteger
 }
 
+/**
+ * Return a list of integers within the given range. The start
+ * parameter is inclusive and the end parameter is exclusive.
+ *
+ * @since 0.23.1
+ * @example
+ * range(3, 3) // []
+ * range(3, 5) // [3, 4]
+ */
+range :: Integer -> Integer -> List Integer
+export range = (start, end) => List.repeatWith((i) => i + start, end - start)
+
 #iftarget js
 
 toFloat :: Integer -> Float

prelude/__internal__/List.mad

@@ -123,17 +123,6 @@ export repeatWith = (f, count) => {
 }
 
 
-/**
- * Return a list of integers within the given range. The start
- * parameter is inclusive and the end parameter is exclusive.
- *
- * @since 0.12.0
- * @example
- * range(3, 3) // []
- * range(3, 5) // [3, 4]
- */
-range :: Integer -> Integer -> List Integer
-export range = (start, end) => repeatWith((i) => i + start, end - start)
 
 
 /**

prelude/__internal__/Network.mad

@@ -1,10 +1,11 @@
 import type { Maybe } from "Maybe"
 
+import Integer from "Integer"
 import List from "List"
+import Math from "Math"
 import { Just, Nothing } from "Maybe"
 import Short from "Short"
 import String from "String"
-import Math from "Math"
 
 
 
@@ -160,7 +161,7 @@ export getIpAddressesInRange = (start, end) => {
   return pipe(
     ipV4ToInteger,
     Math.add(1),
-    List.range(startInt),
-    map(ipV4FromInteger)
+    Integer.range(startInt),
+    map(ipV4FromInteger),
   )(end)
 }

prelude/__internal__/Random.spec.mad

@@ -1,4 +1,5 @@
 import Float from "Float"
+import Integer from "Integer"
 import List from "List"
 import Math from "Math"
 import String from "String"
@@ -108,7 +109,7 @@ test(
     r1 = generate(num)
     r2 = generate(num)
     multiType = (rand) => {
-      numbers = shuffle(List.range(0, 10), rand)
+      numbers = shuffle(Integer.range(0, 10), rand)
       strings = shuffle(ALPHABET, rand)
       return #[numbers, strings]
     }

prelude/__internal__/Random/LCG.mad

@@ -117,7 +117,10 @@ export mkSeed = pipe(
 stringToInt :: String -> Integer
 export stringToInt = pipe(
   ByteArray.fromString,
-  ByteArray.reduce((hash, byte) => hash + (Integer.fromByte(byte) << 6) + (Integer.fromByte(byte) << 16), 0),
+  ByteArray.reduce(
+    (hash, byte) => hash + (Integer.fromByte(byte) << 6) + (Integer.fromByte(byte) << 16),
+    0,
+  ),
 )
 
 mkSeedFromString :: String -> Seed
@@ -181,7 +184,7 @@ export next = perturb(LCG_C)
  */
 accumulate :: (a -> a) -> Integer -> a -> a
 export accumulate = (fn, steps, initial) => pipe(
-  List.range(0),
+  Integer.range(0),
   List.reduce((agg, _) => fn(agg), initial),
 )(steps)
 

prelude/__internal__/Short.mad

@@ -1,4 +1,6 @@
 import type { Maybe } from "Maybe"
+
+import List from "List"
 import {} from "Scan"
 
 
@@ -31,6 +33,22 @@ instance Scan Short {
 }
 
 
+/**
+ * Return a list of shorts within the given range. The start
+ * parameter is inclusive and the end parameter is exclusive.
+ *
+ * @since 0.23.1
+ * @example
+ * range(3, 3) // []
+ * range(3, 5) // [3, 4]
+ */
+range :: Short -> Short -> List Short
+export range = (start, end) => {
+  s = toInteger(start)
+  return List.repeatWith((i) => fromInteger(i + s), toInteger(end) - s)
+}
+
+
 #iftarget js
 
 toInteger :: Short -> Integer