Effectful finds

Author: jacereda

src/Data/ArrayBuffer/Typed.purs

@@ -84,10 +84,10 @@ foreign import reduceImpl :: forall a b c. EffectFn3 (ArrayView a) (EffectFn3 c
 foreign import reduce1Impl :: forall a b. EffectFn2 (ArrayView a) (EffectFn3 b b Offset b) b
 foreign import reduceRightImpl :: forall a b c. EffectFn3 (ArrayView a) (EffectFn3 c b Offset c) c c
 foreign import reduceRight1Impl :: forall a b. EffectFn2 (ArrayView a) (EffectFn3 b b Offset b) b
-foreign import findImpl :: forall a b. Fn2 (ArrayView a) (Fn2 b Offset Boolean) (Nullable b)
-foreign import findIndexImpl :: forall a b. Fn2 (ArrayView a) (Fn2 b Offset Boolean) (Nullable Offset)
-foreign import indexOfImpl :: forall a b. Fn3 (ArrayView a) b (Nullable Offset) (Nullable Offset)
-foreign import lastIndexOfImpl :: forall a b. Fn3 (ArrayView a) b (Nullable Offset) (Nullable Offset)
+foreign import findImpl :: forall a b. EffectFn2 (ArrayView a) (Fn2 b Offset Boolean) (Nullable b)
+foreign import findIndexImpl :: forall a b. EffectFn2 (ArrayView a) (Fn2 b Offset Boolean) (Nullable Offset)
+foreign import indexOfImpl :: forall a b. EffectFn3 (ArrayView a) b (Nullable Offset) (Nullable Offset)
+foreign import lastIndexOfImpl :: forall a b. EffectFn3 (ArrayView a) b (Nullable Offset) (Nullable Offset)
 
 
 -- | Value-oriented array offset
@@ -281,26 +281,26 @@ foldr1M :: forall a t. TypedArray a t => (t -> t -> Offset -> Effect t) -> Array
 foldr1M f a = runEffectFn2 reduceRight1Impl a (mkEffectFn3 (\acc x o -> f x acc o))
 
 -- | Returns the first value satisfying the predicate
-find :: forall a t. TypedArray a t => (t -> Boolean) -> ArrayView a -> Maybe t
+find :: forall a t. TypedArray a t => (t -> Boolean) -> ArrayView a -> Effect (Maybe t)
 find = findWithIndex' <<< ap1
 
-findWithIndex :: forall a t. TypedArray a t => (Offset -> t -> Boolean) -> ArrayView a -> Maybe t
+findWithIndex :: forall a t. TypedArray a t => (Offset -> t -> Boolean) -> ArrayView a -> Effect (Maybe t)
 findWithIndex = findWithIndex' <<< flip
 
-findWithIndex' :: forall a t. TypedArray a t => (t -> Offset -> Boolean) -> ArrayView a -> Maybe t
-findWithIndex' f a = toMaybe (runFn2 findImpl a (mkFn2 f))
+findWithIndex' :: forall a t. TypedArray a t => (t -> Offset -> Boolean) -> ArrayView a -> Effect (Maybe t)
+findWithIndex' f a = toMaybe <$> runEffectFn2 findImpl a (mkFn2 f)
 
 -- | Returns the first index of the value satisfying the predicate
-findIndex :: forall a t. TypedArray a t => (t -> Offset -> Boolean) -> ArrayView a -> Maybe Offset
-findIndex f a = toMaybe (runFn2 findIndexImpl a (mkFn2 f))
+findIndex :: forall a t. TypedArray a t => (t -> Offset -> Boolean) -> ArrayView a -> Effect (Maybe Offset)
+findIndex f a = toMaybe <$> runEffectFn2 findIndexImpl a (mkFn2 f)
 
 -- | Returns the first index of the element, if it exists, from the left
-indexOf :: forall a t. TypedArray a t => t -> Maybe Offset -> ArrayView a -> Maybe Offset
-indexOf x mo a = toMaybe (runFn3 indexOfImpl a x (toNullable mo))
+indexOf :: forall a t. TypedArray a t => t -> Maybe Offset -> ArrayView a -> Effect (Maybe Offset)
+indexOf x mo a = toMaybe <$> runEffectFn3 indexOfImpl a x (toNullable mo)
 
 -- | Returns the first index of the element, if it exists, from the right
-lastIndexOf :: forall a t. TypedArray a t => t -> Maybe Offset -> ArrayView a -> Maybe Offset
-lastIndexOf x mo a = toMaybe (runFn3 lastIndexOfImpl a x (toNullable mo))
+lastIndexOf :: forall a t. TypedArray a t => t -> Maybe Offset -> ArrayView a -> Effect (Maybe Offset)
+lastIndexOf x mo a = toMaybe <$> runEffectFn3 lastIndexOfImpl a x (toNullable mo)
 
 foldl :: forall a b t. TypedArray a t => (b -> t -> b) -> b -> ArrayView a -> b
 foldl f = foldlWithIndex' (\a x _ -> f a x)

test/Properties/TypedArray.purs

@@ -305,16 +305,16 @@ anyImpliesFindTests :: Ref Int -> Effect Unit
 anyImpliesFindTests count = overAll count anyImpliesFind
   where
     anyImpliesFind :: forall a b t. TestableArrayF a b D0 t Result
-    anyImpliesFind (WithOffset _ xs) =
+    anyImpliesFind (WithOffset _ xs) = do
       let pred x = x /= zero
           p = TA.any pred xs <?> "All don't satisfy the predicate"
-          q =
-            case TA.find pred xs of
+      idx <- TA.find pred xs
+      let q = case idx of
               Nothing -> Failed "Doesn't have a value satisfying the predicate"
               Just z -> if pred z
                         then Success
                         else Failed "Found value doesn't satisfy the predicate"
-      in  pure $ p ==> q
+      pure $ p ==> q
 
 
 -- | Should work with any arbitrary predicate, but we can't generate them
@@ -324,7 +324,7 @@ findIndexImpliesAtTests count = overAll count findIndexImpliesAt
     findIndexImpliesAt :: forall a b t. TestableArrayF a b D0 t Result
     findIndexImpliesAt (WithOffset _ xs) = do
       let pred x _ = x /= zero
-          mo = TA.findIndex pred xs
+      mo <- TA.findIndex pred xs
       case mo of
         Nothing -> pure Success
         Just o -> do
@@ -338,16 +338,18 @@ findIndexImpliesAtTests count = overAll count findIndexImpliesAt
 indexOfImpliesAtTests :: Ref Int -> Effect Unit
 indexOfImpliesAtTests count = overAll count indexOfImpliesAt
   where
-    indexOfImpliesAt :: forall a b t. TestableArrayF a b D0 t Result
+    indexOfImpliesAt :: forall a b t. TestableArrayF a b D1 t Result
     indexOfImpliesAt (WithOffset _ xs) = do
       e <- TA.at xs 0
       case e of
         Nothing -> pure Success
-        Just y -> case TA.indexOf y Nothing xs of
-          Nothing -> pure $ Failed "no index of"
-          Just o -> do
-            e' <- TA.at xs o
-            pure $ e' === Just y
+        Just y -> do
+          idx <- TA.indexOf y Nothing xs
+          case idx of
+            Nothing -> pure $ Failed "no index of"
+            Just o -> do
+              e' <- TA.at xs o
+              pure $ e' === Just y
 
 
 lastIndexOfImpliesAtTests :: Ref Int -> Effect Unit
@@ -358,11 +360,13 @@ lastIndexOfImpliesAtTests count = overAll count lastIndexOfImpliesAt
       e <- TA.at xs 0
       case e of
         Nothing -> pure Success
-        Just y -> case TA.lastIndexOf y Nothing xs of
-          Nothing -> pure $ Failed "no lastIndex of"
-          Just o -> do
-            e' <- TA.at xs o
-            pure $ e' === Just y
+        Just y -> do
+          idx <- TA.lastIndexOf y Nothing xs
+          case idx of
+            Nothing -> pure $ Failed "no lastIndex of"
+            Just o -> do
+              e' <- TA.at xs o
+              pure $ e' === Just y
 
 
 foldrConsIsToArrayTests :: Ref Int -> Effect Unit