Introduce fromLength functions

Author: JamieBallingall

src/Data/Array/AtLeast.purs

@@ -22,6 +22,7 @@ module Data.Array.ArrayAL
   , appendArray
   , prependArray
   , range
+  , fromLength
   , concat
   , intersperse
 
@@ -70,6 +71,7 @@ import Data.Foldable (class Foldable)
 import Data.FoldableWithIndex (class FoldableWithIndex)
 import Data.FunctorWithIndex (class FunctorWithIndex)
 import Data.Int.AtLeast (IntAL, fromInt', toInt)
+import Data.Int.AtLeast (fromLength) as IntAL
 import Data.Maybe (Maybe(Nothing, Just), fromJust)
 import Data.Reflectable (class Reflectable, reflectType)
 import Data.Semigroup.Foldable (class Foldable1, foldMap1DefaultL)
@@ -263,6 +265,26 @@ range i = ArrayAL $ toIntAL <$> values
   values :: Array Int
   values = Array.range (reflectType (Proxy :: _ min)) (toInt i)
 
+-- | Construct an `ArrayAL` of sequential `IntAL` from a starting `IntAL` and
+-- | the required length of the `ArrayAL`
+fromLength
+  :: ∀ (min_len :: Int) (min_val :: Int)
+   . Compare (-1) min_len LT
+  => IntAL min_val
+  -> IntAL min_len
+  -> ArrayAL min_len (IntAL min_val)
+fromLength first len = ArrayAL $ IntAL.fromLength first len
+
+-- | Construct an `ArrayAL` of sequential integers from a starting integer and
+-- | the required length of the `ArrayAL`
+fromLength'
+  :: ∀ (min :: Int). Compare (-1) min LT => Int -> IntAL min -> ArrayAL min Int
+fromLength' first len =
+  let
+    lenInt = toInt len
+  in
+    ArrayAL if lenInt == 0 then [] else Array.range first (first + lenInt - 1)
+
 concat
   :: ∀ (m :: Int) (n :: Int) (mn :: Int) (a :: Type)
    . Compare (-1) m LT

src/Data/Int/AtLeast.purs

@@ -2,7 +2,9 @@ module Data.Int.AtLeast
   ( IntAL -- Constructor not exported. Use fromInt, fromInt' or clamp
   , fromInt
   , fromInt'
+  , fromMin
   , clamp
+  , fromLength
   , toInt
   , toNumber
   , extent
@@ -28,7 +30,7 @@ module Data.Int.AtLeast
 
 import Prelude hiding (lcm, gcd)
 
-import Data.Array (length) as Array
+import Data.Array (length, range) as Array
 import Data.Array.NonEmpty (NonEmptyArray, cons', length, singleton) as NEA
 import Data.Enum (class Enum)
 import Data.EuclideanRing (gcd) as Int
@@ -95,13 +97,31 @@ fromInt' i =
     else crashWith $
       "Cannot convert Int " <> show i <> " to IntAL " <> show minInt
 
+-- | Construct an `IntAL` equal to its type-level minimum
+fromMin :: ∀ (min :: Int). Reflectable min Int => IntAL min
+fromMin = IntAL $ reflectType (Proxy :: _ min)
+
+-- | Convert an `Int` to an `IntAL`, increasing the value to the type-level
+-- | minimum if required
 clamp :: ∀ (min :: Int). Reflectable min Int => Int -> IntAL min
 clamp i =
   let
     minInt = reflectType (Proxy :: _ min)
   in
     if i >= minInt then IntAL i else IntAL minInt
 
+-- | Construct an `Array` of `IntAL`. To construct an `ArrayAL` of `IntAL` see
+-- | Data.Array.AtLeast.fromLength'
+fromLength
+  :: ∀ (min_val :: Int) (min_len :: Int)
+   . Compare (-1) min_len LT
+  => IntAL min_val
+  -> IntAL min_len
+  -> Array (IntAL min_val)
+fromLength (IntAL first) (IntAL len) =
+  if len == 0 then []
+  else IntAL <$> Array.range first (first + len - 1)
+
 -- | Convert an `IntAL` to an `Int`
 toInt :: ∀ (min :: Int). IntAL min -> Int
 toInt (IntAL i) = i