60d3f39 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Relax version constraints for primitive to >= 0.5.4.0

60d3f39adithyaov7 years ago

src/Streamly/Internal/Data/SmallArray.hs+1−1

compare with master

unifiedsplit

@@ -50,8 +50,8 @@ import Control.Monad (when)

50import Control.Monad.IO.Class (MonadIO, liftIO)

51import GHC.IO (unsafePerformIO)

52import Data.Functor.Identity (runIdentity)

53−import Data.Primitive.SmallArray

54+import Streamly.Internal.Data.SmallArray.Types

55import Streamly.Internal.Data.Unfold.Types (Unfold(..))

56import Streamly.Internal.Data.Fold.Types (Fold(..))

57import Streamly.Internal.Data.Stream.StreamK.Type (IsStream)

src/Streamly/Internal/Data/SmallArray/Types.hs+10−149

@@ -13,7 +13,7 @@

14-- License: BSD3

15--

16−-- Maintainer: libraries@haskell.org

16+-- Maintainer : streamly@composewell.com

17-- Portability: non-portable

18--

19-- Small arrays are boxed (im)mutable arrays.

@@ -36,7 +36,7 @@

36-- The underlying type, 'SmallArray#', was introduced in GHC 7.10, so prior to

37-- that version, this module simply implements small arrays as 'Array'.

39−module Data.Primitive.SmallArray

39+module Streamly.Internal.Data.SmallArray.Types

40 ( SmallArray(..)

41 , SmallMutableArray(..)

42 , newSmallArray

@@ -62,19 +62,14 @@ module Data.Primitive.SmallArray

62 , traverseSmallArrayP

63 ) where

65−

66−#if (__GLASGOW_HASKELL__ >= 710)

67−#define HAVE_SMALL_ARRAY 1

68−#endif

69−

70−#if MIN_VERSION_base(4,7,0)

71import GHC.Exts hiding (toList)

65import GHC.Exts hiding (toList)

72import qualified GHC.Exts

66import qualified GHC.Exts

73−#endif

75import Control.Applicative

68import Control.Applicative

76import Control.Monad

69import Control.Monad

70+#if MIN_VERSION_base(4,9,0)

77import qualified Control.Monad.Fail as Fail

71import qualified Control.Monad.Fail as Fail

72+#endif

78import Control.Monad.Fix

73import Control.Monad.Fix

79import Control.Monad.Primitive

74import Control.Monad.Primitive

80import Control.Monad.ST

75import Control.Monad.ST

@@ -90,66 +85,20 @@ import qualified GHC.ST as GHCST

90import qualified Data.Semigroup as Sem

85import qualified Data.Semigroup as Sem

91#endif

86#endif

92import Text.ParserCombinators.ReadP

87import Text.ParserCombinators.ReadP

93−#if MIN_VERSION_base(4,10,0)

94−import GHC.Exts (runRW#)

95−#elif MIN_VERSION_base(4,9,0)

96−import GHC.Base (runRW#)

97−#endif

99−#if !(HAVE_SMALL_ARRAY)

89+#if MIN_VERSION_base(4,9,0) && !MIN_VERSION_base(4,10,0)

100−import Data.Primitive.Array

90+import GHC.Base (runRW#)

101−import Data.Traversable

102−import qualified Data.Primitive.Array as Array

103#endif

91#endif

104

105#if MIN_VERSION_base(4,9,0) || MIN_VERSION_transformers(0,4,0)

93#if MIN_VERSION_base(4,9,0) || MIN_VERSION_transformers(0,4,0)

106import Data.Functor.Classes (Eq1(..),Ord1(..),Show1(..),Read1(..))

94import Data.Functor.Classes (Eq1(..),Ord1(..),Show1(..),Read1(..))

107#endif

95#endif

108

109−#if HAVE_SMALL_ARRAY

110data SmallArray a = SmallArray (SmallArray# a)

97data SmallArray a = SmallArray (SmallArray# a)

111 deriving Typeable

98 deriving Typeable

112−#else

113−newtype SmallArray a = SmallArray (Array a) deriving

114− ( Eq

115− , Ord

116− , Show

117− , Read

118− , Foldable

119− , Traversable

120− , Functor

121− , Applicative

122− , Alternative

123− , Monad

124− , MonadPlus

125− , MonadZip

126− , MonadFix

127− , Monoid

128− , Typeable

129−#if MIN_VERSION_base(4,9,0) || MIN_VERSION_transformers(0,4,0)

130− , Eq1

131− , Ord1

132− , Show1

133− , Read1

134−#endif

135− )

136−

137−#if MIN_VERSION_base(4,7,0)

138−instance IsList (SmallArray a) where

139− type Item (SmallArray a) = a

140− fromListN n l = SmallArray (fromListN n l)

141− fromList l = SmallArray (fromList l)

142− toList a = Foldable.toList a

143−#endif

144−#endif

145

146−#if HAVE_SMALL_ARRAY

147data SmallMutableArray s a = SmallMutableArray (SmallMutableArray# s a)

100data SmallMutableArray s a = SmallMutableArray (SmallMutableArray# s a)

148 deriving Typeable

101 deriving Typeable

149−#else

150−newtype SmallMutableArray s a = SmallMutableArray (MutableArray s a)

151− deriving (Eq, Typeable)

152−#endif

153

102

154-- | Create a new small mutable array.

103-- | Create a new small mutable array.

155newSmallArray

104newSmallArray

@@ -157,13 +106,9 @@ newSmallArray

157 => Int -- ^ size

106 => Int -- ^ size

158 -> a -- ^ initial contents

107 -> a -- ^ initial contents

159 -> m (SmallMutableArray (PrimState m) a)

108 -> m (SmallMutableArray (PrimState m) a)

160−#if HAVE_SMALL_ARRAY

161newSmallArray (I# i#) x = primitive $ \s ->

109newSmallArray (I# i#) x = primitive $ \s ->

162 case newSmallArray# i# x s of

110 case newSmallArray# i# x s of

163 (# s', sma# #) -> (# s', SmallMutableArray sma# #)

111 (# s', sma# #) -> (# s', SmallMutableArray sma# #)

164−#else

165−newSmallArray n e = SmallMutableArray `liftM` newArray n e

166−#endif

167{-# INLINE newSmallArray #-}

112{-# INLINE newSmallArray #-}

168

113

169-- | Read the element at a given index in a mutable array.

114-- | Read the element at a given index in a mutable array.

@@ -172,12 +117,8 @@ readSmallArray

172 => SmallMutableArray (PrimState m) a -- ^ array

117 => SmallMutableArray (PrimState m) a -- ^ array

173 -> Int -- ^ index

118 -> Int -- ^ index

174 -> m a

119 -> m a

175−#if HAVE_SMALL_ARRAY

176readSmallArray (SmallMutableArray sma#) (I# i#) =

120readSmallArray (SmallMutableArray sma#) (I# i#) =

177 primitive $ readSmallArray# sma# i#

121 primitive $ readSmallArray# sma# i#

178−#else

179−readSmallArray (SmallMutableArray a) = readArray a

180−#endif

181{-# INLINE readSmallArray #-}

122{-# INLINE readSmallArray #-}

182

123

183-- | Write an element at the given idex in a mutable array.

124-- | Write an element at the given idex in a mutable array.

@@ -187,12 +128,8 @@ writeSmallArray

187 -> Int -- ^ index

128 -> Int -- ^ index

188 -> a -- ^ new element

129 -> a -- ^ new element

189 -> m ()

130 -> m ()

190−#if HAVE_SMALL_ARRAY

191writeSmallArray (SmallMutableArray sma#) (I# i#) x =

131writeSmallArray (SmallMutableArray sma#) (I# i#) x =

192 primitive_ $ writeSmallArray# sma# i# x

132 primitive_ $ writeSmallArray# sma# i# x

193−#else

194−writeSmallArray (SmallMutableArray a) = writeArray a

195−#endif

196{-# INLINE writeSmallArray #-}

133{-# INLINE writeSmallArray #-}

197

134

198-- | Look up an element in an immutable array.

135-- | Look up an element in an immutable array.

@@ -223,13 +160,9 @@ indexSmallArrayM

223 => SmallArray a -- ^ array

160 => SmallArray a -- ^ array

224 -> Int -- ^ index

161 -> Int -- ^ index

225 -> m a

162 -> m a

226−#if HAVE_SMALL_ARRAY

227indexSmallArrayM (SmallArray sa#) (I# i#) =

163indexSmallArrayM (SmallArray sa#) (I# i#) =

228 case indexSmallArray# sa# i# of

164 case indexSmallArray# sa# i# of

229 (# x #) -> pure x

165 (# x #) -> pure x

230−#else

231−indexSmallArrayM (SmallArray a) = indexArrayM a

232−#endif

233{-# INLINE indexSmallArrayM #-}

166{-# INLINE indexSmallArrayM #-}

234

167

235-- | Look up an element in an immutable array.

168-- | Look up an element in an immutable array.

@@ -237,22 +170,14 @@ indexSmallArray

237 :: SmallArray a -- ^ array

170 :: SmallArray a -- ^ array

238 -> Int -- ^ index

171 -> Int -- ^ index

239 -> a

172 -> a

240−#if HAVE_SMALL_ARRAY

241indexSmallArray sa i = runIdentity $ indexSmallArrayM sa i

173indexSmallArray sa i = runIdentity $ indexSmallArrayM sa i

242−#else

243−indexSmallArray (SmallArray a) = indexArray a

244−#endif

245{-# INLINE indexSmallArray #-}

174{-# INLINE indexSmallArray #-}

246

175

247-- | Read a value from the immutable array at the given index, returning

176-- | Read a value from the immutable array at the given index, returning

248-- the result in an unboxed unary tuple. This is currently used to implement

177-- the result in an unboxed unary tuple. This is currently used to implement

249-- folds.

178-- folds.

250indexSmallArray## :: SmallArray a -> Int -> (# a #)

179indexSmallArray## :: SmallArray a -> Int -> (# a #)

251−#if HAVE_SMALL_ARRAY

252indexSmallArray## (SmallArray ary) (I# i) = indexSmallArray# ary i

180indexSmallArray## (SmallArray ary) (I# i) = indexSmallArray# ary i

253−#else

254−indexSmallArray## (SmallArray a) = indexArray## a

255−#endif

256{-# INLINE indexSmallArray## #-}

181{-# INLINE indexSmallArray## #-}

257

182

258-- | Create a copy of a slice of an immutable array.

183-- | Create a copy of a slice of an immutable array.

@@ -261,12 +186,8 @@ cloneSmallArray

261 -> Int -- ^ offset

186 -> Int -- ^ offset

262 -> Int -- ^ length

187 -> Int -- ^ length

263 -> SmallArray a

188 -> SmallArray a

264−#if HAVE_SMALL_ARRAY

265cloneSmallArray (SmallArray sa#) (I# i#) (I# j#) =

189cloneSmallArray (SmallArray sa#) (I# i#) (I# j#) =

266 SmallArray (cloneSmallArray# sa# i# j#)

190 SmallArray (cloneSmallArray# sa# i# j#)

267−#else

268−cloneSmallArray (SmallArray a) i j = SmallArray $ cloneArray a i j

269−#endif

270{-# INLINE cloneSmallArray #-}

191{-# INLINE cloneSmallArray #-}

271

192

272-- | Create a copy of a slice of a mutable array.

193-- | Create a copy of a slice of a mutable array.

@@ -276,14 +197,9 @@ cloneSmallMutableArray

276 -> Int -- ^ offset

197 -> Int -- ^ offset

277 -> Int -- ^ length

198 -> Int -- ^ length

278 -> m (SmallMutableArray (PrimState m) a)

199 -> m (SmallMutableArray (PrimState m) a)

279−#if HAVE_SMALL_ARRAY

280cloneSmallMutableArray (SmallMutableArray sma#) (I# o#) (I# l#) =

200cloneSmallMutableArray (SmallMutableArray sma#) (I# o#) (I# l#) =

281 primitive $ \s -> case cloneSmallMutableArray# sma# o# l# s of

201 primitive $ \s -> case cloneSmallMutableArray# sma# o# l# s of

282 (# s', smb# #) -> (# s', SmallMutableArray smb# #)

202 (# s', smb# #) -> (# s', SmallMutableArray smb# #)

283−#else

284−cloneSmallMutableArray (SmallMutableArray ma) i j =

285− SmallMutableArray `liftM` cloneMutableArray ma i j

286−#endif

287{-# INLINE cloneSmallMutableArray #-}

203{-# INLINE cloneSmallMutableArray #-}

288

204

289-- | Create an immutable array corresponding to a slice of a mutable array.

205-- | Create an immutable array corresponding to a slice of a mutable array.

@@ -295,14 +211,9 @@ freezeSmallArray

295 -> Int -- ^ offset

211 -> Int -- ^ offset

296 -> Int -- ^ length

212 -> Int -- ^ length

297 -> m (SmallArray a)

213 -> m (SmallArray a)

298−#if HAVE_SMALL_ARRAY

299freezeSmallArray (SmallMutableArray sma#) (I# i#) (I# j#) =

214freezeSmallArray (SmallMutableArray sma#) (I# i#) (I# j#) =

300 primitive $ \s -> case freezeSmallArray# sma# i# j# s of

215 primitive $ \s -> case freezeSmallArray# sma# i# j# s of

301 (# s', sa# #) -> (# s', SmallArray sa# #)

216 (# s', sa# #) -> (# s', SmallArray sa# #)

302−#else

303−freezeSmallArray (SmallMutableArray ma) i j =

304− SmallArray `liftM` freezeArray ma i j

305−#endif

306{-# INLINE freezeSmallArray #-}

217{-# INLINE freezeSmallArray #-}

307

218

308-- | Render a mutable array immutable.

219-- | Render a mutable array immutable.

@@ -311,14 +222,9 @@ freezeSmallArray (SmallMutableArray ma) i j =

311-- input array after freezing.

222-- input array after freezing.

312unsafeFreezeSmallArray

223unsafeFreezeSmallArray

313 :: PrimMonad m => SmallMutableArray (PrimState m) a -> m (SmallArray a)

224 :: PrimMonad m => SmallMutableArray (PrimState m) a -> m (SmallArray a)

314−#if HAVE_SMALL_ARRAY

315unsafeFreezeSmallArray (SmallMutableArray sma#) =

225unsafeFreezeSmallArray (SmallMutableArray sma#) =

316 primitive $ \s -> case unsafeFreezeSmallArray# sma# s of

226 primitive $ \s -> case unsafeFreezeSmallArray# sma# s of

317 (# s', sa# #) -> (# s', SmallArray sa# #)

227 (# s', sa# #) -> (# s', SmallArray sa# #)

318−#else

319−unsafeFreezeSmallArray (SmallMutableArray ma) =

320− SmallArray `liftM` unsafeFreezeArray ma

321−#endif

322{-# INLINE unsafeFreezeSmallArray #-}

228{-# INLINE unsafeFreezeSmallArray #-}

323

229

324-- | Create a mutable array corresponding to a slice of an immutable array.

230-- | Create a mutable array corresponding to a slice of an immutable array.

@@ -330,14 +236,9 @@ thawSmallArray

330 -> Int -- ^ offset

236 -> Int -- ^ offset

331 -> Int -- ^ length

237 -> Int -- ^ length

332 -> m (SmallMutableArray (PrimState m) a)

238 -> m (SmallMutableArray (PrimState m) a)

333−#if HAVE_SMALL_ARRAY

334thawSmallArray (SmallArray sa#) (I# o#) (I# l#) =

239thawSmallArray (SmallArray sa#) (I# o#) (I# l#) =

335 primitive $ \s -> case thawSmallArray# sa# o# l# s of

240 primitive $ \s -> case thawSmallArray# sa# o# l# s of

336 (# s', sma# #) -> (# s', SmallMutableArray sma# #)

241 (# s', sma# #) -> (# s', SmallMutableArray sma# #)

337−#else

338−thawSmallArray (SmallArray a) off len =

339− SmallMutableArray `liftM` thawArray a off len

340−#endif

341{-# INLINE thawSmallArray #-}

242{-# INLINE thawSmallArray #-}

342

243

343-- | Render an immutable array mutable.

244-- | Render an immutable array mutable.

@@ -345,13 +246,9 @@ thawSmallArray (SmallArray a) off len =

345-- This operation performs no copying, so care must be taken with its use.

246-- This operation performs no copying, so care must be taken with its use.

346unsafeThawSmallArray

247unsafeThawSmallArray

347 :: PrimMonad m => SmallArray a -> m (SmallMutableArray (PrimState m) a)

248 :: PrimMonad m => SmallArray a -> m (SmallMutableArray (PrimState m) a)

348−#if HAVE_SMALL_ARRAY

349unsafeThawSmallArray (SmallArray sa#) =

249unsafeThawSmallArray (SmallArray sa#) =

350 primitive $ \s -> case unsafeThawSmallArray# sa# s of

250 primitive $ \s -> case unsafeThawSmallArray# sa# s of

351 (# s', sma# #) -> (# s', SmallMutableArray sma# #)

251 (# s', sma# #) -> (# s', SmallMutableArray sma# #)

352−#else

353−unsafeThawSmallArray (SmallArray a) = SmallMutableArray `liftM` unsafeThawArray a

354−#endif

355{-# INLINE unsafeThawSmallArray #-}

252{-# INLINE unsafeThawSmallArray #-}

356

253

357-- | Copy a slice of an immutable array into a mutable array.

254-- | Copy a slice of an immutable array into a mutable array.

@@ -363,13 +260,9 @@ copySmallArray

363 -> Int -- ^ source offset

260 -> Int -- ^ source offset

364 -> Int -- ^ length

261 -> Int -- ^ length

365 -> m ()

262 -> m ()

366−#if HAVE_SMALL_ARRAY

367copySmallArray

263copySmallArray

368 (SmallMutableArray dst#) (I# do#) (SmallArray src#) (I# so#) (I# l#) =

264 (SmallMutableArray dst#) (I# do#) (SmallArray src#) (I# so#) (I# l#) =

369 primitive_ $ copySmallArray# src# so# dst# do# l#

265 primitive_ $ copySmallArray# src# so# dst# do# l#

370−#else

371−copySmallArray (SmallMutableArray dst) i (SmallArray src) = copyArray dst i src

372−#endif

373{-# INLINE copySmallArray #-}

266{-# INLINE copySmallArray #-}

374

267

375-- | Copy a slice of one mutable array into another.

268-- | Copy a slice of one mutable array into another.

@@ -381,33 +274,20 @@ copySmallMutableArray

381 -> Int -- ^ source offset

274 -> Int -- ^ source offset

382 -> Int -- ^ length

275 -> Int -- ^ length

383 -> m ()

276 -> m ()

384−#if HAVE_SMALL_ARRAY

385copySmallMutableArray

277copySmallMutableArray

386 (SmallMutableArray dst#) (I# do#)

278 (SmallMutableArray dst#) (I# do#)

387 (SmallMutableArray src#) (I# so#)

279 (SmallMutableArray src#) (I# so#)

388 (I# l#) =

280 (I# l#) =

389 primitive_ $ copySmallMutableArray# src# so# dst# do# l#

281 primitive_ $ copySmallMutableArray# src# so# dst# do# l#

390−#else

391−copySmallMutableArray (SmallMutableArray dst) i (SmallMutableArray src) =

392− copyMutableArray dst i src

393−#endif

394{-# INLINE copySmallMutableArray #-}

282{-# INLINE copySmallMutableArray #-}

395

283

396sizeofSmallArray :: SmallArray a -> Int

284sizeofSmallArray :: SmallArray a -> Int

397−#if HAVE_SMALL_ARRAY

398sizeofSmallArray (SmallArray sa#) = I# (sizeofSmallArray# sa#)

285sizeofSmallArray (SmallArray sa#) = I# (sizeofSmallArray# sa#)

399−#else

400−sizeofSmallArray (SmallArray a) = sizeofArray a

401−#endif

402{-# INLINE sizeofSmallArray #-}

286{-# INLINE sizeofSmallArray #-}

403

287

404sizeofSmallMutableArray :: SmallMutableArray s a -> Int

288sizeofSmallMutableArray :: SmallMutableArray s a -> Int

405−#if HAVE_SMALL_ARRAY

406sizeofSmallMutableArray (SmallMutableArray sa#) =

289sizeofSmallMutableArray (SmallMutableArray sa#) =

407 I# (sizeofSmallMutableArray# sa#)

290 I# (sizeofSmallMutableArray# sa#)

408−#else

409−sizeofSmallMutableArray (SmallMutableArray ma) = sizeofMutableArray ma

410−#endif

411{-# INLINE sizeofSmallMutableArray #-}

291{-# INLINE sizeofSmallMutableArray #-}

412

292

413-- | This is the fastest, most straightforward way to traverse

293-- | This is the fastest, most straightforward way to traverse

@@ -420,7 +300,6 @@ traverseSmallArrayP

420 => (a -> m b)

300 => (a -> m b)

421 -> SmallArray a

301 -> SmallArray a

422 -> m (SmallArray b)

302 -> m (SmallArray b)

423−#if HAVE_SMALL_ARRAY

424traverseSmallArrayP f = \ !ary ->

303traverseSmallArrayP f = \ !ary ->

425 let

304 let

426 !sz = sizeofSmallArray ary

305 !sz = sizeofSmallArray ary

@@ -436,33 +315,19 @@ traverseSmallArrayP f = \ !ary ->

436 in do

315 in do

437 mary <- newSmallArray sz badTraverseValue

316 mary <- newSmallArray sz badTraverseValue

438 go 0 mary

317 go 0 mary

439−#else

440−traverseSmallArrayP f (SmallArray ar) = SmallArray `liftM` traverseArrayP f ar

441−#endif

442{-# INLINE traverseSmallArrayP #-}

318{-# INLINE traverseSmallArrayP #-}

443

319

444-- | Strict map over the elements of the array.

320-- | Strict map over the elements of the array.

445mapSmallArray' :: (a -> b) -> SmallArray a -> SmallArray b

321mapSmallArray' :: (a -> b) -> SmallArray a -> SmallArray b

446−#if HAVE_SMALL_ARRAY

447mapSmallArray' f sa = createSmallArray (length sa) (die "mapSmallArray'" "impossible") $ \smb ->

322mapSmallArray' f sa = createSmallArray (length sa) (die "mapSmallArray'" "impossible") $ \smb ->

448 fix ? 0 $ \go i ->

323 fix ? 0 $ \go i ->

449 when (i < length sa) $ do

324 when (i < length sa) $ do

450 x <- indexSmallArrayM sa i

325 x <- indexSmallArrayM sa i

451 let !y = f x

326 let !y = f x

452 writeSmallArray smb i y *> go (i+1)

327 writeSmallArray smb i y *> go (i+1)

453−#else

454−mapSmallArray' f (SmallArray ar) = SmallArray (mapArray' f ar)

455−#endif

456{-# INLINE mapSmallArray' #-}

328{-# INLINE mapSmallArray' #-}

457

329

458−#ifndef HAVE_SMALL_ARRAY

459−runSmallArray

460− :: (forall s. ST s (SmallMutableArray s a))

461− -> SmallArray a

462−runSmallArray m = SmallArray $ runArray $

463− m >>= \(SmallMutableArray mary) -> return mary

464−

465−#elif !MIN_VERSION_base(4,9,0)

330+#if !MIN_VERSION_base(4,9,0)

466runSmallArray

331runSmallArray

467 :: (forall s. ST s (SmallMutableArray s a))

332 :: (forall s. ST s (SmallMutableArray s a))

468 -> SmallArray a

333 -> SmallArray a

@@ -493,7 +358,6 @@ unST (GHCST.ST f) = f

493

358

494#endif

359#endif

495

360

496−#if HAVE_SMALL_ARRAY

497-- See the comment on runSmallArray for why we use emptySmallArray#.

361-- See the comment on runSmallArray for why we use emptySmallArray#.

498createSmallArray

362createSmallArray

499 :: Int

363 :: Int

@@ -809,12 +673,14 @@ instance Monad SmallArray where

809 copySmallArray smb off sb 0 (length sb)

673 copySmallArray smb off sb 0 (length sb)

810 *> fill (off + length sb) sbs smb

674 *> fill (off + length sb) sbs smb

811

675

812−#if !(MIN_VERSION_base(4,13,0))

676+#if !(MIN_VERSION_base(4,13,0)) && MIN_VERSION_base(4,9,0)

813 fail = Fail.fail

677 fail = Fail.fail

814#endif

678#endif

815

679

680+#if MIN_VERSION_base(4,9,0)

816instance Fail.MonadFail SmallArray where

681instance Fail.MonadFail SmallArray where

817 fail _ = emptySmallArray

682 fail _ = emptySmallArray

683+#endif

818

684

819instance MonadPlus SmallArray where

685instance MonadPlus SmallArray where

820 mzero = empty

686 mzero = empty

@@ -946,12 +812,10 @@ instance (Typeable s, Typeable a) => Data (SmallMutableArray s a) where

946 toConstr _ = die "toConstr" "SmallMutableArray"

812 toConstr _ = die "toConstr" "SmallMutableArray"

947 gunfold _ _ = die "gunfold" "SmallMutableArray"

813 gunfold _ _ = die "gunfold" "SmallMutableArray"

948 dataTypeOf _ = mkNoRepType "Data.Primitive.SmallArray.SmallMutableArray"

814 dataTypeOf _ = mkNoRepType "Data.Primitive.SmallArray.SmallMutableArray"

949−#endif

950

815

951-- | Create a 'SmallArray' from a list of a known length. If the length

816-- | Create a 'SmallArray' from a list of a known length. If the length

952-- of the list does not match the given length, this throws an exception.

817-- of the list does not match the given length, this throws an exception.

953smallArrayFromListN :: Int -> [a] -> SmallArray a

818smallArrayFromListN :: Int -> [a] -> SmallArray a

954−#if HAVE_SMALL_ARRAY

955smallArrayFromListN n l =

819smallArrayFromListN n l =

956 createSmallArray n

820 createSmallArray n

957 (die "smallArrayFromListN" "uninitialized element") $ \sma ->

821 (die "smallArrayFromListN" "uninitialized element") $ \sma ->

@@ -964,9 +828,6 @@ smallArrayFromListN n l =

964 go (ix+1) xs

828 go (ix+1) xs

965 else die "smallArrayFromListN" "list length greater than specified size"

829 else die "smallArrayFromListN" "list length greater than specified size"

966 in go 0 l

830 in go 0 l

967−#else

968−smallArrayFromListN n l = SmallArray (Array.fromListN n l)

969−#endif

970

831

971-- | Create a 'SmallArray' from a list.

832-- | Create a 'SmallArray' from a list.

972smallArrayFromList :: [a] -> SmallArray a

833smallArrayFromList :: [a] -> SmallArray a

streamly.cabal+2−1

@@ -308,6 +308,7 @@ library

308 , Streamly.Internal.Data.Array

309 , Streamly.Internal.Data.Prim.Array.Types

310 , Streamly.Internal.Data.Prim.Array

311+ , Streamly.Internal.Data.SmallArray.Types

311 , Streamly.Internal.Data.SmallArray

312 , Streamly.Internal.Data.SmallArray

312 , Streamly.Internal.Memory.Array.Types

313 , Streamly.Internal.Memory.Array.Types

313 , Streamly.Internal.Memory.Array

314 , Streamly.Internal.Memory.Array

@@ -371,7 +372,7 @@ library

371 , transformers >= 0.4 && < 0.6

372 , transformers >= 0.4 && < 0.6

372

373

373 , heaps >= 0.3 && < 0.4

374 , heaps >= 0.3 && < 0.4

374− , primitive >= 0.6.2.0 && < 0.8

375+ , primitive >= 0.5.4.0 && < 0.8

375

376

376 -- concurrency

377 -- concurrency

377 , atomic-primops >= 0.8 && < 0.9

378 , atomic-primops >= 0.8 && < 0.9