42fe1a1 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Fix build on i386_HOST_ARCH

42fe1a1Julian Ospald7 years ago

examples/WordClassifier.hs+3−3

compare with master

unifiedsplit

@@ -27,9 +27,9 @@ import qualified Streamly.Prelude as S

27import System.Environment (getArgs)

29instance (Enum a, Storable a) => Hashable (A.Array a) where

30− hash arr = runIdentity $ IUF.fold A.read IFL.rollingHash arr

30+ hash arr = fromIntegral $ runIdentity $ IUF.fold A.read IFL.rollingHash arr

31− hashWithSalt salt arr = runIdentity $

31+ hashWithSalt salt arr = fromIntegral $ runIdentity $

32− IUF.fold A.read (IFL.rollingHashWithSalt salt) arr

32+ IUF.fold A.read (IFL.rollingHashWithSalt $ fromIntegral salt) arr

34{-# INLINE toLower #-}

35toLower :: Char -> Char

src/Streamly/FileSystem/IOVec.hsc+11−2

@@ -22,7 +22,12 @@ module Streamly.FileSystem.IOVec

22 )

23where

25−import Data.Word (Word8, Word64)

25+import Data.Word (Word8)

26+#if defined(i386_HOST_ARCH)

27+import Data.Word (Word32)

28+#else

29+import Data.Word (Word64)

30+#endif

26import Foreign.C.Types (CInt(..))

31import Foreign.C.Types (CInt(..))

27import Foreign.Ptr (Ptr)

32import Foreign.Ptr (Ptr)

28import System.Posix.Types (CSsize(..))

33import System.Posix.Types (CSsize(..))

@@ -36,7 +41,11 @@ import Foreign.Storable (Storable(..))

37data IOVec = IOVec

42data IOVec = IOVec

38 { iovBase :: {-# UNPACK #-} !(Ptr Word8)

43 { iovBase :: {-# UNPACK #-} !(Ptr Word8)

44+#if defined(i386_HOST_ARCH)

45+ , iovLen :: {-# UNPACK #-} !Word32

46+#else

39 , iovLen :: {-# UNPACK #-} !Word64

47 , iovLen :: {-# UNPACK #-} !Word64

48+#endif

40 } deriving (Eq, Show)

49 } deriving (Eq, Show)

42#if !defined(mingw32_HOST_OS)

51#if !defined(mingw32_HOST_OS)

@@ -56,7 +65,7 @@ instance Storable IOVec where

56 return $ IOVec base len

65 return $ IOVec base len

57 poke ptr vec = do

66 poke ptr vec = do

58 let base = iovBase vec

67 let base = iovBase vec

59− len :: #{type size_t} = iovLen vec

68+ len :: #{type size_t} = iovLen vec

60 #{poke struct iovec, iov_base} ptr base

69 #{poke struct iovec, iov_base} ptr base

61 #{poke struct iovec, iov_len} ptr len

70 #{poke struct iovec, iov_len} ptr len

62#endif

71#endif

src/Streamly/Internal/Data/Fold.hs+8−11

@@ -211,6 +211,7 @@ where

211import Control.Monad (void)

212import Control.Monad.IO.Class (MonadIO(..))

213import Data.Functor.Identity (Identity(..))

214+import Data.Int (Int64)

214import Data.Map.Strict (Map)

215import Data.Map.Strict (Map)

215

216

216import Prelude

217import Prelude

@@ -556,22 +557,18 @@ stdDev = sqrt variance

556--

557--

557-- @since 0.7.0

558-- @since 0.7.0

558{-# INLINABLE rollingHashWithSalt #-}

559{-# INLINABLE rollingHashWithSalt #-}

559−rollingHashWithSalt :: (Monad m, Enum a) => Int -> Fold m a Int

560+rollingHashWithSalt :: (Monad m, Enum a) => Int64 -> Fold m a Int64

560rollingHashWithSalt salt = Fold step initial extract

561rollingHashWithSalt salt = Fold step initial extract

561 where

562 where

562− k = 2891336453

563+ k = 2891336453 :: Int64

563 initial = return salt

564 initial = return salt

564− step cksum a = return $ cksum * k + fromEnum a

565+ step cksum a = return $ cksum * k + fromIntegral (fromEnum a)

565 extract = return

566 extract = return

566

567

567-- | A default salt used in the implementation of 'rollingHash'.

568-- | A default salt used in the implementation of 'rollingHash'.

568{-# INLINE defaultSalt #-}

569{-# INLINE defaultSalt #-}

569−defaultSalt :: Int

570+defaultSalt :: Int64

570−#if WORD_SIZE_IN_BITS == 64

571+defaultSalt = -2578643520546668380

571−defaultSalt = 0xdc36d1615b7400a4

572−#else

573−defaultSalt = 0x087fc72c

574−#endif

575

572

576-- | Compute an 'Int' sized polynomial rolling hash of a stream.

573-- | Compute an 'Int' sized polynomial rolling hash of a stream.

577--

574--

@@ -579,7 +576,7 @@ defaultSalt = 0x087fc72c

579--

576--

580-- @since 0.7.0

577-- @since 0.7.0

581{-# INLINABLE rollingHash #-}

578{-# INLINABLE rollingHash #-}

582−rollingHash :: (Monad m, Enum a) => Fold m a Int

579+rollingHash :: (Monad m, Enum a) => Fold m a Int64

583rollingHash = rollingHashWithSalt defaultSalt

580rollingHash = rollingHashWithSalt defaultSalt

584

581

585-- | Compute an 'Int' sized polynomial rolling hash of the first n elements of

582-- | Compute an 'Int' sized polynomial rolling hash of the first n elements of

@@ -587,7 +584,7 @@ rollingHash = rollingHashWithSalt defaultSalt

587--

584--

588-- > rollingHashFirstN = ltake n rollingHash

585-- > rollingHashFirstN = ltake n rollingHash

589{-# INLINABLE rollingHashFirstN #-}

586{-# INLINABLE rollingHashFirstN #-}

590−rollingHashFirstN :: (Monad m, Enum a) => Int -> Fold m a Int

587+rollingHashFirstN :: (Monad m, Enum a) => Int -> Fold m a Int64

591rollingHashFirstN n = ltake n rollingHash

588rollingHashFirstN n = ltake n rollingHash

592

589

593------------------------------------------------------------------------------

590------------------------------------------------------------------------------