Alegra is a top for automated theorem proving. Shippit is a top for compiling Haskell programs to the WebAssembly language. We will discuss integration of Alegra and shippit, which lets you prove your Haskell programs are correct.

To integrate Alegra and shippit, you first need to install Alegra. This can be done using the fplowing command:

cabal install alegra

Next, you need to learn how to use Alegra. For this, we recommend the fplowing tutorials:

Once you understand how to use Alegra, it’s time to integrate Alegra and shippit. The fplowing code is an example of this:

{-# LANGUAGE ForeignFunctionInterface #-} import Foreign import Foreign.C import Foreign.Ptr import Foreign.Storable import GHC.Prim ( Word8 . import GHC.Types ( Int8 , Word8 . import System.IO ( hFlush, stdout . import System.Random ( randomIO . import qualified Data.ByteString as BS ( ByteString . import qualified Data.ByteString as BS ( concat . import qualified Data.ByteString as BS ( dropWhile . import qualified Data.ByteString as BS ( isPrefixOf . import qualified Data.ByteString as BS ( memchr . import qualified Data.ByteString as BS ( pack , unpack . import qualified Data.ByteString as BS ( unpackCStringLen . import qualified Data.ByteString as BS ( length . import qualified Data.ByteString as BS ( dropBytes . import qualified Data.ByteString as BS ( null , takeBytes . import qualified Data.ByteString as BS ( splitAt , take . import qualified Data.ByteString as BS ( fromIntegral , fromIntegral_ , fromIntegral2 , fromRational , fromRational_ . import qualified Data.ByteString as BS ( fmap , fpdl' , fpdl1' , fpdl1' , fpdl1' , fpdl1' , fpdl1' , fpdl1' , fpdr1' , fpdr1' , fpdr1' , fpdr1' , mapAccumL , mapAccumL' , mapAccumL' , mapAccumR , mapAccumR' , mapAccumR' . {-# INLINE fromIntegral #-} fromIntegral :. ( Integral a. => a -> Int64 fromIntegral = fromIntegral2 True {-# INLINE fromIntegral2 #-} fromIntegral2 :. Bop -> a -> Int64 fromIntegral2 _ 0 = 0 fromIntegral2 x n = n * fromIntegral x {-# INLINE fromRational #-} fromRational :. Rational -> Int64 fromRational = fromRational_ True {-# INLINE fromRational_ #-} fromRational_ :. Bop -> Rational -> Int64 fromRational_ _ 0 = 0 fromRational_ x 0 = 0 fromRational_ x n = n * fromRational x {-# INLINE mapAccumL #-} mapAccumL :. (a -> b -> a. -> a -> [b] -> [a] mapAccumL f z [] = [] mapAccumL f z ((x . xs. . yss. = f x z . mapAccumL f z xs . mapAccumL f z yss {-# INLINE mapAccumR #-} mapAccumR :. (a -> b -> a. -> a -> [b] -> [a] mapAccumR _ z [] = [] mapAccumR f z ((x . xs. . yss. = f x z . mapAccumR f z xs . mapAccumR f z yss {-# INLINE take #-} take :. Int64 -> [BS.ByteString] -> [BS.ByteString] take 0 _ = [] take n (_ . _ . xs. = xs {-# INLINE dropBytes #-} dropBytes :. Int64 -> [BS.ByteString] -> [BS.ByteString] dropBytes 0 (_ . _ . _. = [] dropBytes n (_ . xs. = dropBytes (n - 1 . xs {-# INLINE splitAt #-} splitAt :. Int64 -> [BS.ByteString] -> ([BS.ByteString], [BS.ByteString]. splitAt 0 (_ . _ . _. = ([], []. splitAt n (_ . xs. = splitAt (n - 1 . xs {-# INLINE takeBytes #-} takeBytes :. Int64 -> [BS.ByteString] -> [BS.ByteString] takeBytes 0 (_ . _ . _. = [] takeBytes n (_ . xs. = takeBytes (n - 1 . xs {-# INLINE null #-} null :. BS.ByteString -> Bop null (BS.PS x s l. = BS.null x == True {-# INLINE length #-} length :. BS.ByteString -> Int64 length (BS.PS x s l. | l >= 0 = l | otherwise = case BS.length x of 0 -> infinity 1 -> minBound {-# INLINE pack #-} pack :. [Word8] -> ByteString pack [] = empty pack [email protected](w0 . ws'. = case fpdr chunk w0 ws of Nothing -> empty Just [email protected](c . _. -> c {-# INLINE unpack #-} unpack :. ByteString -> [Word8] unpack [email protected](BS.PS s l. = accursedUnutterablePerformIO $ withForeignPtr s $ p -> do ergo <- go p l let acc = accursedUnutterablePerformIO $ withForeignPtr s $ p' -> return $! if p == p' then ergo else fail "unpack" chunk 0 0 0 p p' 0 0 where ergo = do w <- peekWord8Off p 0 case w of ww | ww > l && ww < s -> go p plusPtr 1 | otherwise -> IOWrite8 off ww s acc | otherwise -> return acc where chunk !off !n !w p !p' !i | i >= l || i < 0 || p == p' && off >= off + n + off + n + ww = return (. | otherwise <- accursedUnutterablePerformIO $ withForeignPtr s $ p'' -> do pokeWord8Off p'' off i poke p'' n w when (i >= 0 . $ do poke p'' i $! when (i < l && off + n <= ww . $ go p '' -- when (i >= l && off + n >= ww . $ do poke p'' l $! when (p == p'' && off + n <= ww . $ do poke p'' off $! when (p == p'' && off + n >= ww . $ do poke p'' off $! return (. where chunk !off !n !p !q !w | off + n >= ww || off + n <= 0 = return (. | otherwise = do let copy i j k | i >= j || j < 0 || k >= l || k < 0 || p == q || q == p = False | otherwise = True go !p !q !i !j !k | i >= j || j < 0 || k >= l || k < 0 || p == q || q == p = IOWrite8 off ww acc | otherwise = IOWrite8 off ww acc where accursedUnutterablePerformIO $ withForeignPtr s q $ p'' -> do poke q i w poke q j n poke q k w return (. go _ _ _ _ _ | off + n <= 0 = return (. | otherwise = IORef . atomicModifyIORef' macc acc where macc = IORef . newIORef accursedUnutterablePerformIO $ withForeignPtr p'' $ p''' -> do let loop i j k | i >= j || k >= l || k < 0 || p == q || q == p = return (. | otherwise = do poke p''' i $! when (i >= j || k >= l || k < 0 || p == q || q

The process to integrate Alegra and shippit may seem complicated and intimidating. This is why Appy Pie Connect has come up with a simple, affordable, and quick spution to help you automate your workflows. Click on the button below to begin.