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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
DominikDitoIvosevic/Uni | IRG/src/Irg/Lab1/Geometry/Shapes.hs | mit | myTrace :: Show a => a -> a
myTrace x = if False then traceShowId x else x | 74 | myTrace :: Show a => a -> a
myTrace x = if False then traceShowId x else x | 74 | myTrace x = if False then traceShowId x else x | 46 | false | true | 0 | 6 | 17 | 36 | 18 | 18 | null | null |
Noeda/Megaman | src/NetHack/Data/Level.hs | mit | maybeMarkAsOpenDoor :: Level -> T.Terminal -> Coords -> Level
maybeMarkAsOpenDoor level term coords
| featureAt level coords /= Just ClosedDoor = level
| featureByCh char attributes /= [] = level
| otherwise =
updateElement level coords
(\elem -> setFeature elem (Just OpenedDoor))
where
char = head $ T.strAt coords term
attributes = T.attributesAt coords term | 433 | maybeMarkAsOpenDoor :: Level -> T.Terminal -> Coords -> Level
maybeMarkAsOpenDoor level term coords
| featureAt level coords /= Just ClosedDoor = level
| featureByCh char attributes /= [] = level
| otherwise =
updateElement level coords
(\elem -> setFeature elem (Just OpenedDoor))
where
char = head $ T.strAt coords term
attributes = T.attributesAt coords term | 433 | maybeMarkAsOpenDoor level term coords
| featureAt level coords /= Just ClosedDoor = level
| featureByCh char attributes /= [] = level
| otherwise =
updateElement level coords
(\elem -> setFeature elem (Just OpenedDoor))
where
char = head $ T.strAt coords term
attributes = T.attributesAt coords term | 371 | false | true | 1 | 10 | 126 | 136 | 65 | 71 | null | null |
andygill/er-systemf | Language/SystemF/Parser.hs | bsd-3-clause | parseContextName :: Parser String
parseContextName = lexeme $ primParseContextName | 82 | parseContextName :: Parser String
parseContextName = lexeme $ primParseContextName | 82 | parseContextName = lexeme $ primParseContextName | 48 | false | true | 0 | 5 | 8 | 18 | 9 | 9 | null | null |
brendanhay/gogol | gogol-cloudsearch/gen/Network/Google/CloudSearch/Types/Product.hs | mpl-2.0 | -- | Can this operator be used to get facets.
qoIsFacetable :: Lens' QueryOperator (Maybe Bool)
qoIsFacetable
= lens _qoIsFacetable
(\ s a -> s{_qoIsFacetable = a}) | 172 | qoIsFacetable :: Lens' QueryOperator (Maybe Bool)
qoIsFacetable
= lens _qoIsFacetable
(\ s a -> s{_qoIsFacetable = a}) | 126 | qoIsFacetable
= lens _qoIsFacetable
(\ s a -> s{_qoIsFacetable = a}) | 76 | true | true | 1 | 9 | 34 | 52 | 25 | 27 | null | null |
cchalmers/geometry | src/Geometry/TwoD/Curvature.hs | bsd-3-clause | -- Package up problematic values with the appropriate infinity.
toPosInf :: RealFloat a => V2 a -> PosInf a
toPosInf (V2 _ 0) = Infinity | 136 | toPosInf :: RealFloat a => V2 a -> PosInf a
toPosInf (V2 _ 0) = Infinity | 72 | toPosInf (V2 _ 0) = Infinity | 28 | true | true | 0 | 10 | 24 | 45 | 20 | 25 | null | null |
mdsteele/fallback | src/Fallback/Test/Pathfind.hs | gpl-3.0 | -------------------------------------------------------------------------------
pathfindTest :: Int -> String -> Test
pathfindTest limit terrain =
let strings = lines terrain
width = length (head strings)
height = length strings
arr = listArray ((0, 0), (width - 1, height - 1)) $ concat $
transpose strings
get (Point x y) = arr ! (x, y)
allPoints = range (Point 0 0, Point (width - 1) (height - 1))
isBlocked = ('O' ==) . get
isGoal pt = let c = get pt in c == 'e' || c == 'g'
goals = filter isGoal allPoints
heuristic pos = minimum $ flip map goals $ \goal ->
pDist (fromIntegral <$> pos) (fromIntegral <$> goal)
start = head $ filter (('s' ==) . get) $ allPoints
path = pathfind isBlocked isGoal heuristic limit start
expected = Just $
let fn (mbCurrent, prev) =
case mbCurrent of
Nothing -> Nothing
Just current ->
let mbNext = listToMaybe $ filter (ok prev) $
map (current `plusDir`) allDirections
in Just (current, (mbNext, current))
ok prev next =
next /= prev && (let c = get next in c == '.' || c == 'e')
in tail $ unfoldr fn (Just start, start)
in insistEq expected path | 1,347 | pathfindTest :: Int -> String -> Test
pathfindTest limit terrain =
let strings = lines terrain
width = length (head strings)
height = length strings
arr = listArray ((0, 0), (width - 1, height - 1)) $ concat $
transpose strings
get (Point x y) = arr ! (x, y)
allPoints = range (Point 0 0, Point (width - 1) (height - 1))
isBlocked = ('O' ==) . get
isGoal pt = let c = get pt in c == 'e' || c == 'g'
goals = filter isGoal allPoints
heuristic pos = minimum $ flip map goals $ \goal ->
pDist (fromIntegral <$> pos) (fromIntegral <$> goal)
start = head $ filter (('s' ==) . get) $ allPoints
path = pathfind isBlocked isGoal heuristic limit start
expected = Just $
let fn (mbCurrent, prev) =
case mbCurrent of
Nothing -> Nothing
Just current ->
let mbNext = listToMaybe $ filter (ok prev) $
map (current `plusDir`) allDirections
in Just (current, (mbNext, current))
ok prev next =
next /= prev && (let c = get next in c == '.' || c == 'e')
in tail $ unfoldr fn (Just start, start)
in insistEq expected path | 1,266 | pathfindTest limit terrain =
let strings = lines terrain
width = length (head strings)
height = length strings
arr = listArray ((0, 0), (width - 1, height - 1)) $ concat $
transpose strings
get (Point x y) = arr ! (x, y)
allPoints = range (Point 0 0, Point (width - 1) (height - 1))
isBlocked = ('O' ==) . get
isGoal pt = let c = get pt in c == 'e' || c == 'g'
goals = filter isGoal allPoints
heuristic pos = minimum $ flip map goals $ \goal ->
pDist (fromIntegral <$> pos) (fromIntegral <$> goal)
start = head $ filter (('s' ==) . get) $ allPoints
path = pathfind isBlocked isGoal heuristic limit start
expected = Just $
let fn (mbCurrent, prev) =
case mbCurrent of
Nothing -> Nothing
Just current ->
let mbNext = listToMaybe $ filter (ok prev) $
map (current `plusDir`) allDirections
in Just (current, (mbNext, current))
ok prev next =
next /= prev && (let c = get next in c == '.' || c == 'e')
in tail $ unfoldr fn (Just start, start)
in insistEq expected path | 1,228 | true | true | 5 | 13 | 462 | 463 | 248 | 215 | null | null |
mumuki/mumuki-hspec-server | src/Server/Test/TestRunner.hs | mit | toTestResults :: [Maybe (String, String, String)] -> TestResults
toTestResults = map (toTestResult.fromJust) . filter isJust | 124 | toTestResults :: [Maybe (String, String, String)] -> TestResults
toTestResults = map (toTestResult.fromJust) . filter isJust | 124 | toTestResults = map (toTestResult.fromJust) . filter isJust | 59 | false | true | 0 | 9 | 14 | 51 | 25 | 26 | null | null |
ddssff/pandoc | src/Text/Pandoc/Readers/LaTeX.hs | gpl-2.0 | circ :: Char -> String
circ 'A' = "Â" | 37 | circ :: Char -> String
circ 'A' = "Â" | 37 | circ 'A' = "Â" | 14 | false | true | 0 | 5 | 8 | 18 | 9 | 9 | null | null |
juodaspaulius/bclafer_old | src/Language/Clafer/Front/LayoutResolver.hs | mit | readC n = if n > 0 then getc else return '\n' | 45 | readC n = if n > 0 then getc else return '\n' | 45 | readC n = if n > 0 then getc else return '\n' | 45 | false | false | 0 | 6 | 11 | 24 | 12 | 12 | null | null |
ozgurakgun/cmdargs | System/Console/CmdArgs/Test/Implicit/Tests.hs | bsd-3-clause | test10 = do
let Tester{..} = tester "Test10" mode10
isHelp ["-?=one"] [" -f --food=INT"]
isHelpNot ["-?=one"] [" -b --bard=INT"]
-- test for GHC over-optimising | 175 | test10 = do
let Tester{..} = tester "Test10" mode10
isHelp ["-?=one"] [" -f --food=INT"]
isHelpNot ["-?=one"] [" -b --bard=INT"]
-- test for GHC over-optimising | 175 | test10 = do
let Tester{..} = tester "Test10" mode10
isHelp ["-?=one"] [" -f --food=INT"]
isHelpNot ["-?=one"] [" -b --bard=INT"]
-- test for GHC over-optimising | 175 | false | false | 0 | 11 | 38 | 56 | 27 | 29 | null | null |
snapframework/snap-core | test/Snap/Internal/Routing/Tests.hs | bsd-3-clause | testRouting6 :: Test
testRouting6 = testCase "route/6" $ do
r5 <- go routes "foo/bar/sproing"
assertEqual "/foo/bar/sproing" "fooBar" r5
------------------------------------------------------------------------------ | 225 | testRouting6 :: Test
testRouting6 = testCase "route/6" $ do
r5 <- go routes "foo/bar/sproing"
assertEqual "/foo/bar/sproing" "fooBar" r5
------------------------------------------------------------------------------ | 225 | testRouting6 = testCase "route/6" $ do
r5 <- go routes "foo/bar/sproing"
assertEqual "/foo/bar/sproing" "fooBar" r5
------------------------------------------------------------------------------ | 204 | false | true | 0 | 9 | 28 | 41 | 19 | 22 | null | null |
apunktbau/co4 | test/CO4/Thesis/WCB_MatrixStandalone.hs | gpl-3.0 | tail' :: List a -> List a
tail' xs = case xs of
Nill -> Nill
Conss y ys -> ys | 81 | tail' :: List a -> List a
tail' xs = case xs of
Nill -> Nill
Conss y ys -> ys | 81 | tail' xs = case xs of
Nill -> Nill
Conss y ys -> ys | 55 | false | true | 0 | 8 | 24 | 49 | 22 | 27 | null | null |
GaloisInc/saw-script | heapster-saw/src/Verifier/SAW/Heapster/archival/Permissions.hs | bsd-3-clause | remLLVMFieldAt off (LLVMFieldShapePerm (LLVMFieldPerm off' spl p) : shapes)
| off' == off = Just (spl, p, shapes) | 115 | remLLVMFieldAt off (LLVMFieldShapePerm (LLVMFieldPerm off' spl p) : shapes)
| off' == off = Just (spl, p, shapes) | 115 | remLLVMFieldAt off (LLVMFieldShapePerm (LLVMFieldPerm off' spl p) : shapes)
| off' == off = Just (spl, p, shapes) | 115 | false | false | 0 | 10 | 19 | 53 | 26 | 27 | null | null |
prt2121/haskell-practice | parconc/distrib-db/DatabaseSample.hs | apache-2.0 | loop :: [[ProcessId]] -> Int -> Process ()
loop worker_pairs n_slices
= receiveWait
[ match $ \req -> handleRequest req >> loop worker_pairs n_slices
, match $ \(ProcessMonitorNotification _ pid reason) -> do
say (printf "process %s died: %s" (show pid) (show reason))
loop (map (filter (/= pid)) worker_pairs) n_slices
]
where
workersForKey :: Key -> [ProcessId]
workersForKey k = worker_pairs !! (ord (head k) `mod` n_slices)
handleRequest :: Request -> Process ()
handleRequest r =
case r of
Set k _ -> mapM_ (! r) (workersForKey k)
Get k _ -> mapM_ (! r) (workersForKey k) | 665 | loop :: [[ProcessId]] -> Int -> Process ()
loop worker_pairs n_slices
= receiveWait
[ match $ \req -> handleRequest req >> loop worker_pairs n_slices
, match $ \(ProcessMonitorNotification _ pid reason) -> do
say (printf "process %s died: %s" (show pid) (show reason))
loop (map (filter (/= pid)) worker_pairs) n_slices
]
where
workersForKey :: Key -> [ProcessId]
workersForKey k = worker_pairs !! (ord (head k) `mod` n_slices)
handleRequest :: Request -> Process ()
handleRequest r =
case r of
Set k _ -> mapM_ (! r) (workersForKey k)
Get k _ -> mapM_ (! r) (workersForKey k) | 665 | loop worker_pairs n_slices
= receiveWait
[ match $ \req -> handleRequest req >> loop worker_pairs n_slices
, match $ \(ProcessMonitorNotification _ pid reason) -> do
say (printf "process %s died: %s" (show pid) (show reason))
loop (map (filter (/= pid)) worker_pairs) n_slices
]
where
workersForKey :: Key -> [ProcessId]
workersForKey k = worker_pairs !! (ord (head k) `mod` n_slices)
handleRequest :: Request -> Process ()
handleRequest r =
case r of
Set k _ -> mapM_ (! r) (workersForKey k)
Get k _ -> mapM_ (! r) (workersForKey k) | 622 | false | true | 0 | 16 | 185 | 265 | 133 | 132 | null | null |
urbanslug/nairobi-bot | tests/Bot/EchoSpec.hs | gpl-3.0 | echoBotProperties :: Spec
echoBotProperties = do
describe "Echo property tests" $ do
it "Echobot just echoes what it receives but escapes unsafe chars" $ do
--property $ forAll (arbitrary :: Gen String) propEcho
pendingWith "Fix propEcho" | 256 | echoBotProperties :: Spec
echoBotProperties = do
describe "Echo property tests" $ do
it "Echobot just echoes what it receives but escapes unsafe chars" $ do
--property $ forAll (arbitrary :: Gen String) propEcho
pendingWith "Fix propEcho" | 256 | echoBotProperties = do
describe "Echo property tests" $ do
it "Echobot just echoes what it receives but escapes unsafe chars" $ do
--property $ forAll (arbitrary :: Gen String) propEcho
pendingWith "Fix propEcho" | 230 | false | true | 0 | 13 | 53 | 38 | 17 | 21 | null | null |
ComputationWithBoundedResources/ara-inference | doc/tpdb_trs/Haskell/basic_haskell/enumFromThenTo_6.hs | mit | toEnum4 wx wy = toEnum3 wy | 26 | toEnum4 wx wy = toEnum3 wy | 26 | toEnum4 wx wy = toEnum3 wy | 26 | false | false | 0 | 5 | 5 | 14 | 6 | 8 | null | null |
alphaHeavy/quickfix-hs | src/AlphaHeavy/QuickFIX.hs | bsd-3-clause | sourceQuickFIX
:: (Generic a, GRecvMessage (Rep a), MonadIO m)
=> ConduitApp
-> Source m a
sourceQuickFIX ConduitApp{conduitAppRecv, conduitAppStatus} = step where
step = do
mval <- liftIO . atomically $ do
mval <- Right <$> takeTMVar conduitAppRecv <|> Left <$> readTVar conduitAppStatus
case mval of
Left EngineRunning -> retry
_ -> return mval
case mval of
Right (val, future) -> do
-- the QuickFIX callbacks don't know the correct type, so we need to do
-- the parsing with the GRecvMessage constraint in scope. The QuickFIX engine
-- needs any parse related exceptions returned synchronously... this is
-- done by passing a future for the exception along with the message pointer
mmsg <- liftIO $ catch
(receiveMessage val >>= \ !msg -> future Nothing >> return (Just msg))
(\ ex -> future (Just ex) >> return Nothing)
case mmsg of
Just msg -> yield msg
Nothing -> return ()
step
-- this should always be Left EngineStopped
Left _ -> return () | 1,109 | sourceQuickFIX
:: (Generic a, GRecvMessage (Rep a), MonadIO m)
=> ConduitApp
-> Source m a
sourceQuickFIX ConduitApp{conduitAppRecv, conduitAppStatus} = step where
step = do
mval <- liftIO . atomically $ do
mval <- Right <$> takeTMVar conduitAppRecv <|> Left <$> readTVar conduitAppStatus
case mval of
Left EngineRunning -> retry
_ -> return mval
case mval of
Right (val, future) -> do
-- the QuickFIX callbacks don't know the correct type, so we need to do
-- the parsing with the GRecvMessage constraint in scope. The QuickFIX engine
-- needs any parse related exceptions returned synchronously... this is
-- done by passing a future for the exception along with the message pointer
mmsg <- liftIO $ catch
(receiveMessage val >>= \ !msg -> future Nothing >> return (Just msg))
(\ ex -> future (Just ex) >> return Nothing)
case mmsg of
Just msg -> yield msg
Nothing -> return ()
step
-- this should always be Left EngineStopped
Left _ -> return () | 1,109 | sourceQuickFIX ConduitApp{conduitAppRecv, conduitAppStatus} = step where
step = do
mval <- liftIO . atomically $ do
mval <- Right <$> takeTMVar conduitAppRecv <|> Left <$> readTVar conduitAppStatus
case mval of
Left EngineRunning -> retry
_ -> return mval
case mval of
Right (val, future) -> do
-- the QuickFIX callbacks don't know the correct type, so we need to do
-- the parsing with the GRecvMessage constraint in scope. The QuickFIX engine
-- needs any parse related exceptions returned synchronously... this is
-- done by passing a future for the exception along with the message pointer
mmsg <- liftIO $ catch
(receiveMessage val >>= \ !msg -> future Nothing >> return (Just msg))
(\ ex -> future (Just ex) >> return Nothing)
case mmsg of
Just msg -> yield msg
Nothing -> return ()
step
-- this should always be Left EngineStopped
Left _ -> return () | 1,012 | false | true | 4 | 22 | 322 | 284 | 134 | 150 | null | null |
brendanhay/gogol | gogol-dlp/gen/Network/Google/Resource/DLP/Projects/JobTriggers/List.hs | mpl-2.0 | -- | V1 error format.
pjtlXgafv :: Lens' ProjectsJobTriggersList (Maybe Xgafv)
pjtlXgafv
= lens _pjtlXgafv (\ s a -> s{_pjtlXgafv = a}) | 137 | pjtlXgafv :: Lens' ProjectsJobTriggersList (Maybe Xgafv)
pjtlXgafv
= lens _pjtlXgafv (\ s a -> s{_pjtlXgafv = a}) | 115 | pjtlXgafv
= lens _pjtlXgafv (\ s a -> s{_pjtlXgafv = a}) | 58 | true | true | 0 | 9 | 23 | 48 | 25 | 23 | null | null |
haskellbr/missingh | missingh-all/src/System/Path/WildMatch.hs | mit | convpat :: String -> String
convpat ('\\':xs) = "\\\\" ++ convpat xs | 68 | convpat :: String -> String
convpat ('\\':xs) = "\\\\" ++ convpat xs | 68 | convpat ('\\':xs) = "\\\\" ++ convpat xs | 40 | false | true | 2 | 9 | 11 | 38 | 17 | 21 | null | null |
bergmark/clay | src/Clay/Text.hs | bsd-3-clause | preLine = WhiteSpace "pre-line" | 31 | preLine = WhiteSpace "pre-line" | 31 | preLine = WhiteSpace "pre-line" | 31 | false | false | 0 | 5 | 3 | 9 | 4 | 5 | null | null |
daewon/til | exercism/haskell/raindrops/src/Raindrops.hs | mpl-2.0 | toRainStr :: Int -> String
toRainStr 3 = "Pling" | 48 | toRainStr :: Int -> String
toRainStr 3 = "Pling" | 48 | toRainStr 3 = "Pling" | 21 | false | true | 0 | 5 | 8 | 18 | 9 | 9 | null | null |
mightymoose/liquidhaskell | benchmarks/base-4.5.1.0/Foreign/C/Error.hs | bsd-3-clause | throwErrnoIf_ :: (a -> Bool) -> String -> IO a -> IO ()
throwErrnoIf_ pred loc f = void $ throwErrnoIf pred loc f | 116 | throwErrnoIf_ :: (a -> Bool) -> String -> IO a -> IO ()
throwErrnoIf_ pred loc f = void $ throwErrnoIf pred loc f | 116 | throwErrnoIf_ pred loc f = void $ throwErrnoIf pred loc f | 58 | false | true | 0 | 9 | 26 | 56 | 27 | 29 | null | null |
ctford/Idris-Elba-dev | src/Idris/AbsSyntaxTree.hs | bsd-3-clause | getConsts :: [PArg] -> [PTerm]
getConsts [] = [] | 48 | getConsts :: [PArg] -> [PTerm]
getConsts [] = [] | 48 | getConsts [] = [] | 17 | false | true | 0 | 6 | 8 | 28 | 15 | 13 | null | null |
robdockins/edison | edison-core/src/Data/Edison/Seq/MyersStack.hs | mit | fold = foldr | 13 | fold = foldr | 13 | fold = foldr | 13 | false | false | 0 | 4 | 3 | 6 | 3 | 3 | null | null |
Rydgel/advent-of-code | src/Day6.hs | bsd-3-clause | instruction :: Parser Instruction
instruction = action <*> (char ' ' *> range) | 78 | instruction :: Parser Instruction
instruction = action <*> (char ' ' *> range) | 78 | instruction = action <*> (char ' ' *> range) | 44 | false | true | 0 | 8 | 12 | 28 | 14 | 14 | null | null |
ytakano/tsukuyomi | validator/lunar_lisp/lunar_lisp_parser.hs | bsd-3-clause | -- op ::= '+' | '/' | '~' | '!' | '@' | '#' | '$' | '%' | ':' | '?'
-- '^' | '*' | '-' | '=' | '_' | '<' | '>' | '|' | '&'
parseOp :: Parsec.Parsec String () Char
parseOp = Parsec.oneOf "+/~!@#$%:?^*-=_<>|&" | 224 | parseOp :: Parsec.Parsec String () Char
parseOp = Parsec.oneOf "+/~!@#$%:?^*-=_<>|&" | 84 | parseOp = Parsec.oneOf "+/~!@#$%:?^*-=_<>|&" | 44 | true | true | 0 | 6 | 66 | 29 | 15 | 14 | null | null |
hvr/jhc | src/FrontEnd/KindInfer.hs | mit | hsAsstToPred' _ kt (HsAsstEq t1 t2) = IsEq (runIdentity $ hsTypeToType' kt t1) (runIdentity $ hsTypeToType' kt t2) | 114 | hsAsstToPred' _ kt (HsAsstEq t1 t2) = IsEq (runIdentity $ hsTypeToType' kt t1) (runIdentity $ hsTypeToType' kt t2) | 114 | hsAsstToPred' _ kt (HsAsstEq t1 t2) = IsEq (runIdentity $ hsTypeToType' kt t1) (runIdentity $ hsTypeToType' kt t2) | 114 | false | false | 1 | 8 | 17 | 52 | 24 | 28 | null | null |
pparkkin/eta | compiler/ETA/Main/DynFlags.hs | bsd-3-clause | -- See Note [Supporting CLI completion]
package_flags :: [Flag (CmdLineP DynFlags)]
package_flags = [
------- Packages ----------------------------------------------------
defFlag "package-db" (HasArg (addPkgConfRef . PkgConfFile))
, defFlag "clear-package-db" (NoArg clearPkgConf)
, defFlag "no-global-package-db" (NoArg removeGlobalPkgConf)
, defFlag "no-user-package-db" (NoArg removeUserPkgConf)
, defFlag "global-package-db" (NoArg (addPkgConfRef GlobalPkgConf))
, defFlag "user-package-db" (NoArg (addPkgConfRef UserPkgConf))
-- backwards compat with GHC<=7.4 :
, defFlag "package-conf" (HasArg $ \path -> do
addPkgConfRef (PkgConfFile path)
deprecate "Use -package-db instead")
, defFlag "no-user-package-conf"
(NoArg $ do removeUserPkgConf
deprecate "Use -no-user-package-db instead")
, defGhcFlag "package-name" (hasArg setUnitId)
, defGhcFlag "this-package-key" (HasArg $ \uid -> do
upd (setUnitId uid)
deprecate "Use -this-unit-id instead")
, defGhcFlag "this-unit-id" (hasArg setUnitId)
, defFlag "package" (HasArg exposePackage)
, defFlag "package-id" (HasArg exposePackageId)
, defFlag "hide-package" (HasArg hidePackage)
, defFlag "hide-all-packages" (NoArg (setGeneralFlag Opt_HideAllPackages))
, defFlag "package-env" (HasArg setPackageEnv)
, defFlag "ignore-package" (HasArg ignorePackage)
, defFlag "syslib"
(HasArg (\s -> do exposePackage s
deprecate "Use -package instead"))
, defFlag "distrust-all-packages"
(NoArg (setGeneralFlag Opt_DistrustAllPackages))
, defFlag "trust" (HasArg trustPackage)
, defFlag "distrust" (HasArg distrustPackage)
]
where
setPackageEnv env = upd $ \s -> s { packageEnv = Just env }
-- | Make a list of flags for shell completion.
-- Filter all available flags into two groups, for interactive GHC vs all other. | 2,183 | package_flags :: [Flag (CmdLineP DynFlags)]
package_flags = [
------- Packages ----------------------------------------------------
defFlag "package-db" (HasArg (addPkgConfRef . PkgConfFile))
, defFlag "clear-package-db" (NoArg clearPkgConf)
, defFlag "no-global-package-db" (NoArg removeGlobalPkgConf)
, defFlag "no-user-package-db" (NoArg removeUserPkgConf)
, defFlag "global-package-db" (NoArg (addPkgConfRef GlobalPkgConf))
, defFlag "user-package-db" (NoArg (addPkgConfRef UserPkgConf))
-- backwards compat with GHC<=7.4 :
, defFlag "package-conf" (HasArg $ \path -> do
addPkgConfRef (PkgConfFile path)
deprecate "Use -package-db instead")
, defFlag "no-user-package-conf"
(NoArg $ do removeUserPkgConf
deprecate "Use -no-user-package-db instead")
, defGhcFlag "package-name" (hasArg setUnitId)
, defGhcFlag "this-package-key" (HasArg $ \uid -> do
upd (setUnitId uid)
deprecate "Use -this-unit-id instead")
, defGhcFlag "this-unit-id" (hasArg setUnitId)
, defFlag "package" (HasArg exposePackage)
, defFlag "package-id" (HasArg exposePackageId)
, defFlag "hide-package" (HasArg hidePackage)
, defFlag "hide-all-packages" (NoArg (setGeneralFlag Opt_HideAllPackages))
, defFlag "package-env" (HasArg setPackageEnv)
, defFlag "ignore-package" (HasArg ignorePackage)
, defFlag "syslib"
(HasArg (\s -> do exposePackage s
deprecate "Use -package instead"))
, defFlag "distrust-all-packages"
(NoArg (setGeneralFlag Opt_DistrustAllPackages))
, defFlag "trust" (HasArg trustPackage)
, defFlag "distrust" (HasArg distrustPackage)
]
where
setPackageEnv env = upd $ \s -> s { packageEnv = Just env }
-- | Make a list of flags for shell completion.
-- Filter all available flags into two groups, for interactive GHC vs all other. | 2,143 | package_flags = [
------- Packages ----------------------------------------------------
defFlag "package-db" (HasArg (addPkgConfRef . PkgConfFile))
, defFlag "clear-package-db" (NoArg clearPkgConf)
, defFlag "no-global-package-db" (NoArg removeGlobalPkgConf)
, defFlag "no-user-package-db" (NoArg removeUserPkgConf)
, defFlag "global-package-db" (NoArg (addPkgConfRef GlobalPkgConf))
, defFlag "user-package-db" (NoArg (addPkgConfRef UserPkgConf))
-- backwards compat with GHC<=7.4 :
, defFlag "package-conf" (HasArg $ \path -> do
addPkgConfRef (PkgConfFile path)
deprecate "Use -package-db instead")
, defFlag "no-user-package-conf"
(NoArg $ do removeUserPkgConf
deprecate "Use -no-user-package-db instead")
, defGhcFlag "package-name" (hasArg setUnitId)
, defGhcFlag "this-package-key" (HasArg $ \uid -> do
upd (setUnitId uid)
deprecate "Use -this-unit-id instead")
, defGhcFlag "this-unit-id" (hasArg setUnitId)
, defFlag "package" (HasArg exposePackage)
, defFlag "package-id" (HasArg exposePackageId)
, defFlag "hide-package" (HasArg hidePackage)
, defFlag "hide-all-packages" (NoArg (setGeneralFlag Opt_HideAllPackages))
, defFlag "package-env" (HasArg setPackageEnv)
, defFlag "ignore-package" (HasArg ignorePackage)
, defFlag "syslib"
(HasArg (\s -> do exposePackage s
deprecate "Use -package instead"))
, defFlag "distrust-all-packages"
(NoArg (setGeneralFlag Opt_DistrustAllPackages))
, defFlag "trust" (HasArg trustPackage)
, defFlag "distrust" (HasArg distrustPackage)
]
where
setPackageEnv env = upd $ \s -> s { packageEnv = Just env }
-- | Make a list of flags for shell completion.
-- Filter all available flags into two groups, for interactive GHC vs all other. | 2,099 | true | true | 0 | 14 | 628 | 461 | 231 | 230 | null | null |
a143753/AOJ | 0087.hs | apache-2.0 | op :: (Double -> Double -> Double) -> [String] -> [String]
op e (s0:s1:ss) =
let s0' = read s0 :: Double
s1' = read s1 :: Double
re = e s1' s0'
r' = show re
in
r':ss | 193 | op :: (Double -> Double -> Double) -> [String] -> [String]
op e (s0:s1:ss) =
let s0' = read s0 :: Double
s1' = read s1 :: Double
re = e s1' s0'
r' = show re
in
r':ss | 193 | op e (s0:s1:ss) =
let s0' = read s0 :: Double
s1' = read s1 :: Double
re = e s1' s0'
r' = show re
in
r':ss | 134 | false | true | 2 | 9 | 66 | 109 | 54 | 55 | null | null |
lambdacms/lambdacms.org | lambdacmsorg-tutorial/LambdaCmsOrg/Tutorial/Foundation.hs | mit | defaultTutorialAdminMenu :: LambdaCmsOrgTutorial master => (Route TutorialAdmin -> Route master) -> [AdminMenuItem master]
defaultTutorialAdminMenu tp = [ MenuItem (SomeMessage Msg.MenuTutorial) (tp TutorialAdminIndexR) "book" ] | 228 | defaultTutorialAdminMenu :: LambdaCmsOrgTutorial master => (Route TutorialAdmin -> Route master) -> [AdminMenuItem master]
defaultTutorialAdminMenu tp = [ MenuItem (SomeMessage Msg.MenuTutorial) (tp TutorialAdminIndexR) "book" ] | 228 | defaultTutorialAdminMenu tp = [ MenuItem (SomeMessage Msg.MenuTutorial) (tp TutorialAdminIndexR) "book" ] | 105 | false | true | 0 | 9 | 23 | 68 | 33 | 35 | null | null |
rsasse/tamarin-prover | lib/theory/src/Theory/Text/Parser/Token.hs | gpl-3.0 | -- | Parse a graph node variable.
nodevar :: Parser NodeId
nodevar = asum
[ sortedLVar [LSortNode]
, (\(n, i) -> LVar n LSortNode i) <$> indexedIdentifier ]
<?> "timepoint variable" | 187 | nodevar :: Parser NodeId
nodevar = asum
[ sortedLVar [LSortNode]
, (\(n, i) -> LVar n LSortNode i) <$> indexedIdentifier ]
<?> "timepoint variable" | 153 | nodevar = asum
[ sortedLVar [LSortNode]
, (\(n, i) -> LVar n LSortNode i) <$> indexedIdentifier ]
<?> "timepoint variable" | 128 | true | true | 2 | 9 | 36 | 61 | 32 | 29 | null | null |
sgillespie/ghc | compiler/codeGen/StgCmmPrim.hs | bsd-3-clause | callishOp _ = Nothing | 21 | callishOp _ = Nothing | 21 | callishOp _ = Nothing | 21 | false | false | 0 | 5 | 3 | 9 | 4 | 5 | null | null |
armoredsoftware/protocol | tpm/mainline/protoMonad/ProtoActions.hs | bsd-3-clause | --mconcat bslist
--where bslist = map tobs as
--Concrete unpacking implementation
unpackImpl :: Binary a => ByteString -> [a]
unpackImpl bs = decode bs | 153 | unpackImpl :: Binary a => ByteString -> [a]
unpackImpl bs = decode bs | 69 | unpackImpl bs = decode bs | 25 | true | true | 0 | 9 | 25 | 40 | 19 | 21 | null | null |
antalsz/hs-to-coq | src/lib/HsToCoq/ConvertHaskell/Type.hs | mit | convertType (HsDocTy NOEXTP ty _doc) =
convertLType ty | 56 | convertType (HsDocTy NOEXTP ty _doc) =
convertLType ty | 56 | convertType (HsDocTy NOEXTP ty _doc) =
convertLType ty | 56 | false | false | 0 | 7 | 9 | 22 | 10 | 12 | null | null |
afiskon/simple-neural-networks | src/MainXorLogistic.hs | bsd-2-clause | calcXor net x y =
let [r] = runNeuralNetwork net [x, y]
in r | 69 | calcXor net x y =
let [r] = runNeuralNetwork net [x, y]
in r | 69 | calcXor net x y =
let [r] = runNeuralNetwork net [x, y]
in r | 69 | false | false | 0 | 10 | 22 | 39 | 19 | 20 | null | null |
ony/Yampa-core | tests/AFRPTestsLaws.hs | bsd-3-clause | laws_t5_lhs :: [(Double, Double)]
laws_t5_lhs = testSF1 (arr dup >>> (first (integral >>> arr (+3.0)))) | 103 | laws_t5_lhs :: [(Double, Double)]
laws_t5_lhs = testSF1 (arr dup >>> (first (integral >>> arr (+3.0)))) | 103 | laws_t5_lhs = testSF1 (arr dup >>> (first (integral >>> arr (+3.0)))) | 69 | false | true | 0 | 13 | 14 | 53 | 29 | 24 | null | null |
ice1000/Kt2Dart | src/Statements.hs | agpl-3.0 | --
declarationP :: Parser String
declarationP = functionP
<|> propertyP
<|> classP
<|> typeAliasP
<|> objectP | 118 | declarationP :: Parser String
declarationP = functionP
<|> propertyP
<|> classP
<|> typeAliasP
<|> objectP | 114 | declarationP = functionP
<|> propertyP
<|> classP
<|> typeAliasP
<|> objectP | 84 | true | true | 12 | 5 | 24 | 44 | 24 | 20 | null | null |
GaloisInc/halvm-ghc | compiler/coreSyn/CoreSyn.hs | bsd-3-clause | -- | The number of argument expressions that are values rather than types at their top level
valArgCount :: [Arg b] -> Int
valArgCount = count isValArg | 151 | valArgCount :: [Arg b] -> Int
valArgCount = count isValArg | 58 | valArgCount = count isValArg | 28 | true | true | 0 | 8 | 26 | 32 | 14 | 18 | null | null |
fcostantini/QuickFuzz | src/DeriveMArbitrary.hs | gpl-3.0 | compat tname (ConT c) = unqualify tname == unqualify c | 54 | compat tname (ConT c) = unqualify tname == unqualify c | 54 | compat tname (ConT c) = unqualify tname == unqualify c | 54 | false | false | 0 | 7 | 9 | 27 | 12 | 15 | null | null |
bens/hurtle | test-src/Main.hs | apache-2.0 | joinXs :: Int -> Hurtle s TestConn [Int]
joinXs = makeGolden $ \xm xsm ysm -> do
xs <- xsm
return $ do
x <- xm
ys <- ysm
return $ x : xs ++ ys | 175 | joinXs :: Int -> Hurtle s TestConn [Int]
joinXs = makeGolden $ \xm xsm ysm -> do
xs <- xsm
return $ do
x <- xm
ys <- ysm
return $ x : xs ++ ys | 175 | joinXs = makeGolden $ \xm xsm ysm -> do
xs <- xsm
return $ do
x <- xm
ys <- ysm
return $ x : xs ++ ys | 134 | false | true | 0 | 14 | 68 | 81 | 39 | 42 | null | null |
RossMeikleham/Idris-dev | src/IRTS/CodegenC.hs | bsd-3-clause | doOp v (LEq ATFloat) [l, r] = v ++ "FLOATBOP(==," ++ creg l ++ ", " ++ creg r ++ ")" | 84 | doOp v (LEq ATFloat) [l, r] = v ++ "FLOATBOP(==," ++ creg l ++ ", " ++ creg r ++ ")" | 84 | doOp v (LEq ATFloat) [l, r] = v ++ "FLOATBOP(==," ++ creg l ++ ", " ++ creg r ++ ")" | 84 | false | false | 0 | 9 | 20 | 51 | 25 | 26 | null | null |
prl-tokyo/bigul-configuration-adaptation | Transformations/src/BiFlux/Trans/Translation.hs | mit | varPat2DirectionEnv (VarT var _) dynRPat@(DynR tv' ev' RVar) = return $ Map.singleton var (DynD tv' ev' tv' DVar RVar) | 118 | varPat2DirectionEnv (VarT var _) dynRPat@(DynR tv' ev' RVar) = return $ Map.singleton var (DynD tv' ev' tv' DVar RVar) | 118 | varPat2DirectionEnv (VarT var _) dynRPat@(DynR tv' ev' RVar) = return $ Map.singleton var (DynD tv' ev' tv' DVar RVar) | 118 | false | false | 0 | 8 | 18 | 57 | 28 | 29 | null | null |
mightybyte/reflex-dom-stubs | src/GHCJS/DOM/HTMLElement.hs | bsd-3-clause | ghcjs_dom_html_element_get_webkitdropzone = undefined | 53 | ghcjs_dom_html_element_get_webkitdropzone = undefined | 53 | ghcjs_dom_html_element_get_webkitdropzone = undefined | 53 | false | false | 0 | 4 | 2 | 6 | 3 | 3 | null | null |
blamario/incremental-parser | Test/TestIncrementalParser.hs | gpl-3.0 | parser3l :: TestParser LeftBiasedLocal (String, String, String)
parser3l = undefined | 84 | parser3l :: TestParser LeftBiasedLocal (String, String, String)
parser3l = undefined | 84 | parser3l = undefined | 20 | false | true | 0 | 6 | 9 | 25 | 14 | 11 | null | null |
alexander-at-github/eta | compiler/ETA/TypeCheck/TcType.hs | bsd-3-clause | -----------------------
tcTyConAppTyCon :: Type -> TyCon
tcTyConAppTyCon ty = case tcSplitTyConApp_maybe ty of
Just (tc, _) -> tc
Nothing -> pprPanic "tcTyConAppTyCon" (pprType ty) | 233 | tcTyConAppTyCon :: Type -> TyCon
tcTyConAppTyCon ty = case tcSplitTyConApp_maybe ty of
Just (tc, _) -> tc
Nothing -> pprPanic "tcTyConAppTyCon" (pprType ty) | 209 | tcTyConAppTyCon ty = case tcSplitTyConApp_maybe ty of
Just (tc, _) -> tc
Nothing -> pprPanic "tcTyConAppTyCon" (pprType ty) | 176 | true | true | 0 | 10 | 76 | 58 | 29 | 29 | null | null |
polux/snippets | Merge.hs | apache-2.0 | lparen = symbol (char '(') | 26 | lparen = symbol (char '(') | 26 | lparen = symbol (char '(') | 26 | false | false | 1 | 7 | 4 | 19 | 7 | 12 | null | null |
phadej/streaming-commons | test/Data/Streaming/ByteString/BuilderSpec.hs | mit | testerFlush :: StreamingBuilder b
=> BufferAllocStrategy -> [Maybe b] -> IO [Maybe S.ByteString]
testerFlush strat builders0 = do
(recv, finish) <- newBuilderRecv strat
let loop front [] = do
mbs <- finish
return $ front $ maybe [] (return . Just) mbs
loop front0 (mbu:bus) = do
popper <- recv $ fromMaybe builderFlush mbu
let go front = do
bs <- popper
if S.null bs
then
case mbu of
Nothing -> loop (front . (Nothing:)) bus
Just _ -> loop front bus
else go (front . (Just bs:))
go front0
loop id builders0 | 778 | testerFlush :: StreamingBuilder b
=> BufferAllocStrategy -> [Maybe b] -> IO [Maybe S.ByteString]
testerFlush strat builders0 = do
(recv, finish) <- newBuilderRecv strat
let loop front [] = do
mbs <- finish
return $ front $ maybe [] (return . Just) mbs
loop front0 (mbu:bus) = do
popper <- recv $ fromMaybe builderFlush mbu
let go front = do
bs <- popper
if S.null bs
then
case mbu of
Nothing -> loop (front . (Nothing:)) bus
Just _ -> loop front bus
else go (front . (Just bs:))
go front0
loop id builders0 | 778 | testerFlush strat builders0 = do
(recv, finish) <- newBuilderRecv strat
let loop front [] = do
mbs <- finish
return $ front $ maybe [] (return . Just) mbs
loop front0 (mbu:bus) = do
popper <- recv $ fromMaybe builderFlush mbu
let go front = do
bs <- popper
if S.null bs
then
case mbu of
Nothing -> loop (front . (Nothing:)) bus
Just _ -> loop front bus
else go (front . (Just bs:))
go front0
loop id builders0 | 669 | false | true | 0 | 24 | 364 | 253 | 120 | 133 | null | null |
suhailshergill/hakaru | Historical/Partial.hs | bsd-3-clause | toDynamic :: Partial repr a -> Maybe (repr a)
toDynamic (Partial d _) = d | 73 | toDynamic :: Partial repr a -> Maybe (repr a)
toDynamic (Partial d _) = d | 73 | toDynamic (Partial d _) = d | 27 | false | true | 0 | 8 | 14 | 40 | 19 | 21 | null | null |
lih/Alpha | src/Context/Language.hs | bsd-2-clause | createSym l@(Language { maxIDL = m }) = (m,l { maxIDL = succ m }) | 65 | createSym l@(Language { maxIDL = m }) = (m,l { maxIDL = succ m }) | 65 | createSym l@(Language { maxIDL = m }) = (m,l { maxIDL = succ m }) | 65 | false | false | 7 | 6 | 14 | 46 | 23 | 23 | null | null |
geophf/1HaskellADay | exercises/HAD/Control/Map.hs | mit | {--
for example:
to make a simple multimap from a [(k,v)]
snarf return
If we have something like:
match :: Map Name Winery -> (Neo4jIxWinery, Country) -> Maybe (Country, IxWikiWinery)
match m (neo, c) = (c,) . flip IxWiki (ix neo) <$> Map.lookup (namei neo) m
see Y2021.M01.D29.Solution
then
snarf (match . byName) (translateByCountry)
gets you WineriesByCountry
(the ByCountry a map-type is used here)
--}
-- now when we which to preserve, say: two transactions that look the same, ...
snarfL :: Ord c => (a -> Maybe (c,d)) -> [a] -> Map c [d]
snarfL f = foldr inserterL Map.empty . mapMaybe f | 605 | snarfL :: Ord c => (a -> Maybe (c,d)) -> [a] -> Map c [d]
snarfL f = foldr inserterL Map.empty . mapMaybe f | 107 | snarfL f = foldr inserterL Map.empty . mapMaybe f | 49 | true | true | 0 | 10 | 114 | 72 | 37 | 35 | null | null |
spechub/Hets | CASL/Sign.hs | gpl-2.0 | addSort :: SortsKind -> Annoted a -> SORT -> State.State (Sign f e) ()
addSort sk a s = do
e <- State.get
let r = sortRel e
em = emptySortSet e
known = Rel.memberKey s r
if known then addDiags [mkDiag Hint "redeclared sort" s]
else do
State.put e { sortRel = Rel.insertKey s r }
addDiags $ checkNamePrefix s
case sk of
NonEmptySorts -> when (Set.member s em) $ do
e2 <- State.get
State.put e2 { emptySortSet = Set.delete s em }
addDiags [mkDiag Warning "redeclared sort as non-empty" s]
PossiblyEmptySorts -> if known then
addDiags [mkDiag Warning "non-empty sort remains non-empty" s]
else do
e2 <- State.get
State.put e2 { emptySortSet = Set.insert s em }
addAnnoSet a $ Symbol s SortAsItemType | 794 | addSort :: SortsKind -> Annoted a -> SORT -> State.State (Sign f e) ()
addSort sk a s = do
e <- State.get
let r = sortRel e
em = emptySortSet e
known = Rel.memberKey s r
if known then addDiags [mkDiag Hint "redeclared sort" s]
else do
State.put e { sortRel = Rel.insertKey s r }
addDiags $ checkNamePrefix s
case sk of
NonEmptySorts -> when (Set.member s em) $ do
e2 <- State.get
State.put e2 { emptySortSet = Set.delete s em }
addDiags [mkDiag Warning "redeclared sort as non-empty" s]
PossiblyEmptySorts -> if known then
addDiags [mkDiag Warning "non-empty sort remains non-empty" s]
else do
e2 <- State.get
State.put e2 { emptySortSet = Set.insert s em }
addAnnoSet a $ Symbol s SortAsItemType | 794 | addSort sk a s = do
e <- State.get
let r = sortRel e
em = emptySortSet e
known = Rel.memberKey s r
if known then addDiags [mkDiag Hint "redeclared sort" s]
else do
State.put e { sortRel = Rel.insertKey s r }
addDiags $ checkNamePrefix s
case sk of
NonEmptySorts -> when (Set.member s em) $ do
e2 <- State.get
State.put e2 { emptySortSet = Set.delete s em }
addDiags [mkDiag Warning "redeclared sort as non-empty" s]
PossiblyEmptySorts -> if known then
addDiags [mkDiag Warning "non-empty sort remains non-empty" s]
else do
e2 <- State.get
State.put e2 { emptySortSet = Set.insert s em }
addAnnoSet a $ Symbol s SortAsItemType | 723 | false | true | 0 | 17 | 222 | 300 | 141 | 159 | null | null |
aszlig/language-javascript | src/Language/JavaScript/Parser/AST.hs | bsd-3-clause | showStrippedNode (JSLabelled x1 _c x2) = "JSLabelled (" ++ ss x1 ++ ") (" ++ ss x2 ++ ")" | 89 | showStrippedNode (JSLabelled x1 _c x2) = "JSLabelled (" ++ ss x1 ++ ") (" ++ ss x2 ++ ")" | 89 | showStrippedNode (JSLabelled x1 _c x2) = "JSLabelled (" ++ ss x1 ++ ") (" ++ ss x2 ++ ")" | 89 | false | false | 0 | 9 | 18 | 42 | 19 | 23 | null | null |
ihc/futhark | src/Futhark/Pass/ExtractKernels.hs | isc | transformStm (Let pat _ (Op (Stream w
(Parallel o comm red_fun nes) fold_fun arrs)))
| Just fold_fun' <- extLambdaToLambda fold_fun = do
-- Generate a kernel immediately.
red_fun_sequential <- Kernelise.transformLambda red_fun
fold_fun_sequential <- Kernelise.transformLambda fold_fun'
blockedReductionStream pat w comm' red_fun_sequential fold_fun_sequential nes arrs
where comm' | commutativeLambda red_fun, o /= InOrder = Commutative
| otherwise = comm | 542 | transformStm (Let pat _ (Op (Stream w
(Parallel o comm red_fun nes) fold_fun arrs)))
| Just fold_fun' <- extLambdaToLambda fold_fun = do
-- Generate a kernel immediately.
red_fun_sequential <- Kernelise.transformLambda red_fun
fold_fun_sequential <- Kernelise.transformLambda fold_fun'
blockedReductionStream pat w comm' red_fun_sequential fold_fun_sequential nes arrs
where comm' | commutativeLambda red_fun, o /= InOrder = Commutative
| otherwise = comm | 542 | transformStm (Let pat _ (Op (Stream w
(Parallel o comm red_fun nes) fold_fun arrs)))
| Just fold_fun' <- extLambdaToLambda fold_fun = do
-- Generate a kernel immediately.
red_fun_sequential <- Kernelise.transformLambda red_fun
fold_fun_sequential <- Kernelise.transformLambda fold_fun'
blockedReductionStream pat w comm' red_fun_sequential fold_fun_sequential nes arrs
where comm' | commutativeLambda red_fun, o /= InOrder = Commutative
| otherwise = comm | 542 | false | false | 1 | 12 | 143 | 145 | 65 | 80 | null | null |
unknownloner/calccomp | Asm/QQ.hs | mit | parseExp f s = case P.parseExp s of
Left err -> fail err
Right x -> f `appE` return x | 119 | parseExp f s = case P.parseExp s of
Left err -> fail err
Right x -> f `appE` return x | 119 | parseExp f s = case P.parseExp s of
Left err -> fail err
Right x -> f `appE` return x | 119 | false | false | 0 | 9 | 53 | 50 | 23 | 27 | null | null |
thenaesh/SoCFault | src/Config.hs | gpl-3.0 | loadConfig :: FilePath -> IO Config
loadConfig fileName = do
file <- B.readFile path
case decode file of
Nothing -> error errorMsg -- unrecoverable error, terminate the program
Just config -> return config
where
path = mconcat [basePath, "/", fileName]
basePath = "config"
errorMsg = "Error reading " ++ fileName ++ "!" | 371 | loadConfig :: FilePath -> IO Config
loadConfig fileName = do
file <- B.readFile path
case decode file of
Nothing -> error errorMsg -- unrecoverable error, terminate the program
Just config -> return config
where
path = mconcat [basePath, "/", fileName]
basePath = "config"
errorMsg = "Error reading " ++ fileName ++ "!" | 371 | loadConfig fileName = do
file <- B.readFile path
case decode file of
Nothing -> error errorMsg -- unrecoverable error, terminate the program
Just config -> return config
where
path = mconcat [basePath, "/", fileName]
basePath = "config"
errorMsg = "Error reading " ++ fileName ++ "!" | 335 | false | true | 2 | 10 | 103 | 105 | 50 | 55 | null | null |
simonmichael/hledger | hledger-lib/Hledger/Read/CsvReader.hs | gpl-3.0 | tests_CsvReader = testGroup "CsvReader" [
testGroup "parseCsvRules" [
testCase "empty file" $
parseCsvRules "unknown" "" @?= Right (mkrules defrules)
]
,testGroup "rulesp" [
testCase "trailing comments" $
parseWithState' defrules rulesp "skip\n# \n#\n" @?= Right (mkrules $ defrules{rdirectives = [("skip","")]})
,testCase "trailing blank lines" $
parseWithState' defrules rulesp "skip\n\n \n" @?= (Right (mkrules $ defrules{rdirectives = [("skip","")]}))
,testCase "no final newline" $
parseWithState' defrules rulesp "skip" @?= (Right (mkrules $ defrules{rdirectives=[("skip","")]}))
,testCase "assignment with empty value" $
parseWithState' defrules rulesp "account1 \nif foo\n account2 foo\n" @?=
(Right (mkrules $ defrules{rassignments = [("account1","")], rconditionalblocks = [CB{cbMatchers=[RecordMatcher None (toRegex' "foo")],cbAssignments=[("account2","foo")]}]}))
]
,testGroup "conditionalblockp" [
testCase "space after conditional" $ -- #1120
parseWithState' defrules conditionalblockp "if a\n account2 b\n \n" @?=
(Right $ CB{cbMatchers=[RecordMatcher None $ toRegexCI' "a"],cbAssignments=[("account2","b")]})
,testGroup "csvfieldreferencep" [
testCase "number" $ parseWithState' defrules csvfieldreferencep "%1" @?= (Right "%1")
,testCase "name" $ parseWithState' defrules csvfieldreferencep "%date" @?= (Right "%date")
,testCase "quoted name" $ parseWithState' defrules csvfieldreferencep "%\"csv date\"" @?= (Right "%\"csv date\"")
]
,testGroup "matcherp" [
testCase "recordmatcherp" $
parseWithState' defrules matcherp "A A\n" @?= (Right $ RecordMatcher None $ toRegexCI' "A A")
,testCase "recordmatcherp.starts-with-&" $
parseWithState' defrules matcherp "& A A\n" @?= (Right $ RecordMatcher And $ toRegexCI' "A A")
,testCase "fieldmatcherp.starts-with-%" $
parseWithState' defrules matcherp "description A A\n" @?= (Right $ RecordMatcher None $ toRegexCI' "description A A")
,testCase "fieldmatcherp" $
parseWithState' defrules matcherp "%description A A\n" @?= (Right $ FieldMatcher None "%description" $ toRegexCI' "A A")
,testCase "fieldmatcherp.starts-with-&" $
parseWithState' defrules matcherp "& %description A A\n" @?= (Right $ FieldMatcher And "%description" $ toRegexCI' "A A")
-- ,testCase "fieldmatcherp with operator" $
-- parseWithState' defrules matcherp "%description ~ A A\n" @?= (Right $ FieldMatcher "%description" "A A")
]
,testGroup "getEffectiveAssignment" [
let rules = mkrules $ defrules {rcsvfieldindexes=[("csvdate",1)],rassignments=[("date","%csvdate")]}
in testCase "toplevel" $ getEffectiveAssignment rules ["a","b"] "date" @?= (Just "%csvdate")
,let rules = mkrules $ defrules{rcsvfieldindexes=[("csvdate",1)], rconditionalblocks=[CB [FieldMatcher None "%csvdate" $ toRegex' "a"] [("date","%csvdate")]]}
in testCase "conditional" $ getEffectiveAssignment rules ["a","b"] "date" @?= (Just "%csvdate")
,let rules = mkrules $ defrules{rcsvfieldindexes=[("csvdate",1),("description",2)], rconditionalblocks=[CB [FieldMatcher None "%csvdate" $ toRegex' "a", FieldMatcher None "%description" $ toRegex' "b"] [("date","%csvdate")]]}
in testCase "conditional-with-or-a" $ getEffectiveAssignment rules ["a"] "date" @?= (Just "%csvdate")
,let rules = mkrules $ defrules{rcsvfieldindexes=[("csvdate",1),("description",2)], rconditionalblocks=[CB [FieldMatcher None "%csvdate" $ toRegex' "a", FieldMatcher None "%description" $ toRegex' "b"] [("date","%csvdate")]]}
in testCase "conditional-with-or-b" $ getEffectiveAssignment rules ["_", "b"] "date" @?= (Just "%csvdate")
,let rules = mkrules $ defrules{rcsvfieldindexes=[("csvdate",1),("description",2)], rconditionalblocks=[CB [FieldMatcher None "%csvdate" $ toRegex' "a", FieldMatcher And "%description" $ toRegex' "b"] [("date","%csvdate")]]}
in testCase "conditional.with-and" $ getEffectiveAssignment rules ["a", "b"] "date" @?= (Just "%csvdate")
,let rules = mkrules $ defrules{rcsvfieldindexes=[("csvdate",1),("description",2)], rconditionalblocks=[CB [FieldMatcher None "%csvdate" $ toRegex' "a", FieldMatcher And "%description" $ toRegex' "b", FieldMatcher None "%description" $ toRegex' "c"] [("date","%csvdate")]]}
in testCase "conditional.with-and-or" $ getEffectiveAssignment rules ["_", "c"] "date" @?= (Just "%csvdate")
]
]
] | 4,472 | tests_CsvReader = testGroup "CsvReader" [
testGroup "parseCsvRules" [
testCase "empty file" $
parseCsvRules "unknown" "" @?= Right (mkrules defrules)
]
,testGroup "rulesp" [
testCase "trailing comments" $
parseWithState' defrules rulesp "skip\n# \n#\n" @?= Right (mkrules $ defrules{rdirectives = [("skip","")]})
,testCase "trailing blank lines" $
parseWithState' defrules rulesp "skip\n\n \n" @?= (Right (mkrules $ defrules{rdirectives = [("skip","")]}))
,testCase "no final newline" $
parseWithState' defrules rulesp "skip" @?= (Right (mkrules $ defrules{rdirectives=[("skip","")]}))
,testCase "assignment with empty value" $
parseWithState' defrules rulesp "account1 \nif foo\n account2 foo\n" @?=
(Right (mkrules $ defrules{rassignments = [("account1","")], rconditionalblocks = [CB{cbMatchers=[RecordMatcher None (toRegex' "foo")],cbAssignments=[("account2","foo")]}]}))
]
,testGroup "conditionalblockp" [
testCase "space after conditional" $ -- #1120
parseWithState' defrules conditionalblockp "if a\n account2 b\n \n" @?=
(Right $ CB{cbMatchers=[RecordMatcher None $ toRegexCI' "a"],cbAssignments=[("account2","b")]})
,testGroup "csvfieldreferencep" [
testCase "number" $ parseWithState' defrules csvfieldreferencep "%1" @?= (Right "%1")
,testCase "name" $ parseWithState' defrules csvfieldreferencep "%date" @?= (Right "%date")
,testCase "quoted name" $ parseWithState' defrules csvfieldreferencep "%\"csv date\"" @?= (Right "%\"csv date\"")
]
,testGroup "matcherp" [
testCase "recordmatcherp" $
parseWithState' defrules matcherp "A A\n" @?= (Right $ RecordMatcher None $ toRegexCI' "A A")
,testCase "recordmatcherp.starts-with-&" $
parseWithState' defrules matcherp "& A A\n" @?= (Right $ RecordMatcher And $ toRegexCI' "A A")
,testCase "fieldmatcherp.starts-with-%" $
parseWithState' defrules matcherp "description A A\n" @?= (Right $ RecordMatcher None $ toRegexCI' "description A A")
,testCase "fieldmatcherp" $
parseWithState' defrules matcherp "%description A A\n" @?= (Right $ FieldMatcher None "%description" $ toRegexCI' "A A")
,testCase "fieldmatcherp.starts-with-&" $
parseWithState' defrules matcherp "& %description A A\n" @?= (Right $ FieldMatcher And "%description" $ toRegexCI' "A A")
-- ,testCase "fieldmatcherp with operator" $
-- parseWithState' defrules matcherp "%description ~ A A\n" @?= (Right $ FieldMatcher "%description" "A A")
]
,testGroup "getEffectiveAssignment" [
let rules = mkrules $ defrules {rcsvfieldindexes=[("csvdate",1)],rassignments=[("date","%csvdate")]}
in testCase "toplevel" $ getEffectiveAssignment rules ["a","b"] "date" @?= (Just "%csvdate")
,let rules = mkrules $ defrules{rcsvfieldindexes=[("csvdate",1)], rconditionalblocks=[CB [FieldMatcher None "%csvdate" $ toRegex' "a"] [("date","%csvdate")]]}
in testCase "conditional" $ getEffectiveAssignment rules ["a","b"] "date" @?= (Just "%csvdate")
,let rules = mkrules $ defrules{rcsvfieldindexes=[("csvdate",1),("description",2)], rconditionalblocks=[CB [FieldMatcher None "%csvdate" $ toRegex' "a", FieldMatcher None "%description" $ toRegex' "b"] [("date","%csvdate")]]}
in testCase "conditional-with-or-a" $ getEffectiveAssignment rules ["a"] "date" @?= (Just "%csvdate")
,let rules = mkrules $ defrules{rcsvfieldindexes=[("csvdate",1),("description",2)], rconditionalblocks=[CB [FieldMatcher None "%csvdate" $ toRegex' "a", FieldMatcher None "%description" $ toRegex' "b"] [("date","%csvdate")]]}
in testCase "conditional-with-or-b" $ getEffectiveAssignment rules ["_", "b"] "date" @?= (Just "%csvdate")
,let rules = mkrules $ defrules{rcsvfieldindexes=[("csvdate",1),("description",2)], rconditionalblocks=[CB [FieldMatcher None "%csvdate" $ toRegex' "a", FieldMatcher And "%description" $ toRegex' "b"] [("date","%csvdate")]]}
in testCase "conditional.with-and" $ getEffectiveAssignment rules ["a", "b"] "date" @?= (Just "%csvdate")
,let rules = mkrules $ defrules{rcsvfieldindexes=[("csvdate",1),("description",2)], rconditionalblocks=[CB [FieldMatcher None "%csvdate" $ toRegex' "a", FieldMatcher And "%description" $ toRegex' "b", FieldMatcher None "%description" $ toRegex' "c"] [("date","%csvdate")]]}
in testCase "conditional.with-and-or" $ getEffectiveAssignment rules ["_", "c"] "date" @?= (Just "%csvdate")
]
]
] | 4,472 | tests_CsvReader = testGroup "CsvReader" [
testGroup "parseCsvRules" [
testCase "empty file" $
parseCsvRules "unknown" "" @?= Right (mkrules defrules)
]
,testGroup "rulesp" [
testCase "trailing comments" $
parseWithState' defrules rulesp "skip\n# \n#\n" @?= Right (mkrules $ defrules{rdirectives = [("skip","")]})
,testCase "trailing blank lines" $
parseWithState' defrules rulesp "skip\n\n \n" @?= (Right (mkrules $ defrules{rdirectives = [("skip","")]}))
,testCase "no final newline" $
parseWithState' defrules rulesp "skip" @?= (Right (mkrules $ defrules{rdirectives=[("skip","")]}))
,testCase "assignment with empty value" $
parseWithState' defrules rulesp "account1 \nif foo\n account2 foo\n" @?=
(Right (mkrules $ defrules{rassignments = [("account1","")], rconditionalblocks = [CB{cbMatchers=[RecordMatcher None (toRegex' "foo")],cbAssignments=[("account2","foo")]}]}))
]
,testGroup "conditionalblockp" [
testCase "space after conditional" $ -- #1120
parseWithState' defrules conditionalblockp "if a\n account2 b\n \n" @?=
(Right $ CB{cbMatchers=[RecordMatcher None $ toRegexCI' "a"],cbAssignments=[("account2","b")]})
,testGroup "csvfieldreferencep" [
testCase "number" $ parseWithState' defrules csvfieldreferencep "%1" @?= (Right "%1")
,testCase "name" $ parseWithState' defrules csvfieldreferencep "%date" @?= (Right "%date")
,testCase "quoted name" $ parseWithState' defrules csvfieldreferencep "%\"csv date\"" @?= (Right "%\"csv date\"")
]
,testGroup "matcherp" [
testCase "recordmatcherp" $
parseWithState' defrules matcherp "A A\n" @?= (Right $ RecordMatcher None $ toRegexCI' "A A")
,testCase "recordmatcherp.starts-with-&" $
parseWithState' defrules matcherp "& A A\n" @?= (Right $ RecordMatcher And $ toRegexCI' "A A")
,testCase "fieldmatcherp.starts-with-%" $
parseWithState' defrules matcherp "description A A\n" @?= (Right $ RecordMatcher None $ toRegexCI' "description A A")
,testCase "fieldmatcherp" $
parseWithState' defrules matcherp "%description A A\n" @?= (Right $ FieldMatcher None "%description" $ toRegexCI' "A A")
,testCase "fieldmatcherp.starts-with-&" $
parseWithState' defrules matcherp "& %description A A\n" @?= (Right $ FieldMatcher And "%description" $ toRegexCI' "A A")
-- ,testCase "fieldmatcherp with operator" $
-- parseWithState' defrules matcherp "%description ~ A A\n" @?= (Right $ FieldMatcher "%description" "A A")
]
,testGroup "getEffectiveAssignment" [
let rules = mkrules $ defrules {rcsvfieldindexes=[("csvdate",1)],rassignments=[("date","%csvdate")]}
in testCase "toplevel" $ getEffectiveAssignment rules ["a","b"] "date" @?= (Just "%csvdate")
,let rules = mkrules $ defrules{rcsvfieldindexes=[("csvdate",1)], rconditionalblocks=[CB [FieldMatcher None "%csvdate" $ toRegex' "a"] [("date","%csvdate")]]}
in testCase "conditional" $ getEffectiveAssignment rules ["a","b"] "date" @?= (Just "%csvdate")
,let rules = mkrules $ defrules{rcsvfieldindexes=[("csvdate",1),("description",2)], rconditionalblocks=[CB [FieldMatcher None "%csvdate" $ toRegex' "a", FieldMatcher None "%description" $ toRegex' "b"] [("date","%csvdate")]]}
in testCase "conditional-with-or-a" $ getEffectiveAssignment rules ["a"] "date" @?= (Just "%csvdate")
,let rules = mkrules $ defrules{rcsvfieldindexes=[("csvdate",1),("description",2)], rconditionalblocks=[CB [FieldMatcher None "%csvdate" $ toRegex' "a", FieldMatcher None "%description" $ toRegex' "b"] [("date","%csvdate")]]}
in testCase "conditional-with-or-b" $ getEffectiveAssignment rules ["_", "b"] "date" @?= (Just "%csvdate")
,let rules = mkrules $ defrules{rcsvfieldindexes=[("csvdate",1),("description",2)], rconditionalblocks=[CB [FieldMatcher None "%csvdate" $ toRegex' "a", FieldMatcher And "%description" $ toRegex' "b"] [("date","%csvdate")]]}
in testCase "conditional.with-and" $ getEffectiveAssignment rules ["a", "b"] "date" @?= (Just "%csvdate")
,let rules = mkrules $ defrules{rcsvfieldindexes=[("csvdate",1),("description",2)], rconditionalblocks=[CB [FieldMatcher None "%csvdate" $ toRegex' "a", FieldMatcher And "%description" $ toRegex' "b", FieldMatcher None "%description" $ toRegex' "c"] [("date","%csvdate")]]}
in testCase "conditional.with-and-or" $ getEffectiveAssignment rules ["_", "c"] "date" @?= (Just "%csvdate")
]
]
] | 4,472 | false | false | 0 | 22 | 701 | 1,379 | 731 | 648 | null | null |
arne-schroppe/dash | src/Language/Dash/BuiltIn/BuiltInDefinitions.hs | mit | bifStringLengthName = "string_length" | 37 | bifStringLengthName = "string_length" | 37 | bifStringLengthName = "string_length" | 37 | false | false | 0 | 4 | 2 | 6 | 3 | 3 | null | null |
nomeata/cryptonite | Crypto/PubKey/RSA.hs | bsd-3-clause | {-
-- some bad implementation will not serialize ASN.1 integer properly, leading
-- to negative modulus.
-- TODO : Find a better place for this
toPositive :: Integer -> Integer
toPositive int
| int < 0 = uintOfBytes $ bytesOfInt int
| otherwise = int
where uintOfBytes = foldl (\acc n -> (acc `shiftL` 8) + fromIntegral n) 0
bytesOfInt :: Integer -> [Word8]
bytesOfInt n = if testBit (head nints) 7 then nints else 0xff : nints
where nints = reverse $ plusOne $ reverse $ map complement $ bytesOfUInt (abs n)
plusOne [] = [1]
plusOne (x:xs) = if x == 0xff then 0 : plusOne xs else (x+1) : xs
bytesOfUInt x = reverse (list x)
where list i = if i <= 0xff then [fromIntegral i] else (fromIntegral i .&. 0xff) : list (i `shiftR` 8)
-}
-- | Generate a key pair given p and q.
--
-- p and q need to be distinct prime numbers.
--
-- e need to be coprime to phi=(p-1)*(q-1). If that's not the
-- case, the function will not return a key pair.
-- A small hamming weight results in better performance.
--
-- * e=0x10001 is a popular choice
--
-- * e=3 is popular as well, but proven to not be as secure for some cases.
--
generateWith :: (Integer, Integer) -- ^ chosen distinct primes p and q
-> Int -- ^ size in bytes
-> Integer -- ^ RSA public exponant 'e'
-> Maybe (PublicKey, PrivateKey)
generateWith (p,q) size e =
case inverse e phi of
Nothing -> Nothing
Just d -> Just (pub,priv d)
where n = p*q
phi = (p-1)*(q-1)
-- q and p should be *distinct* *prime* numbers, hence always coprime
qinv = inverseCoprimes q p
pub = PublicKey { public_size = size
, public_n = n
, public_e = e
}
priv d = PrivateKey { private_pub = pub
, private_d = d
, private_p = p
, private_q = q
, private_dP = d `mod` (p-1)
, private_dQ = d `mod` (q-1)
, private_qinv = qinv
}
-- | generate a pair of (private, public) key of size in bytes. | 2,338 | generateWith :: (Integer, Integer) -- ^ chosen distinct primes p and q
-> Int -- ^ size in bytes
-> Integer -- ^ RSA public exponant 'e'
-> Maybe (PublicKey, PrivateKey)
generateWith (p,q) size e =
case inverse e phi of
Nothing -> Nothing
Just d -> Just (pub,priv d)
where n = p*q
phi = (p-1)*(q-1)
-- q and p should be *distinct* *prime* numbers, hence always coprime
qinv = inverseCoprimes q p
pub = PublicKey { public_size = size
, public_n = n
, public_e = e
}
priv d = PrivateKey { private_pub = pub
, private_d = d
, private_p = p
, private_q = q
, private_dP = d `mod` (p-1)
, private_dQ = d `mod` (q-1)
, private_qinv = qinv
}
-- | generate a pair of (private, public) key of size in bytes. | 1,117 | generateWith (p,q) size e =
case inverse e phi of
Nothing -> Nothing
Just d -> Just (pub,priv d)
where n = p*q
phi = (p-1)*(q-1)
-- q and p should be *distinct* *prime* numbers, hence always coprime
qinv = inverseCoprimes q p
pub = PublicKey { public_size = size
, public_n = n
, public_e = e
}
priv d = PrivateKey { private_pub = pub
, private_d = d
, private_p = p
, private_q = q
, private_dP = d `mod` (p-1)
, private_dQ = d `mod` (q-1)
, private_qinv = qinv
}
-- | generate a pair of (private, public) key of size in bytes. | 882 | true | true | 7 | 10 | 888 | 284 | 155 | 129 | null | null |
mettekou/ghc | compiler/nativeGen/PPC/Ppr.hs | bsd-3-clause | pprBasicBlock :: BlockEnv CmmStatics -> NatBasicBlock Instr -> SDoc
pprBasicBlock info_env (BasicBlock blockid instrs)
= maybe_infotable $$
pprLabel (mkAsmTempLabel (getUnique blockid)) $$
vcat (map pprInstr instrs)
where
maybe_infotable = case mapLookup blockid info_env of
Nothing -> empty
Just (Statics info_lbl info) ->
pprAlignForSection Text $$
vcat (map pprData info) $$
pprLabel info_lbl | 460 | pprBasicBlock :: BlockEnv CmmStatics -> NatBasicBlock Instr -> SDoc
pprBasicBlock info_env (BasicBlock blockid instrs)
= maybe_infotable $$
pprLabel (mkAsmTempLabel (getUnique blockid)) $$
vcat (map pprInstr instrs)
where
maybe_infotable = case mapLookup blockid info_env of
Nothing -> empty
Just (Statics info_lbl info) ->
pprAlignForSection Text $$
vcat (map pprData info) $$
pprLabel info_lbl | 460 | pprBasicBlock info_env (BasicBlock blockid instrs)
= maybe_infotable $$
pprLabel (mkAsmTempLabel (getUnique blockid)) $$
vcat (map pprInstr instrs)
where
maybe_infotable = case mapLookup blockid info_env of
Nothing -> empty
Just (Statics info_lbl info) ->
pprAlignForSection Text $$
vcat (map pprData info) $$
pprLabel info_lbl | 392 | false | true | 0 | 12 | 116 | 141 | 65 | 76 | null | null |
fpco/cabal | Cabal/Distribution/Simple/Program/Db.hs | bsd-3-clause | -- -------------------------------
-- Managing unconfigured programs
-- | Add a known program that we may configure later
--
addKnownProgram :: Program -> ProgramDb -> ProgramDb
addKnownProgram prog = updateUnconfiguredProgs $
Map.insertWith combine (programName prog) (prog, Nothing, [])
where combine _ (_, path, args) = (prog, path, args) | 346 | addKnownProgram :: Program -> ProgramDb -> ProgramDb
addKnownProgram prog = updateUnconfiguredProgs $
Map.insertWith combine (programName prog) (prog, Nothing, [])
where combine _ (_, path, args) = (prog, path, args) | 220 | addKnownProgram prog = updateUnconfiguredProgs $
Map.insertWith combine (programName prog) (prog, Nothing, [])
where combine _ (_, path, args) = (prog, path, args) | 167 | true | true | 0 | 8 | 51 | 86 | 49 | 37 | null | null |
kelnage/tamarin-prover | lib/theory/src/Theory/Model/Rule.hs | gpl-3.0 | unifiableRuleACInsts :: RuleACInst -> RuleACInst -> WithMaude Bool
unifiableRuleACInsts ru1 ru2 =
(not . null) <$> unifyRuleACInstEqs [Equal ru1 ru2] | 153 | unifiableRuleACInsts :: RuleACInst -> RuleACInst -> WithMaude Bool
unifiableRuleACInsts ru1 ru2 =
(not . null) <$> unifyRuleACInstEqs [Equal ru1 ru2] | 153 | unifiableRuleACInsts ru1 ru2 =
(not . null) <$> unifyRuleACInstEqs [Equal ru1 ru2] | 86 | false | true | 0 | 8 | 23 | 49 | 24 | 25 | null | null |
Icelandjack/lens | src/Control/Lens/Fold.hs | bsd-3-clause | -- | Return whether or not none of the elements viewed through an 'IndexedFold' or 'IndexedTraversal'
-- satisfy a predicate, with access to the @i@.
--
-- When you don't need access to the index then 'noneOf' is more flexible in what it accepts.
--
-- @
-- 'noneOf' l ≡ 'inoneOf' l '.' 'const'
-- @
--
-- @
-- 'inoneOf' :: 'IndexedGetter' i s a -> (i -> a -> 'Bool') -> s -> 'Bool'
-- 'inoneOf' :: 'IndexedFold' i s a -> (i -> a -> 'Bool') -> s -> 'Bool'
-- 'inoneOf' :: 'IndexedLens'' i s a -> (i -> a -> 'Bool') -> s -> 'Bool'
-- 'inoneOf' :: 'IndexedTraversal'' i s a -> (i -> a -> 'Bool') -> s -> 'Bool'
-- @
inoneOf :: IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
inoneOf l = noneOf l .# Indexed | 729 | inoneOf :: IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
inoneOf l = noneOf l .# Indexed | 100 | inoneOf l = noneOf l .# Indexed | 31 | true | true | 2 | 10 | 168 | 76 | 43 | 33 | null | null |
mcschroeder/ghc | compiler/stgSyn/StgLint.hs | bsd-3-clause | addLoc :: LintLocInfo -> LintM a -> LintM a
addLoc extra_loc m = LintM $ \loc scope errs
-> unLintM m (extra_loc:loc) scope errs | 131 | addLoc :: LintLocInfo -> LintM a -> LintM a
addLoc extra_loc m = LintM $ \loc scope errs
-> unLintM m (extra_loc:loc) scope errs | 131 | addLoc extra_loc m = LintM $ \loc scope errs
-> unLintM m (extra_loc:loc) scope errs | 87 | false | true | 0 | 7 | 26 | 65 | 30 | 35 | null | null |
loganbraga/hunch | app/Hunch/Options/CommandLine.hs | mit | noChecksOpt :: Parser Bool
noChecksOpt = switch $
long "no-check"
<> short 'c'
<> help "Do not check input for invalid names or not found templates" | 165 | noChecksOpt :: Parser Bool
noChecksOpt = switch $
long "no-check"
<> short 'c'
<> help "Do not check input for invalid names or not found templates" | 165 | noChecksOpt = switch $
long "no-check"
<> short 'c'
<> help "Do not check input for invalid names or not found templates" | 138 | false | true | 6 | 6 | 42 | 44 | 17 | 27 | null | null |
nushio3/ghc | libraries/base/Foreign/C/Error.hs | bsd-3-clause | eBUSY = Errno (CONST_EBUSY) | 37 | eBUSY = Errno (CONST_EBUSY) | 37 | eBUSY = Errno (CONST_EBUSY) | 37 | false | false | 0 | 6 | 13 | 12 | 6 | 6 | null | null |
yav/monadlib | tests/DynamicScopeRW.hs | mit | testWStat = runId $ runContT return $ runWriterT $ testW () | 64 | testWStat = runId $ runContT return $ runWriterT $ testW () | 64 | testWStat = runId $ runContT return $ runWriterT $ testW () | 64 | false | false | 0 | 8 | 15 | 26 | 12 | 14 | null | null |
DavidAlphaFox/ghc | libraries/Cabal/Cabal/Distribution/Simple/Program/Builtin.hs | bsd-3-clause | ghcProgram :: Program
ghcProgram = (simpleProgram "ghc") {
programFindVersion = findProgramVersion "--numeric-version" id,
-- Workaround for https://ghc.haskell.org/trac/ghc/ticket/8825
-- (spurious warning on non-english locales)
programPostConf = \_verbosity ghcProg ->
do let ghcProg' = ghcProg {
programOverrideEnv = ("LANGUAGE", Just "en")
: programOverrideEnv ghcProg
}
-- Only the 7.8 branch seems to be affected. Fixed in 7.8.4.
affectedVersionRange = intersectVersionRanges
(laterVersion $ Version [7,8,0] [])
(earlierVersion $ Version [7,8,4] [])
return $ maybe ghcProg
(\v -> if withinRange v affectedVersionRange
then ghcProg' else ghcProg)
(programVersion ghcProg)
} | 898 | ghcProgram :: Program
ghcProgram = (simpleProgram "ghc") {
programFindVersion = findProgramVersion "--numeric-version" id,
-- Workaround for https://ghc.haskell.org/trac/ghc/ticket/8825
-- (spurious warning on non-english locales)
programPostConf = \_verbosity ghcProg ->
do let ghcProg' = ghcProg {
programOverrideEnv = ("LANGUAGE", Just "en")
: programOverrideEnv ghcProg
}
-- Only the 7.8 branch seems to be affected. Fixed in 7.8.4.
affectedVersionRange = intersectVersionRanges
(laterVersion $ Version [7,8,0] [])
(earlierVersion $ Version [7,8,4] [])
return $ maybe ghcProg
(\v -> if withinRange v affectedVersionRange
then ghcProg' else ghcProg)
(programVersion ghcProg)
} | 898 | ghcProgram = (simpleProgram "ghc") {
programFindVersion = findProgramVersion "--numeric-version" id,
-- Workaround for https://ghc.haskell.org/trac/ghc/ticket/8825
-- (spurious warning on non-english locales)
programPostConf = \_verbosity ghcProg ->
do let ghcProg' = ghcProg {
programOverrideEnv = ("LANGUAGE", Just "en")
: programOverrideEnv ghcProg
}
-- Only the 7.8 branch seems to be affected. Fixed in 7.8.4.
affectedVersionRange = intersectVersionRanges
(laterVersion $ Version [7,8,0] [])
(earlierVersion $ Version [7,8,4] [])
return $ maybe ghcProg
(\v -> if withinRange v affectedVersionRange
then ghcProg' else ghcProg)
(programVersion ghcProg)
} | 876 | false | true | 0 | 17 | 303 | 176 | 96 | 80 | null | null |
aztek/voogie | src/Voogie/Boogie/Smart.hs | gpl-3.0 | assume, assert :: Formula -> Property
assume = Assume | 53 | assume, assert :: Formula -> Property
assume = Assume | 53 | assume = Assume | 15 | false | true | 0 | 5 | 8 | 17 | 10 | 7 | null | null |
text-utf8/text | Data/Text.hs | bsd-2-clause | -- | /O(1)/ Returns the last character of a 'Text', which must be
-- non-empty. Subject to fusion.
last :: Text -> Char
last (Text arr off len)
| len <= 0 = emptyError "last"
| otherwise = U8.reverseDecodeCharIndex (\c _ -> c) idx (off + len - 1)
where
idx = A.unsafeIndex arr
| 308 | last :: Text -> Char
last (Text arr off len)
| len <= 0 = emptyError "last"
| otherwise = U8.reverseDecodeCharIndex (\c _ -> c) idx (off + len - 1)
where
idx = A.unsafeIndex arr
| 208 | last (Text arr off len)
| len <= 0 = emptyError "last"
| otherwise = U8.reverseDecodeCharIndex (\c _ -> c) idx (off + len - 1)
where
idx = A.unsafeIndex arr
| 187 | true | true | 1 | 8 | 85 | 93 | 47 | 46 | null | null |
vTurbine/ghc | compiler/types/Type.hs | bsd-3-clause | seqTypes (ty:tys) = seqType ty `seq` seqTypes tys | 49 | seqTypes (ty:tys) = seqType ty `seq` seqTypes tys | 49 | seqTypes (ty:tys) = seqType ty `seq` seqTypes tys | 49 | false | false | 0 | 7 | 7 | 28 | 14 | 14 | null | null |
svenssonjoel/MonadObsidian | Obsidian/MonadObsidian/GenCuda.hs | bsd-3-clause | -- -----------------------------------------------------------------------------
rename :: Name -> MemoryMap -> Name
rename n mm = if (not ("source" `isPrefixOf` n))
then n'
else n
where
(j,at) = case Map.lookup n mm of
Nothing -> error $ "error: "++ n ++" not found in MemoryMap"
Just a -> a
n' = case at of
Global_Array t ->
"(("++ptrStr t++")(gbase+"++ show j++"))"
Shared_Array t ->
"(("++ptrStr t++")(sbase+"++ show j++"))"
Constant_Array t ->
"(("++ptrStr t++")(cbase+"++ show j++"))" | 680 | rename :: Name -> MemoryMap -> Name
rename n mm = if (not ("source" `isPrefixOf` n))
then n'
else n
where
(j,at) = case Map.lookup n mm of
Nothing -> error $ "error: "++ n ++" not found in MemoryMap"
Just a -> a
n' = case at of
Global_Array t ->
"(("++ptrStr t++")(gbase+"++ show j++"))"
Shared_Array t ->
"(("++ptrStr t++")(sbase+"++ show j++"))"
Constant_Array t ->
"(("++ptrStr t++")(cbase+"++ show j++"))" | 598 | rename n mm = if (not ("source" `isPrefixOf` n))
then n'
else n
where
(j,at) = case Map.lookup n mm of
Nothing -> error $ "error: "++ n ++" not found in MemoryMap"
Just a -> a
n' = case at of
Global_Array t ->
"(("++ptrStr t++")(gbase+"++ show j++"))"
Shared_Array t ->
"(("++ptrStr t++")(sbase+"++ show j++"))"
Constant_Array t ->
"(("++ptrStr t++")(cbase+"++ show j++"))" | 562 | true | true | 0 | 14 | 261 | 202 | 100 | 102 | null | null |
ambiata/zodiac | zodiac-http-client/src/Zodiac/HttpClient/Request.hs | bsd-3-clause | -- | Convert an http-client Request to canonical form for signing or
-- verification.
toCanonicalRequest :: Request -> Either RequestError CRequest
toCanonicalRequest r =
-- URI part and query string are both already URL-encoded in http-client.
let uri = toCURI $ HC.path r
qs = toCQueryString $ HC.queryString r in do
method <- reqCMethod r
payload <- reqCPayload r
headers <- reqCHeaders r
pure $ CRequest method uri qs headers payload
-- | Canonicalise the request path. The paths "" and "/" are
-- semantically identical in HTTP ("" is converted to "/" when
-- building the request), so we don't differentiate between them. | 646 | toCanonicalRequest :: Request -> Either RequestError CRequest
toCanonicalRequest r =
-- URI part and query string are both already URL-encoded in http-client.
let uri = toCURI $ HC.path r
qs = toCQueryString $ HC.queryString r in do
method <- reqCMethod r
payload <- reqCPayload r
headers <- reqCHeaders r
pure $ CRequest method uri qs headers payload
-- | Canonicalise the request path. The paths "" and "/" are
-- semantically identical in HTTP ("" is converted to "/" when
-- building the request), so we don't differentiate between them. | 560 | toCanonicalRequest r =
-- URI part and query string are both already URL-encoded in http-client.
let uri = toCURI $ HC.path r
qs = toCQueryString $ HC.queryString r in do
method <- reqCMethod r
payload <- reqCPayload r
headers <- reqCHeaders r
pure $ CRequest method uri qs headers payload
-- | Canonicalise the request path. The paths "" and "/" are
-- semantically identical in HTTP ("" is converted to "/" when
-- building the request), so we don't differentiate between them. | 498 | true | true | 0 | 11 | 122 | 111 | 53 | 58 | null | null |
fmapfmapfmap/amazonka | amazonka-codepipeline/gen/Network/AWS/CodePipeline/Types/Product.hs | mpl-2.0 | -- | The stage of the pipeline.
pcStage :: Lens' PipelineContext (Maybe StageContext)
pcStage = lens _pcStage (\ s a -> s{_pcStage = a}) | 136 | pcStage :: Lens' PipelineContext (Maybe StageContext)
pcStage = lens _pcStage (\ s a -> s{_pcStage = a}) | 104 | pcStage = lens _pcStage (\ s a -> s{_pcStage = a}) | 50 | true | true | 0 | 9 | 23 | 46 | 25 | 21 | null | null |
Velro/sdl2 | src/SDL/Raw/Filesystem.hs | bsd-3-clause | rwClose :: MonadIO m => Ptr RWops -> m CInt
rwClose v1 = liftIO $ rwCloseFFI v1 | 79 | rwClose :: MonadIO m => Ptr RWops -> m CInt
rwClose v1 = liftIO $ rwCloseFFI v1 | 79 | rwClose v1 = liftIO $ rwCloseFFI v1 | 35 | false | true | 2 | 8 | 16 | 44 | 18 | 26 | null | null |
flipstone/orville | orville-postgresql/test/WhereConditionTest.hs | mit | -- Order definitions
orderTable :: O.TableDefinition Order Order OrderId
orderTable =
O.mkTableDefinition $
O.TableParams
{ O.tblName = "order"
, O.tblPrimaryKey = O.primaryKey orderIdField
, O.tblMapper =
Order <$> O.attrField orderId orderIdField <*>
O.attrField customerFkId customerFkIdField <*>
O.attrField orderName orderNameField
, O.tblGetKey = orderId
, O.tblSafeToDelete = []
, O.tblComments = O.noComments
} | 474 | orderTable :: O.TableDefinition Order Order OrderId
orderTable =
O.mkTableDefinition $
O.TableParams
{ O.tblName = "order"
, O.tblPrimaryKey = O.primaryKey orderIdField
, O.tblMapper =
Order <$> O.attrField orderId orderIdField <*>
O.attrField customerFkId customerFkIdField <*>
O.attrField orderName orderNameField
, O.tblGetKey = orderId
, O.tblSafeToDelete = []
, O.tblComments = O.noComments
} | 453 | orderTable =
O.mkTableDefinition $
O.TableParams
{ O.tblName = "order"
, O.tblPrimaryKey = O.primaryKey orderIdField
, O.tblMapper =
Order <$> O.attrField orderId orderIdField <*>
O.attrField customerFkId customerFkIdField <*>
O.attrField orderName orderNameField
, O.tblGetKey = orderId
, O.tblSafeToDelete = []
, O.tblComments = O.noComments
} | 401 | true | true | 0 | 12 | 107 | 121 | 65 | 56 | null | null |
nikai3d/ce-challenges | easy/sum_digits.hs | bsd-3-clause | main :: IO ()
main = do
[inpFile] <- getArgs
input <- readFile inpFile
putStr . unlines . map (show . sum . map (read . (:[]))) $ lines input | 153 | main :: IO ()
main = do
[inpFile] <- getArgs
input <- readFile inpFile
putStr . unlines . map (show . sum . map (read . (:[]))) $ lines input | 153 | main = do
[inpFile] <- getArgs
input <- readFile inpFile
putStr . unlines . map (show . sum . map (read . (:[]))) $ lines input | 139 | false | true | 0 | 16 | 41 | 84 | 41 | 43 | null | null |
nc6/cabin | Cabin/Package.hs | bsd-3-clause | findCabinByName :: String -> CabinDB -> Maybe Cabin
findCabinByName name = findCabin (\(Cabin name' _) -> name == name') | 120 | findCabinByName :: String -> CabinDB -> Maybe Cabin
findCabinByName name = findCabin (\(Cabin name' _) -> name == name') | 120 | findCabinByName name = findCabin (\(Cabin name' _) -> name == name') | 68 | false | true | 0 | 9 | 18 | 48 | 24 | 24 | null | null |
vincenthz/hs-foundation | basement/Basement/BoxedArray.hs | bsd-3-clause | arrayType :: DataType
arrayType = mkNoRepType "Foundation.Array" | 64 | arrayType :: DataType
arrayType = mkNoRepType "Foundation.Array" | 64 | arrayType = mkNoRepType "Foundation.Array" | 42 | false | true | 0 | 5 | 6 | 14 | 7 | 7 | null | null |
luzhuomi/cpp-obs | Language/C/Obfuscate/ASTUtils.hs | apache-2.0 | endsWithBreak :: [AST.CCompoundBlockItem N.NodeInfo] -> Bool
endsWithBreak [] = False | 86 | endsWithBreak :: [AST.CCompoundBlockItem N.NodeInfo] -> Bool
endsWithBreak [] = False | 85 | endsWithBreak [] = False | 24 | false | true | 0 | 8 | 10 | 30 | 15 | 15 | null | null |
narrative/stack | src/Stack/Init.hs | bsd-3-clause | checkBundleResolver
:: ( 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 (Either [PackageName] ( Map PackageName (Map FlagName Bool)
, Map PackageName Version))
checkBundleResolver stackYaml initOpts bundle resolver = do
result <- checkResolverSpec gpds Nothing resolver
case result of
BuildPlanCheckOk f -> return $ Right (f, Map.empty)
BuildPlanCheckPartial f e
| needSolver resolver initOpts -> do
warnPartial result
solve f
| omitPackages initOpts -> do
warnPartial result
$logWarn "*** Omitting packages with unsatisfied dependencies"
return $ Left $ failedUserPkgs e
| otherwise -> throwM $ ResolverPartial resolver (show result)
BuildPlanCheckFail _ e _
| omitPackages initOpts -> do
$logWarn $ "*** Resolver compiler mismatch: "
<> resolverName resolver
$logWarn $ indent $ T.pack $ show result
return $ Left $ failedUserPkgs e
| otherwise -> throwM $ ResolverMismatch resolver (show result)
where
indent t = T.unlines $ fmap (" " <>) (T.lines t)
warnPartial res = do
$logWarn $ "*** Resolver " <> resolverName resolver
<> " will need external packages: "
$logWarn $ indent $ T.pack $ show res
failedUserPkgs e = Map.keys $ Map.unions (Map.elems (fmap deNeededBy e))
gpds = Map.elems (fmap snd bundle)
solve flags = do
let cabalDirs = map parent (Map.elems (fmap fst bundle))
srcConstraints = mergeConstraints (gpdPackages gpds) flags
eresult <- solveResolverSpec stackYaml cabalDirs
(resolver, srcConstraints, Map.empty)
case eresult of
Right (src, ext) ->
return $ Right (fmap snd (Map.union src ext), fmap fst ext)
Left packages
| omitPackages initOpts, srcpkgs /= []-> do
pkg <- findOneIndependent srcpkgs flags
return $ Left [pkg]
| otherwise -> throwM (SolverGiveUp giveUpMsg)
where srcpkgs = intersect (Map.keys bundle) packages
-- among a list of packages find one on which none among the rest of the
-- packages depend. This package is a good candidate to be removed from
-- the list of packages when there is conflict in dependencies among this
-- set of packages.
findOneIndependent packages flags = do
platform <- asks (configPlatform . getConfig)
(compiler, _) <- getResolverConstraints stackYaml resolver
let getGpd pkg = snd (fromJust (Map.lookup pkg bundle))
getFlags pkg = fromJust (Map.lookup pkg flags)
deps pkg = gpdPackageDeps (getGpd pkg) compiler platform
(getFlags pkg)
allDeps = concat $ map (Map.keys . deps) packages
isIndependent pkg = not $ pkg `elem` allDeps
-- prefer to reject packages in deeper directories
path pkg = fst (fromJust (Map.lookup pkg bundle))
pathlen = length . FP.splitPath . toFilePath . path
maxPathlen = maximumBy (compare `on` pathlen)
return $ maxPathlen (filter isIndependent packages)
giveUpMsg = concat
[ " - Use '--omit-packages to exclude conflicting package(s).\n"
, " - Tweak the generated "
, toFilePath stackDotYaml <> " and then run 'stack solver':\n"
, " - Add any missing remote packages.\n"
, " - Add extra dependencies to guide solver.\n"
, " - Update external packages with 'stack update' and try again.\n"
]
needSolver _ (InitOpts {useSolver = True}) = True
needSolver (ResolverCompiler _) _ = True
needSolver _ _ = False | 4,425 | checkBundleResolver
:: ( 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 (Either [PackageName] ( Map PackageName (Map FlagName Bool)
, Map PackageName Version))
checkBundleResolver stackYaml initOpts bundle resolver = do
result <- checkResolverSpec gpds Nothing resolver
case result of
BuildPlanCheckOk f -> return $ Right (f, Map.empty)
BuildPlanCheckPartial f e
| needSolver resolver initOpts -> do
warnPartial result
solve f
| omitPackages initOpts -> do
warnPartial result
$logWarn "*** Omitting packages with unsatisfied dependencies"
return $ Left $ failedUserPkgs e
| otherwise -> throwM $ ResolverPartial resolver (show result)
BuildPlanCheckFail _ e _
| omitPackages initOpts -> do
$logWarn $ "*** Resolver compiler mismatch: "
<> resolverName resolver
$logWarn $ indent $ T.pack $ show result
return $ Left $ failedUserPkgs e
| otherwise -> throwM $ ResolverMismatch resolver (show result)
where
indent t = T.unlines $ fmap (" " <>) (T.lines t)
warnPartial res = do
$logWarn $ "*** Resolver " <> resolverName resolver
<> " will need external packages: "
$logWarn $ indent $ T.pack $ show res
failedUserPkgs e = Map.keys $ Map.unions (Map.elems (fmap deNeededBy e))
gpds = Map.elems (fmap snd bundle)
solve flags = do
let cabalDirs = map parent (Map.elems (fmap fst bundle))
srcConstraints = mergeConstraints (gpdPackages gpds) flags
eresult <- solveResolverSpec stackYaml cabalDirs
(resolver, srcConstraints, Map.empty)
case eresult of
Right (src, ext) ->
return $ Right (fmap snd (Map.union src ext), fmap fst ext)
Left packages
| omitPackages initOpts, srcpkgs /= []-> do
pkg <- findOneIndependent srcpkgs flags
return $ Left [pkg]
| otherwise -> throwM (SolverGiveUp giveUpMsg)
where srcpkgs = intersect (Map.keys bundle) packages
-- among a list of packages find one on which none among the rest of the
-- packages depend. This package is a good candidate to be removed from
-- the list of packages when there is conflict in dependencies among this
-- set of packages.
findOneIndependent packages flags = do
platform <- asks (configPlatform . getConfig)
(compiler, _) <- getResolverConstraints stackYaml resolver
let getGpd pkg = snd (fromJust (Map.lookup pkg bundle))
getFlags pkg = fromJust (Map.lookup pkg flags)
deps pkg = gpdPackageDeps (getGpd pkg) compiler platform
(getFlags pkg)
allDeps = concat $ map (Map.keys . deps) packages
isIndependent pkg = not $ pkg `elem` allDeps
-- prefer to reject packages in deeper directories
path pkg = fst (fromJust (Map.lookup pkg bundle))
pathlen = length . FP.splitPath . toFilePath . path
maxPathlen = maximumBy (compare `on` pathlen)
return $ maxPathlen (filter isIndependent packages)
giveUpMsg = concat
[ " - Use '--omit-packages to exclude conflicting package(s).\n"
, " - Tweak the generated "
, toFilePath stackDotYaml <> " and then run 'stack solver':\n"
, " - Add any missing remote packages.\n"
, " - Add extra dependencies to guide solver.\n"
, " - Update external packages with 'stack update' and try again.\n"
]
needSolver _ (InitOpts {useSolver = True}) = True
needSolver (ResolverCompiler _) _ = True
needSolver _ _ = False | 4,425 | checkBundleResolver stackYaml initOpts bundle resolver = do
result <- checkResolverSpec gpds Nothing resolver
case result of
BuildPlanCheckOk f -> return $ Right (f, Map.empty)
BuildPlanCheckPartial f e
| needSolver resolver initOpts -> do
warnPartial result
solve f
| omitPackages initOpts -> do
warnPartial result
$logWarn "*** Omitting packages with unsatisfied dependencies"
return $ Left $ failedUserPkgs e
| otherwise -> throwM $ ResolverPartial resolver (show result)
BuildPlanCheckFail _ e _
| omitPackages initOpts -> do
$logWarn $ "*** Resolver compiler mismatch: "
<> resolverName resolver
$logWarn $ indent $ T.pack $ show result
return $ Left $ failedUserPkgs e
| otherwise -> throwM $ ResolverMismatch resolver (show result)
where
indent t = T.unlines $ fmap (" " <>) (T.lines t)
warnPartial res = do
$logWarn $ "*** Resolver " <> resolverName resolver
<> " will need external packages: "
$logWarn $ indent $ T.pack $ show res
failedUserPkgs e = Map.keys $ Map.unions (Map.elems (fmap deNeededBy e))
gpds = Map.elems (fmap snd bundle)
solve flags = do
let cabalDirs = map parent (Map.elems (fmap fst bundle))
srcConstraints = mergeConstraints (gpdPackages gpds) flags
eresult <- solveResolverSpec stackYaml cabalDirs
(resolver, srcConstraints, Map.empty)
case eresult of
Right (src, ext) ->
return $ Right (fmap snd (Map.union src ext), fmap fst ext)
Left packages
| omitPackages initOpts, srcpkgs /= []-> do
pkg <- findOneIndependent srcpkgs flags
return $ Left [pkg]
| otherwise -> throwM (SolverGiveUp giveUpMsg)
where srcpkgs = intersect (Map.keys bundle) packages
-- among a list of packages find one on which none among the rest of the
-- packages depend. This package is a good candidate to be removed from
-- the list of packages when there is conflict in dependencies among this
-- set of packages.
findOneIndependent packages flags = do
platform <- asks (configPlatform . getConfig)
(compiler, _) <- getResolverConstraints stackYaml resolver
let getGpd pkg = snd (fromJust (Map.lookup pkg bundle))
getFlags pkg = fromJust (Map.lookup pkg flags)
deps pkg = gpdPackageDeps (getGpd pkg) compiler platform
(getFlags pkg)
allDeps = concat $ map (Map.keys . deps) packages
isIndependent pkg = not $ pkg `elem` allDeps
-- prefer to reject packages in deeper directories
path pkg = fst (fromJust (Map.lookup pkg bundle))
pathlen = length . FP.splitPath . toFilePath . path
maxPathlen = maximumBy (compare `on` pathlen)
return $ maxPathlen (filter isIndependent packages)
giveUpMsg = concat
[ " - Use '--omit-packages to exclude conflicting package(s).\n"
, " - Tweak the generated "
, toFilePath stackDotYaml <> " and then run 'stack solver':\n"
, " - Add any missing remote packages.\n"
, " - Add extra dependencies to guide solver.\n"
, " - Update external packages with 'stack update' and try again.\n"
]
needSolver _ (InitOpts {useSolver = True}) = True
needSolver (ResolverCompiler _) _ = True
needSolver _ _ = False | 3,851 | false | true | 7 | 17 | 1,533 | 1,123 | 532 | 591 | null | null |
phaazon/OpenGLRaw | src/Graphics/Rendering/OpenGL/Raw/Tokens.hs | bsd-3-clause | gl_TRANSFORM_BIT :: GLbitfield
gl_TRANSFORM_BIT = 0x00001000 | 60 | gl_TRANSFORM_BIT :: GLbitfield
gl_TRANSFORM_BIT = 0x00001000 | 60 | gl_TRANSFORM_BIT = 0x00001000 | 29 | false | true | 0 | 4 | 5 | 11 | 6 | 5 | null | null |
HJvT/hdirect | src/Parser.hs | bsd-3-clause | action_445 x = happyTcHack x happyReduce_267 | 44 | action_445 x = happyTcHack x happyReduce_267 | 44 | action_445 x = happyTcHack x happyReduce_267 | 44 | false | false | 0 | 5 | 5 | 14 | 6 | 8 | null | null |
spechub/Hets | THF/Utils.hs | gpl-2.0 | thfMappingTypeToType :: [THFUnitaryType] -> Maybe Type
thfMappingTypeToType [] = Nothing | 88 | thfMappingTypeToType :: [THFUnitaryType] -> Maybe Type
thfMappingTypeToType [] = Nothing | 88 | thfMappingTypeToType [] = Nothing | 33 | false | true | 0 | 6 | 9 | 26 | 13 | 13 | null | null |
jacekszymanski/wxHaskell | samples/wx/TimeFlowsEx.hs | lgpl-2.1 | -- | Return the mouse position at a certain time.
posAtTime :: Time -> History -> Point
posAtTime _time [(_t,pos)] = pos | 122 | posAtTime :: Time -> History -> Point
posAtTime _time [(_t,pos)] = pos | 72 | posAtTime _time [(_t,pos)] = pos | 34 | true | true | 0 | 7 | 23 | 34 | 19 | 15 | null | null |
flannelhead/flannelhead.github.io | site.hs | bsd-3-clause | main :: IO ()
main = hakyll $ do
let pandocMathCompiler =
let pandocOptions = defaultHakyllWriterOptions
{ writerHTMLMathMethod = MathJax "" }
in pandocCompilerWith defaultHakyllReaderOptions pandocOptions
match "images/*" $ do
route idRoute
compile copyFileCompiler
match "css/*" $ do
route idRoute
compile compressCssCompiler
match (fromList ["about.md"]) $ do
route $ setExtension "html"
compile $ pandocCompiler
>>= loadAndApplyTemplate "templates/default.html" defaultContext
>>= relativizeUrls
match "posts/*" $ do
route $ setExtension "html"
compile $ pandocMathCompiler
>>= loadAndApplyTemplate "templates/post.html" postCtx
>>= loadAndApplyTemplate "templates/default.html" postCtx
>>= relativizeUrls
match "index.html" $ do
route idRoute
compile $ do
posts <- recentFirst =<< loadAll "posts/*"
let indexCtx =
listField "posts" postCtx (return posts) <>
defaultContext
getResourceBody
>>= applyAsTemplate indexCtx
>>= loadAndApplyTemplate "templates/default.html" indexCtx
>>= relativizeUrls
match "templates/*" $ compile templateCompiler
version "redirects" $ createRedirects brokenLinks | 1,454 | main :: IO ()
main = hakyll $ do
let pandocMathCompiler =
let pandocOptions = defaultHakyllWriterOptions
{ writerHTMLMathMethod = MathJax "" }
in pandocCompilerWith defaultHakyllReaderOptions pandocOptions
match "images/*" $ do
route idRoute
compile copyFileCompiler
match "css/*" $ do
route idRoute
compile compressCssCompiler
match (fromList ["about.md"]) $ do
route $ setExtension "html"
compile $ pandocCompiler
>>= loadAndApplyTemplate "templates/default.html" defaultContext
>>= relativizeUrls
match "posts/*" $ do
route $ setExtension "html"
compile $ pandocMathCompiler
>>= loadAndApplyTemplate "templates/post.html" postCtx
>>= loadAndApplyTemplate "templates/default.html" postCtx
>>= relativizeUrls
match "index.html" $ do
route idRoute
compile $ do
posts <- recentFirst =<< loadAll "posts/*"
let indexCtx =
listField "posts" postCtx (return posts) <>
defaultContext
getResourceBody
>>= applyAsTemplate indexCtx
>>= loadAndApplyTemplate "templates/default.html" indexCtx
>>= relativizeUrls
match "templates/*" $ compile templateCompiler
version "redirects" $ createRedirects brokenLinks | 1,454 | main = hakyll $ do
let pandocMathCompiler =
let pandocOptions = defaultHakyllWriterOptions
{ writerHTMLMathMethod = MathJax "" }
in pandocCompilerWith defaultHakyllReaderOptions pandocOptions
match "images/*" $ do
route idRoute
compile copyFileCompiler
match "css/*" $ do
route idRoute
compile compressCssCompiler
match (fromList ["about.md"]) $ do
route $ setExtension "html"
compile $ pandocCompiler
>>= loadAndApplyTemplate "templates/default.html" defaultContext
>>= relativizeUrls
match "posts/*" $ do
route $ setExtension "html"
compile $ pandocMathCompiler
>>= loadAndApplyTemplate "templates/post.html" postCtx
>>= loadAndApplyTemplate "templates/default.html" postCtx
>>= relativizeUrls
match "index.html" $ do
route idRoute
compile $ do
posts <- recentFirst =<< loadAll "posts/*"
let indexCtx =
listField "posts" postCtx (return posts) <>
defaultContext
getResourceBody
>>= applyAsTemplate indexCtx
>>= loadAndApplyTemplate "templates/default.html" indexCtx
>>= relativizeUrls
match "templates/*" $ compile templateCompiler
version "redirects" $ createRedirects brokenLinks | 1,440 | false | true | 2 | 20 | 482 | 317 | 134 | 183 | null | null |
TomMD/ghc | utils/deriveConstants/DeriveConstants.hs | bsd-3-clause | getWanted :: Bool -> FilePath -> FilePath -> [String] -> FilePath -> IO Results
getWanted verbose tmpdir gccProgram gccFlags nmProgram
= do let cStuff = unlines (headers ++ concatMap (doWanted . snd) wanteds)
cFile = tmpdir </> "tmp.c"
oFile = tmpdir </> "tmp.o"
writeFile cFile cStuff
execute verbose gccProgram (gccFlags ++ ["-c", cFile, "-o", oFile])
xs <- case os of
"openbsd" -> readProcess "/usr/bin/objdump" ["--syms", oFile] ""
_ -> readProcess nmProgram ["-P", oFile] ""
let ls = lines xs
ms = map parseNmLine ls
m = Map.fromList $ catMaybes ms
rs <- mapM (lookupResult m) wanteds
return rs
where headers = ["#define IN_STG_CODE 0",
"",
"/*",
" * We need offsets of profiled things...",
" * better be careful that this doesn't",
" * affect the offsets of anything else.",
" */",
"",
"#define PROFILING",
"#define THREADED_RTS",
"",
"#include \"PosixSource.h\"",
"#include \"Rts.h\"",
"#include \"Stable.h\"",
"#include \"Capability.h\"",
"",
"#include <inttypes.h>",
"#include <stddef.h>",
"#include <stdio.h>",
"#include <string.h>",
"",
"#define FIELD_SIZE(s_type, field) ((size_t)sizeof(((s_type*)0)->field))",
"#define TYPE_SIZE(type) (sizeof(type))",
"#define FUN_OFFSET(sym) (offsetof(Capability,f.sym) - offsetof(Capability,r))",
"",
"#pragma GCC poison sizeof"
]
prefix = "derivedConstant"
mkFullName name = prefix ++ name
-- We add 1 to the value, as some platforms will make a symbol
-- of size 1 when for
-- char foo[0];
-- We then subtract 1 again when parsing.
doWanted (GetFieldType name (Fst (CExpr cExpr)))
= ["char " ++ mkFullName name ++ "[1 + " ++ cExpr ++ "];"]
doWanted (GetClosureSize name (Fst (CExpr cExpr)))
= ["char " ++ mkFullName name ++ "[1 + " ++ cExpr ++ "];"]
doWanted (GetWord name (Fst (CExpr cExpr)))
= ["char " ++ mkFullName name ++ "[1 + " ++ cExpr ++ "];"]
doWanted (GetInt name (Fst (CExpr cExpr)))
= ["char " ++ mkFullName name ++ "Mag[1 + ((intptr_t)(" ++ cExpr ++ ") >= 0 ? (" ++ cExpr ++ ") : -(" ++ cExpr ++ "))];",
"char " ++ mkFullName name ++ "Sig[(intptr_t)(" ++ cExpr ++ ") >= 0 ? 3 : 1];"]
doWanted (GetNatural name (Fst (CExpr cExpr)))
= -- These casts fix "right shift count >= width of type"
-- warnings
let cExpr' = "(uint64_t)(size_t)(" ++ cExpr ++ ")"
in ["char " ++ mkFullName name ++ "0[1 + ((" ++ cExpr' ++ ") & 0xFFFF)];",
"char " ++ mkFullName name ++ "1[1 + (((" ++ cExpr' ++ ") >> 16) & 0xFFFF)];",
"char " ++ mkFullName name ++ "2[1 + (((" ++ cExpr' ++ ") >> 32) & 0xFFFF)];",
"char " ++ mkFullName name ++ "3[1 + (((" ++ cExpr' ++ ") >> 48) & 0xFFFF)];"]
doWanted (GetBool name (Fst (CPPExpr cppExpr)))
= ["#if " ++ cppExpr,
"char " ++ mkFullName name ++ "[1];",
"#else",
"char " ++ mkFullName name ++ "[2];",
"#endif"]
doWanted (StructFieldMacro {}) = []
doWanted (ClosureFieldMacro {}) = []
doWanted (ClosurePayloadMacro {}) = []
doWanted (FieldTypeGcptrMacro {}) = []
-- parseNmLine parses "nm -P" output that looks like
-- "derivedConstantMAX_Vanilla_REG C 0000000b 0000000b" (GNU nm)
-- "_derivedConstantMAX_Vanilla_REG C b 0" (Mac OS X)
-- "_derivedConstantMAX_Vanilla_REG C 000000b" (MinGW)
-- "derivedConstantMAX_Vanilla_REG D 1 b" (Solaris)
-- and returns ("MAX_Vanilla_REG", 11)
parseNmLine line
= case words line of
('_' : n) : "C" : s : _ -> mkP n s
n : "C" : s : _ -> mkP n s
[n, "D", _, s] -> mkP n s
[s, "O", "*COM*", _, n] -> mkP n s
_ -> Nothing
where mkP r s = case (stripPrefix prefix r, readHex s) of
(Just name, [(size, "")]) -> Just (name, size)
_ -> Nothing
-- If an Int value is larger than 2^28 or smaller
-- than -2^28, then fail.
-- This test is a bit conservative, but if any
-- constants are roughly maxBound or minBound then
-- we probably need them to be Integer rather than
-- Int so that -- cross-compiling between 32bit and
-- 64bit platforms works.
lookupSmall :: Map String Integer -> Name -> IO Integer
lookupSmall m name
= case Map.lookup name m of
Just v
| v > 2^(28 :: Int) ||
v < -(2^(28 :: Int)) ->
die ("Value too large for GetWord: " ++ show v)
| otherwise -> return v
Nothing -> die ("Can't find " ++ show name)
lookupResult :: Map String Integer -> (Where, What Fst)
-> IO (Where, What Snd)
lookupResult m (w, GetWord name _)
= do v <- lookupSmall m name
return (w, GetWord name (Snd (v - 1)))
lookupResult m (w, GetInt name _)
= do mag <- lookupSmall m (name ++ "Mag")
sig <- lookupSmall m (name ++ "Sig")
return (w, GetWord name (Snd ((mag - 1) * (sig - 2))))
lookupResult m (w, GetNatural name _)
= do v0 <- lookupSmall m (name ++ "0")
v1 <- lookupSmall m (name ++ "1")
v2 <- lookupSmall m (name ++ "2")
v3 <- lookupSmall m (name ++ "3")
let v = (v0 - 1)
+ shiftL (v1 - 1) 16
+ shiftL (v2 - 1) 32
+ shiftL (v3 - 1) 48
return (w, GetWord name (Snd v))
lookupResult m (w, GetBool name _)
= do v <- lookupSmall m name
case v of
1 -> return (w, GetBool name (Snd True))
2 -> return (w, GetBool name (Snd False))
_ -> die ("Bad boolean: " ++ show v)
lookupResult m (w, GetFieldType name _)
= do v <- lookupSmall m name
return (w, GetFieldType name (Snd (v - 1)))
lookupResult m (w, GetClosureSize name _)
= do v <- lookupSmall m name
return (w, GetClosureSize name (Snd (v - 1)))
lookupResult _ (w, StructFieldMacro name)
= return (w, StructFieldMacro name)
lookupResult _ (w, ClosureFieldMacro name)
= return (w, ClosureFieldMacro name)
lookupResult _ (w, ClosurePayloadMacro name)
= return (w, ClosurePayloadMacro name)
lookupResult _ (w, FieldTypeGcptrMacro name)
= return (w, FieldTypeGcptrMacro name) | 7,649 | getWanted :: Bool -> FilePath -> FilePath -> [String] -> FilePath -> IO Results
getWanted verbose tmpdir gccProgram gccFlags nmProgram
= do let cStuff = unlines (headers ++ concatMap (doWanted . snd) wanteds)
cFile = tmpdir </> "tmp.c"
oFile = tmpdir </> "tmp.o"
writeFile cFile cStuff
execute verbose gccProgram (gccFlags ++ ["-c", cFile, "-o", oFile])
xs <- case os of
"openbsd" -> readProcess "/usr/bin/objdump" ["--syms", oFile] ""
_ -> readProcess nmProgram ["-P", oFile] ""
let ls = lines xs
ms = map parseNmLine ls
m = Map.fromList $ catMaybes ms
rs <- mapM (lookupResult m) wanteds
return rs
where headers = ["#define IN_STG_CODE 0",
"",
"/*",
" * We need offsets of profiled things...",
" * better be careful that this doesn't",
" * affect the offsets of anything else.",
" */",
"",
"#define PROFILING",
"#define THREADED_RTS",
"",
"#include \"PosixSource.h\"",
"#include \"Rts.h\"",
"#include \"Stable.h\"",
"#include \"Capability.h\"",
"",
"#include <inttypes.h>",
"#include <stddef.h>",
"#include <stdio.h>",
"#include <string.h>",
"",
"#define FIELD_SIZE(s_type, field) ((size_t)sizeof(((s_type*)0)->field))",
"#define TYPE_SIZE(type) (sizeof(type))",
"#define FUN_OFFSET(sym) (offsetof(Capability,f.sym) - offsetof(Capability,r))",
"",
"#pragma GCC poison sizeof"
]
prefix = "derivedConstant"
mkFullName name = prefix ++ name
-- We add 1 to the value, as some platforms will make a symbol
-- of size 1 when for
-- char foo[0];
-- We then subtract 1 again when parsing.
doWanted (GetFieldType name (Fst (CExpr cExpr)))
= ["char " ++ mkFullName name ++ "[1 + " ++ cExpr ++ "];"]
doWanted (GetClosureSize name (Fst (CExpr cExpr)))
= ["char " ++ mkFullName name ++ "[1 + " ++ cExpr ++ "];"]
doWanted (GetWord name (Fst (CExpr cExpr)))
= ["char " ++ mkFullName name ++ "[1 + " ++ cExpr ++ "];"]
doWanted (GetInt name (Fst (CExpr cExpr)))
= ["char " ++ mkFullName name ++ "Mag[1 + ((intptr_t)(" ++ cExpr ++ ") >= 0 ? (" ++ cExpr ++ ") : -(" ++ cExpr ++ "))];",
"char " ++ mkFullName name ++ "Sig[(intptr_t)(" ++ cExpr ++ ") >= 0 ? 3 : 1];"]
doWanted (GetNatural name (Fst (CExpr cExpr)))
= -- These casts fix "right shift count >= width of type"
-- warnings
let cExpr' = "(uint64_t)(size_t)(" ++ cExpr ++ ")"
in ["char " ++ mkFullName name ++ "0[1 + ((" ++ cExpr' ++ ") & 0xFFFF)];",
"char " ++ mkFullName name ++ "1[1 + (((" ++ cExpr' ++ ") >> 16) & 0xFFFF)];",
"char " ++ mkFullName name ++ "2[1 + (((" ++ cExpr' ++ ") >> 32) & 0xFFFF)];",
"char " ++ mkFullName name ++ "3[1 + (((" ++ cExpr' ++ ") >> 48) & 0xFFFF)];"]
doWanted (GetBool name (Fst (CPPExpr cppExpr)))
= ["#if " ++ cppExpr,
"char " ++ mkFullName name ++ "[1];",
"#else",
"char " ++ mkFullName name ++ "[2];",
"#endif"]
doWanted (StructFieldMacro {}) = []
doWanted (ClosureFieldMacro {}) = []
doWanted (ClosurePayloadMacro {}) = []
doWanted (FieldTypeGcptrMacro {}) = []
-- parseNmLine parses "nm -P" output that looks like
-- "derivedConstantMAX_Vanilla_REG C 0000000b 0000000b" (GNU nm)
-- "_derivedConstantMAX_Vanilla_REG C b 0" (Mac OS X)
-- "_derivedConstantMAX_Vanilla_REG C 000000b" (MinGW)
-- "derivedConstantMAX_Vanilla_REG D 1 b" (Solaris)
-- and returns ("MAX_Vanilla_REG", 11)
parseNmLine line
= case words line of
('_' : n) : "C" : s : _ -> mkP n s
n : "C" : s : _ -> mkP n s
[n, "D", _, s] -> mkP n s
[s, "O", "*COM*", _, n] -> mkP n s
_ -> Nothing
where mkP r s = case (stripPrefix prefix r, readHex s) of
(Just name, [(size, "")]) -> Just (name, size)
_ -> Nothing
-- If an Int value is larger than 2^28 or smaller
-- than -2^28, then fail.
-- This test is a bit conservative, but if any
-- constants are roughly maxBound or minBound then
-- we probably need them to be Integer rather than
-- Int so that -- cross-compiling between 32bit and
-- 64bit platforms works.
lookupSmall :: Map String Integer -> Name -> IO Integer
lookupSmall m name
= case Map.lookup name m of
Just v
| v > 2^(28 :: Int) ||
v < -(2^(28 :: Int)) ->
die ("Value too large for GetWord: " ++ show v)
| otherwise -> return v
Nothing -> die ("Can't find " ++ show name)
lookupResult :: Map String Integer -> (Where, What Fst)
-> IO (Where, What Snd)
lookupResult m (w, GetWord name _)
= do v <- lookupSmall m name
return (w, GetWord name (Snd (v - 1)))
lookupResult m (w, GetInt name _)
= do mag <- lookupSmall m (name ++ "Mag")
sig <- lookupSmall m (name ++ "Sig")
return (w, GetWord name (Snd ((mag - 1) * (sig - 2))))
lookupResult m (w, GetNatural name _)
= do v0 <- lookupSmall m (name ++ "0")
v1 <- lookupSmall m (name ++ "1")
v2 <- lookupSmall m (name ++ "2")
v3 <- lookupSmall m (name ++ "3")
let v = (v0 - 1)
+ shiftL (v1 - 1) 16
+ shiftL (v2 - 1) 32
+ shiftL (v3 - 1) 48
return (w, GetWord name (Snd v))
lookupResult m (w, GetBool name _)
= do v <- lookupSmall m name
case v of
1 -> return (w, GetBool name (Snd True))
2 -> return (w, GetBool name (Snd False))
_ -> die ("Bad boolean: " ++ show v)
lookupResult m (w, GetFieldType name _)
= do v <- lookupSmall m name
return (w, GetFieldType name (Snd (v - 1)))
lookupResult m (w, GetClosureSize name _)
= do v <- lookupSmall m name
return (w, GetClosureSize name (Snd (v - 1)))
lookupResult _ (w, StructFieldMacro name)
= return (w, StructFieldMacro name)
lookupResult _ (w, ClosureFieldMacro name)
= return (w, ClosureFieldMacro name)
lookupResult _ (w, ClosurePayloadMacro name)
= return (w, ClosurePayloadMacro name)
lookupResult _ (w, FieldTypeGcptrMacro name)
= return (w, FieldTypeGcptrMacro name) | 7,649 | getWanted verbose tmpdir gccProgram gccFlags nmProgram
= do let cStuff = unlines (headers ++ concatMap (doWanted . snd) wanteds)
cFile = tmpdir </> "tmp.c"
oFile = tmpdir </> "tmp.o"
writeFile cFile cStuff
execute verbose gccProgram (gccFlags ++ ["-c", cFile, "-o", oFile])
xs <- case os of
"openbsd" -> readProcess "/usr/bin/objdump" ["--syms", oFile] ""
_ -> readProcess nmProgram ["-P", oFile] ""
let ls = lines xs
ms = map parseNmLine ls
m = Map.fromList $ catMaybes ms
rs <- mapM (lookupResult m) wanteds
return rs
where headers = ["#define IN_STG_CODE 0",
"",
"/*",
" * We need offsets of profiled things...",
" * better be careful that this doesn't",
" * affect the offsets of anything else.",
" */",
"",
"#define PROFILING",
"#define THREADED_RTS",
"",
"#include \"PosixSource.h\"",
"#include \"Rts.h\"",
"#include \"Stable.h\"",
"#include \"Capability.h\"",
"",
"#include <inttypes.h>",
"#include <stddef.h>",
"#include <stdio.h>",
"#include <string.h>",
"",
"#define FIELD_SIZE(s_type, field) ((size_t)sizeof(((s_type*)0)->field))",
"#define TYPE_SIZE(type) (sizeof(type))",
"#define FUN_OFFSET(sym) (offsetof(Capability,f.sym) - offsetof(Capability,r))",
"",
"#pragma GCC poison sizeof"
]
prefix = "derivedConstant"
mkFullName name = prefix ++ name
-- We add 1 to the value, as some platforms will make a symbol
-- of size 1 when for
-- char foo[0];
-- We then subtract 1 again when parsing.
doWanted (GetFieldType name (Fst (CExpr cExpr)))
= ["char " ++ mkFullName name ++ "[1 + " ++ cExpr ++ "];"]
doWanted (GetClosureSize name (Fst (CExpr cExpr)))
= ["char " ++ mkFullName name ++ "[1 + " ++ cExpr ++ "];"]
doWanted (GetWord name (Fst (CExpr cExpr)))
= ["char " ++ mkFullName name ++ "[1 + " ++ cExpr ++ "];"]
doWanted (GetInt name (Fst (CExpr cExpr)))
= ["char " ++ mkFullName name ++ "Mag[1 + ((intptr_t)(" ++ cExpr ++ ") >= 0 ? (" ++ cExpr ++ ") : -(" ++ cExpr ++ "))];",
"char " ++ mkFullName name ++ "Sig[(intptr_t)(" ++ cExpr ++ ") >= 0 ? 3 : 1];"]
doWanted (GetNatural name (Fst (CExpr cExpr)))
= -- These casts fix "right shift count >= width of type"
-- warnings
let cExpr' = "(uint64_t)(size_t)(" ++ cExpr ++ ")"
in ["char " ++ mkFullName name ++ "0[1 + ((" ++ cExpr' ++ ") & 0xFFFF)];",
"char " ++ mkFullName name ++ "1[1 + (((" ++ cExpr' ++ ") >> 16) & 0xFFFF)];",
"char " ++ mkFullName name ++ "2[1 + (((" ++ cExpr' ++ ") >> 32) & 0xFFFF)];",
"char " ++ mkFullName name ++ "3[1 + (((" ++ cExpr' ++ ") >> 48) & 0xFFFF)];"]
doWanted (GetBool name (Fst (CPPExpr cppExpr)))
= ["#if " ++ cppExpr,
"char " ++ mkFullName name ++ "[1];",
"#else",
"char " ++ mkFullName name ++ "[2];",
"#endif"]
doWanted (StructFieldMacro {}) = []
doWanted (ClosureFieldMacro {}) = []
doWanted (ClosurePayloadMacro {}) = []
doWanted (FieldTypeGcptrMacro {}) = []
-- parseNmLine parses "nm -P" output that looks like
-- "derivedConstantMAX_Vanilla_REG C 0000000b 0000000b" (GNU nm)
-- "_derivedConstantMAX_Vanilla_REG C b 0" (Mac OS X)
-- "_derivedConstantMAX_Vanilla_REG C 000000b" (MinGW)
-- "derivedConstantMAX_Vanilla_REG D 1 b" (Solaris)
-- and returns ("MAX_Vanilla_REG", 11)
parseNmLine line
= case words line of
('_' : n) : "C" : s : _ -> mkP n s
n : "C" : s : _ -> mkP n s
[n, "D", _, s] -> mkP n s
[s, "O", "*COM*", _, n] -> mkP n s
_ -> Nothing
where mkP r s = case (stripPrefix prefix r, readHex s) of
(Just name, [(size, "")]) -> Just (name, size)
_ -> Nothing
-- If an Int value is larger than 2^28 or smaller
-- than -2^28, then fail.
-- This test is a bit conservative, but if any
-- constants are roughly maxBound or minBound then
-- we probably need them to be Integer rather than
-- Int so that -- cross-compiling between 32bit and
-- 64bit platforms works.
lookupSmall :: Map String Integer -> Name -> IO Integer
lookupSmall m name
= case Map.lookup name m of
Just v
| v > 2^(28 :: Int) ||
v < -(2^(28 :: Int)) ->
die ("Value too large for GetWord: " ++ show v)
| otherwise -> return v
Nothing -> die ("Can't find " ++ show name)
lookupResult :: Map String Integer -> (Where, What Fst)
-> IO (Where, What Snd)
lookupResult m (w, GetWord name _)
= do v <- lookupSmall m name
return (w, GetWord name (Snd (v - 1)))
lookupResult m (w, GetInt name _)
= do mag <- lookupSmall m (name ++ "Mag")
sig <- lookupSmall m (name ++ "Sig")
return (w, GetWord name (Snd ((mag - 1) * (sig - 2))))
lookupResult m (w, GetNatural name _)
= do v0 <- lookupSmall m (name ++ "0")
v1 <- lookupSmall m (name ++ "1")
v2 <- lookupSmall m (name ++ "2")
v3 <- lookupSmall m (name ++ "3")
let v = (v0 - 1)
+ shiftL (v1 - 1) 16
+ shiftL (v2 - 1) 32
+ shiftL (v3 - 1) 48
return (w, GetWord name (Snd v))
lookupResult m (w, GetBool name _)
= do v <- lookupSmall m name
case v of
1 -> return (w, GetBool name (Snd True))
2 -> return (w, GetBool name (Snd False))
_ -> die ("Bad boolean: " ++ show v)
lookupResult m (w, GetFieldType name _)
= do v <- lookupSmall m name
return (w, GetFieldType name (Snd (v - 1)))
lookupResult m (w, GetClosureSize name _)
= do v <- lookupSmall m name
return (w, GetClosureSize name (Snd (v - 1)))
lookupResult _ (w, StructFieldMacro name)
= return (w, StructFieldMacro name)
lookupResult _ (w, ClosureFieldMacro name)
= return (w, ClosureFieldMacro name)
lookupResult _ (w, ClosurePayloadMacro name)
= return (w, ClosurePayloadMacro name)
lookupResult _ (w, FieldTypeGcptrMacro name)
= return (w, FieldTypeGcptrMacro name) | 7,569 | false | true | 0 | 17 | 3,179 | 1,954 | 1,003 | 951 | null | null |
bergmark/clay | src/Clay/Selector.hs | bsd-3-clause | -- | Named alias for `|>`.
child :: Selector -> Selector -> Selector
child a b = In (SelectorF (Refinement []) (Child a b)) | 124 | child :: Selector -> Selector -> Selector
child a b = In (SelectorF (Refinement []) (Child a b)) | 96 | child a b = In (SelectorF (Refinement []) (Child a b)) | 54 | true | true | 0 | 9 | 24 | 57 | 27 | 30 | null | null |
RayRacine/aws | Aws/DynamoDb/Commands/Table.hs | bsd-3-clause | dropOpt :: Int -> A.Options
dropOpt d = A.defaultOptions { A.fieldLabelModifier = drop d } | 90 | dropOpt :: Int -> A.Options
dropOpt d = A.defaultOptions { A.fieldLabelModifier = drop d } | 90 | dropOpt d = A.defaultOptions { A.fieldLabelModifier = drop d } | 62 | false | true | 0 | 7 | 14 | 35 | 18 | 17 | null | null |
mariefarrell/Hets | CspCASLProver/CspProverConsts.hs | gpl-2.0 | cspProver_action_prefixAltArgPrios :: [Int]
cspProver_action_prefixAltArgPrios = [150, 80] | 90 | cspProver_action_prefixAltArgPrios :: [Int]
cspProver_action_prefixAltArgPrios = [150, 80] | 90 | cspProver_action_prefixAltArgPrios = [150, 80] | 46 | false | true | 0 | 5 | 6 | 20 | 12 | 8 | null | null |
pack-it-forms/msgfmt | src/PackItForms/MsgFmt.hs | apache-2.0 | -- | Accessor for the value of an envelope field
getEnvVal :: MsgFmt -> String -> Maybe String
getEnvVal (MsgFmt e _ _) k = M.lookup k e | 136 | getEnvVal :: MsgFmt -> String -> Maybe String
getEnvVal (MsgFmt e _ _) k = M.lookup k e | 87 | getEnvVal (MsgFmt e _ _) k = M.lookup k e | 41 | true | true | 0 | 7 | 27 | 45 | 22 | 23 | null | null |
mapinguari/SC_HS_Proxy | src/Proxy/Query/Unit.hs | mit | buildTime ZergNydusCanal = 600 | 30 | buildTime ZergNydusCanal = 600 | 30 | buildTime ZergNydusCanal = 600 | 30 | false | false | 0 | 5 | 3 | 9 | 4 | 5 | null | null |
agentm/project-m36 | src/lib/ProjectM36/AtomType.hs | unlicense | atomTypeForAttributeExpr (AttributeAndTypeNameExpr _ tCons _) tConsMap tvMap = atomTypeForTypeConstructorValidate True tCons tConsMap tvMap | 139 | atomTypeForAttributeExpr (AttributeAndTypeNameExpr _ tCons _) tConsMap tvMap = atomTypeForTypeConstructorValidate True tCons tConsMap tvMap | 139 | atomTypeForAttributeExpr (AttributeAndTypeNameExpr _ tCons _) tConsMap tvMap = atomTypeForTypeConstructorValidate True tCons tConsMap tvMap | 139 | false | false | 0 | 7 | 12 | 32 | 15 | 17 | null | null |
snoyberg/ghc | compiler/codeGen/StgCmmClosure.hs | bsd-3-clause | might_be_a_function :: Type -> Bool
-- Return False only if we are *sure* it's a data type
-- Look through newtypes etc as much as poss
might_be_a_function ty
| UnaryRep rep <- repType ty
, Just tc <- tyConAppTyCon_maybe rep
, isDataTyCon tc
= False
| otherwise
= True | 280 | might_be_a_function :: Type -> Bool
might_be_a_function ty
| UnaryRep rep <- repType ty
, Just tc <- tyConAppTyCon_maybe rep
, isDataTyCon tc
= False
| otherwise
= True | 180 | might_be_a_function ty
| UnaryRep rep <- repType ty
, Just tc <- tyConAppTyCon_maybe rep
, isDataTyCon tc
= False
| otherwise
= True | 144 | true | true | 0 | 9 | 60 | 69 | 31 | 38 | null | null |
MichielDerhaeg/stack | src/Stack/Types/Package.hs | bsd-3-clause | isCExe :: NamedComponent -> Bool
isCExe CExe{} = True | 53 | isCExe :: NamedComponent -> Bool
isCExe CExe{} = True | 53 | isCExe CExe{} = True | 20 | false | true | 0 | 6 | 8 | 22 | 11 | 11 | null | null |
JohnLato/jaek | src/Jaek/UI/Controllers/Base.hs | lgpl-3.0 | aKeys :: ControlGraph (Event KeyVal)
aKeys = (extract keysPass . last) <$> St.get | 81 | aKeys :: ControlGraph (Event KeyVal)
aKeys = (extract keysPass . last) <$> St.get | 81 | aKeys = (extract keysPass . last) <$> St.get | 44 | false | true | 0 | 8 | 12 | 36 | 18 | 18 | null | null |
reuleaux/pire | src/Pire/Parser/Decl.hs | bsd-3-clause | Def_ :: (TokenParsing m
-- , Fresh m
, LookAheadParsing m
, DeltaParsing m
, MonadState PiState m) => m (Decl T.Text T.Text)
valDef_ = do
-- (n, e) <- try (do {n <- var_; e <- eq_; return (n, e)})
-- val <- expr_
-- return $ Def_ n e val
(n, ws, e) <- try (do {(n, ws) <- var2_; e <- eq_; return (n, ws, e)})
val <- expr_
return $ Def_ (Nm1_ n ws) e val
-- for testing
-- let natstr = unlines [ "data Nat : Type where", " Zero", " Succ of (Nat)" ]
-- then
-- nopos $ fromSuccess $ parseString (runInnerParser $ evalStateT (whiteSpace *> dataDef) piInit) beginning natstr
-- datatype decls
-- eg.
--
-- data Nat : Type where
-- Zero
-- Succ of (Nat)
--
da | 728 | valDef_ :: (TokenParsing m
-- , Fresh m
, LookAheadParsing m
, DeltaParsing m
, MonadState PiState m) => m (Decl T.Text T.Text)
valDef_ = do
-- (n, e) <- try (do {n <- var_; e <- eq_; return (n, e)})
-- val <- expr_
-- return $ Def_ n e val
(n, ws, e) <- try (do {(n, ws) <- var2_; e <- eq_; return (n, ws, e)})
val <- expr_
return $ Def_ (Nm1_ n ws) e val
-- for testing
-- let natstr = unlines [ "data Nat : Type where", " Zero", " Succ of (Nat)" ]
-- then
-- nopos $ fromSuccess $ parseString (runInnerParser $ evalStateT (whiteSpace *> dataDef) piInit) beginning natstr
-- datatype decls
-- eg.
--
-- data Nat : Type where
-- Zero
-- Succ of (Nat)
-- | 728 | valDef_ = do
-- (n, e) <- try (do {n <- var_; e <- eq_; return (n, e)})
-- val <- expr_
-- return $ Def_ n e val
(n, ws, e) <- try (do {(n, ws) <- var2_; e <- eq_; return (n, ws, e)})
val <- expr_
return $ Def_ (Nm1_ n ws) e val
-- for testing
-- let natstr = unlines [ "data Nat : Type where", " Zero", " Succ of (Nat)" ]
-- then
-- nopos $ fromSuccess $ parseString (runInnerParser $ evalStateT (whiteSpace *> dataDef) piInit) beginning natstr
-- datatype decls
-- eg.
--
-- data Nat : Type where
-- Zero
-- Succ of (Nat)
-- | 556 | false | true | 0 | 13 | 211 | 169 | 92 | 77 | null | null |
peterson/lets-tree | src/Lets/BinomialHeap.hs | bsd-3-clause | t2 = Node 1 1 [Node 0 5 []] | 27 | t2 = Node 1 1 [Node 0 5 []] | 27 | t2 = Node 1 1 [Node 0 5 []] | 27 | false | false | 1 | 7 | 8 | 30 | 12 | 18 | null | null |
d0kt0r0/estuary | client/src/Estuary/Types/Terminal.hs | gpl-3.0 | -- <?> "expecting view"
identifierText :: H Text
identifierText = do
s <- identifier
return $ T.pack s | 107 | identifierText :: H Text
identifierText = do
s <- identifier
return $ T.pack s | 82 | identifierText = do
s <- identifier
return $ T.pack s | 57 | true | true | 0 | 10 | 22 | 40 | 17 | 23 | null | null |
kapilash/dc | src/ccs2c/ccs2cs-lib/src/Language/CCS/Parser.hs | bsd-3-clause | enumValue = hashedEnumVal <|> enumComplex
<?> "Enum Value" | 70 | enumValue = hashedEnumVal <|> enumComplex
<?> "Enum Value" | 70 | enumValue = hashedEnumVal <|> enumComplex
<?> "Enum Value" | 70 | false | false | 0 | 6 | 19 | 14 | 7 | 7 | null | null |
IanConnolly/aws-sdk-fork | AWS/Lib/Parser.hs | bsd-3-clause | fromMaybeM :: Monad m => m a -> Maybe a -> m a
fromMaybeM a Nothing = a | 72 | fromMaybeM :: Monad m => m a -> Maybe a -> m a
fromMaybeM a Nothing = a | 72 | fromMaybeM a Nothing = a | 25 | false | true | 0 | 8 | 18 | 40 | 18 | 22 | null | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.