Add List.Extra.insertAt

benchmarks/src/Benchmarks.elm

@@ -20,6 +20,7 @@ import Benchmark.Runner.Alternative as BenchmarkRunner
 import List.Extra
 import List.Extra.DropRight
 import List.Extra.GroupsOf
+import List.Extra.InsertAt
 import List.Extra.Lift
 import List.Extra.NotMember
 import List.Extra.TakeRight
@@ -275,6 +276,30 @@ listExtra =
             , ( "reverse", List.Extra.TakeRight.takeRightReverse )
             , ( "length", List.Extra.TakeRight.takeRightLength )
             ]
+         , rank "insertAt negative index"
+            (\insertAt -> insertAt -3 999 intList)
+            [ ( "recursion", List.Extra.InsertAt.insertAtRecursion )
+            , ( "takeDrop", List.Extra.InsertAt.insertAtTakeDrop )
+            , ( "splitAt", List.Extra.InsertAt.insertAtSplitAt )
+            , ( "recursion2", List.Extra.InsertAt.insertAtRecursion2 )
+            , ( "recursion3", List.Extra.InsertAt.insertAtRecursion3 )
+            ]
+         , rank "insertAt good positive index"
+            (\insertAt -> insertAt 50 999 intList)
+            [ ( "recursion", List.Extra.InsertAt.insertAtRecursion )
+            , ( "takeDrop", List.Extra.InsertAt.insertAtTakeDrop )
+            , ( "splitAt", List.Extra.InsertAt.insertAtSplitAt )
+            , ( "recursion2", List.Extra.InsertAt.insertAtRecursion2 )
+            , ( "recursion3", List.Extra.InsertAt.insertAtRecursion3 )
+            ]
+         , rank "insertAt bad positive index"
+            (\insertAt -> insertAt 150 999 intList)
+            [ ( "recursion", List.Extra.InsertAt.insertAtRecursion )
+            , ( "takeDrop", List.Extra.InsertAt.insertAtTakeDrop )
+            , ( "splitAt", List.Extra.InsertAt.insertAtSplitAt )
+            , ( "recursion2", List.Extra.InsertAt.insertAtRecursion2 )
+            , ( "recursion3", List.Extra.InsertAt.insertAtRecursion3 )
+            ]
          ]
             ++ List.concatMap toComparisonsGroupsOfWithStep (List.range 1 4)
         )

benchmarks/src/List/Extra/InsertAt.elm

@@ -0,0 +1,115 @@
+module List.Extra.InsertAt exposing
+    ( insertAtRecursion
+    , insertAtRecursion2
+    , insertAtRecursion3
+    , insertAtSplitAt
+    , insertAtTakeDrop
+    )
+
+import List.Extra
+
+
+insertAtRecursion : Int -> a -> List a -> List a
+insertAtRecursion index value list =
+    if index <= -1 then
+        list
+
+    else
+        let
+            go : Int -> List a -> List a -> List a
+            go i rest acc =
+                if i == index then
+                    List.reverse acc ++ (value :: rest)
+
+                else
+                    case rest of
+                        [] ->
+                            -- index > length list
+                            list
+
+                        head :: newRest ->
+                            go (i + 1) newRest (head :: acc)
+        in
+        go 0 list []
+
+
+insertAtRecursion2Help : Int -> a -> List a -> Int -> List a -> List a -> List a
+insertAtRecursion2Help index value list i rest acc =
+    if i == index then
+        List.foldl (::) (value :: rest) acc
+
+    else
+        case rest of
+            [] ->
+                -- index > length list
+                list
+
+            head :: newRest ->
+                insertAtRecursion2Help index value list (i + 1) newRest (head :: acc)
+
+
+insertAtRecursion2 : Int -> a -> List a -> List a
+insertAtRecursion2 index value list =
+    if index <= -1 then
+        list
+
+    else
+        insertAtRecursion2Help index value list 0 list []
+
+
+insertAtTakeDrop : Int -> a -> List a -> List a
+insertAtTakeDrop index value list =
+    if index <= -1 then
+        list
+
+    else
+        let
+            length =
+                List.length list
+        in
+        if length < index then
+            list
+
+        else
+            List.take index list ++ (value :: List.drop index list)
+
+
+insertAtSplitAt : Int -> a -> List a -> List a
+insertAtSplitAt index value list =
+    if index <= -1 then
+        list
+
+    else
+        let
+            ( before, after ) =
+                List.Extra.splitAt index list
+        in
+        if List.isEmpty after && List.length before < index then
+            list
+
+        else
+            before ++ (value :: after)
+
+
+insertAtRecursion3Help : a -> List a -> Int -> List a -> List a -> List a
+insertAtRecursion3Help value list i rest acc =
+    if i == 0 then
+        List.foldl (::) (value :: rest) acc
+
+    else
+        case rest of
+            [] ->
+                -- index > length list
+                list
+
+            head :: newRest ->
+                insertAtRecursion3Help value list (i - 1) newRest (head :: acc)
+
+
+insertAtRecursion3 : Int -> a -> List a -> List a
+insertAtRecursion3 index value list =
+    if index <= -1 then
+        list
+
+    else
+        insertAtRecursion3Help value list index list []

src/List/Extra.elm

@@ -1,5 +1,5 @@
 module List.Extra exposing
-    ( last, init, getAt, cons, uncons, unconsLast, push, appendTo, prependTo, maximumBy, maximumWith, minimumBy, minimumWith, andMap, andThen, reverseMap, takeWhile, dropWhile, unique, uniqueBy, allDifferent, allDifferentBy, setIf, setAt, remove, updateIf, updateAt, updateIfIndex, removeAt, removeIfIndex, removeWhen, swapAt, stableSortWith
+    ( last, init, getAt, cons, uncons, unconsLast, push, appendTo, prependTo, maximumBy, maximumWith, minimumBy, minimumWith, andMap, andThen, reverseMap, takeWhile, dropWhile, unique, uniqueBy, allDifferent, allDifferentBy, insertAt, setIf, setAt, remove, updateIf, updateAt, updateIfIndex, removeAt, removeIfIndex, removeWhen, swapAt, stableSortWith
     , intercalate, transpose, subsequences, permutations, interweave, cartesianProduct, uniquePairs
     , foldl1, foldr1, indexedFoldl, indexedFoldr, Step(..), stoppableFoldl
     , scanl, scanl1, scanr, scanr1, mapAccuml, mapAccumr, unfoldr, iterate, initialize, cycle, reverseRange
@@ -17,7 +17,7 @@ module List.Extra exposing
 
 # Basics
 
-@docs last, init, getAt, cons, uncons, unconsLast, push, appendTo, prependTo, maximumBy, maximumWith, minimumBy, minimumWith, andMap, andThen, reverseMap, takeWhile, dropWhile, unique, uniqueBy, allDifferent, allDifferentBy, setIf, setAt, remove, updateIf, updateAt, updateIfIndex, removeAt, removeIfIndex, removeWhen, swapAt, stableSortWith
+@docs last, init, getAt, cons, uncons, unconsLast, push, appendTo, prependTo, maximumBy, maximumWith, minimumBy, minimumWith, andMap, andThen, reverseMap, takeWhile, dropWhile, unique, uniqueBy, allDifferent, allDifferentBy, insertAt, setIf, setAt, remove, updateIf, updateAt, updateIfIndex, removeAt, removeIfIndex, removeWhen, swapAt, stableSortWith
 
 
 # List transformations
@@ -831,6 +831,43 @@ count predicate =
         0
 
 
+{-| Insert an element at a given index.
+If the index is out of bounds, nothing is changed.
+
+    [ 'a', 'c' ] |> insertAt 1 'b'
+    --> [ 'a', 'b', 'c' ]
+
+    [ 'a', 'c' ] |> insertAt -1 'b'
+    --> [ 'a', 'c' ]
+
+    [ 'a', 'c' ] |>  insertAt 100 'b'
+    --> [ 'a', 'c' ]
+
+-}
+insertAt : Int -> a -> List a -> List a
+insertAt index value list =
+    if index <= -1 then
+        list
+
+    else
+        insertAtHelp value list index list []
+
+
+insertAtHelp : a -> List a -> Int -> List a -> List a -> List a
+insertAtHelp value list i rest acc =
+    if i == 0 then
+        List.foldl (::) (value :: rest) acc
+
+    else
+        case rest of
+            [] ->
+                -- index > length list
+                list
+
+            head :: newRest ->
+                insertAtHelp value list (i - 1) newRest (head :: acc)
+
+
 {-| Replace all values that satisfy a predicate with a replacement value.
 -}
 setIf : (a -> Bool) -> a -> List a -> List a
@@ -1596,7 +1633,8 @@ splitWhen predicate list =
 
 {-| Take the last _n_ members of a list.
 
-    takeRight 2 [ 1, 2, 3, 4, 5 ] == [ 4, 5 ]
+    takeRight 2 [ 1, 2, 3, 4, 5 ]
+    --> [ 4, 5 ]
 
 -}
 takeRight : Int -> List a -> List a
@@ -1609,7 +1647,8 @@ takeRight n lst =
 
 {-| Drop the last _n_ members of a list.
 
-    dropRight 2 [ 1, 2, 3, 4, 5 ] == [ 1, 2, 3 ]
+    dropRight 2 [ 1, 2, 3, 4, 5 ]
+    --> [ 1, 2, 3 ]
 
 -}
 dropRight : Int -> List a -> List a

tests/ListTests.elm

@@ -1,7 +1,7 @@
 module ListTests exposing (all)
 
 import Expect
-import Fuzz
+import Fuzz exposing (Fuzzer)
 import List.Extra exposing (Step(..))
 import Test exposing (Test, describe, fuzz, fuzz2, fuzz3, test)
 
@@ -1001,6 +1001,36 @@ all =
                     Expect.equal (List.Extra.minimumBy (\x -> x.val) [ { id = 1, val = 2 }, { id = 2, val = 1 }, { id = 3, val = 1 } ])
                         (Just { id = 2, val = 1 })
             ]
+        , describe "insertAt"
+            [ fuzz3
+                negativeIntFuzzer
+                Fuzz.int
+                (Fuzz.list Fuzz.int)
+                "negative index returns original list"
+              <|
+                \negativeIndex value list ->
+                    List.Extra.insertAt negativeIndex value list
+                        |> Expect.equalLists list
+            , fuzz2
+                (Fuzz.intRange 0 4)
+                (Fuzz.listOfLengthBetween 4 10 (Fuzz.intRange 0 10))
+                "index in bounds (0 <= index <= length) inserts in the right place in the list"
+              <|
+                \goodIndex list ->
+                    -- -1 is guaranteed to not be in the fuzzed input list
+                    List.Extra.insertAt goodIndex -1 list
+                        |> List.Extra.removeAt goodIndex
+                        |> Expect.equalLists list
+            , fuzz3
+                (Fuzz.intRange 5 10)
+                Fuzz.int
+                (Fuzz.listOfLengthBetween 0 4 Fuzz.int)
+                "index out of bounds returns original list"
+              <|
+                \badPositiveIndex value list ->
+                    List.Extra.insertAt badPositiveIndex value list
+                        |> Expect.equalLists list
+            ]
         , describe "setIf"
             [ test "empty list" <|
                 \() ->
@@ -1204,3 +1234,16 @@ all =
                         |> Expect.equal 50
             ]
         ]
+
+
+negativeIntFuzzer : Fuzzer Int
+negativeIntFuzzer =
+    Fuzz.int
+        |> Fuzz.map
+            (\n ->
+                if n == 0 then
+                    -1
+
+                else
+                    -(abs n)
+            )