Make 'length' fusible

This change makes fusible 'Data.Vector.Generic.length',
which currently can be inlined but doesn't fuse well.
Before this revision, 'length' uses non-fusible 'stream''.
This revision replaces 'stream'' with fusible 'stream',
and at the same time substitute the mutually-recursive
occurrences of 'length' with 'basicLength'.

Rationale:
The current definition was introduced in the commit
a811a86.
Prior to that commit,
'length' could not even be inlined with older GHCs,
which elected 'length' to be a loop-breaker due to the cyclic
references among 'clone', 'unsafeCopy', 'length' and 'stream':
* 'clone' refers to 'length' and 'unsafeCopy' in its definition;
* 'unsafeCopy' refers to 'length' in its definition;
* 'length' referred to 'stream' in its definition;
* 'stream' refers to none of the above in its definition,
  but the rule 'New.unstream/stream' rewrites
  @'New.unstream' ('stream' v)@ with @'clone' v@.
This failure of inlining was reported as
haskell#97.

To be precise, this cycle of references is immaterial with newer
GHCs like GHC 8.8.3.
Since 'New.unstream' does not occur in the definitions of
'clone', 'unsafeCopy', and 'length',
indefinite inlining will not happen anyway.
GHC 8.8.3 seems to detect this immateriality of the
referencial loop in question and refrains from setting 'length' as a
loop-breaker, even with
acdcff3
(the parent commit of a811a86).
However with older GHCs, including GHC 8.0.2, regarded
the cyclic references fatal and marked 'length' as a loop-breaker.
Note that GHC 8.0.2 was current at the time a811a86 was introduced.

The commit a811a86 resolved this by replacing 'stream'
with 'stream'' in the definition of 'length'. The function
'stream' refers to 'clone' in its fusion rule, but 'stream''
doesn't possess any rule. This cut open the cycle of references
and made 'length' inlinable.

However, since 'stream'' doesn't possess any rule, defining
'length' = 'Bundle.length' . 'stream''
is all the same as setting
'length' = 'basicLength'.
This prevents any stream fusion from happening.

This commit resolves this problem by resetting 'length' back
to be @'Bundle.length' . 'stream'@, and instead replacing
cyclic occurrence of 'length' with 'basicLength'
(Just *inlined the simplification result of the definition*).
Now 'length' is both inlinable and fusible, even with older GHCs.

Fixes: haskell#306
See also: haskell#97
  haskell#111
  haskell#155

Author: gksato

Data/Vector/Generic.hs

@@ -222,7 +222,7 @@ import qualified Data.Traversable as T (Traversable(mapM))
 -- | /O(1)/ Yield the length of the vector
 length :: Vector v a => v a -> Int
 {-# INLINE length #-}
-length = Bundle.length . stream'
+length = Bundle.length . stream
 
 -- | /O(1)/ Test whether a vector is empty
 null :: Vector v a => v a -> Bool
@@ -1986,7 +1986,7 @@ copy
   :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> v a -> m ()
 {-# INLINE copy #-}
 copy dst src = BOUNDS_CHECK(check) "copy" "length mismatch"
-                                          (M.length dst == length src)
+                                          (M.length dst == basicLength src)
              $ unsafeCopy dst src
 
 -- | /O(n)/ Copy an immutable vector into a mutable one. The two vectors must
@@ -1995,7 +1995,7 @@ unsafeCopy
   :: (PrimMonad m, Vector v a) => Mutable v (PrimState m) a -> v a -> m ()
 {-# INLINE unsafeCopy #-}
 unsafeCopy dst src = UNSAFE_CHECK(check) "unsafeCopy" "length mismatch"
-                                         (M.length dst == length src)
+                                         (M.length dst == basicLength src)
                    $ (dst `seq` src `seq` basicUnsafeCopy dst src)
 
 -- Conversions to/from Bundles
@@ -2004,13 +2004,7 @@ unsafeCopy dst src = UNSAFE_CHECK(check) "unsafeCopy" "length mismatch"
 -- | /O(1)/ Convert a vector to a 'Bundle'
 stream :: Vector v a => v a -> Bundle v a
 {-# INLINE_FUSED stream #-}
-stream v = stream' v
-
--- Same as 'stream', but can be used to avoid having a cycle in the dependency
--- graph of functions, which forces GHC to create a loop breaker.
-stream' :: Vector v a => v a -> Bundle v a
-{-# INLINE stream' #-}
-stream' v = Bundle.fromVector v
+stream v = Bundle.fromVector v
 
 {-
 stream v = v `seq` n `seq` (Bundle.unfoldr get 0 `Bundle.sized` Exact n)
@@ -2133,7 +2127,7 @@ clone :: Vector v a => v a -> New v a
 {-# INLINE_FUSED clone #-}
 clone v = v `seq` New.create (
   do
-    mv <- M.new (length v)
+    mv <- M.new (basicLength v)
     unsafeCopy mv v
     return mv)