Address review comments

Author: zliu41

vec/src/Data/Vec/DataFamily/SpineStrict.hs

@@ -1,3 +1,4 @@
+{-# LANGUAGE BangPatterns          #-}
 {-# LANGUAGE CPP                   #-}
 {-# LANGUAGE DataKinds             #-}
 {-# LANGUAGE FlexibleInstances     #-}
@@ -851,29 +852,36 @@ ifoldr = getIFoldr $ N.induction1 start step where
 newtype IFoldr a n b = IFoldr { getIFoldr :: (Fin n -> a -> b -> b) -> b -> Vec n a -> b }
 
 scanr :: forall a b n. N.SNatI n => (a -> b -> b) -> b -> Vec n a -> Vec ('S n) b
-scanr f z = getScan $ N.induction1 start step where
-    start :: Scan a 'Z b
-    start = Scan $ \_ -> singleton z
+scanr f z = getScanr $ N.induction1 start step where
+    start :: Scanr a 'Z b
+    start = Scanr $ \_ -> singleton z
 
-    step :: Scan a m b -> Scan a ('S m) b
-    step (Scan go) = Scan $ \(x ::: xs) -> let ys@(y ::: _) = go xs in f x y ::: ys
+    step :: Scanr a m b -> Scanr a ('S m) b
+    step (Scanr go) = Scanr $ \(x ::: xs) -> let ys@(y ::: _) = go xs in f x y ::: ys
 
-newtype Scan a n b = Scan { getScan :: Vec n a -> Vec ('S n) b }
+newtype Scanr a n b = Scanr { getScanr :: Vec n a -> Vec ('S n) b }
 
 scanl :: forall a b n. N.SNatI n => (b -> a -> b) -> b -> Vec n a -> Vec ('S n) b
-scanl f z = reverse . scanr (flip f) z . reverse
+scanl f = getScanl $ N.induction1 start step where
+    start :: Scanl a 'Z b
+    start = Scanl $ \z VNil -> singleton z
+
+    step :: Scanl a m b -> Scanl a ('S m) b
+    step (Scanl go) = Scanl $ \(!acc) (x ::: xs) -> acc ::: go (f acc x) xs
+
+newtype Scanl a n b = Scanl { getScanl :: b -> Vec n a -> Vec ('S n) b }
 
 scanr1 :: forall a n. N.SNatI n => (a -> a -> a) -> Vec n a -> Vec n a
-scanr1 f = getScan1 $ N.induction1 start step where
-    start :: Scan1 'Z a
-    start = Scan1 $ \_ -> VNil
+scanr1 f = getScanr1 $ N.induction1 start step where
+    start :: Scanr1 'Z a
+    start = Scanr1 $ \_ -> VNil
 
-    step :: forall m. N.SNatI m => Scan1 m a -> Scan1 ('S m) a
-    step (Scan1 go) = Scan1 $ \(x ::: xs) -> case N.snat :: N.SNat m of
+    step :: forall m. N.SNatI m => Scanr1 m a -> Scanr1 ('S m) a
+    step (Scanr1 go) = Scanr1 $ \(x ::: xs) -> case N.snat :: N.SNat m of
         N.SZ -> x ::: VNil
         N.SS -> let ys@(y ::: _) = go xs in f x y ::: ys
 
-newtype Scan1 n a = Scan1 { getScan1 :: Vec n a -> Vec n a }
+newtype Scanr1 n a = Scanr1 { getScanr1 :: Vec n a -> Vec n a }
 
 scanl1 :: forall a n. N.SNatI n => (a -> a -> a) -> Vec n a -> Vec n a
 scanl1 f xs = case N.snat :: N.SNat n of

vec/src/Data/Vec/Lazy.hs

@@ -700,7 +700,7 @@ scanr :: forall a b n. (a -> b -> b) -> b -> Vec n a -> Vec ('S n) b
 scanr f z = go where
     go :: Vec m a -> Vec ('S m) b
     go VNil = singleton z
-    go (x ::: xs) = let ys@(y ::: _) = go xs in f x y ::: ys
+    go (x ::: xs) = case go xs of ys@(y ::: _) -> f x y ::: ys
 
 scanl :: forall a b n. (b -> a -> b) -> b -> Vec n a -> Vec ('S n) b
 scanl f = go where
@@ -713,7 +713,7 @@ scanr1 f = go where
     go :: Vec m a -> Vec m a
     go VNil = VNil
     go (x ::: VNil) = x ::: VNil
-    go (x ::: xs@(_ ::: _)) = let ys@(y ::: _) = go xs in f x y ::: ys
+    go (x ::: xs@(_ ::: _)) = case go xs of ys@(y ::: _) -> f x y ::: ys
 
 scanl1 :: forall a n. (a -> a -> a) -> Vec n a -> Vec n a
 scanl1 _ VNil = VNil

vec/src/Data/Vec/Lazy/Inline.hs

@@ -1,3 +1,4 @@
+{-# LANGUAGE BangPatterns          #-}
 {-# LANGUAGE CPP                   #-}
 {-# LANGUAGE DataKinds             #-}
 {-# LANGUAGE FlexibleInstances     #-}
@@ -12,7 +13,7 @@
 -- The hypothesis is that these (goursive) functions could be fully unrolled,
 -- if the 'Vec' size @n@ is known at compile time.
 --
--- The module has the same API as "Data.Vec.Lazy" (sans 'L.withDict', 'foldl'', 'scanl' and 'scanl1').
+-- The module has the same API as "Data.Vec.Lazy" (sans 'L.withDict' and 'foldl'').
 -- /Note:/ instance methods aren't changed, the 'Vec' type is the same.
 module Data.Vec.Lazy.Inline (
     Vec (..),
@@ -53,7 +54,9 @@ module Data.Vec.Lazy.Inline (
     ifoldr,
     -- * Scans
     scanr,
+    scanl,
     scanr1,
+    scanl1,
     -- * Special folds
     length,
     null,
@@ -524,26 +527,42 @@ ifoldr = getIFoldr $ N.induction1 start step where
 newtype IFoldr a n b = IFoldr { getIFoldr :: (Fin n -> a -> b -> b) -> b -> Vec n a -> b }
 
 scanr :: forall a b n. N.SNatI n => (a -> b -> b) -> b -> Vec n a -> Vec ('S n) b
-scanr f z = getScan $ N.induction1 start step where
-    start :: Scan a 'Z b
-    start = Scan $ \_ -> singleton z
+scanr f z = getScanr $ N.induction1 start step where
+    start :: Scanr a 'Z b
+    start = Scanr $ \_ -> singleton z
 
-    step :: Scan a m b -> Scan a ('S m) b
-    step (Scan go) = Scan $ \(x ::: xs) -> let ys@(y ::: _) = go xs in f x y ::: ys
+    step :: Scanr a m b -> Scanr a ('S m) b
+    step (Scanr go) = Scanr $ \(x ::: xs) -> case go xs of
+        ys@(y ::: _) -> f x y ::: ys
 
-newtype Scan a n b = Scan { getScan :: Vec n a -> Vec ('S n) b }
+newtype Scanr a n b = Scanr { getScanr :: Vec n a -> Vec ('S n) b }
+
+scanl :: forall a b n. N.SNatI n => (b -> a -> b) -> b -> Vec n a -> Vec ('S n) b
+scanl f = getScanl $ N.induction1 start step where
+    start :: Scanl a 'Z b
+    start = Scanl $ \z VNil -> singleton z
+
+    step :: Scanl a m b -> Scanl a ('S m) b
+    step (Scanl go) = Scanl $ \(!acc) (x ::: xs) -> acc ::: go (f acc x) xs
+
+newtype Scanl a n b = Scanl { getScanl :: b -> Vec n a -> Vec ('S n) b }
 
 scanr1 :: forall a n. N.SNatI n => (a -> a -> a) -> Vec n a -> Vec n a
-scanr1 f = getScan1 $ N.induction1 start step where
-    start :: Scan1 'Z a
-    start = Scan1 $ \_ -> VNil
+scanr1 f = getScanr1 $ N.induction1 start step where
+    start :: Scanr1 'Z a
+    start = Scanr1 $ \_ -> VNil
 
-    step :: forall m. N.SNatI m => Scan1 m a -> Scan1 ('S m) a
-    step (Scan1 go) = Scan1 $ \(x ::: xs) -> case N.snat :: N.SNat m of
+    step :: forall m. N.SNatI m => Scanr1 m a -> Scanr1 ('S m) a
+    step (Scanr1 go) = Scanr1 $ \(x ::: xs) -> case N.snat :: N.SNat m of
         N.SZ -> x ::: VNil
-        N.SS -> let ys@(y ::: _) = go xs in f x y ::: ys
+        N.SS -> case go xs of ys@(y ::: _) -> f x y ::: ys
+
+newtype Scanr1 n a = Scanr1 { getScanr1 :: Vec n a -> Vec n a }
 
-newtype Scan1 n a = Scan1 { getScan1 :: Vec n a -> Vec n a }
+scanl1 :: forall a n. N.SNatI n => (a -> a -> a) -> Vec n a -> Vec n a
+scanl1 f xs = case N.snat :: N.SNat n of
+    N.SZ -> VNil
+    N.SS -> case xs of y ::: ys -> scanl f y ys
 
 -- | Yield the length of a 'Vec'. /O(n)/
 length :: forall n a. N.SNatI n => Vec n a -> Int

vec/src/Data/Vec/Pull.hs

@@ -12,7 +12,7 @@
 --
 -- The module tries to have same API as "Data.Vec.Lazy", missing bits:
 -- @withDict@, @toPull@, @fromPull@, @traverse@ (and variants),
--- @(++)@, @concat@ and @split@.
+-- @scanr@ (and variants), @(++)@, @concat@ and @split@.
 module Data.Vec.Pull (
     Vec (..),
     -- * Construction
@@ -43,11 +43,6 @@ module Data.Vec.Pull (
     foldr,
     ifoldr,
     foldl',
-    -- * Scans
-    scanr,
-    scanl,
-    scanr1,
-    scanl1,
     -- * Special folds
     length,
     null,
@@ -74,10 +69,7 @@ import Prelude
 import Control.Applicative (Applicative (..), (<$>))
 import Data.Boring         (Boring (..))
 import Data.Fin            (Fin (..))
-import qualified Data.List as List
 import Data.List.NonEmpty  (NonEmpty (..))
-import qualified Data.List.NonEmpty as NonEmpty
-import Data.Maybe          (fromJust)
 import Data.Monoid         (Monoid (..))
 import Data.Nat            (Nat (..))
 import Data.Proxy          (Proxy (..))
@@ -388,18 +380,6 @@ ifoldr f z (Vec v) = I.foldr (\a b -> f a (v a) b) z F.universe
 foldl' :: N.SNatI n => (b -> a -> b) -> b -> Vec n a -> b
 foldl' f z (Vec v) = I.foldl' (\b a -> f b (v a)) z F.universe
 
-scanr :: forall a b n. N.SNatI n => (a -> b -> b) -> b -> Vec n a -> Vec ('S n) b
-scanr f z = fromJust . fromList . NonEmpty.toList . NonEmpty.scanr f z
-
-scanl :: forall a b n. N.SNatI n => (b -> a -> b) -> b -> Vec n a -> Vec ('S n) b
-scanl f z = fromJust . fromList . NonEmpty.toList . NonEmpty.scanl f z
-
-scanr1 :: forall a n. N.SNatI n => (a -> a -> a) -> Vec n a -> Vec n a
-scanr1 f = fromJust . fromList . List.scanr1 f . toList
-
-scanl1 :: forall a n. N.SNatI n => (a -> a -> a) -> Vec n a -> Vec n a
-scanl1 f = fromJust . fromList . List.scanl1 f . toList
-
 -- | Yield the length of a 'Vec'.
 length :: forall n a. N.SNatI n => Vec n a -> Int
 length _ = N.reflectToNum (Proxy :: Proxy n)

vec/test/Inspection.hs

@@ -6,7 +6,6 @@ module Inspection where
 import Prelude hiding (zipWith)
 
 import Data.Fin        (Fin (..))
-import qualified Data.List as List
 import Data.List.NonEmpty (NonEmpty (..))
 import Data.Vec.Lazy   (Vec (..))
 import Test.Inspection
@@ -185,3 +184,51 @@ rhsScanr = (-2) ::: 3 ::: (-1) ::: 4 ::: 0 ::: VNil
 
 inspect $ 'lhsScanr  === 'rhsScanr
 inspect $ 'lhsScanr' =/= 'rhsScanr
+
+-------------------------------------------------------------------------------
+-- scanl
+-------------------------------------------------------------------------------
+
+lhsScanl :: Vec N.Nat5 Int
+lhsScanl = I.scanl (-) 0 $ 1 ::: 2 ::: 3 ::: 4 ::: VNil
+
+lhsScanl' :: Vec N.Nat5 Int
+lhsScanl' = L.scanl (-) 0 $ 1 ::: 2 ::: 3 ::: 4 ::: VNil
+
+rhsScanl :: Vec N.Nat5 Int
+rhsScanl = 0 ::: (-1) ::: (-3) ::: (-6) ::: (-10) ::: VNil
+
+inspect $ 'lhsScanl  === 'rhsScanl
+inspect $ 'lhsScanl' =/= 'rhsScanl
+
+-------------------------------------------------------------------------------
+-- scanr1
+-------------------------------------------------------------------------------
+
+lhsScanr1 :: Vec N.Nat4 Int
+lhsScanr1 = I.scanr1 (-) $ 1 ::: 2 ::: 3 ::: 4 ::: VNil
+
+lhsScanr1' :: Vec N.Nat4 Int
+lhsScanr1' = L.scanr1 (-) $ 1 ::: 2 ::: 3 ::: 4 ::: VNil
+
+rhsScanr1 :: Vec N.Nat4 Int
+rhsScanr1 = (-2) ::: 3 ::: (-1) ::: 4 ::: VNil
+
+inspect $ 'lhsScanr1  === 'rhsScanr1
+inspect $ 'lhsScanr1' =/= 'rhsScanr1
+
+-------------------------------------------------------------------------------
+-- scanl1
+-------------------------------------------------------------------------------
+
+lhsScanl1 :: Vec N.Nat4 Int
+lhsScanl1 = I.scanl1 (-) $ 1 ::: 2 ::: 3 ::: 4 ::: VNil
+
+lhsScanl1' :: Vec N.Nat4 Int
+lhsScanl1' = L.scanl1 (-) $ 1 ::: 2 ::: 3 ::: 4 ::: VNil
+
+rhsScanl1 :: Vec N.Nat4 Int
+rhsScanl1 = 1 ::: (-1) ::: (-4) ::: (-8) ::: VNil
+
+inspect $ 'lhsScanl1  === 'rhsScanl1
+inspect $ 'lhsScanl1' =/= 'rhsScanl1

vec/test/Inspection/DataFamily/SpineStrict.hs

@@ -117,3 +117,27 @@ rhsScanl :: Vec N.Nat5 Int
 rhsScanl = 0 ::: (-1) ::: (-3) ::: (-6) ::: (-10) ::: VNil
 
 inspect $ 'lhsScanl  === 'rhsScanl
+
+-------------------------------------------------------------------------------
+-- scanr1
+-------------------------------------------------------------------------------
+
+lhsScanr1 :: Vec N.Nat4 Int
+lhsScanr1 = I.scanr1 (-) $ 1 ::: 2 ::: 3 ::: 4 ::: VNil
+
+rhsScanr1 :: Vec N.Nat4 Int
+rhsScanr1 = (-2) ::: 3 ::: (-1) ::: 4 ::: VNil
+
+inspect $ 'lhsScanr1  === 'rhsScanr1
+
+-------------------------------------------------------------------------------
+-- scanl1
+-------------------------------------------------------------------------------
+
+lhsScanl1 :: Vec N.Nat4 Int
+lhsScanl1 = I.scanl1 (-) $ 1 ::: 2 ::: 3 ::: 4 ::: VNil
+
+rhsScanl1 :: Vec N.Nat4 Int
+rhsScanl1 = 1 ::: (-1) ::: (-4) ::: (-8) ::: VNil
+
+inspect $ 'lhsScanl1  === 'rhsScanl1