Merge pull request #83 from safareli/index

add Indexl and indexr

Author: garyb

package.json

@@ -7,8 +7,8 @@
   },
   "devDependencies": {
     "eslint": "^3.17.1",
-    "pulp": "^10.0.4",
-    "purescript-psa": "^0.5.0-rc.1",
+    "pulp": "^11.0.0",
+    "purescript-psa": "^0.5.1",
     "rimraf": "^2.6.1"
   }
 }

src/Data/Foldable.purs

@@ -19,6 +19,8 @@ module Data.Foldable
   , product
   , elem
   , notElem
+  , indexl
+  , indexr
   , find
   , findMap
   , maximum
@@ -325,6 +327,30 @@ elem = any <<< (==)
 notElem :: forall a f. Foldable f => Eq a => a -> f a -> Boolean
 notElem x = not <<< elem x
 
+-- | Try to get nth element from the left in a data structure
+indexl :: forall a f. Foldable f => Int -> f a -> Maybe a
+indexl idx = _.elem <<< foldl go { elem: Nothing, pos: 0 }
+  where
+  go cursor elem =
+    case cursor.elem of 
+      Just _ -> cursor
+      _ ->
+        if cursor.pos == idx
+          then { elem: Just elem, pos: cursor.pos }
+          else { pos: cursor.pos + 1, elem: cursor.elem }
+
+-- | Try to get nth element from the right in a data structure
+indexr :: forall a f. Foldable f => Int -> f a -> Maybe a
+indexr idx = _.elem <<< foldr go { elem: Nothing, pos: 0 }
+  where
+  go elem cursor =
+    case cursor.elem of 
+      Just _ -> cursor
+      _ ->
+        if cursor.pos == idx
+          then { elem: Just elem, pos: cursor.pos }
+          else { pos: cursor.pos + 1, elem: cursor.elem }
+
 -- | Try to find an element in a data structure which satisfies a predicate.
 find :: forall a f. Foldable f => (a -> Boolean) -> f a -> Maybe a
 find p = foldl go Nothing

test/Main.purs

@@ -7,7 +7,7 @@ import Control.Monad.Eff.Console (CONSOLE, log)
 import Data.Bifoldable (class Bifoldable, bifoldl, bifoldr, bifoldMap, bifoldrDefault, bifoldlDefault, bifoldMapDefaultR, bifoldMapDefaultL)
 import Data.Bifunctor (class Bifunctor, bimap)
 import Data.Bitraversable (class Bitraversable, bisequenceDefault, bitraverse, bisequence, bitraverseDefault)
-import Data.Foldable (class Foldable, find, findMap, fold, foldMap, foldMapDefaultL, foldMapDefaultR, foldl, foldlDefault, foldr, foldrDefault, length, maximum, maximumBy, minimum, minimumBy, null, surroundMap)
+import Data.Foldable (class Foldable, find, findMap, fold, indexl, indexr, foldMap, foldMapDefaultL, foldMapDefaultR, foldl, foldlDefault, foldr, foldrDefault, length, maximum, maximumBy, minimum, minimumBy, null, surroundMap)
 import Data.FoldableWithIndex (class FoldableWithIndex, findWithIndex, foldMapWithIndex, foldMapWithIndexDefaultL, foldMapWithIndexDefaultR, foldlWithIndex, foldlWithIndexDefault, foldrWithIndex, foldrWithIndexDefault, surroundMapWithIndex)
 import Data.Function (on)
 import Data.FunctorWithIndex (class FunctorWithIndex, mapWithIndex)
@@ -95,6 +95,16 @@ main = do
   log "Test bisequenceDefault"
   testBitraversableIOrWith BSD
 
+  log "Test indexl"
+  assert $ indexl 2 [1, 5, 10] == Just 10
+  assert $ indexl 0 [1, 5, 10] == Just 1
+  assert $ indexl 9 [1, 5, 10] == Nothing
+
+  log "Test indexr"
+  assert $ indexr 2 [1, 5, 10] == Just 1
+  assert $ indexr 0 [1, 5, 10] == Just 10
+  assert $ indexr 9 [1, 5, 10] == Nothing
+
   log "Test find"
   assert $ find (_ == 10) [1, 5, 10] == Just 10
   assert $ find (\x -> x `mod` 2 == 0) [1, 4, 10] == Just 4