Search is not available for this dataset
repo_name string | path string | license string | full_code string | full_size int64 | uncommented_code string | uncommented_size int64 | function_only_code string | function_only_size int64 | is_commented bool | is_signatured bool | n_ast_errors int64 | ast_max_depth int64 | n_whitespaces int64 | n_ast_nodes int64 | n_ast_terminals int64 | n_ast_nonterminals int64 | loc int64 | cycloplexity int64 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
JPMoresmau/leksah | src/IDE/Utils/ServerConnection.hs | gpl-2.0 | doServerCommand' :: ServerCommand -> (ServerAnswer -> IDEM ()) -> IDEAction
doServerCommand' command cont = do
server' <- readIDE server
case server' of
Just handle -> do
isOpen <- liftIO $ hIsOpen handle
if isOpen
then void (doCommand handle)
else do
modifyIDE_ (\ ide -> ide{server = Nothing})
doServerCommand command cont
Nothing -> do
prefs' <- readIDE prefs
handle <- reifyIDE $ \ideR ->
catch (connectTo (T.unpack $ serverIP prefs') (PortNumber (fromIntegral $ serverPort prefs')))
(\(exc :: SomeException) -> do
catch (startServer (serverPort prefs'))
(\(exc :: SomeException) -> throwIDE ("Can't start leksah-server" <> T.pack (show exc)))
mbHandle <- waitForServer prefs' 100
case mbHandle of
Just handle -> return handle
Nothing -> throwIDE "Can't connect to leksah-server")
modifyIDE_ (\ ide -> ide{server = Just handle})
doCommand handle
return ()
where
doCommand handle = do
postAsyncIDE . void $ triggerEventIDE (StatusbarChanged [CompartmentCollect True])
resp <- liftIO $ do
debugM "leksah" $ "Sending server command " ++ show command
hPrint handle command
hFlush handle
debugM "leksah" $ "Waiting on server command " ++ show command
hGetLine handle
liftIO . debugM "leksah" $ "Server result " ++ resp
postAsyncIDE $ do
triggerEventIDE (StatusbarChanged [CompartmentCollect False])
cont (read resp) | 1,864 | doServerCommand' :: ServerCommand -> (ServerAnswer -> IDEM ()) -> IDEAction
doServerCommand' command cont = do
server' <- readIDE server
case server' of
Just handle -> do
isOpen <- liftIO $ hIsOpen handle
if isOpen
then void (doCommand handle)
else do
modifyIDE_ (\ ide -> ide{server = Nothing})
doServerCommand command cont
Nothing -> do
prefs' <- readIDE prefs
handle <- reifyIDE $ \ideR ->
catch (connectTo (T.unpack $ serverIP prefs') (PortNumber (fromIntegral $ serverPort prefs')))
(\(exc :: SomeException) -> do
catch (startServer (serverPort prefs'))
(\(exc :: SomeException) -> throwIDE ("Can't start leksah-server" <> T.pack (show exc)))
mbHandle <- waitForServer prefs' 100
case mbHandle of
Just handle -> return handle
Nothing -> throwIDE "Can't connect to leksah-server")
modifyIDE_ (\ ide -> ide{server = Just handle})
doCommand handle
return ()
where
doCommand handle = do
postAsyncIDE . void $ triggerEventIDE (StatusbarChanged [CompartmentCollect True])
resp <- liftIO $ do
debugM "leksah" $ "Sending server command " ++ show command
hPrint handle command
hFlush handle
debugM "leksah" $ "Waiting on server command " ++ show command
hGetLine handle
liftIO . debugM "leksah" $ "Server result " ++ resp
postAsyncIDE $ do
triggerEventIDE (StatusbarChanged [CompartmentCollect False])
cont (read resp) | 1,864 | doServerCommand' command cont = do
server' <- readIDE server
case server' of
Just handle -> do
isOpen <- liftIO $ hIsOpen handle
if isOpen
then void (doCommand handle)
else do
modifyIDE_ (\ ide -> ide{server = Nothing})
doServerCommand command cont
Nothing -> do
prefs' <- readIDE prefs
handle <- reifyIDE $ \ideR ->
catch (connectTo (T.unpack $ serverIP prefs') (PortNumber (fromIntegral $ serverPort prefs')))
(\(exc :: SomeException) -> do
catch (startServer (serverPort prefs'))
(\(exc :: SomeException) -> throwIDE ("Can't start leksah-server" <> T.pack (show exc)))
mbHandle <- waitForServer prefs' 100
case mbHandle of
Just handle -> return handle
Nothing -> throwIDE "Can't connect to leksah-server")
modifyIDE_ (\ ide -> ide{server = Just handle})
doCommand handle
return ()
where
doCommand handle = do
postAsyncIDE . void $ triggerEventIDE (StatusbarChanged [CompartmentCollect True])
resp <- liftIO $ do
debugM "leksah" $ "Sending server command " ++ show command
hPrint handle command
hFlush handle
debugM "leksah" $ "Waiting on server command " ++ show command
hGetLine handle
liftIO . debugM "leksah" $ "Server result " ++ resp
postAsyncIDE $ do
triggerEventIDE (StatusbarChanged [CompartmentCollect False])
cont (read resp) | 1,788 | false | true | 0 | 28 | 742 | 505 | 234 | 271 | null | null |
nomeata/ghc | compiler/codeGen/CgUtils.hs | bsd-3-clause | baseRegOffset (FloatReg 4) = oFFSET_StgRegTable_rF4 | 58 | baseRegOffset (FloatReg 4) = oFFSET_StgRegTable_rF4 | 58 | baseRegOffset (FloatReg 4) = oFFSET_StgRegTable_rF4 | 58 | false | false | 0 | 6 | 11 | 16 | 7 | 9 | null | null |
roman-smrz/rawe | src/FRP/Rawe/Prelude.hs | bsd-3-clause | -- take n, applied to a list xs, returns the prefix of xs of length n,
-- or xs itself if n > length xs. drop n xs returns the suffix of xs
-- after the first n elements, or [] if n > length xs. splitAt n xs
-- is equivalent to (take n xs, drop n xs).
take :: Bhv Int -> Bhv [a] -> Bhv [a]
take = bfix $ \tk n xs -> ite (n <= 0) nil $ list nil (\x xs -> x ~: tk (n-1) xs) xs | 377 | take :: Bhv Int -> Bhv [a] -> Bhv [a]
take = bfix $ \tk n xs -> ite (n <= 0) nil $ list nil (\x xs -> x ~: tk (n-1) xs) xs | 122 | take = bfix $ \tk n xs -> ite (n <= 0) nil $ list nil (\x xs -> x ~: tk (n-1) xs) xs | 84 | true | true | 2 | 12 | 96 | 107 | 54 | 53 | null | null |
input-output-hk/cardano-sl | explorer/src/Pos/Explorer/TestUtil.hs | apache-2.0 | ----------------------------------------------------------------
-- Function mocks
----------------------------------------------------------------
-- | More predictable generation that doesn't violate the invariants.
generateValidExplorerMockableMode
:: BlockNumber
-> SlotsPerEpoch
-> IO ExplorerMockableMode
generateValidExplorerMockableMode blocksNumber slotsPerEpoch = do
slotStart <- liftIO $ generate $ arbitrary
slotLeaders <- produceSlotLeaders blocksNumber
secretKeys <- produceSecretKeys blocksNumber
blocks <- withDefConfigurations $ \_ _ _ ->
produceBlocksByBlockNumberAndSlots blocksNumber slotsPerEpoch slotLeaders secretKeys
let tipBlock = Prelude.last blocks
let pagedHHs = withDefConfigurations $ \_ _ _ -> createMapPageHHs blocks
let hHsBlunds = withDefConfigurations $ \_ _ _ -> createMapHHsBlund blocks
let epochPageHHs = withDefConfigurations
$ \_ _ _ -> createMapEpochPageHHs blocks slotsPerEpoch
let mapEpochMaxPages = withDefConfigurations
$ \_ _ _ -> createMapEpochMaxPages (keys epochPageHHs)
pure $ ExplorerMockableMode
{ emmGetTipBlock = pure tipBlock
, emmGetPageBlocks = \page -> pure $ pagedHHs ^. at page
, emmGetBlundFromHH = \hh -> pure $ hHsBlunds ^. at hh
, emmGetSlotStart = \_ -> pure $ Just slotStart
, emmGetLeadersFromEpoch = \_ -> pure $ Just slotLeaders
, emmGetEpochBlocks = \epoch page -> pure $ epochPageHHs ^. at (epoch, page)
, emmGetEpochPages = \epoch -> pure $ mapEpochMaxPages ^. at epoch
}
where
createMapPageHHs :: [Block] -> Map Page [HeaderHash]
createMapPageHHs blocks =
fromListWith (++) [ (page, [hHash]) | (page, hHash) <- createPagedHeaderHashesPair blocks]
createMapHHsBlund :: [Block] -> Map HeaderHash Blund
createMapHHsBlund blocks = fromList $ map blockHH blocks
where
blockHH :: Block -> (HeaderHash, Blund)
blockHH block = (headerHash block, (block, createEmptyUndo))
-- | TODO(ks): Need to add `getSlotIndex $ siSlot $ fst blund ^. mainBlockSlot`.
createMapEpochPageHHs
:: [Block]
-> SlotsPerEpoch
-> Map EpochPagedBlocksKey [HeaderHash]
createMapEpochPageHHs blocks slotsPerEpoch' =
unions $ map convertToPagedMap epochBlock
where
epochBlock :: [(EpochIndex, [HeaderHash])]
epochBlock = zip [minBound..] epochHHs
epochHHs :: [[HeaderHash]]
epochHHs = headerHash <<$>> epochBlocks
epochBlocks :: [[Block]]
epochBlocks = splitEvery (fromIntegral slotsPerEpoch') blocks
where
splitEvery :: Int -> [a] -> [[a]]
splitEvery _ [] = []
splitEvery n xs = as : splitEvery n bs
where
(as,bs) = splitAt n xs
createMapEpochMaxPages
:: [EpochPagedBlocksKey]
-> Map Epoch Page
createMapEpochMaxPages epochPages = do
let groupedEpochPages :: [[(Epoch, Page)]]
groupedEpochPages = groupBy ((==) `on` fst) epochPages
fromList $ maximumBy (compare `on` fst) <$> groupedEpochPages
-- | The first aproximation. Ideally, I wanted to have something to generate @Undo@ from
-- @Block@. We could generate @Undo@ from _produceBlocksByBlockNumberAndSlots_, but we
-- need to add quite a bit of logic to it. For now, it's good enough, since we are
-- testing just the "sunny day" scenario, and we don't worry about rollbacks. There
-- are already tests that cover a lot of rollback logic.
-- For a more realistic @Undo@, check @Pos.Chain.Block.VAR.verifyBlocksPrefix@. | 3,739 | generateValidExplorerMockableMode
:: BlockNumber
-> SlotsPerEpoch
-> IO ExplorerMockableMode
generateValidExplorerMockableMode blocksNumber slotsPerEpoch = do
slotStart <- liftIO $ generate $ arbitrary
slotLeaders <- produceSlotLeaders blocksNumber
secretKeys <- produceSecretKeys blocksNumber
blocks <- withDefConfigurations $ \_ _ _ ->
produceBlocksByBlockNumberAndSlots blocksNumber slotsPerEpoch slotLeaders secretKeys
let tipBlock = Prelude.last blocks
let pagedHHs = withDefConfigurations $ \_ _ _ -> createMapPageHHs blocks
let hHsBlunds = withDefConfigurations $ \_ _ _ -> createMapHHsBlund blocks
let epochPageHHs = withDefConfigurations
$ \_ _ _ -> createMapEpochPageHHs blocks slotsPerEpoch
let mapEpochMaxPages = withDefConfigurations
$ \_ _ _ -> createMapEpochMaxPages (keys epochPageHHs)
pure $ ExplorerMockableMode
{ emmGetTipBlock = pure tipBlock
, emmGetPageBlocks = \page -> pure $ pagedHHs ^. at page
, emmGetBlundFromHH = \hh -> pure $ hHsBlunds ^. at hh
, emmGetSlotStart = \_ -> pure $ Just slotStart
, emmGetLeadersFromEpoch = \_ -> pure $ Just slotLeaders
, emmGetEpochBlocks = \epoch page -> pure $ epochPageHHs ^. at (epoch, page)
, emmGetEpochPages = \epoch -> pure $ mapEpochMaxPages ^. at epoch
}
where
createMapPageHHs :: [Block] -> Map Page [HeaderHash]
createMapPageHHs blocks =
fromListWith (++) [ (page, [hHash]) | (page, hHash) <- createPagedHeaderHashesPair blocks]
createMapHHsBlund :: [Block] -> Map HeaderHash Blund
createMapHHsBlund blocks = fromList $ map blockHH blocks
where
blockHH :: Block -> (HeaderHash, Blund)
blockHH block = (headerHash block, (block, createEmptyUndo))
-- | TODO(ks): Need to add `getSlotIndex $ siSlot $ fst blund ^. mainBlockSlot`.
createMapEpochPageHHs
:: [Block]
-> SlotsPerEpoch
-> Map EpochPagedBlocksKey [HeaderHash]
createMapEpochPageHHs blocks slotsPerEpoch' =
unions $ map convertToPagedMap epochBlock
where
epochBlock :: [(EpochIndex, [HeaderHash])]
epochBlock = zip [minBound..] epochHHs
epochHHs :: [[HeaderHash]]
epochHHs = headerHash <<$>> epochBlocks
epochBlocks :: [[Block]]
epochBlocks = splitEvery (fromIntegral slotsPerEpoch') blocks
where
splitEvery :: Int -> [a] -> [[a]]
splitEvery _ [] = []
splitEvery n xs = as : splitEvery n bs
where
(as,bs) = splitAt n xs
createMapEpochMaxPages
:: [EpochPagedBlocksKey]
-> Map Epoch Page
createMapEpochMaxPages epochPages = do
let groupedEpochPages :: [[(Epoch, Page)]]
groupedEpochPages = groupBy ((==) `on` fst) epochPages
fromList $ maximumBy (compare `on` fst) <$> groupedEpochPages
-- | The first aproximation. Ideally, I wanted to have something to generate @Undo@ from
-- @Block@. We could generate @Undo@ from _produceBlocksByBlockNumberAndSlots_, but we
-- need to add quite a bit of logic to it. For now, it's good enough, since we are
-- testing just the "sunny day" scenario, and we don't worry about rollbacks. There
-- are already tests that cover a lot of rollback logic.
-- For a more realistic @Undo@, check @Pos.Chain.Block.VAR.verifyBlocksPrefix@. | 3,520 | generateValidExplorerMockableMode blocksNumber slotsPerEpoch = do
slotStart <- liftIO $ generate $ arbitrary
slotLeaders <- produceSlotLeaders blocksNumber
secretKeys <- produceSecretKeys blocksNumber
blocks <- withDefConfigurations $ \_ _ _ ->
produceBlocksByBlockNumberAndSlots blocksNumber slotsPerEpoch slotLeaders secretKeys
let tipBlock = Prelude.last blocks
let pagedHHs = withDefConfigurations $ \_ _ _ -> createMapPageHHs blocks
let hHsBlunds = withDefConfigurations $ \_ _ _ -> createMapHHsBlund blocks
let epochPageHHs = withDefConfigurations
$ \_ _ _ -> createMapEpochPageHHs blocks slotsPerEpoch
let mapEpochMaxPages = withDefConfigurations
$ \_ _ _ -> createMapEpochMaxPages (keys epochPageHHs)
pure $ ExplorerMockableMode
{ emmGetTipBlock = pure tipBlock
, emmGetPageBlocks = \page -> pure $ pagedHHs ^. at page
, emmGetBlundFromHH = \hh -> pure $ hHsBlunds ^. at hh
, emmGetSlotStart = \_ -> pure $ Just slotStart
, emmGetLeadersFromEpoch = \_ -> pure $ Just slotLeaders
, emmGetEpochBlocks = \epoch page -> pure $ epochPageHHs ^. at (epoch, page)
, emmGetEpochPages = \epoch -> pure $ mapEpochMaxPages ^. at epoch
}
where
createMapPageHHs :: [Block] -> Map Page [HeaderHash]
createMapPageHHs blocks =
fromListWith (++) [ (page, [hHash]) | (page, hHash) <- createPagedHeaderHashesPair blocks]
createMapHHsBlund :: [Block] -> Map HeaderHash Blund
createMapHHsBlund blocks = fromList $ map blockHH blocks
where
blockHH :: Block -> (HeaderHash, Blund)
blockHH block = (headerHash block, (block, createEmptyUndo))
-- | TODO(ks): Need to add `getSlotIndex $ siSlot $ fst blund ^. mainBlockSlot`.
createMapEpochPageHHs
:: [Block]
-> SlotsPerEpoch
-> Map EpochPagedBlocksKey [HeaderHash]
createMapEpochPageHHs blocks slotsPerEpoch' =
unions $ map convertToPagedMap epochBlock
where
epochBlock :: [(EpochIndex, [HeaderHash])]
epochBlock = zip [minBound..] epochHHs
epochHHs :: [[HeaderHash]]
epochHHs = headerHash <<$>> epochBlocks
epochBlocks :: [[Block]]
epochBlocks = splitEvery (fromIntegral slotsPerEpoch') blocks
where
splitEvery :: Int -> [a] -> [[a]]
splitEvery _ [] = []
splitEvery n xs = as : splitEvery n bs
where
(as,bs) = splitAt n xs
createMapEpochMaxPages
:: [EpochPagedBlocksKey]
-> Map Epoch Page
createMapEpochMaxPages epochPages = do
let groupedEpochPages :: [[(Epoch, Page)]]
groupedEpochPages = groupBy ((==) `on` fst) epochPages
fromList $ maximumBy (compare `on` fst) <$> groupedEpochPages
-- | The first aproximation. Ideally, I wanted to have something to generate @Undo@ from
-- @Block@. We could generate @Undo@ from _produceBlocksByBlockNumberAndSlots_, but we
-- need to add quite a bit of logic to it. For now, it's good enough, since we are
-- testing just the "sunny day" scenario, and we don't worry about rollbacks. There
-- are already tests that cover a lot of rollback logic.
-- For a more realistic @Undo@, check @Pos.Chain.Block.VAR.verifyBlocksPrefix@. | 3,415 | true | true | 0 | 14 | 953 | 808 | 429 | 379 | null | null |
nevrenato/Hets_Fork | CSL/quickchecks.hs | gpl-2.0 | finsetC :: (Ord a) => Gen a -> Gen (SetOrInterval a)
finsetC g = fmap (Set . Set.fromList) $ listOf1 g | 102 | finsetC :: (Ord a) => Gen a -> Gen (SetOrInterval a)
finsetC g = fmap (Set . Set.fromList) $ listOf1 g | 102 | finsetC g = fmap (Set . Set.fromList) $ listOf1 g | 49 | false | true | 0 | 10 | 20 | 62 | 29 | 33 | null | null |
ronwalf/ridemap | src/ridemap.hs | bsd-3-clause | gCirc :: Double
gCirc = 20037508.34*2 | 37 | gCirc :: Double
gCirc = 20037508.34*2 | 37 | gCirc = 20037508.34*2 | 21 | false | true | 0 | 5 | 5 | 15 | 8 | 7 | null | null |
shlevy/ghc | compiler/basicTypes/RdrName.hs | bsd-3-clause | extendLocalRdrEnv :: LocalRdrEnv -> Name -> LocalRdrEnv
-- The Name should be a non-top-level thing
extendLocalRdrEnv lre@(LRE { lre_env = env, lre_in_scope = ns }) name
= WARN( isExternalName name, ppr name )
lre { lre_env = extendOccEnv env (nameOccName name) name
, lre_in_scope = extendNameSet ns name } | 326 | extendLocalRdrEnv :: LocalRdrEnv -> Name -> LocalRdrEnv
extendLocalRdrEnv lre@(LRE { lre_env = env, lre_in_scope = ns }) name
= WARN( isExternalName name, ppr name )
lre { lre_env = extendOccEnv env (nameOccName name) name
, lre_in_scope = extendNameSet ns name } | 282 | extendLocalRdrEnv lre@(LRE { lre_env = env, lre_in_scope = ns }) name
= WARN( isExternalName name, ppr name )
lre { lre_env = extendOccEnv env (nameOccName name) name
, lre_in_scope = extendNameSet ns name } | 226 | true | true | 1 | 10 | 67 | 103 | 53 | 50 | null | null |
Spawek/HCPParse | src/Data/Either/Unwrap.hs | mit | whenLeft _ _ = return () | 31 | whenLeft _ _ = return () | 31 | whenLeft _ _ = return () | 31 | false | false | 0 | 6 | 12 | 16 | 7 | 9 | null | null |
diku-dk/futhark | src/Language/Futhark/Prop.hs | isc | decImports ValDec {} = [] | 25 | decImports ValDec {} = [] | 25 | decImports ValDec {} = [] | 25 | false | false | 0 | 6 | 4 | 15 | 7 | 8 | null | null |
mightymoose/liquidhaskell | benchmarks/llrbtree-0.1.1/Data/Set/LLRBTree.hs | bsd-3-clause | ----------------------------------------------------------------
turnR :: RBTree a -> RBTree a
turnR Leaf = error "turnR" | 134 | turnR :: RBTree a -> RBTree a
turnR Leaf = error "turnR" | 68 | turnR Leaf = error "turnR" | 38 | true | true | 0 | 6 | 25 | 28 | 13 | 15 | null | null |
uwap/Idris-dev | src/Idris/Delaborate.hs | bsd-3-clause | pprintErr' i (LoadingFailed fn e) = text "Loading" <+> text fn <+> text "failed:" <+> pprintErr' i e | 101 | pprintErr' i (LoadingFailed fn e) = text "Loading" <+> text fn <+> text "failed:" <+> pprintErr' i e | 101 | pprintErr' i (LoadingFailed fn e) = text "Loading" <+> text fn <+> text "failed:" <+> pprintErr' i e | 101 | false | false | 0 | 8 | 18 | 47 | 20 | 27 | null | null |
tonymorris/language-javascript | src/Language/JavaScript/Parser/AST.hs | bsd-3-clause | ss (NT node _ _) = showStrippedNode node | 40 | ss (NT node _ _) = showStrippedNode node | 40 | ss (NT node _ _) = showStrippedNode node | 40 | false | false | 0 | 6 | 7 | 23 | 10 | 13 | null | null |
spockwangs/scheme.in.haskell | list7.hs | unlicense | -- | Implementing 'cdr'.
-- Rules:
-- (cdr (a b c)) = (b c)
-- (cdr (a b)) = (b)
-- (cdr (a)) = NIL
-- (cdr (a b . c)) = (b . c)
-- (cdr (a . b)) = b
-- (cdr a) = error (not list)
-- (cdr a b) = error (too many args)
cdr :: [LispVal] -> ThrowsError LispVal
cdr [List (x : xs)] = return $ List xs | 309 | cdr :: [LispVal] -> ThrowsError LispVal
cdr [List (x : xs)] = return $ List xs | 78 | cdr [List (x : xs)] = return $ List xs | 38 | true | true | 0 | 11 | 87 | 57 | 32 | 25 | null | null |
lovasko/swim | src/Command/Export/Perform.hs | bsd-2-clause | optionTimestamp :: Parser Bool -- ^ parser
optionTimestamp = switch
$ short 't'
<> long "timestamp"
<> help "Display time values as timestamps" | 158 | optionTimestamp :: Parser Bool
optionTimestamp = switch
$ short 't'
<> long "timestamp"
<> help "Display time values as timestamps" | 146 | optionTimestamp = switch
$ short 't'
<> long "timestamp"
<> help "Display time values as timestamps" | 115 | true | true | 6 | 5 | 37 | 39 | 17 | 22 | null | null |
dmjio/stripe | stripe-core/src/Web/Stripe/Charge.hs | mit | ------------------------------------------------------------------------------
-- | Retrieve all `Charge`s
getCharges
:: StripeRequest GetCharges
getCharges = request
where request = mkStripeRequest GET url params
url = "charges"
params = [] | 268 | getCharges
:: StripeRequest GetCharges
getCharges = request
where request = mkStripeRequest GET url params
url = "charges"
params = [] | 161 | getCharges = request
where request = mkStripeRequest GET url params
url = "charges"
params = [] | 118 | true | true | 2 | 6 | 52 | 45 | 23 | 22 | null | null |
ygale/yesod | yesod-core/Yesod/Core/Handler.hs | mit | -- | Returns a function that runs 'HandlerT' actions inside @IO@.
--
-- Sometimes you want to run an inner 'HandlerT' action outside
-- the control flow of an HTTP request (on the outer 'HandlerT'
-- action). For example, you may want to spawn a new thread:
--
-- @
-- getFooR :: Handler RepHtml
-- getFooR = do
-- runInnerHandler <- handlerToIO
-- liftIO $ forkIO $ runInnerHandler $ do
-- /Code here runs inside GHandler but on a new thread./
-- /This is the inner GHandler./
-- ...
-- /Code here runs inside the request's control flow./
-- /This is the outer GHandler./
-- ...
-- @
--
-- Another use case for this function is creating a stream of
-- server-sent events using 'GHandler' actions (see
-- @yesod-eventsource@).
--
-- Most of the environment from the outer 'GHandler' is preserved
-- on the inner 'GHandler', however:
--
-- * The request body is cleared (otherwise it would be very
-- difficult to prevent huge memory leaks).
--
-- * The cache is cleared (see 'CacheKey').
--
-- Changes to the response made inside the inner 'GHandler' are
-- ignored (e.g., session variables, cookies, response headers).
-- This allows the inner 'GHandler' to outlive the outer
-- 'GHandler' (e.g., on the @forkIO@ example above, a response
-- may be sent to the client without killing the new thread).
handlerToIO :: (MonadIO m1, MonadIO m2) => HandlerT site m1 (HandlerT site IO a -> m2 a)
handlerToIO =
HandlerT $ \oldHandlerData -> do
-- Take just the bits we need from oldHandlerData.
let newReq = oldReq { reqWaiRequest = newWaiReq }
where
oldReq = handlerRequest oldHandlerData
oldWaiReq = reqWaiRequest oldReq
newWaiReq = oldWaiReq { W.requestBody = return mempty
, W.requestBodyLength = W.KnownLength 0
}
oldEnv = handlerEnv oldHandlerData
newState <- liftIO $ do
oldState <- I.readIORef (handlerState oldHandlerData)
return $ oldState { ghsRBC = Nothing
, ghsIdent = 1
, ghsCache = mempty
, ghsCacheBy = mempty
, ghsHeaders = mempty }
-- xx From this point onwards, no references to oldHandlerData xx
liftIO $ evaluate (newReq `seq` oldEnv `seq` newState `seq` ())
-- Return GHandler running function.
return $ \(HandlerT f) ->
liftIO $
runResourceT $ withInternalState $ \resState -> do
-- The state IORef needs to be created here, otherwise it
-- will be shared by different invocations of this function.
newStateIORef <- liftIO (I.newIORef newState)
let newHandlerData =
HandlerData
{ handlerRequest = newReq
, handlerEnv = oldEnv
, handlerState = newStateIORef
, handlerToParent = const ()
, handlerResource = resState
}
liftIO (f newHandlerData)
-- | forkIO for a Handler (run an action in the background)
--
-- Uses 'handlerToIO', liftResourceT, and resourceForkIO
-- for correctness and efficiency
--
-- Since 1.2.8 | 3,194 | handlerToIO :: (MonadIO m1, MonadIO m2) => HandlerT site m1 (HandlerT site IO a -> m2 a)
handlerToIO =
HandlerT $ \oldHandlerData -> do
-- Take just the bits we need from oldHandlerData.
let newReq = oldReq { reqWaiRequest = newWaiReq }
where
oldReq = handlerRequest oldHandlerData
oldWaiReq = reqWaiRequest oldReq
newWaiReq = oldWaiReq { W.requestBody = return mempty
, W.requestBodyLength = W.KnownLength 0
}
oldEnv = handlerEnv oldHandlerData
newState <- liftIO $ do
oldState <- I.readIORef (handlerState oldHandlerData)
return $ oldState { ghsRBC = Nothing
, ghsIdent = 1
, ghsCache = mempty
, ghsCacheBy = mempty
, ghsHeaders = mempty }
-- xx From this point onwards, no references to oldHandlerData xx
liftIO $ evaluate (newReq `seq` oldEnv `seq` newState `seq` ())
-- Return GHandler running function.
return $ \(HandlerT f) ->
liftIO $
runResourceT $ withInternalState $ \resState -> do
-- The state IORef needs to be created here, otherwise it
-- will be shared by different invocations of this function.
newStateIORef <- liftIO (I.newIORef newState)
let newHandlerData =
HandlerData
{ handlerRequest = newReq
, handlerEnv = oldEnv
, handlerState = newStateIORef
, handlerToParent = const ()
, handlerResource = resState
}
liftIO (f newHandlerData)
-- | forkIO for a Handler (run an action in the background)
--
-- Uses 'handlerToIO', liftResourceT, and resourceForkIO
-- for correctness and efficiency
--
-- Since 1.2.8 | 1,866 | handlerToIO =
HandlerT $ \oldHandlerData -> do
-- Take just the bits we need from oldHandlerData.
let newReq = oldReq { reqWaiRequest = newWaiReq }
where
oldReq = handlerRequest oldHandlerData
oldWaiReq = reqWaiRequest oldReq
newWaiReq = oldWaiReq { W.requestBody = return mempty
, W.requestBodyLength = W.KnownLength 0
}
oldEnv = handlerEnv oldHandlerData
newState <- liftIO $ do
oldState <- I.readIORef (handlerState oldHandlerData)
return $ oldState { ghsRBC = Nothing
, ghsIdent = 1
, ghsCache = mempty
, ghsCacheBy = mempty
, ghsHeaders = mempty }
-- xx From this point onwards, no references to oldHandlerData xx
liftIO $ evaluate (newReq `seq` oldEnv `seq` newState `seq` ())
-- Return GHandler running function.
return $ \(HandlerT f) ->
liftIO $
runResourceT $ withInternalState $ \resState -> do
-- The state IORef needs to be created here, otherwise it
-- will be shared by different invocations of this function.
newStateIORef <- liftIO (I.newIORef newState)
let newHandlerData =
HandlerData
{ handlerRequest = newReq
, handlerEnv = oldEnv
, handlerState = newStateIORef
, handlerToParent = const ()
, handlerResource = resState
}
liftIO (f newHandlerData)
-- | forkIO for a Handler (run an action in the background)
--
-- Uses 'handlerToIO', liftResourceT, and resourceForkIO
-- for correctness and efficiency
--
-- Since 1.2.8 | 1,777 | true | true | 2 | 21 | 918 | 399 | 231 | 168 | null | null |
hinneburg/TopicExplorer | creator-server/common/src/TopicExplorer/Configuration/Date.hs | agpl-3.0 | format :: Date -> String
format d =
printf "%04d-%02d-%02d %02d:%02d"
(year d) (month d) (day d) (hour d) (minute d) | 125 | format :: Date -> String
format d =
printf "%04d-%02d-%02d %02d:%02d"
(year d) (month d) (day d) (hour d) (minute d) | 125 | format d =
printf "%04d-%02d-%02d %02d:%02d"
(year d) (month d) (day d) (hour d) (minute d) | 100 | false | true | 0 | 7 | 29 | 61 | 30 | 31 | null | null |
wavewave/lhc-analysis-collection | analysis/2013-08-05-XQLD-prospino_2sq.hs | gpl-3.0 | snd3 (_,a,_) = a | 16 | snd3 (_,a,_) = a | 16 | snd3 (_,a,_) = a | 16 | false | false | 0 | 5 | 3 | 19 | 10 | 9 | null | null |
mstksg/hledger | hledger-lib/Hledger/Read/CsvReader.hs | gpl-3.0 | addDirective :: (DirectiveName, String) -> CsvRules -> CsvRules
addDirective d r = r{rdirectives=d:rdirectives r} | 113 | addDirective :: (DirectiveName, String) -> CsvRules -> CsvRules
addDirective d r = r{rdirectives=d:rdirectives r} | 113 | addDirective d r = r{rdirectives=d:rdirectives r} | 49 | false | true | 0 | 9 | 13 | 55 | 26 | 29 | null | null |
ununsept/lambdaHTTP | Engine.hs | mit | loger :: Config -> SockAddr -> String -> IO ()
loger conf addr request = do
time <- getClockTime
case fileLog conf of
Just file -> appendFile file $
(show addr) ++ " = " ++ (show time) ++ "\n" ++ request
Nothing -> putStrLn $
(show addr) ++ " = " ++ (show time) ++ "\n" ++ request | 328 | loger :: Config -> SockAddr -> String -> IO ()
loger conf addr request = do
time <- getClockTime
case fileLog conf of
Just file -> appendFile file $
(show addr) ++ " = " ++ (show time) ++ "\n" ++ request
Nothing -> putStrLn $
(show addr) ++ " = " ++ (show time) ++ "\n" ++ request | 328 | loger conf addr request = do
time <- getClockTime
case fileLog conf of
Just file -> appendFile file $
(show addr) ++ " = " ++ (show time) ++ "\n" ++ request
Nothing -> putStrLn $
(show addr) ++ " = " ++ (show time) ++ "\n" ++ request | 281 | false | true | 0 | 16 | 106 | 134 | 64 | 70 | null | null |
eugenkiss/mastermind | haskell/Strategies/Entropy.hs | bsd-3-clause | extractGuess' :: StrategyState -> Code
extractGuess' = guess | 60 | extractGuess' :: StrategyState -> Code
extractGuess' = guess | 60 | extractGuess' = guess | 21 | false | true | 0 | 5 | 7 | 15 | 8 | 7 | null | null |
ku-fpg/kansas-amber | System/Hardware/Haskino/Compiler.hs | bsd-3-clause | compileExpr (ModI16 e1 e2) = compileTwoSubExpr "mod16" e1 e2 | 60 | compileExpr (ModI16 e1 e2) = compileTwoSubExpr "mod16" e1 e2 | 60 | compileExpr (ModI16 e1 e2) = compileTwoSubExpr "mod16" e1 e2 | 60 | false | false | 0 | 7 | 8 | 24 | 11 | 13 | null | null |
joelburget/haste-compiler | Tests/Read.hs | bsd-3-clause | strList = "[32,7,6,49,0,9,9]" | 29 | strList = "[32,7,6,49,0,9,9]" | 29 | strList = "[32,7,6,49,0,9,9]" | 29 | false | false | 1 | 5 | 2 | 10 | 3 | 7 | null | null |
urbanslug/ghc | libraries/base/Data/Data.hs | bsd-3-clause | -- | Gets the fixity of a constructor
constrFixity :: Constr -> Fixity
constrFixity = confixity | 95 | constrFixity :: Constr -> Fixity
constrFixity = confixity | 57 | constrFixity = confixity | 24 | true | true | 0 | 7 | 15 | 23 | 10 | 13 | null | null |
kylc/torrent | src/BitTorrent/Bencode.hs | bsd-3-clause | bInt :: Parser Bencode
bInt = BInt <$> (char 'i' *> signed decimal <* char 'e') | 79 | bInt :: Parser Bencode
bInt = BInt <$> (char 'i' *> signed decimal <* char 'e') | 79 | bInt = BInt <$> (char 'i' *> signed decimal <* char 'e') | 56 | false | true | 0 | 9 | 15 | 38 | 18 | 20 | null | null |
beni55/hspec-snap | src/Test/Hspec/Snap.hs | bsd-3-clause | setResult :: Result -> SnapHspecM b ()
setResult r = do (SnapHspecState r' s a i sess bef aft) <- S.get
case r' of
Success -> S.put (SnapHspecState r s a i sess bef aft)
_ -> return ()
-- | Asserts that a given stateful action will produce a specific different result after
-- an action has been run. | 356 | setResult :: Result -> SnapHspecM b ()
setResult r = do (SnapHspecState r' s a i sess bef aft) <- S.get
case r' of
Success -> S.put (SnapHspecState r s a i sess bef aft)
_ -> return ()
-- | Asserts that a given stateful action will produce a specific different result after
-- an action has been run. | 356 | setResult r = do (SnapHspecState r' s a i sess bef aft) <- S.get
case r' of
Success -> S.put (SnapHspecState r s a i sess bef aft)
_ -> return ()
-- | Asserts that a given stateful action will produce a specific different result after
-- an action has been run. | 317 | false | true | 0 | 13 | 115 | 106 | 50 | 56 | null | null |
mfpi/hnars | src/FingerTree.hs | mit | (><) :: (Measured v a) => FingerTree v a -> FingerTree v a -> FingerTree v a
xs >< ys = app3 xs [] ys | 101 | (><) :: (Measured v a) => FingerTree v a -> FingerTree v a -> FingerTree v a
xs >< ys = app3 xs [] ys | 101 | xs >< ys = app3 xs [] ys | 24 | false | true | 0 | 10 | 24 | 62 | 30 | 32 | null | null |
fpco/esqueleto | src/Database/Esqueleto/Internal/Sql.hs | bsd-3-clause | -- | Create a fresh 'Ident'. If possible, use the given
-- 'DBName'.
newIdentFor :: DBName -> SqlQuery Ident
newIdentFor = Q . lift . try . unDBName
where
try orig = do
s <- S.get
let go (t:ts) | t `HS.member` inUse s = go ts
| otherwise = use t
go [] = error "Esqueleto/Sql/newIdentFor: never here"
go (possibilities orig)
possibilities t = t : map addNum [2..]
where
addNum :: Int -> T.Text
addNum = T.append t . T.pack . show
use t = do
S.modify (\s -> s { inUse = HS.insert t (inUse s) })
return (I t)
-- | Information needed to escape and use identifiers. | 673 | newIdentFor :: DBName -> SqlQuery Ident
newIdentFor = Q . lift . try . unDBName
where
try orig = do
s <- S.get
let go (t:ts) | t `HS.member` inUse s = go ts
| otherwise = use t
go [] = error "Esqueleto/Sql/newIdentFor: never here"
go (possibilities orig)
possibilities t = t : map addNum [2..]
where
addNum :: Int -> T.Text
addNum = T.append t . T.pack . show
use t = do
S.modify (\s -> s { inUse = HS.insert t (inUse s) })
return (I t)
-- | Information needed to escape and use identifiers. | 603 | newIdentFor = Q . lift . try . unDBName
where
try orig = do
s <- S.get
let go (t:ts) | t `HS.member` inUse s = go ts
| otherwise = use t
go [] = error "Esqueleto/Sql/newIdentFor: never here"
go (possibilities orig)
possibilities t = t : map addNum [2..]
where
addNum :: Int -> T.Text
addNum = T.append t . T.pack . show
use t = do
S.modify (\s -> s { inUse = HS.insert t (inUse s) })
return (I t)
-- | Information needed to escape and use identifiers. | 563 | true | true | 0 | 14 | 224 | 239 | 116 | 123 | null | null |
nevrenato/Hets_Fork | CASL/ToDoc.hs | gpl-2.0 | mkJunctDoc :: FormExtension f => Bool -> FORMULA f -> Doc -> Doc
mkJunctDoc b f = if isJunct f || b && isQuant f then parens else id | 132 | mkJunctDoc :: FormExtension f => Bool -> FORMULA f -> Doc -> Doc
mkJunctDoc b f = if isJunct f || b && isQuant f then parens else id | 132 | mkJunctDoc b f = if isJunct f || b && isQuant f then parens else id | 67 | false | true | 0 | 8 | 28 | 60 | 29 | 31 | null | null |
AndrewRademacher/hasql-postgres | library/Hasql/Postgres/ErrorCode.hs | mit | -- | Code \"2201F\".
invalid_argument_for_power_function :: ErrorCode = "2201F" | 96 | invalid_argument_for_power_function :: ErrorCode = "2201F" | 75 | invalid_argument_for_power_function :: ErrorCode = "2201F" | 75 | true | false | 0 | 5 | 25 | 12 | 6 | 6 | null | null |
vincenthz/hs-crypto-random | Crypto/Random/Entropy.hs | bsd-3-clause | createTestEntropyPool :: ByteString -> EntropyPool
createTestEntropyPool bs
| B.null bs = error "cannot create entropy pool from an empty bytestring"
| otherwise = unsafePerformIO $ createEntropyPoolWith defaultPoolSize [EntropyBackend $ TestEntropySource bs] | 267 | createTestEntropyPool :: ByteString -> EntropyPool
createTestEntropyPool bs
| B.null bs = error "cannot create entropy pool from an empty bytestring"
| otherwise = unsafePerformIO $ createEntropyPoolWith defaultPoolSize [EntropyBackend $ TestEntropySource bs] | 267 | createTestEntropyPool bs
| B.null bs = error "cannot create entropy pool from an empty bytestring"
| otherwise = unsafePerformIO $ createEntropyPoolWith defaultPoolSize [EntropyBackend $ TestEntropySource bs] | 216 | false | true | 1 | 9 | 38 | 58 | 27 | 31 | null | null |
bacchanalia/KitchenSink | KitchenSink/Qualified.hs | gpl-3.0 | -- |'VG.init'
vg_init = VG.init | 31 | vg_init = VG.init | 17 | vg_init = VG.init | 17 | true | false | 0 | 5 | 4 | 9 | 5 | 4 | null | null |
davidspies/regret-solver | game/src/Data/Dist.hs | gpl-3.0 | withProbability :: Dist a -> Dist (Probability, a)
withProbability (Bottom d) = Bottom (1, d) | 93 | withProbability :: Dist a -> Dist (Probability, a)
withProbability (Bottom d) = Bottom (1, d) | 93 | withProbability (Bottom d) = Bottom (1, d) | 42 | false | true | 0 | 9 | 14 | 49 | 24 | 25 | null | null |
utky/lycopene | src/Lycopene/Print.hs | apache-2.0 | (<&>) :: Printer a -> Printer a -> Printer a
(<&>) = pappend | 60 | (<&>) :: Printer a -> Printer a -> Printer a
(<&>) = pappend | 60 | (<&>) = pappend | 15 | false | true | 0 | 8 | 12 | 38 | 18 | 20 | null | null |
ezyang/ghc | compiler/prelude/THNames.hs | bsd-3-clause | staticEIdKey = mkPreludeMiscIdUnique 298 | 45 | staticEIdKey = mkPreludeMiscIdUnique 298 | 45 | staticEIdKey = mkPreludeMiscIdUnique 298 | 45 | false | false | 0 | 5 | 8 | 9 | 4 | 5 | null | null |
garetxe/cabal | cabal-install/tests/UnitTests/Distribution/Client/Dependency/Modular/Solver.hs | bsd-3-clause | -- | cabal must set enable-lib to false in order to avoid the unavailable
-- dependency. Flags are true by default. The flag choice causes "pkg" to
-- depend on "false-dep".
testBuildable :: String -> ExampleDependency -> TestTree
testBuildable testName unavailableDep =
runTest $ mkTestExtLangPC (Just []) (Just []) [] db testName ["pkg"] expected
where
expected = Just [("false-dep", 1), ("pkg", 1)]
db = [
Right $ exAv "pkg" 1 [
unavailableDep
, ExFlag "enable-lib" (Buildable []) NotBuildable
, ExTest "test" [exFlag "enable-lib"
[ExAny "true-dep"]
[ExAny "false-dep"]]
]
, Right $ exAv "true-dep" 1 []
, Right $ exAv "false-dep" 1 []
]
-- | cabal must choose -flag1 +flag2 for "pkg", which requires packages
-- "flag1-false" and "flag2-true". | 934 | testBuildable :: String -> ExampleDependency -> TestTree
testBuildable testName unavailableDep =
runTest $ mkTestExtLangPC (Just []) (Just []) [] db testName ["pkg"] expected
where
expected = Just [("false-dep", 1), ("pkg", 1)]
db = [
Right $ exAv "pkg" 1 [
unavailableDep
, ExFlag "enable-lib" (Buildable []) NotBuildable
, ExTest "test" [exFlag "enable-lib"
[ExAny "true-dep"]
[ExAny "false-dep"]]
]
, Right $ exAv "true-dep" 1 []
, Right $ exAv "false-dep" 1 []
]
-- | cabal must choose -flag1 +flag2 for "pkg", which requires packages
-- "flag1-false" and "flag2-true". | 760 | testBuildable testName unavailableDep =
runTest $ mkTestExtLangPC (Just []) (Just []) [] db testName ["pkg"] expected
where
expected = Just [("false-dep", 1), ("pkg", 1)]
db = [
Right $ exAv "pkg" 1 [
unavailableDep
, ExFlag "enable-lib" (Buildable []) NotBuildable
, ExTest "test" [exFlag "enable-lib"
[ExAny "true-dep"]
[ExAny "false-dep"]]
]
, Right $ exAv "true-dep" 1 []
, Right $ exAv "false-dep" 1 []
]
-- | cabal must choose -flag1 +flag2 for "pkg", which requires packages
-- "flag1-false" and "flag2-true". | 703 | true | true | 3 | 14 | 305 | 208 | 107 | 101 | null | null |
FranklinChen/stable-maps | System/Mem/StableName/Map.hs | bsd-3-clause | null :: Map f -> Bool
null (Map m) = IntMap.null m | 50 | null :: Map f -> Bool
null (Map m) = IntMap.null m | 50 | null (Map m) = IntMap.null m | 28 | false | true | 0 | 7 | 11 | 32 | 15 | 17 | null | null |
adinapoli/Shelly.hs | test/src/Help.hs | bsd-3-clause | within_dir :: FilePath -> Sh a -> Sh a
within_dir d action =
with_dir d $ chdir d action | 90 | within_dir :: FilePath -> Sh a -> Sh a
within_dir d action =
with_dir d $ chdir d action | 90 | within_dir d action =
with_dir d $ chdir d action | 51 | false | true | 0 | 7 | 20 | 42 | 19 | 23 | null | null |
Noeda/dfterm3 | src/Dfterm3/CP437ToUnicode.hs | isc | cp437ToUnicode 10 = '\x25d9' | 28 | cp437ToUnicode 10 = '\x25d9' | 28 | cp437ToUnicode 10 = '\x25d9' | 28 | false | false | 0 | 5 | 3 | 9 | 4 | 5 | null | null |
parsonsmatt/lambda | src/Lambda/Core.hs | bsd-3-clause | (~>) :: String -> Lambda -> Lambda
v ~> x = Wrap (Abs (Variable v) x) | 69 | (~>) :: String -> Lambda -> Lambda
v ~> x = Wrap (Abs (Variable v) x) | 69 | v ~> x = Wrap (Abs (Variable v) x) | 34 | false | true | 0 | 9 | 15 | 45 | 22 | 23 | null | null |
tabemann/amphibian | src_old/Network/IRC/Client/Amphibian/Commands.hs | bsd-3-clause | rpl_NONE :: MessageCommand
rpl_NONE = "300" | 43 | rpl_NONE :: MessageCommand
rpl_NONE = "300" | 43 | rpl_NONE = "300" | 16 | false | true | 0 | 4 | 5 | 11 | 6 | 5 | null | null |
liamoc/composition-tree | Data/Compositions/Internal.hs | bsd-3-clause | -- | Convert a compositions list into a list of elements. The other direction
-- is provided in the 'Data.Foldable.Foldable' instance. This will perform O(n log n) element compositions.
--
-- __Isomorphism to lists__:
--
-- prop> \(Compositions x) -> fromList (toList x) == x
-- prop> \(x :: [Element]) -> toList (fromList x) == x
--
-- __Is monoid morphism__:
--
-- prop> fromList ([] :: [Element]) == mempty
-- prop> \(a :: [Element]) b -> fromList (a ++ b) == fromList a <> fromList b
fromList :: Monoid a => [a] -> Compositions a
fromList = mconcat . map singleton | 570 | fromList :: Monoid a => [a] -> Compositions a
fromList = mconcat . map singleton | 80 | fromList = mconcat . map singleton | 34 | true | true | 0 | 7 | 103 | 47 | 29 | 18 | null | null |
juodaspaulius/clafer-old-customBNFC | src/Language/Clafer/Intermediate/Analysis.hs | mit | runListT_ :: Monad m => ListT m a -> m ()
runListT_ l = runListT l >> return () | 79 | runListT_ :: Monad m => ListT m a -> m ()
runListT_ l = runListT l >> return () | 79 | runListT_ l = runListT l >> return () | 37 | false | true | 0 | 8 | 18 | 47 | 21 | 26 | null | null |
ComputationWithBoundedResources/ara-inference | doc/tpdb_trs/Haskell/basic_haskell/enumFromThenTo_1.hs | mit | primCmpInt (Neg x) (Neg y) = primCmpNat y x | 43 | primCmpInt (Neg x) (Neg y) = primCmpNat y x | 43 | primCmpInt (Neg x) (Neg y) = primCmpNat y x | 43 | false | false | 0 | 7 | 8 | 28 | 13 | 15 | null | null |
beni55/cryptol | src/Cryptol/TypeCheck/Solver/Numeric/SimplifyExpr.hs | bsd-3-clause | crySimpExprStep :: Expr -> Maybe Expr
crySimpExprStep e =
case crySimpExprStep1 e of
Just e1 -> Just e1
Nothing -> do let e1 = normSum e
guard (e /= e1)
return e1
-- | Make a simplification step, assuming the expression is well-formed. | 282 | crySimpExprStep :: Expr -> Maybe Expr
crySimpExprStep e =
case crySimpExprStep1 e of
Just e1 -> Just e1
Nothing -> do let e1 = normSum e
guard (e /= e1)
return e1
-- | Make a simplification step, assuming the expression is well-formed. | 282 | crySimpExprStep e =
case crySimpExprStep1 e of
Just e1 -> Just e1
Nothing -> do let e1 = normSum e
guard (e /= e1)
return e1
-- | Make a simplification step, assuming the expression is well-formed. | 244 | false | true | 0 | 13 | 89 | 78 | 35 | 43 | null | null |
kovach/web | res2/Unification.hs | gpl-2.0 | freshTerm (Variable var) e@(Env{..}) =
let f = Ref (R freshName)
in (f, e{freshName = freshName + 1, context = M.insert var f context}) | 139 | freshTerm (Variable var) e@(Env{..}) =
let f = Ref (R freshName)
in (f, e{freshName = freshName + 1, context = M.insert var f context}) | 139 | freshTerm (Variable var) e@(Env{..}) =
let f = Ref (R freshName)
in (f, e{freshName = freshName + 1, context = M.insert var f context}) | 139 | false | false | 0 | 11 | 27 | 82 | 43 | 39 | null | null |
krakrjak/ImplicitCAD | Graphics/Implicit/ExtOpenScad/Eval/Expr.hs | agpl-3.0 | patMatch Wild _ = Just [] | 25 | patMatch Wild _ = Just [] | 25 | patMatch Wild _ = Just [] | 25 | false | false | 0 | 6 | 5 | 16 | 7 | 9 | null | null |
chrisdotcode/hackage-server | Distribution/Server/Framework/BackupRestore.hs | bsd-3-clause | fromEntry :: Tar.Entry -> Import ()
fromEntry entry =
case Tar.entryContent entry of
Tar.NormalFile bytes _ -> fromFile (Tar.entryPath entry) bytes
Tar.Directory {} -> return () -- ignore directory entries
Tar.SymbolicLink target -> fromLink (Tar.entryPath entry) (Tar.fromLinkTarget target)
_ -> throwError $ "Unexpected entry in backup tarball: " ++ Tar.entryPath entry | 407 | fromEntry :: Tar.Entry -> Import ()
fromEntry entry =
case Tar.entryContent entry of
Tar.NormalFile bytes _ -> fromFile (Tar.entryPath entry) bytes
Tar.Directory {} -> return () -- ignore directory entries
Tar.SymbolicLink target -> fromLink (Tar.entryPath entry) (Tar.fromLinkTarget target)
_ -> throwError $ "Unexpected entry in backup tarball: " ++ Tar.entryPath entry | 407 | fromEntry entry =
case Tar.entryContent entry of
Tar.NormalFile bytes _ -> fromFile (Tar.entryPath entry) bytes
Tar.Directory {} -> return () -- ignore directory entries
Tar.SymbolicLink target -> fromLink (Tar.entryPath entry) (Tar.fromLinkTarget target)
_ -> throwError $ "Unexpected entry in backup tarball: " ++ Tar.entryPath entry | 371 | false | true | 0 | 11 | 86 | 129 | 61 | 68 | null | null |
thomasjm/ot.hs | test/Control/OperationalTransformation/Text0/Specs.hs | mit | apply :: T.Text -> Text0Operation -> T.Text
apply input op = case C.apply op input of
Left err -> error err
Right x -> x | 124 | apply :: T.Text -> Text0Operation -> T.Text
apply input op = case C.apply op input of
Left err -> error err
Right x -> x | 124 | apply input op = case C.apply op input of
Left err -> error err
Right x -> x | 80 | false | true | 0 | 8 | 28 | 60 | 28 | 32 | null | null |
lorcanmcdonald/mars | src/Mars/Command/Ls.hs | bsd-3-clause | ansiColor Red = ansiWrap "31" | 29 | ansiColor Red = ansiWrap "31" | 29 | ansiColor Red = ansiWrap "31" | 29 | false | false | 0 | 5 | 4 | 12 | 5 | 7 | null | null |
JacquesCarette/literate-scientific-software | code/drasil-example/Drasil/SSP/DataDefs.hs | bsd-2-clause | --Notes
--FIXME: fill empty lists in
lengthBQD :: QDefinition
lengthBQD = mkQuantDef baseWthX lengthBEqn | 105 | lengthBQD :: QDefinition
lengthBQD = mkQuantDef baseWthX lengthBEqn | 67 | lengthBQD = mkQuantDef baseWthX lengthBEqn | 42 | true | true | 0 | 6 | 14 | 26 | 11 | 15 | null | null |
NerdGGuy/wai-middleware-session-stateless | src/Network/Wai/Middleware/Session/Stateless.hs | mit | clearSession :: [ByteString]
-> (Request -> (Response -> IO ResponseReceived) -> IO ResponseReceived)
-> Request
-> (Response -> IO ResponseReceived)
-> IO ResponseReceived
clearSession x app req = foldr (\x' a -> setNullCookie x' a) app x req | 307 | clearSession :: [ByteString]
-> (Request -> (Response -> IO ResponseReceived) -> IO ResponseReceived)
-> Request
-> (Response -> IO ResponseReceived)
-> IO ResponseReceived
clearSession x app req = foldr (\x' a -> setNullCookie x' a) app x req | 307 | clearSession x app req = foldr (\x' a -> setNullCookie x' a) app x req | 70 | false | true | 0 | 12 | 101 | 98 | 49 | 49 | null | null |
denibertovic/haskell | kubernetes/lib/Kubernetes/OpenAPI/ModelLens.hs | bsd-3-clause | -- | 'v1ComponentStatusKind' Lens
v1ComponentStatusKindL :: Lens_' V1ComponentStatus (Maybe Text)
v1ComponentStatusKindL f V1ComponentStatus{..} = (\v1ComponentStatusKind -> V1ComponentStatus { v1ComponentStatusKind, ..} ) <$> f v1ComponentStatusKind | 250 | v1ComponentStatusKindL :: Lens_' V1ComponentStatus (Maybe Text)
v1ComponentStatusKindL f V1ComponentStatus{..} = (\v1ComponentStatusKind -> V1ComponentStatus { v1ComponentStatusKind, ..} ) <$> f v1ComponentStatusKind | 216 | v1ComponentStatusKindL f V1ComponentStatus{..} = (\v1ComponentStatusKind -> V1ComponentStatus { v1ComponentStatusKind, ..} ) <$> f v1ComponentStatusKind | 152 | true | true | 1 | 8 | 23 | 62 | 30 | 32 | null | null |
AlbinTheander/oden | test/Oden/Compiler/InstantiateSpec.hs | mit | recordPoly :: Core.Expr Poly.Type
recordPoly =
Core.RecordInitializer
missing
(Poly.TRecord
missing
(Poly.RExtension missing (Identifier "foo") tvarA (Poly.REmpty missing)))
[Core.FieldInitializer missing (Identifier "foo") (Core.Symbol missing (Identifier "x") tvarA)] | 283 | recordPoly :: Core.Expr Poly.Type
recordPoly =
Core.RecordInitializer
missing
(Poly.TRecord
missing
(Poly.RExtension missing (Identifier "foo") tvarA (Poly.REmpty missing)))
[Core.FieldInitializer missing (Identifier "foo") (Core.Symbol missing (Identifier "x") tvarA)] | 283 | recordPoly =
Core.RecordInitializer
missing
(Poly.TRecord
missing
(Poly.RExtension missing (Identifier "foo") tvarA (Poly.REmpty missing)))
[Core.FieldInitializer missing (Identifier "foo") (Core.Symbol missing (Identifier "x") tvarA)] | 249 | false | true | 0 | 11 | 39 | 108 | 51 | 57 | null | null |
lukexi/cabal | Cabal/Distribution/PackageDescription/Configuration.hs | bsd-3-clause | libFillInDefaults :: Library -> Library
libFillInDefaults lib@(Library { libBuildInfo = bi }) =
lib { libBuildInfo = biFillInDefaults bi } | 142 | libFillInDefaults :: Library -> Library
libFillInDefaults lib@(Library { libBuildInfo = bi }) =
lib { libBuildInfo = biFillInDefaults bi } | 142 | libFillInDefaults lib@(Library { libBuildInfo = bi }) =
lib { libBuildInfo = biFillInDefaults bi } | 102 | false | true | 0 | 10 | 23 | 44 | 24 | 20 | null | null |
edom/ptt | src/Haskell/Interpret/Expression.hs | apache-2.0 | substitute :: String -> Expr -> Expr -> Expr
substitute name rep = go
where
go (Var n) | name == n = rep
go (App a b) = App (go a) (go b)
go (Lam n body) | name /= n = Lam n (go body)
go x = x | 228 | substitute :: String -> Expr -> Expr -> Expr
substitute name rep = go
where
go (Var n) | name == n = rep
go (App a b) = App (go a) (go b)
go (Lam n body) | name /= n = Lam n (go body)
go x = x | 228 | substitute name rep = go
where
go (Var n) | name == n = rep
go (App a b) = App (go a) (go b)
go (Lam n body) | name /= n = Lam n (go body)
go x = x | 183 | false | true | 2 | 8 | 86 | 131 | 63 | 68 | null | null |
drmaruyama/Paraiso | Language/Paraiso/OM/Builder/Boolean.hs | bsd-3-clause | -- | Less than
lt :: CompareOp
lt = mkOp2B A.LT | 47 | lt :: CompareOp
lt = mkOp2B A.LT | 32 | lt = mkOp2B A.LT | 16 | true | true | 0 | 6 | 10 | 23 | 10 | 13 | null | null |
NICTA/validation | test/hunit_tests.hs | bsd-3-clause | main :: IO ()
main = do
c <- runTestTT tests
when (errors c > 0 || failures c > 0) exitFailure | 98 | main :: IO ()
main = do
c <- runTestTT tests
when (errors c > 0 || failures c > 0) exitFailure | 98 | main = do
c <- runTestTT tests
when (errors c > 0 || failures c > 0) exitFailure | 84 | false | true | 0 | 13 | 25 | 61 | 26 | 35 | null | null |
bergmark/purescript | psc-make/Main.hs | mit | mkdirp :: FilePath -> IO ()
mkdirp = createDirectoryIfMissing True . takeDirectory | 82 | mkdirp :: FilePath -> IO ()
mkdirp = createDirectoryIfMissing True . takeDirectory | 82 | mkdirp = createDirectoryIfMissing True . takeDirectory | 54 | false | true | 0 | 7 | 11 | 27 | 13 | 14 | null | null |
kmate/HaRe | old/testing/addCon/B1AST.hs | bsd-3-clause | addedC4 = error "added C4 Float to Data1" | 41 | addedC4 = error "added C4 Float to Data1" | 41 | addedC4 = error "added C4 Float to Data1" | 41 | false | false | 0 | 5 | 7 | 9 | 4 | 5 | null | null |
keera-studios/hsQt | Qtc/Gui/QStyleOptionViewItem.hs | bsd-2-clause | setDecorationAlignment :: QStyleOptionViewItem a -> ((Alignment)) -> IO ()
setDecorationAlignment x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QStyleOptionViewItem_setDecorationAlignment cobj_x0 (toCLong $ qFlags_toInt x1) | 228 | setDecorationAlignment :: QStyleOptionViewItem a -> ((Alignment)) -> IO ()
setDecorationAlignment x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QStyleOptionViewItem_setDecorationAlignment cobj_x0 (toCLong $ qFlags_toInt x1) | 228 | setDecorationAlignment x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QStyleOptionViewItem_setDecorationAlignment cobj_x0 (toCLong $ qFlags_toInt x1) | 153 | false | true | 2 | 9 | 29 | 74 | 35 | 39 | null | null |
luzhuomi/cpp-obs | Language/C/Obfuscate/SSA.hs | apache-2.0 | {- The SSA Language
___ _ _
(Prog) p::= t x (t x) { d b }
(Decl) d::= t x
_
(Block) b::= l:{s} | l:{i,s}
(Stmts) s::= x = e; s | goto l; | return e; | e; s | if e { s } else { s }
_
(Phi) i::= x = phi(g)
_
(Exp) e::= v | e(e)
(Labelled args) g::= l:v
(Labels) l::= l0 | l1 | ...
(Values) v::= x | c
(Types) t::= int | bool | t* | t[] | void
(Loop Envs) \delta = (l_if, e, l_t, l_f)
-}
{-
prettyLB :: LabeledBlock -> String
prettyLB lb = "LB {" ++ "phis:" ++ (show (phis lb)) ++ ", stmts:" ++ (show (lb_stmts lb)) ++ "}"
prettySSA :: SSA -> String
prettySSA ssa = "scope_decls :" ++ (render $ pretty (scoped_decls ssa)) ++ "\n" ++
"labelled_blocks :" ++ (concatMap (\(label, lb) -> (render $ pretty label) ++ ":" ++ (prettyLB lb) ++ ",\n") (M.toList $ labelled_blocks ssa))
-}
-- TODO : incorporating the formal args as allVars
buildSSA :: CFG -> [Ident] -> SSA
buildSSA cfg fargs =
case buildDTree cfg of
{ Nothing -> error "failed to build dominance frontier table"
; Just (dtree, pcm, sdom) ->
let dft = buildDF' (dtree, pcm, sdom, cfg)
allVarsUsed = allVars cfg -- all vars used in this function, local declared, formal args and global
allLocalVars = S.fromList (localDeclaredVars cfg) -- all locally declared vars in this function
-- build a mapping from node label to a
-- set of variables that need to be merged via phi func
-- (note: variables are not yet renamed)
phiLocMap :: M.Map Ident -- node label
[Ident] -- variable idents
phiLocMap = foldl (\m (label,v) -> case M.lookup label m of
{ Nothing -> M.insert label [v] m
; Just vs -> M.update (\_ -> Just $ vs ++ [v]) label m
}) M.empty $ do
{ var <- allVarsUsed -- todo: shall we exclude global vars?
; let phiLocs = phiLoc var cfg dft
; phiLoc <- phiLocs
; return (phiLoc, var)
}
-- given a node's label (as the starting point of the search)
-- a variable (which is not yet renamed), the dom tree
-- to find the label of the node which contains preceding definition of the variable
precDef :: Ident -> Ident -> DTree -> CFG -> Maybe Ident
precDef currLbl var dt cfg =
case M.lookup currLbl phiLocMap of
{ Just vs | var `elem` vs -> Just currLbl -- the var is reassigned through a phi function in the current block
; _ -> -- the var could be reassigned locally
case M.lookup currLbl cfg of
{ Nothing -> error $ "Fatal: Label " ++ show currLbl ++ " is not found in the CFG"
; Just node | var `elem` (lVars node) -> Just currLbl
; Just _ | otherwise ->
case parentOf currLbl dt of
{ Nothing | (var `S.member` formalArguments) ||
(var `S.member` allLocalVars)
-> -- no parent: this is block 0
Just currLbl
-- this could be due to a nested scope var in some inner block of if else or while.
-- we will move it to block 0 (the init block)
-- e.g. refer to the fibiter.c, the variable t
-- this make sense for block 0, all local variables should be lifted and declared in block 0
| otherwise -> Nothing -- as this is to be decided later, it could be a global var
; Just parentLbl -> precDef parentLbl var dt cfg
}
}
}
formalArguments = S.fromList fargs
-- renaming all the variables based on the individual labelled blocks
-- and move all the declaration out.
eachNode :: SSA -> (Ident, Node) -> SSA
eachNode ssa (currLbl, node) = case node of
{ Node statements lvars rvars local_decls precLbls succLbls switchOrLoop ->
let phis_ :: [( Ident -- ^ var being redefined (not yet renamed)
, [(Ident, Maybe Ident)])] -- ^ (incoming block lbl, lbl of preceding blk in which var is redefined)
phis_ = case M.lookup currLbl phiLocMap of
{ Nothing -> []
; Just phiVars -> map (\v ->
let lastDefs =
map (\precLbl ->
let mb_lblVarDefined = precDef precLbl v dtree cfg
in (precLbl, mb_lblVarDefined)) precLbls
in (v, lastDefs)
-- find the preceding node and the renamed variable
) [ v | v <- phiVars, not (v `elem` local_decls) ]
}
-- build the renaming state from the rhs vars with the precDef
-- or from phis_
rnState :: RenameState
rnState = let -- todo, the local_decls should be filtered away from the rVars and local_decls should be appended with the current node label
rnEnvLocal = M.fromList $ map (\var -> (var, var `app` currLbl)) local_decls
rvarsNotLocal = filter (\var -> not (var `M.member` rnEnvLocal)) rvars
rnEnv = case precLbls of
{ [] -> -- entry block -- todo: check, shouldn't be the formal arg?
M.fromList (map (\var ->
if (var `S.member` formalArguments) ||
(var `S.member` allLocalVars)
then (var, var `app` currLbl)
else (var, var) -- global
) rvarsNotLocal)
; [precLbl] -> -- non-phi block
M.fromList (map (\var ->
case precDef precLbl var dtree cfg of
{ Just def_lbl -> (var, var `app` def_lbl)
; Nothing -> -- it is a formal arg and should be redefined in block 0
if (var `S.member` formalArguments) ||
(var `S.member` allLocalVars)
then (var, var `app` (iid (labPref ++ "0")))
else (var, var) -- global
}) rvarsNotLocal)
; precLbls -> -- phi block
M.fromList (map (\var -> case lookup var phis_ of
{ Just _ -> (var, var `app` currLbl)
; Nothing ->
-- not in phi, it's a formal arg and should be redefined in block 0
-- (var, var `app` (iid (labPref ++ "0")))
-- updated: the above is not true, look at sort example, var j in node 7. (7 has preds 4 and 6, both do not redefine j,
-- node 4 & 6 share a common ancestor 3 where j is redefined
case filter isJust $ map (\precLbl -> precDef precLbl var dtree cfg) precLbls of
{ [] -> -- var is global
(var, var)
; (def:defs) | all (\d -> d == def) defs ->
let (Just def_lbl) = def
in (var, var `app` def_lbl)
| otherwise -> error $ "buildSSA: rnState variable " ++ (show var) ++ " has a conflicting preceding definition " ++ (show (def:defs)) ++ "\n current Label " ++ (show currLbl) ++ "\n CFG" ++ (show cfg) ++ "\n Phi loca Map" ++ (show phiLocMap) ++ "\n DFT" ++ (show dft)
}
}) rvarsNotLocal)
}
in RSt currLbl (rnEnvLocal `M.union` rnEnv) [] [] allLocalVars formalArguments
renamedBlkItems_decls_containers :: ([AST.CCompoundBlockItem N.NodeInfo], [AST.CDeclaration N.NodeInfo], [Ident])
renamedBlkItems_decls_containers = renamePure rnState statements
(renamedBlkItems, new_decls, containers) = renamedBlkItems_decls_containers
-- scalar copy for container variables eg. say a[] then a[i] = a[j] --> a_2 = a_1; a_2[i_2] = a_1[j_2];
-- and insert them to the begining of the labeled block
scalar_copy :: [Ident] -> [AST.CCompoundBlockItem N.NodeInfo]
scalar_copy containers =
concatMap (\container -> -- lookup the last def of container variable, similar to building rnState
let containers' = case precLbls of
{ [] -> [] -- entry block
; [precLbl] -> case precDef precLbl container dtree cfg of
{ Just def_lbl -> [container `app` def_lbl]
; Nothing -> [container `app` (iid (labPref ++ "0"))]
}
; precLbls -> case lookup container phis_ of -- phi block
{ Just _ -> [] -- should be covered by the phi translations
; Nothing ->
case filter isJust $ map (\precLbl -> precDef precLbl container dtree cfg) precLbls of
{ [] -> error "impossible"
; (def:defs) | (all (\d -> d == def) defs) ->
let (Just def_lbl) = def
in [container `app` def_lbl]
| otherwise -> error $ "buildSSA: scalar copy variable " ++ (show container) ++ " has a conflicting preceding definition"
}
}
}
in map (\container' -> AST.CBlockStmt (AST.CExpr (Just ((cvar (container `app` currLbl)) .=. (cvar container'))) N.undefNode)) containers'
) containers
isLoop x = case x of { (IsLoop _ _) -> True ; _ -> False }
labelled_block = LB phis_ ((scalar_copy containers) ++ renamedBlkItems) precLbls succLbls (lVars node) (rVars node) containers (isLoop switchOrLoop)
in ssa{ labelled_blocks = M.insert currLbl labelled_block (labelled_blocks ssa)
, scoped_decls = (scoped_decls ssa) ++ new_decls }
}
ssa = foldl eachNode (SSA [] M.empty sdom allLocalVars formalArguments) $ M.toList cfg
io = unsafePerformIO $ print cfg >> print ssa >> print dft >> print pcm >> print dtree -- (map (\var -> (var, modLoc var cfg)) allVarsUsed) >> print dtree >> print dft >> print pcm >> print sdom
in ssa -- the scoped_decls were not yet renamed which will be renamed in SSA to CPS convertion
} | 13,211 | buildSSA :: CFG -> [Ident] -> SSA
buildSSA cfg fargs =
case buildDTree cfg of
{ Nothing -> error "failed to build dominance frontier table"
; Just (dtree, pcm, sdom) ->
let dft = buildDF' (dtree, pcm, sdom, cfg)
allVarsUsed = allVars cfg -- all vars used in this function, local declared, formal args and global
allLocalVars = S.fromList (localDeclaredVars cfg) -- all locally declared vars in this function
-- build a mapping from node label to a
-- set of variables that need to be merged via phi func
-- (note: variables are not yet renamed)
phiLocMap :: M.Map Ident -- node label
[Ident] -- variable idents
phiLocMap = foldl (\m (label,v) -> case M.lookup label m of
{ Nothing -> M.insert label [v] m
; Just vs -> M.update (\_ -> Just $ vs ++ [v]) label m
}) M.empty $ do
{ var <- allVarsUsed -- todo: shall we exclude global vars?
; let phiLocs = phiLoc var cfg dft
; phiLoc <- phiLocs
; return (phiLoc, var)
}
-- given a node's label (as the starting point of the search)
-- a variable (which is not yet renamed), the dom tree
-- to find the label of the node which contains preceding definition of the variable
precDef :: Ident -> Ident -> DTree -> CFG -> Maybe Ident
precDef currLbl var dt cfg =
case M.lookup currLbl phiLocMap of
{ Just vs | var `elem` vs -> Just currLbl -- the var is reassigned through a phi function in the current block
; _ -> -- the var could be reassigned locally
case M.lookup currLbl cfg of
{ Nothing -> error $ "Fatal: Label " ++ show currLbl ++ " is not found in the CFG"
; Just node | var `elem` (lVars node) -> Just currLbl
; Just _ | otherwise ->
case parentOf currLbl dt of
{ Nothing | (var `S.member` formalArguments) ||
(var `S.member` allLocalVars)
-> -- no parent: this is block 0
Just currLbl
-- this could be due to a nested scope var in some inner block of if else or while.
-- we will move it to block 0 (the init block)
-- e.g. refer to the fibiter.c, the variable t
-- this make sense for block 0, all local variables should be lifted and declared in block 0
| otherwise -> Nothing -- as this is to be decided later, it could be a global var
; Just parentLbl -> precDef parentLbl var dt cfg
}
}
}
formalArguments = S.fromList fargs
-- renaming all the variables based on the individual labelled blocks
-- and move all the declaration out.
eachNode :: SSA -> (Ident, Node) -> SSA
eachNode ssa (currLbl, node) = case node of
{ Node statements lvars rvars local_decls precLbls succLbls switchOrLoop ->
let phis_ :: [( Ident -- ^ var being redefined (not yet renamed)
, [(Ident, Maybe Ident)])] -- ^ (incoming block lbl, lbl of preceding blk in which var is redefined)
phis_ = case M.lookup currLbl phiLocMap of
{ Nothing -> []
; Just phiVars -> map (\v ->
let lastDefs =
map (\precLbl ->
let mb_lblVarDefined = precDef precLbl v dtree cfg
in (precLbl, mb_lblVarDefined)) precLbls
in (v, lastDefs)
-- find the preceding node and the renamed variable
) [ v | v <- phiVars, not (v `elem` local_decls) ]
}
-- build the renaming state from the rhs vars with the precDef
-- or from phis_
rnState :: RenameState
rnState = let -- todo, the local_decls should be filtered away from the rVars and local_decls should be appended with the current node label
rnEnvLocal = M.fromList $ map (\var -> (var, var `app` currLbl)) local_decls
rvarsNotLocal = filter (\var -> not (var `M.member` rnEnvLocal)) rvars
rnEnv = case precLbls of
{ [] -> -- entry block -- todo: check, shouldn't be the formal arg?
M.fromList (map (\var ->
if (var `S.member` formalArguments) ||
(var `S.member` allLocalVars)
then (var, var `app` currLbl)
else (var, var) -- global
) rvarsNotLocal)
; [precLbl] -> -- non-phi block
M.fromList (map (\var ->
case precDef precLbl var dtree cfg of
{ Just def_lbl -> (var, var `app` def_lbl)
; Nothing -> -- it is a formal arg and should be redefined in block 0
if (var `S.member` formalArguments) ||
(var `S.member` allLocalVars)
then (var, var `app` (iid (labPref ++ "0")))
else (var, var) -- global
}) rvarsNotLocal)
; precLbls -> -- phi block
M.fromList (map (\var -> case lookup var phis_ of
{ Just _ -> (var, var `app` currLbl)
; Nothing ->
-- not in phi, it's a formal arg and should be redefined in block 0
-- (var, var `app` (iid (labPref ++ "0")))
-- updated: the above is not true, look at sort example, var j in node 7. (7 has preds 4 and 6, both do not redefine j,
-- node 4 & 6 share a common ancestor 3 where j is redefined
case filter isJust $ map (\precLbl -> precDef precLbl var dtree cfg) precLbls of
{ [] -> -- var is global
(var, var)
; (def:defs) | all (\d -> d == def) defs ->
let (Just def_lbl) = def
in (var, var `app` def_lbl)
| otherwise -> error $ "buildSSA: rnState variable " ++ (show var) ++ " has a conflicting preceding definition " ++ (show (def:defs)) ++ "\n current Label " ++ (show currLbl) ++ "\n CFG" ++ (show cfg) ++ "\n Phi loca Map" ++ (show phiLocMap) ++ "\n DFT" ++ (show dft)
}
}) rvarsNotLocal)
}
in RSt currLbl (rnEnvLocal `M.union` rnEnv) [] [] allLocalVars formalArguments
renamedBlkItems_decls_containers :: ([AST.CCompoundBlockItem N.NodeInfo], [AST.CDeclaration N.NodeInfo], [Ident])
renamedBlkItems_decls_containers = renamePure rnState statements
(renamedBlkItems, new_decls, containers) = renamedBlkItems_decls_containers
-- scalar copy for container variables eg. say a[] then a[i] = a[j] --> a_2 = a_1; a_2[i_2] = a_1[j_2];
-- and insert them to the begining of the labeled block
scalar_copy :: [Ident] -> [AST.CCompoundBlockItem N.NodeInfo]
scalar_copy containers =
concatMap (\container -> -- lookup the last def of container variable, similar to building rnState
let containers' = case precLbls of
{ [] -> [] -- entry block
; [precLbl] -> case precDef precLbl container dtree cfg of
{ Just def_lbl -> [container `app` def_lbl]
; Nothing -> [container `app` (iid (labPref ++ "0"))]
}
; precLbls -> case lookup container phis_ of -- phi block
{ Just _ -> [] -- should be covered by the phi translations
; Nothing ->
case filter isJust $ map (\precLbl -> precDef precLbl container dtree cfg) precLbls of
{ [] -> error "impossible"
; (def:defs) | (all (\d -> d == def) defs) ->
let (Just def_lbl) = def
in [container `app` def_lbl]
| otherwise -> error $ "buildSSA: scalar copy variable " ++ (show container) ++ " has a conflicting preceding definition"
}
}
}
in map (\container' -> AST.CBlockStmt (AST.CExpr (Just ((cvar (container `app` currLbl)) .=. (cvar container'))) N.undefNode)) containers'
) containers
isLoop x = case x of { (IsLoop _ _) -> True ; _ -> False }
labelled_block = LB phis_ ((scalar_copy containers) ++ renamedBlkItems) precLbls succLbls (lVars node) (rVars node) containers (isLoop switchOrLoop)
in ssa{ labelled_blocks = M.insert currLbl labelled_block (labelled_blocks ssa)
, scoped_decls = (scoped_decls ssa) ++ new_decls }
}
ssa = foldl eachNode (SSA [] M.empty sdom allLocalVars formalArguments) $ M.toList cfg
io = unsafePerformIO $ print cfg >> print ssa >> print dft >> print pcm >> print dtree -- (map (\var -> (var, modLoc var cfg)) allVarsUsed) >> print dtree >> print dft >> print pcm >> print sdom
in ssa -- the scoped_decls were not yet renamed which will be renamed in SSA to CPS convertion
} | 12,264 | buildSSA cfg fargs =
case buildDTree cfg of
{ Nothing -> error "failed to build dominance frontier table"
; Just (dtree, pcm, sdom) ->
let dft = buildDF' (dtree, pcm, sdom, cfg)
allVarsUsed = allVars cfg -- all vars used in this function, local declared, formal args and global
allLocalVars = S.fromList (localDeclaredVars cfg) -- all locally declared vars in this function
-- build a mapping from node label to a
-- set of variables that need to be merged via phi func
-- (note: variables are not yet renamed)
phiLocMap :: M.Map Ident -- node label
[Ident] -- variable idents
phiLocMap = foldl (\m (label,v) -> case M.lookup label m of
{ Nothing -> M.insert label [v] m
; Just vs -> M.update (\_ -> Just $ vs ++ [v]) label m
}) M.empty $ do
{ var <- allVarsUsed -- todo: shall we exclude global vars?
; let phiLocs = phiLoc var cfg dft
; phiLoc <- phiLocs
; return (phiLoc, var)
}
-- given a node's label (as the starting point of the search)
-- a variable (which is not yet renamed), the dom tree
-- to find the label of the node which contains preceding definition of the variable
precDef :: Ident -> Ident -> DTree -> CFG -> Maybe Ident
precDef currLbl var dt cfg =
case M.lookup currLbl phiLocMap of
{ Just vs | var `elem` vs -> Just currLbl -- the var is reassigned through a phi function in the current block
; _ -> -- the var could be reassigned locally
case M.lookup currLbl cfg of
{ Nothing -> error $ "Fatal: Label " ++ show currLbl ++ " is not found in the CFG"
; Just node | var `elem` (lVars node) -> Just currLbl
; Just _ | otherwise ->
case parentOf currLbl dt of
{ Nothing | (var `S.member` formalArguments) ||
(var `S.member` allLocalVars)
-> -- no parent: this is block 0
Just currLbl
-- this could be due to a nested scope var in some inner block of if else or while.
-- we will move it to block 0 (the init block)
-- e.g. refer to the fibiter.c, the variable t
-- this make sense for block 0, all local variables should be lifted and declared in block 0
| otherwise -> Nothing -- as this is to be decided later, it could be a global var
; Just parentLbl -> precDef parentLbl var dt cfg
}
}
}
formalArguments = S.fromList fargs
-- renaming all the variables based on the individual labelled blocks
-- and move all the declaration out.
eachNode :: SSA -> (Ident, Node) -> SSA
eachNode ssa (currLbl, node) = case node of
{ Node statements lvars rvars local_decls precLbls succLbls switchOrLoop ->
let phis_ :: [( Ident -- ^ var being redefined (not yet renamed)
, [(Ident, Maybe Ident)])] -- ^ (incoming block lbl, lbl of preceding blk in which var is redefined)
phis_ = case M.lookup currLbl phiLocMap of
{ Nothing -> []
; Just phiVars -> map (\v ->
let lastDefs =
map (\precLbl ->
let mb_lblVarDefined = precDef precLbl v dtree cfg
in (precLbl, mb_lblVarDefined)) precLbls
in (v, lastDefs)
-- find the preceding node and the renamed variable
) [ v | v <- phiVars, not (v `elem` local_decls) ]
}
-- build the renaming state from the rhs vars with the precDef
-- or from phis_
rnState :: RenameState
rnState = let -- todo, the local_decls should be filtered away from the rVars and local_decls should be appended with the current node label
rnEnvLocal = M.fromList $ map (\var -> (var, var `app` currLbl)) local_decls
rvarsNotLocal = filter (\var -> not (var `M.member` rnEnvLocal)) rvars
rnEnv = case precLbls of
{ [] -> -- entry block -- todo: check, shouldn't be the formal arg?
M.fromList (map (\var ->
if (var `S.member` formalArguments) ||
(var `S.member` allLocalVars)
then (var, var `app` currLbl)
else (var, var) -- global
) rvarsNotLocal)
; [precLbl] -> -- non-phi block
M.fromList (map (\var ->
case precDef precLbl var dtree cfg of
{ Just def_lbl -> (var, var `app` def_lbl)
; Nothing -> -- it is a formal arg and should be redefined in block 0
if (var `S.member` formalArguments) ||
(var `S.member` allLocalVars)
then (var, var `app` (iid (labPref ++ "0")))
else (var, var) -- global
}) rvarsNotLocal)
; precLbls -> -- phi block
M.fromList (map (\var -> case lookup var phis_ of
{ Just _ -> (var, var `app` currLbl)
; Nothing ->
-- not in phi, it's a formal arg and should be redefined in block 0
-- (var, var `app` (iid (labPref ++ "0")))
-- updated: the above is not true, look at sort example, var j in node 7. (7 has preds 4 and 6, both do not redefine j,
-- node 4 & 6 share a common ancestor 3 where j is redefined
case filter isJust $ map (\precLbl -> precDef precLbl var dtree cfg) precLbls of
{ [] -> -- var is global
(var, var)
; (def:defs) | all (\d -> d == def) defs ->
let (Just def_lbl) = def
in (var, var `app` def_lbl)
| otherwise -> error $ "buildSSA: rnState variable " ++ (show var) ++ " has a conflicting preceding definition " ++ (show (def:defs)) ++ "\n current Label " ++ (show currLbl) ++ "\n CFG" ++ (show cfg) ++ "\n Phi loca Map" ++ (show phiLocMap) ++ "\n DFT" ++ (show dft)
}
}) rvarsNotLocal)
}
in RSt currLbl (rnEnvLocal `M.union` rnEnv) [] [] allLocalVars formalArguments
renamedBlkItems_decls_containers :: ([AST.CCompoundBlockItem N.NodeInfo], [AST.CDeclaration N.NodeInfo], [Ident])
renamedBlkItems_decls_containers = renamePure rnState statements
(renamedBlkItems, new_decls, containers) = renamedBlkItems_decls_containers
-- scalar copy for container variables eg. say a[] then a[i] = a[j] --> a_2 = a_1; a_2[i_2] = a_1[j_2];
-- and insert them to the begining of the labeled block
scalar_copy :: [Ident] -> [AST.CCompoundBlockItem N.NodeInfo]
scalar_copy containers =
concatMap (\container -> -- lookup the last def of container variable, similar to building rnState
let containers' = case precLbls of
{ [] -> [] -- entry block
; [precLbl] -> case precDef precLbl container dtree cfg of
{ Just def_lbl -> [container `app` def_lbl]
; Nothing -> [container `app` (iid (labPref ++ "0"))]
}
; precLbls -> case lookup container phis_ of -- phi block
{ Just _ -> [] -- should be covered by the phi translations
; Nothing ->
case filter isJust $ map (\precLbl -> precDef precLbl container dtree cfg) precLbls of
{ [] -> error "impossible"
; (def:defs) | (all (\d -> d == def) defs) ->
let (Just def_lbl) = def
in [container `app` def_lbl]
| otherwise -> error $ "buildSSA: scalar copy variable " ++ (show container) ++ " has a conflicting preceding definition"
}
}
}
in map (\container' -> AST.CBlockStmt (AST.CExpr (Just ((cvar (container `app` currLbl)) .=. (cvar container'))) N.undefNode)) containers'
) containers
isLoop x = case x of { (IsLoop _ _) -> True ; _ -> False }
labelled_block = LB phis_ ((scalar_copy containers) ++ renamedBlkItems) precLbls succLbls (lVars node) (rVars node) containers (isLoop switchOrLoop)
in ssa{ labelled_blocks = M.insert currLbl labelled_block (labelled_blocks ssa)
, scoped_decls = (scoped_decls ssa) ++ new_decls }
}
ssa = foldl eachNode (SSA [] M.empty sdom allLocalVars formalArguments) $ M.toList cfg
io = unsafePerformIO $ print cfg >> print ssa >> print dft >> print pcm >> print dtree -- (map (\var -> (var, modLoc var cfg)) allVarsUsed) >> print dtree >> print dft >> print pcm >> print sdom
in ssa -- the scoped_decls were not yet renamed which will be renamed in SSA to CPS convertion
} | 12,230 | true | true | 0 | 50 | 6,698 | 2,079 | 1,129 | 950 | null | null |
mightymoose/liquidhaskell | benchmarks/containers-0.5.0.0/Data/IntSet/Base.hs | bsd-3-clause | -- | /O(n)/. Convert the set to a descending list of elements. Subject to list
-- fusion.
toDescList :: IntSet -> [Int]
toDescList = foldl (flip (:)) [] | 152 | toDescList :: IntSet -> [Int]
toDescList = foldl (flip (:)) [] | 62 | toDescList = foldl (flip (:)) [] | 32 | true | true | 0 | 8 | 27 | 43 | 21 | 22 | null | null |
GaloisInc/halvm-ghc | compiler/utils/Outputable.hs | bsd-3-clause | neverQualify = QueryQualify neverQualifyNames
neverQualifyModules
neverQualifyPackages | 145 | neverQualify = QueryQualify neverQualifyNames
neverQualifyModules
neverQualifyPackages | 145 | neverQualify = QueryQualify neverQualifyNames
neverQualifyModules
neverQualifyPackages | 145 | false | false | 0 | 5 | 64 | 13 | 6 | 7 | null | null |
nevrenato/Hets_Fork | Temporal/NuSmv.hs | gpl-2.0 | modul :: Parser Module
modul = do keyword "MODULE"
name <- reserved keywords identifier << ws
params <- option [] (between (token "(") (token ")") parameters)
elements <- many element
return (Module name params elements)
where
parameters = sepBy1 (reserved keywords identifier << ws) (token ",") | 351 | modul :: Parser Module
modul = do keyword "MODULE"
name <- reserved keywords identifier << ws
params <- option [] (between (token "(") (token ")") parameters)
elements <- many element
return (Module name params elements)
where
parameters = sepBy1 (reserved keywords identifier << ws) (token ",") | 351 | modul = do keyword "MODULE"
name <- reserved keywords identifier << ws
params <- option [] (between (token "(") (token ")") parameters)
elements <- many element
return (Module name params elements)
where
parameters = sepBy1 (reserved keywords identifier << ws) (token ",") | 328 | false | true | 1 | 12 | 101 | 137 | 60 | 77 | null | null |
iu-parfunc/containers | Data/Map/Base.hs | bsd-3-clause | -- According to benchmarks, this special case increases
-- performance up to 30%. It does not help in difference or intersection.
hedgeUnion blo bhi (Bin _ kx x l r) t2 = link kx x (hedgeUnion blo bmi l (trim blo bmi t2))
(hedgeUnion bmi bhi r (trim bmi bhi t2))
where bmi = JustS kx
#if __GLASGOW_HASKELL__ >= 700
| 430 | hedgeUnion blo bhi (Bin _ kx x l r) t2 = link kx x (hedgeUnion blo bmi l (trim blo bmi t2))
(hedgeUnion bmi bhi r (trim bmi bhi t2))
where bmi = JustS kx
#if __GLASGOW_HASKELL__ >= 700
| 238 | hedgeUnion blo bhi (Bin _ kx x l r) t2 = link kx x (hedgeUnion blo bmi l (trim blo bmi t2))
(hedgeUnion bmi bhi r (trim bmi bhi t2))
where bmi = JustS kx
#if __GLASGOW_HASKELL__ >= 700
| 238 | true | false | 2 | 9 | 175 | 101 | 48 | 53 | null | null |
pauldoo/scratch | NBody/Main.hs | isc | reshape s@(Size w h) = do
viewport $= (Position 0 0, s) | 59 | reshape s@(Size w h) = do
viewport $= (Position 0 0, s) | 59 | reshape s@(Size w h) = do
viewport $= (Position 0 0, s) | 59 | false | false | 0 | 9 | 15 | 38 | 19 | 19 | null | null |
ocharles/hackage-server | Distribution/Server/Packages/Types.hs | bsd-3-clause | pkgLatestCabalFileText :: PkgInfo -> CabalFileText
pkgLatestCabalFileText = fst . pkgLatestRevision | 99 | pkgLatestCabalFileText :: PkgInfo -> CabalFileText
pkgLatestCabalFileText = fst . pkgLatestRevision | 99 | pkgLatestCabalFileText = fst . pkgLatestRevision | 48 | false | true | 0 | 5 | 9 | 19 | 10 | 9 | null | null |
romac/mental | src/Mental/Infer.hs | bsd-3-clause | declToEnv (TyDecl name ty) =
Map.singleton name (generalize mempty ty) | 72 | declToEnv (TyDecl name ty) =
Map.singleton name (generalize mempty ty) | 72 | declToEnv (TyDecl name ty) =
Map.singleton name (generalize mempty ty) | 72 | false | false | 0 | 7 | 11 | 32 | 15 | 17 | null | null |
andorp/grin | grin/src/Grin/Grin.hs | bsd-3-clause | _VarNode _ rest = pure rest | 27 | _VarNode _ rest = pure rest | 27 | _VarNode _ rest = pure rest | 27 | false | false | 0 | 5 | 5 | 14 | 6 | 8 | null | null |
ulikoehler/ProjectEuler | Euler28.hs | apache-2.0 | main = do
let diameter = 1001
-- First circle: 1 difference between diagonal numbers, second: 3, ...
let differenceList = takeWhile(< diameter) [2,4..]
-- Always 4 numbers per circle
let allDifferences = concatMap (replicate 4) differenceList
print $ sum $ scanl (+) 1 allDifferences | 307 | main = do
let diameter = 1001
-- First circle: 1 difference between diagonal numbers, second: 3, ...
let differenceList = takeWhile(< diameter) [2,4..]
-- Always 4 numbers per circle
let allDifferences = concatMap (replicate 4) differenceList
print $ sum $ scanl (+) 1 allDifferences | 307 | main = do
let diameter = 1001
-- First circle: 1 difference between diagonal numbers, second: 3, ...
let differenceList = takeWhile(< diameter) [2,4..]
-- Always 4 numbers per circle
let allDifferences = concatMap (replicate 4) differenceList
print $ sum $ scanl (+) 1 allDifferences | 307 | false | false | 0 | 12 | 68 | 81 | 41 | 40 | null | null |
AlexanderPankiv/ghc | compiler/prelude/THNames.hs | bsd-3-clause | -- data Exp = ...
varEIdKey, conEIdKey, litEIdKey, appEIdKey, infixEIdKey, infixAppIdKey,
sectionLIdKey, sectionRIdKey, lamEIdKey, lamCaseEIdKey, tupEIdKey,
unboxedTupEIdKey, condEIdKey, multiIfEIdKey,
letEIdKey, caseEIdKey, doEIdKey, compEIdKey,
fromEIdKey, fromThenEIdKey, fromToEIdKey, fromThenToEIdKey,
listEIdKey, sigEIdKey, recConEIdKey, recUpdEIdKey, staticEIdKey,
unboundVarEIdKey :: Unique
varEIdKey = mkPreludeMiscIdUnique 270 | 468 | varEIdKey, conEIdKey, litEIdKey, appEIdKey, infixEIdKey, infixAppIdKey,
sectionLIdKey, sectionRIdKey, lamEIdKey, lamCaseEIdKey, tupEIdKey,
unboxedTupEIdKey, condEIdKey, multiIfEIdKey,
letEIdKey, caseEIdKey, doEIdKey, compEIdKey,
fromEIdKey, fromThenEIdKey, fromToEIdKey, fromThenToEIdKey,
listEIdKey, sigEIdKey, recConEIdKey, recUpdEIdKey, staticEIdKey,
unboundVarEIdKey :: Unique
varEIdKey = mkPreludeMiscIdUnique 270 | 450 | varEIdKey = mkPreludeMiscIdUnique 270 | 45 | true | true | 5 | 5 | 70 | 80 | 62 | 18 | null | null |
BartMassey/anrand | anrand.hs | mit | testHelp :: IO ()
testHelp = do
printf "Available Tests:\n"
mapM_ (\t -> printf " %s\n" t) testSet
exitSuccess | 117 | testHelp :: IO ()
testHelp = do
printf "Available Tests:\n"
mapM_ (\t -> printf " %s\n" t) testSet
exitSuccess | 117 | testHelp = do
printf "Available Tests:\n"
mapM_ (\t -> printf " %s\n" t) testSet
exitSuccess | 99 | false | true | 0 | 10 | 25 | 46 | 21 | 25 | null | null |
kawu/partage | src/NLP/Partage/AStar/Chart.hs | bsd-2-clause | hasPassiveTrav
:: (Ord t, Ord n)
=> Passive n t
-> S.Set (Trav n t)
-> Auto n t
-> Chart n t
-> Bool
hasPassiveTrav p travSet auto chart =
case passiveTrav p auto chart of
Just ExtWeight{..} -> travSet `S.isSubsetOf` prioTrav
Nothing -> False
---------------------------------
-- Extraction of Processed Items
---------------------------------
-- | Check whether the given passive item is final or not. | 428 | hasPassiveTrav
:: (Ord t, Ord n)
=> Passive n t
-> S.Set (Trav n t)
-> Auto n t
-> Chart n t
-> Bool
hasPassiveTrav p travSet auto chart =
case passiveTrav p auto chart of
Just ExtWeight{..} -> travSet `S.isSubsetOf` prioTrav
Nothing -> False
---------------------------------
-- Extraction of Processed Items
---------------------------------
-- | Check whether the given passive item is final or not. | 428 | hasPassiveTrav p travSet auto chart =
case passiveTrav p auto chart of
Just ExtWeight{..} -> travSet `S.isSubsetOf` prioTrav
Nothing -> False
---------------------------------
-- Extraction of Processed Items
---------------------------------
-- | Check whether the given passive item is final or not. | 315 | false | true | 0 | 11 | 90 | 129 | 63 | 66 | null | null |
pharpend/comarkdown | tests/CompilerSpec.hs | gpl-3.0 | spec :: Spec
spec = parallel $ do
describe "AST->Pandoc compiler" $ do
describe "Outputting plain-text" $ do
specify "given many Ignore blks, behave like text all in 1 ignore blk" $
property $
\(xs :: [String]) -> do
result1 <- runDocument (mapM_ ignore xs)
result2 <- runDocument (ignore (mconcat xs))
shouldBe (writePlain def result1) (writePlain def result2)
specify "given many Comment blks, output is mempty" $
property $
\(xs :: [String]) -> do
result <- runDocument (mapM_ comment xs)
shouldBe result mempty
specify
"given many Comment blks interspersed in ignore blocks, same result as ignore blks standalone" $
property $
\(xs :: [String], ys :: [String]) -> do
shuffledList <- generate (shuffle (mappend (fmap Ignore xs) (fmap Comment ys)))
result1 <- runDocument (mapM_ insertPart shuffledList)
result2 <- runDocument
(forM_ shuffledList $
\case
Ignore s -> ignore s
_ -> return ())
shouldBe result1 result2
describe "Testing out Pandoc" $ do
specify "Given two strings, pandoc a + pandoc b = pandoc (a + b)" $ do
property $ \(x :: String, y :: String) ->
let fromPandoc'' = runExceptional
. fromEither
. over _Left show
in do readFirst <- fromPandoc'' $ readMarkdown def x
readSecond <- fromPandoc'' $ readMarkdown def y
let readXreadY = mappend readFirst readSecond
readXY <- fromPandoc'' $ readMarkdown def (mappend x y)
shouldBe readXreadY readXY | 1,820 | spec :: Spec
spec = parallel $ do
describe "AST->Pandoc compiler" $ do
describe "Outputting plain-text" $ do
specify "given many Ignore blks, behave like text all in 1 ignore blk" $
property $
\(xs :: [String]) -> do
result1 <- runDocument (mapM_ ignore xs)
result2 <- runDocument (ignore (mconcat xs))
shouldBe (writePlain def result1) (writePlain def result2)
specify "given many Comment blks, output is mempty" $
property $
\(xs :: [String]) -> do
result <- runDocument (mapM_ comment xs)
shouldBe result mempty
specify
"given many Comment blks interspersed in ignore blocks, same result as ignore blks standalone" $
property $
\(xs :: [String], ys :: [String]) -> do
shuffledList <- generate (shuffle (mappend (fmap Ignore xs) (fmap Comment ys)))
result1 <- runDocument (mapM_ insertPart shuffledList)
result2 <- runDocument
(forM_ shuffledList $
\case
Ignore s -> ignore s
_ -> return ())
shouldBe result1 result2
describe "Testing out Pandoc" $ do
specify "Given two strings, pandoc a + pandoc b = pandoc (a + b)" $ do
property $ \(x :: String, y :: String) ->
let fromPandoc'' = runExceptional
. fromEither
. over _Left show
in do readFirst <- fromPandoc'' $ readMarkdown def x
readSecond <- fromPandoc'' $ readMarkdown def y
let readXreadY = mappend readFirst readSecond
readXY <- fromPandoc'' $ readMarkdown def (mappend x y)
shouldBe readXreadY readXY | 1,820 | spec = parallel $ do
describe "AST->Pandoc compiler" $ do
describe "Outputting plain-text" $ do
specify "given many Ignore blks, behave like text all in 1 ignore blk" $
property $
\(xs :: [String]) -> do
result1 <- runDocument (mapM_ ignore xs)
result2 <- runDocument (ignore (mconcat xs))
shouldBe (writePlain def result1) (writePlain def result2)
specify "given many Comment blks, output is mempty" $
property $
\(xs :: [String]) -> do
result <- runDocument (mapM_ comment xs)
shouldBe result mempty
specify
"given many Comment blks interspersed in ignore blocks, same result as ignore blks standalone" $
property $
\(xs :: [String], ys :: [String]) -> do
shuffledList <- generate (shuffle (mappend (fmap Ignore xs) (fmap Comment ys)))
result1 <- runDocument (mapM_ insertPart shuffledList)
result2 <- runDocument
(forM_ shuffledList $
\case
Ignore s -> ignore s
_ -> return ())
shouldBe result1 result2
describe "Testing out Pandoc" $ do
specify "Given two strings, pandoc a + pandoc b = pandoc (a + b)" $ do
property $ \(x :: String, y :: String) ->
let fromPandoc'' = runExceptional
. fromEither
. over _Left show
in do readFirst <- fromPandoc'' $ readMarkdown def x
readSecond <- fromPandoc'' $ readMarkdown def y
let readXreadY = mappend readFirst readSecond
readXY <- fromPandoc'' $ readMarkdown def (mappend x y)
shouldBe readXreadY readXY | 1,807 | false | true | 0 | 26 | 678 | 481 | 224 | 257 | null | null |
ooz/Hafer | src/Hafer/Data/GenericGraph.hs | mit | vertices :: Graph v e -> [Vertex v]
vertices g = case g of
MathGraph vs es -> vs
ElemSetGraph elems -> foldr (++) [] $ map (\e -> case e of
GVertex v -> [v]
_ -> []) elems | 299 | vertices :: Graph v e -> [Vertex v]
vertices g = case g of
MathGraph vs es -> vs
ElemSetGraph elems -> foldr (++) [] $ map (\e -> case e of
GVertex v -> [v]
_ -> []) elems | 299 | vertices g = case g of
MathGraph vs es -> vs
ElemSetGraph elems -> foldr (++) [] $ map (\e -> case e of
GVertex v -> [v]
_ -> []) elems | 263 | false | true | 0 | 15 | 167 | 108 | 52 | 56 | null | null |
hiteshjasani/nano-hmac | test/hmd5_qc.hs | bsd-3-clause | toString :: [Word8] -> String
toString = unpack . pack | 54 | toString :: [Word8] -> String
toString = unpack . pack | 54 | toString = unpack . pack | 24 | false | true | 1 | 7 | 9 | 30 | 13 | 17 | null | null |
snoyberg/ghc | compiler/basicTypes/OccName.hs | bsd-3-clause | plusOccEnv (A x) (A y) = A $ plusUFM x y | 42 | plusOccEnv (A x) (A y) = A $ plusUFM x y | 42 | plusOccEnv (A x) (A y) = A $ plusUFM x y | 42 | false | false | 0 | 7 | 12 | 32 | 15 | 17 | null | null |
cl04/advent2016 | src/Day7.hs | bsd-3-clause | regularStr :: Monad m => ParsecT String u m (String, String)
regularStr = str >>= \s -> return $! (s, mempty) | 110 | regularStr :: Monad m => ParsecT String u m (String, String)
regularStr = str >>= \s -> return $! (s, mempty) | 110 | regularStr = str >>= \s -> return $! (s, mempty) | 48 | false | true | 0 | 8 | 21 | 52 | 28 | 24 | null | null |
xmonad/xmonad-contrib | XMonad/Prompt/Directory.hs | bsd-3-clause | notboring _ = True | 18 | notboring _ = True | 18 | notboring _ = True | 18 | false | false | 0 | 5 | 3 | 9 | 4 | 5 | null | null |
seckcoder/lang-learn | haskell/lambda-calculus/src/Main.hs | unlicense | eval3 :: Exp -> Eval3 Value
eval3 (Lit i) = return (IntVal i) | 61 | eval3 :: Exp -> Eval3 Value
eval3 (Lit i) = return (IntVal i) | 61 | eval3 (Lit i) = return (IntVal i) | 33 | false | true | 0 | 9 | 12 | 40 | 18 | 22 | null | null |
mightybyte/reflex-dom-stubs | src/GHCJS/DOM/Node.hs | bsd-3-clause | nodeGetParentNode = undefined | 29 | nodeGetParentNode = undefined | 29 | nodeGetParentNode = undefined | 29 | false | false | 0 | 4 | 2 | 6 | 3 | 3 | null | null |
acowley/language-c | src/Language/C/Analysis/TypeUtils.hs | bsd-3-clause | -- | Constructor for a simple floating-point type.
floating :: FloatType -> Type
floating ty = DirectType (TyFloating ty) noTypeQuals noAttributes | 146 | floating :: FloatType -> Type
floating ty = DirectType (TyFloating ty) noTypeQuals noAttributes | 95 | floating ty = DirectType (TyFloating ty) noTypeQuals noAttributes | 65 | true | true | 0 | 7 | 20 | 35 | 17 | 18 | null | null |
brendanhay/gogol | gogol-logging/gen/Network/Google/Resource/Logging/Projects/Locations/Buckets/Views/Patch.hs | mpl-2.0 | -- | JSONP
plbvpCallback :: Lens' ProjectsLocationsBucketsViewsPatch (Maybe Text)
plbvpCallback
= lens _plbvpCallback
(\ s a -> s{_plbvpCallback = a}) | 158 | plbvpCallback :: Lens' ProjectsLocationsBucketsViewsPatch (Maybe Text)
plbvpCallback
= lens _plbvpCallback
(\ s a -> s{_plbvpCallback = a}) | 147 | plbvpCallback
= lens _plbvpCallback
(\ s a -> s{_plbvpCallback = a}) | 76 | true | true | 0 | 8 | 27 | 49 | 25 | 24 | null | null |
narrative/stack | src/Stack/Init.hs | bsd-3-clause | getWorkingResolverPlan
:: ( MonadBaseControl IO m, MonadIO m, MonadLogger m, MonadMask m
, MonadReader env m, HasConfig env , HasGHCVariant env
, HasHttpManager env , HasLogLevel env , HasReExec env
, HasTerminal env)
=> Path Abs File -- ^ stack.yaml
-> InitOpts
-> Map PackageName (Path Abs File, C.GenericPackageDescription)
-- ^ Src package name: cabal dir, cabal package description
-> Resolver
-> m ( Resolver
, Map PackageName (Map FlagName Bool)
, Map PackageName Version
, Map PackageName (Path Abs File, C.GenericPackageDescription))
-- ^ ( Resolver
-- , Flags for src packages and extra deps
-- , Extra dependencies
-- , Src packages actually considered)
getWorkingResolverPlan stackYaml initOpts bundle resolver = do
$logInfo $ "Selected resolver: " <> resolverName resolver
go bundle
where
go info = do
eres <- checkBundleResolver stackYaml initOpts info resolver
-- if some packages failed try again using the rest
case eres of
Right (f, edeps)-> return (resolver, f, edeps, info)
Left ignored
| Map.null available -> do
$logWarn "*** Could not find a working plan for any of \
\the user packages.\nProceeding to create a \
\config anyway."
return (resolver, Map.empty, Map.empty, Map.empty)
| otherwise -> do
when ((Map.size available) == (Map.size info)) $
error "Bug: No packages to ignore"
if length ignored > 1 then do
$logWarn "*** Ignoring packages:"
$logWarn $ indent $ showItems ignored
else
$logWarn $ "*** Ignoring package: "
<> (T.pack $ packageNameString (head ignored))
go available
where
indent t = T.unlines $ fmap (" " <>) (T.lines t)
isAvailable k _ = not (k `elem` ignored)
available = Map.filterWithKey isAvailable info | 2,343 | getWorkingResolverPlan
:: ( MonadBaseControl IO m, MonadIO m, MonadLogger m, MonadMask m
, MonadReader env m, HasConfig env , HasGHCVariant env
, HasHttpManager env , HasLogLevel env , HasReExec env
, HasTerminal env)
=> Path Abs File -- ^ stack.yaml
-> InitOpts
-> Map PackageName (Path Abs File, C.GenericPackageDescription)
-- ^ Src package name: cabal dir, cabal package description
-> Resolver
-> m ( Resolver
, Map PackageName (Map FlagName Bool)
, Map PackageName Version
, Map PackageName (Path Abs File, C.GenericPackageDescription))
getWorkingResolverPlan stackYaml initOpts bundle resolver = do
$logInfo $ "Selected resolver: " <> resolverName resolver
go bundle
where
go info = do
eres <- checkBundleResolver stackYaml initOpts info resolver
-- if some packages failed try again using the rest
case eres of
Right (f, edeps)-> return (resolver, f, edeps, info)
Left ignored
| Map.null available -> do
$logWarn "*** Could not find a working plan for any of \
\the user packages.\nProceeding to create a \
\config anyway."
return (resolver, Map.empty, Map.empty, Map.empty)
| otherwise -> do
when ((Map.size available) == (Map.size info)) $
error "Bug: No packages to ignore"
if length ignored > 1 then do
$logWarn "*** Ignoring packages:"
$logWarn $ indent $ showItems ignored
else
$logWarn $ "*** Ignoring package: "
<> (T.pack $ packageNameString (head ignored))
go available
where
indent t = T.unlines $ fmap (" " <>) (T.lines t)
isAvailable k _ = not (k `elem` ignored)
available = Map.filterWithKey isAvailable info | 2,187 | getWorkingResolverPlan stackYaml initOpts bundle resolver = do
$logInfo $ "Selected resolver: " <> resolverName resolver
go bundle
where
go info = do
eres <- checkBundleResolver stackYaml initOpts info resolver
-- if some packages failed try again using the rest
case eres of
Right (f, edeps)-> return (resolver, f, edeps, info)
Left ignored
| Map.null available -> do
$logWarn "*** Could not find a working plan for any of \
\the user packages.\nProceeding to create a \
\config anyway."
return (resolver, Map.empty, Map.empty, Map.empty)
| otherwise -> do
when ((Map.size available) == (Map.size info)) $
error "Bug: No packages to ignore"
if length ignored > 1 then do
$logWarn "*** Ignoring packages:"
$logWarn $ indent $ showItems ignored
else
$logWarn $ "*** Ignoring package: "
<> (T.pack $ packageNameString (head ignored))
go available
where
indent t = T.unlines $ fmap (" " <>) (T.lines t)
isAvailable k _ = not (k `elem` ignored)
available = Map.filterWithKey isAvailable info | 1,563 | true | true | 1 | 20 | 952 | 519 | 251 | 268 | null | null |
dimitri-xyz/public-bitcoin-type | Test/Test.hs | lgpl-2.1 | showBitcoinTest :: Test
showBitcoinTest = TestCase $ do
assertEqual "0 looks like zero" "0.00000000" (show (0 :: Bitcoin))
assertEqual "Showing an integer" "7.00000000" (show (7 :: Bitcoin))
assertEqual "Showing a fraction" "0.50000000" (show (0.5 :: Bitcoin))
assertEqual "Showing a negative fraction" "-0.33333333" (show ((-0.33333333) :: Bitcoin))
assertEqual "Showing a negative number" "-9.90000000" (show ((-9.9) :: Bitcoin))
------------------------------------------------------------------- | 571 | showBitcoinTest :: Test
showBitcoinTest = TestCase $ do
assertEqual "0 looks like zero" "0.00000000" (show (0 :: Bitcoin))
assertEqual "Showing an integer" "7.00000000" (show (7 :: Bitcoin))
assertEqual "Showing a fraction" "0.50000000" (show (0.5 :: Bitcoin))
assertEqual "Showing a negative fraction" "-0.33333333" (show ((-0.33333333) :: Bitcoin))
assertEqual "Showing a negative number" "-9.90000000" (show ((-9.9) :: Bitcoin))
------------------------------------------------------------------- | 571 | showBitcoinTest = TestCase $ do
assertEqual "0 looks like zero" "0.00000000" (show (0 :: Bitcoin))
assertEqual "Showing an integer" "7.00000000" (show (7 :: Bitcoin))
assertEqual "Showing a fraction" "0.50000000" (show (0.5 :: Bitcoin))
assertEqual "Showing a negative fraction" "-0.33333333" (show ((-0.33333333) :: Bitcoin))
assertEqual "Showing a negative number" "-9.90000000" (show ((-9.9) :: Bitcoin))
------------------------------------------------------------------- | 547 | false | true | 0 | 14 | 128 | 143 | 71 | 72 | null | null |
urbanslug/ghc | compiler/hsSyn/HsDecls.hs | bsd-3-clause | docDeclDoc :: DocDecl -> HsDocString
docDeclDoc (DocCommentNext d) = d | 70 | docDeclDoc :: DocDecl -> HsDocString
docDeclDoc (DocCommentNext d) = d | 70 | docDeclDoc (DocCommentNext d) = d | 33 | false | true | 0 | 7 | 9 | 24 | 12 | 12 | null | null |
YuichiroSato/GameOfSymbolGrounding | src/Data/Cell.hs | bsd-3-clause | randomCell :: (RandomGen g) => Int -> Int -> g -> (Cell, g)
randomCell x0 y0 gen = (Cell ext int, newGen)
where
int = randomInternal t r2 r3
ext@(External t _ _) = randomExternal r1 (x0, y0) r4
((r1, r2, r3, r4), newGen) = runState rand4 gen | 255 | randomCell :: (RandomGen g) => Int -> Int -> g -> (Cell, g)
randomCell x0 y0 gen = (Cell ext int, newGen)
where
int = randomInternal t r2 r3
ext@(External t _ _) = randomExternal r1 (x0, y0) r4
((r1, r2, r3, r4), newGen) = runState rand4 gen | 255 | randomCell x0 y0 gen = (Cell ext int, newGen)
where
int = randomInternal t r2 r3
ext@(External t _ _) = randomExternal r1 (x0, y0) r4
((r1, r2, r3, r4), newGen) = runState rand4 gen | 195 | false | true | 0 | 9 | 61 | 132 | 71 | 61 | null | null |
tibbe/ghc | compiler/codeGen/StgCmmPrim.hs | bsd-3-clause | translateOp dflags WordEqOp = Just (mo_wordEq dflags) | 59 | translateOp dflags WordEqOp = Just (mo_wordEq dflags) | 59 | translateOp dflags WordEqOp = Just (mo_wordEq dflags) | 59 | false | false | 0 | 7 | 12 | 20 | 9 | 11 | null | null |
jvilar/hrows | lib/GUI/BuildMonad.hs | gpl-2.0 | runBuild :: Builder -> GUIControl -> BuildMonad t -> IO t
runBuild builder control action = runReaderT action (builder, control) | 128 | runBuild :: Builder -> GUIControl -> BuildMonad t -> IO t
runBuild builder control action = runReaderT action (builder, control) | 128 | runBuild builder control action = runReaderT action (builder, control) | 70 | false | true | 0 | 9 | 19 | 51 | 24 | 27 | null | null |
ryzhyk/cocoon | cocoon/SMT/SMTLib2.hs | apache-2.0 | smtppExpr mf (EBinOp Neq e1 e2) = smtppExpr mf $ EUnOp Not $ EBinOp Eq e1 e2 | 76 | smtppExpr mf (EBinOp Neq e1 e2) = smtppExpr mf $ EUnOp Not $ EBinOp Eq e1 e2 | 76 | smtppExpr mf (EBinOp Neq e1 e2) = smtppExpr mf $ EUnOp Not $ EBinOp Eq e1 e2 | 76 | false | false | 0 | 7 | 16 | 42 | 19 | 23 | null | null |
ikirill/ComputationalMathematics | Cube/CubeGL.hs | gpl-3.0 | whenM :: Monad m => m Bool -> m () -> m ()
whenM pred work = do x <- pred; unless x work | 88 | whenM :: Monad m => m Bool -> m () -> m ()
whenM pred work = do x <- pred; unless x work | 88 | whenM pred work = do x <- pred; unless x work | 45 | false | true | 0 | 10 | 23 | 65 | 28 | 37 | null | null |
kmels/hledger | hledger/Hledger/Cli/Balance.hs | gpl-3.0 | formatField :: ReportOpts -> Maybe AccountName -> Int -> Amount -> Bool -> Maybe Int -> Maybe Int -> HledgerFormatField -> String
formatField opts accountName depth total ljust min max field = case field of
AccountField -> formatValue ljust min max $ maybe "" (maybeAccountNameDrop opts) accountName
DepthSpacerField -> case min of
Just m -> formatValue ljust Nothing max $ replicate (depth * m) ' '
Nothing -> formatValue ljust Nothing max $ replicate depth ' '
TotalField -> formatValue ljust min max $ showAmountWithoutPrice total
_ -> ""
-- multi-column balance reports
-- | Render a multi-column balance report as CSV. | 747 | formatField :: ReportOpts -> Maybe AccountName -> Int -> Amount -> Bool -> Maybe Int -> Maybe Int -> HledgerFormatField -> String
formatField opts accountName depth total ljust min max field = case field of
AccountField -> formatValue ljust min max $ maybe "" (maybeAccountNameDrop opts) accountName
DepthSpacerField -> case min of
Just m -> formatValue ljust Nothing max $ replicate (depth * m) ' '
Nothing -> formatValue ljust Nothing max $ replicate depth ' '
TotalField -> formatValue ljust min max $ showAmountWithoutPrice total
_ -> ""
-- multi-column balance reports
-- | Render a multi-column balance report as CSV. | 747 | formatField opts accountName depth total ljust min max field = case field of
AccountField -> formatValue ljust min max $ maybe "" (maybeAccountNameDrop opts) accountName
DepthSpacerField -> case min of
Just m -> formatValue ljust Nothing max $ replicate (depth * m) ' '
Nothing -> formatValue ljust Nothing max $ replicate depth ' '
TotalField -> formatValue ljust min max $ showAmountWithoutPrice total
_ -> ""
-- multi-column balance reports
-- | Render a multi-column balance report as CSV. | 617 | false | true | 0 | 14 | 225 | 201 | 94 | 107 | null | null |
forked-upstream-packages-for-ghcjs/ghc | compiler/utils/Pretty.hs | bsd-3-clause | -- Worth a try!
mkNest k p = nest_ k p | 54 | mkNest k p = nest_ k p | 38 | mkNest k p = nest_ k p | 38 | true | false | 0 | 5 | 26 | 17 | 8 | 9 | null | null |
abramhindle/haskell-sand-game | Sand5.hs | lgpl-3.0 | cursorLogic c@(Cursor { center = Eater, above = DustGenerator }) = eatAboveSendMessage c | 88 | cursorLogic c@(Cursor { center = Eater, above = DustGenerator }) = eatAboveSendMessage c | 88 | cursorLogic c@(Cursor { center = Eater, above = DustGenerator }) = eatAboveSendMessage c | 88 | false | false | 0 | 10 | 12 | 33 | 18 | 15 | null | null |
NICTA/coordinate | src/Data/Geodetic/EllipsoidReaderT.hs | bsd-3-clause | wgs84'' ::
EllipsoidReaderT f a
-> f a
wgs84'' r =
(_Unwrapped # r) wgs84 | 79 | wgs84'' ::
EllipsoidReaderT f a
-> f a
wgs84'' r =
(_Unwrapped # r) wgs84 | 79 | wgs84'' r =
(_Unwrapped # r) wgs84 | 36 | false | true | 0 | 7 | 20 | 37 | 17 | 20 | null | null |
rubik/stack | src/Stack/Setup/Installed.hs | bsd-3-clause | listInstalled :: (MonadIO m, MonadReader env m, HasConfig env, MonadThrow m)
=> Path Abs Dir
-> m [Tool]
listInstalled programsPath = do
createTree programsPath
(_, files) <- listDirectory programsPath
return $ mapMaybe toTool files
where
toTool fp = do
x <- T.stripSuffix ".installed" $ T.pack $ toFilePath $ filename fp
parseToolText x | 399 | listInstalled :: (MonadIO m, MonadReader env m, HasConfig env, MonadThrow m)
=> Path Abs Dir
-> m [Tool]
listInstalled programsPath = do
createTree programsPath
(_, files) <- listDirectory programsPath
return $ mapMaybe toTool files
where
toTool fp = do
x <- T.stripSuffix ".installed" $ T.pack $ toFilePath $ filename fp
parseToolText x | 399 | listInstalled programsPath = do
createTree programsPath
(_, files) <- listDirectory programsPath
return $ mapMaybe toTool files
where
toTool fp = do
x <- T.stripSuffix ".installed" $ T.pack $ toFilePath $ filename fp
parseToolText x | 266 | false | true | 1 | 13 | 113 | 146 | 65 | 81 | null | null |
bitemyapp/blpapi-hs | src/Finance/Blpapi/PrettyPrint.hs | mit | (<>) :: Builder -> Builder -> Builder
(<>) = mappend | 52 | (<>) :: Builder -> Builder -> Builder
(<>) = mappend | 52 | (<>) = mappend | 14 | false | true | 0 | 6 | 9 | 23 | 14 | 9 | null | null |
stevely/hspirv | src/SpirV/Builder/Raw.hs | bsd-3-clause | typeVoid :: Builder Id
typeVoid = addTypeDeclaration RepVoid OpTypeVoid | 71 | typeVoid :: Builder Id
typeVoid = addTypeDeclaration RepVoid OpTypeVoid | 71 | typeVoid = addTypeDeclaration RepVoid OpTypeVoid | 48 | false | true | 0 | 5 | 8 | 19 | 9 | 10 | null | null |
limaner2002/EPC-tools | USACScripts/src/Scripts/FCCForm471Types.hs | bsd-3-clause | checkLineItemCost :: LineItemCost -> Bool
checkLineItemCost lineItem = checkCosts (lineItem ^. lineMonthly) (lineItem ^. lineOneTime) | 133 | checkLineItemCost :: LineItemCost -> Bool
checkLineItemCost lineItem = checkCosts (lineItem ^. lineMonthly) (lineItem ^. lineOneTime) | 133 | checkLineItemCost lineItem = checkCosts (lineItem ^. lineMonthly) (lineItem ^. lineOneTime) | 91 | false | true | 0 | 7 | 14 | 40 | 20 | 20 | null | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.