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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
DanielWaterworth/Idris-dev
|
src/IRTS/CodegenLLVM.hs
|
bsd-3-clause
|
conType :: Word64 -> Type
conType nargs = StructureType False
[ IntegerType 32
, ArrayType nargs (PointerType valueType (AddrSpace 0))
]
| 184
|
conType :: Word64 -> Type
conType nargs = StructureType False
[ IntegerType 32
, ArrayType nargs (PointerType valueType (AddrSpace 0))
]
| 184
|
conType nargs = StructureType False
[ IntegerType 32
, ArrayType nargs (PointerType valueType (AddrSpace 0))
]
| 158
| false
| true
| 0
| 10
| 68
| 57
| 26
| 31
| null | null |
ghc-android/ghc
|
testsuite/tests/ghci/should_run/ghcirun004.hs
|
bsd-3-clause
|
2897 = 2896
| 11
|
2897 = 2896
| 11
|
2897 = 2896
| 11
| false
| false
| 1
| 5
| 2
| 10
| 3
| 7
| null | null |
ygale/yesod
|
yesod-auth/Yesod/Auth/Email.hs
|
mit
|
getRegisterR :: YesodAuthEmail master => HandlerT Auth (HandlerT master IO) Html
getRegisterR = registerHandler
| 111
|
getRegisterR :: YesodAuthEmail master => HandlerT Auth (HandlerT master IO) Html
getRegisterR = registerHandler
| 111
|
getRegisterR = registerHandler
| 30
| false
| true
| 0
| 8
| 13
| 33
| 16
| 17
| null | null |
mrmonday/Idris-dev
|
src/IRTS/JavaScript/AST.hs
|
bsd-3-clause
|
compileJS' indent (JSString str) =
"\"" `T.append` T.pack str `T.append` "\""
| 79
|
compileJS' indent (JSString str) =
"\"" `T.append` T.pack str `T.append` "\""
| 79
|
compileJS' indent (JSString str) =
"\"" `T.append` T.pack str `T.append` "\""
| 79
| false
| false
| 0
| 8
| 12
| 38
| 20
| 18
| null | null |
AaronFriel/eff-experiments
|
src/Eff/Internal/Eff1.hs
|
bsd-3-clause
|
th1 :: Member (Yield Int ()) r => Eff r ()
th1 = yieldInt 1 >> yieldInt 2
| 73
|
th1 :: Member (Yield Int ()) r => Eff r ()
th1 = yieldInt 1 >> yieldInt 2
| 73
|
th1 = yieldInt 1 >> yieldInt 2
| 30
| false
| true
| 0
| 10
| 17
| 52
| 23
| 29
| null | null |
shlevy/ghc
|
compiler/hsSyn/HsDecls.hs
|
bsd-3-clause
|
pprTyClDeclFlavour (SynDecl {}) = text "type"
| 49
|
pprTyClDeclFlavour (SynDecl {}) = text "type"
| 49
|
pprTyClDeclFlavour (SynDecl {}) = text "type"
| 49
| false
| false
| 0
| 7
| 9
| 19
| 9
| 10
| null | null |
jwiegley/ghc-release
|
libraries/bytestring/Data/ByteString/Builder/ASCII.hs
|
gpl-3.0
|
intDec :: Int -> Builder
intDec = P.primBounded P.intDec
| 56
|
intDec :: Int -> Builder
intDec = P.primBounded P.intDec
| 56
|
intDec = P.primBounded P.intDec
| 31
| false
| true
| 0
| 6
| 8
| 22
| 11
| 11
| null | null |
silky/Tidal
|
Sound/Tidal/Tempo.hs
|
gpl-3.0
|
serverApp :: MVar Tempo -> MVar ClientState -> WS.ServerApp
serverApp tempoState clientState pending = do
conn <- WS.acceptRequest pending
tempo <- liftIO $ readMVar tempoState
liftIO $ WS.sendTextData conn $ T.pack $ show tempo
clients <- liftIO $ readMVar clientState
liftIO $ modifyMVar_ clientState $ \s -> return $ addClient conn s
serverLoop conn tempoState clientState
| 399
|
serverApp :: MVar Tempo -> MVar ClientState -> WS.ServerApp
serverApp tempoState clientState pending = do
conn <- WS.acceptRequest pending
tempo <- liftIO $ readMVar tempoState
liftIO $ WS.sendTextData conn $ T.pack $ show tempo
clients <- liftIO $ readMVar clientState
liftIO $ modifyMVar_ clientState $ \s -> return $ addClient conn s
serverLoop conn tempoState clientState
| 399
|
serverApp tempoState clientState pending = do
conn <- WS.acceptRequest pending
tempo <- liftIO $ readMVar tempoState
liftIO $ WS.sendTextData conn $ T.pack $ show tempo
clients <- liftIO $ readMVar clientState
liftIO $ modifyMVar_ clientState $ \s -> return $ addClient conn s
serverLoop conn tempoState clientState
| 339
| false
| true
| 0
| 12
| 79
| 142
| 62
| 80
| null | null |
christiaanb/ghc
|
compiler/deSugar/Check.hs
|
bsd-3-clause
|
tidy_pat (ListPat ps ty Nothing)
= unLoc $ foldr (\ x y -> mkPrefixConPat consDataCon [x,y] [ty])
(mkNilPat ty)
(map tidy_lpat ps)
| 200
|
tidy_pat (ListPat ps ty Nothing)
= unLoc $ foldr (\ x y -> mkPrefixConPat consDataCon [x,y] [ty])
(mkNilPat ty)
(map tidy_lpat ps)
| 200
|
tidy_pat (ListPat ps ty Nothing)
= unLoc $ foldr (\ x y -> mkPrefixConPat consDataCon [x,y] [ty])
(mkNilPat ty)
(map tidy_lpat ps)
| 200
| false
| false
| 0
| 10
| 91
| 70
| 36
| 34
| null | null |
jaccokrijnen/leksah
|
src/IDE/TextEditor/CodeMirror.hs
|
gpl-2.0
|
setMode m = jss "mode" m
| 32
|
setMode m = jss "mode" m
| 32
|
setMode m = jss "mode" m
| 32
| false
| false
| 0
| 5
| 13
| 14
| 6
| 8
| null | null |
text-utf8/text
|
tests/Tests/Properties.hs
|
bsd-2-clause
|
tl_repeat n = (L.take m . L.repeat) `eq`
(unpackS . TL.take (fromIntegral m) . TL.repeat)
where m = fromIntegral (n :: Word8)
| 155
|
tl_repeat n = (L.take m . L.repeat) `eq`
(unpackS . TL.take (fromIntegral m) . TL.repeat)
where m = fromIntegral (n :: Word8)
| 155
|
tl_repeat n = (L.take m . L.repeat) `eq`
(unpackS . TL.take (fromIntegral m) . TL.repeat)
where m = fromIntegral (n :: Word8)
| 155
| false
| false
| 0
| 11
| 51
| 70
| 36
| 34
| null | null |
mreid/papersite
|
src/lib/Page.hs
|
mit
|
get :: String -> T -> Maybe String
get key = lookup key . fields
| 64
|
get :: String -> T -> Maybe String
get key = lookup key . fields
| 64
|
get key = lookup key . fields
| 29
| false
| true
| 0
| 7
| 14
| 36
| 16
| 20
| null | null |
uvNikita/SyntacticAnalyzer
|
src/Operation.hs
|
mit
|
inverse Div = Mul
| 18
|
inverse Div = Mul
| 18
|
inverse Div = Mul
| 18
| false
| false
| 1
| 5
| 4
| 13
| 4
| 9
| null | null |
kaliumxyz/learnings
|
haskell/baby.hs
|
mit
|
doubleMe x = x + x
| 18
|
doubleMe x = x + x
| 18
|
doubleMe x = x + x
| 18
| false
| false
| 3
| 5
| 5
| 18
| 6
| 12
| null | null |
nicball/orlin
|
src/Orlin/Frontend/TypeChecker.hs
|
mit
|
lookupSymbol :: String -> TypeChecker (Maybe (Type, Word))
lookupSymbol name = do
st <- get
return (iter st name 0)
where iter (st:rest) name level =
case lookup name st of
Just t -> Just (t, level)
Nothing -> iter rest name (level + 1)
iter [] _ _ = Nothing
| 306
|
lookupSymbol :: String -> TypeChecker (Maybe (Type, Word))
lookupSymbol name = do
st <- get
return (iter st name 0)
where iter (st:rest) name level =
case lookup name st of
Just t -> Just (t, level)
Nothing -> iter rest name (level + 1)
iter [] _ _ = Nothing
| 306
|
lookupSymbol name = do
st <- get
return (iter st name 0)
where iter (st:rest) name level =
case lookup name st of
Just t -> Just (t, level)
Nothing -> iter rest name (level + 1)
iter [] _ _ = Nothing
| 247
| false
| true
| 1
| 11
| 98
| 141
| 69
| 72
| null | null |
fredyr/copilot-libraries
|
src/Copilot/Library/Voting.hs
|
bsd-3-clause
|
aMajority :: (P.Eq a, Typed a) =>
[Stream a] -- ^ Vote streams
-> Stream a -- ^ Candidate stream
-> Stream Bool -- ^ True if candidate holds majority
aMajority [] _ = badUsage "aMajority: empty list not allowed"
| 250
|
aMajority :: (P.Eq a, Typed a) =>
[Stream a] -- ^ Vote streams
-> Stream a -- ^ Candidate stream
-> Stream Bool
aMajority [] _ = badUsage "aMajority: empty list not allowed"
| 212
|
aMajority [] _ = badUsage "aMajority: empty list not allowed"
| 61
| true
| true
| 0
| 8
| 78
| 61
| 31
| 30
| null | null |
spoqa/nirum
|
src/Nirum/Docs/Html.hs
|
gpl-3.0
|
renderInline (Code code') = [qq|<code>{escape code'}</code>|]
| 61
|
renderInline (Code code') = [qq|<code>{escape code'}</code>|]
| 61
|
renderInline (Code code') = [qq|<code>{escape code'}</code>|]
| 61
| false
| false
| 0
| 7
| 5
| 19
| 11
| 8
| null | null |
TomMD/ghc
|
libraries/base/GHC/Exts.hs
|
bsd-3-clause
|
groupByFB :: ([a] -> lst -> lst) -> lst -> (a -> a -> Bool) -> [a] -> lst
groupByFB c n eq xs0 = groupByFBCore xs0
where groupByFBCore [] = n
groupByFBCore (x:xs) = c (x:ys) (groupByFBCore zs)
where (ys, zs) = span (eq x) xs
-- -----------------------------------------------------------------------------
-- tracing
| 340
|
groupByFB :: ([a] -> lst -> lst) -> lst -> (a -> a -> Bool) -> [a] -> lst
groupByFB c n eq xs0 = groupByFBCore xs0
where groupByFBCore [] = n
groupByFBCore (x:xs) = c (x:ys) (groupByFBCore zs)
where (ys, zs) = span (eq x) xs
-- -----------------------------------------------------------------------------
-- tracing
| 340
|
groupByFB c n eq xs0 = groupByFBCore xs0
where groupByFBCore [] = n
groupByFBCore (x:xs) = c (x:ys) (groupByFBCore zs)
where (ys, zs) = span (eq x) xs
-- -----------------------------------------------------------------------------
-- tracing
| 266
| false
| true
| 1
| 11
| 74
| 150
| 74
| 76
| null | null |
pdmurray/haskell-book-ex
|
src/ch10/Exercises10.10.hs
|
bsd-3-clause
|
myMinimumBy f (x:xs) = foldl (\a b -> if f a b == LT then a else b) x xs
| 72
|
myMinimumBy f (x:xs) = foldl (\a b -> if f a b == LT then a else b) x xs
| 72
|
myMinimumBy f (x:xs) = foldl (\a b -> if f a b == LT then a else b) x xs
| 72
| false
| false
| 0
| 10
| 19
| 52
| 27
| 25
| null | null |
matthewleon/libmpd-haskell
|
src/Network/MPD/Commands/Database.hs
|
mit
|
-- | Update the server's database.
--
-- If no path is given, the whole library will be scanned. Unreadable or
-- non-existent paths are silently ignored.
--
-- The update job id is returned.
update :: MonadMPD m => Maybe Path -> m Integer
update = A.runCommand . A.update
| 273
|
update :: MonadMPD m => Maybe Path -> m Integer
update = A.runCommand . A.update
| 80
|
update = A.runCommand . A.update
| 32
| true
| true
| 0
| 7
| 50
| 42
| 23
| 19
| null | null |
DylanSp/zmachine-interpreter
|
src/ImmutableBytes.hs
|
mit
|
writeByte :: ImmutableBytes -> ByteAddress -> Word8 -> ImmutableBytes
writeByte bytes addr@(ByteAddress address) value
| isOutOfRange addr (size bytes) = error "ImmutableBytes.writeByte: Address is out of range"
| otherwise = ImmutableBytes { originalBytes = originalBytes bytes,
edits = Map.insert address value (edits bytes)}
| 412
|
writeByte :: ImmutableBytes -> ByteAddress -> Word8 -> ImmutableBytes
writeByte bytes addr@(ByteAddress address) value
| isOutOfRange addr (size bytes) = error "ImmutableBytes.writeByte: Address is out of range"
| otherwise = ImmutableBytes { originalBytes = originalBytes bytes,
edits = Map.insert address value (edits bytes)}
| 412
|
writeByte bytes addr@(ByteAddress address) value
| isOutOfRange addr (size bytes) = error "ImmutableBytes.writeByte: Address is out of range"
| otherwise = ImmutableBytes { originalBytes = originalBytes bytes,
edits = Map.insert address value (edits bytes)}
| 342
| false
| true
| 0
| 10
| 127
| 100
| 49
| 51
| null | null |
adinapoli/api-tools
|
src/Data/API/Markdown.hs
|
bsd-3-clause
|
union_ :: MarkdownMethods -> APINode -> SpecUnion -> [MDComment]
union_ mdm an su =
summary_lines mdm an "union object" ++ mk_md_union_table mdm (suFields su)
| 162
|
union_ :: MarkdownMethods -> APINode -> SpecUnion -> [MDComment]
union_ mdm an su =
summary_lines mdm an "union object" ++ mk_md_union_table mdm (suFields su)
| 162
|
union_ mdm an su =
summary_lines mdm an "union object" ++ mk_md_union_table mdm (suFields su)
| 97
| false
| true
| 0
| 8
| 27
| 59
| 28
| 31
| null | null |
vincenthz/hs-foundation
|
foundation/tests/Test/Foundation/Primitive/BlockN.hs
|
bsd-3-clause
|
createBlockSized :: CountOf Int -> B.Block Int
createBlockSized n@(CountOf n') = B.create n (const n')
| 102
|
createBlockSized :: CountOf Int -> B.Block Int
createBlockSized n@(CountOf n') = B.create n (const n')
| 102
|
createBlockSized n@(CountOf n') = B.create n (const n')
| 55
| false
| true
| 1
| 8
| 14
| 55
| 24
| 31
| null | null |
spatial-reasoning/zeno
|
src/compareGivenNetworks.hs
|
bsd-2-clause
|
checkNetworks = do
-- dpNet0 <- loadBinaryNetwork ("bla2.net") :: IO (Network [String] (Set.Set Dipole72))
-- dpNet1 <- loadBinaryNetwork ("../testsuite/dipole/24/alleq.net") :: IO (Network [String] (Set.Set Dipole72))
-- dpNet2 <- loadBinaryNetwork ("../testsuite/dipole/24/consistent_01.net") :: IO (Network [String] (Set.Set Dipole72))
-- dpNet3 <- loadBinaryNetwork ("../testsuite/dipole/24/inconsistent_01.net") :: IO (Network [String] (Set.Set Dipole72))
-- let dpNet4 = forwardCircle 8
-- -- At a sizo of 12 this network overwhelms the backtracking of the
-- -- oriented matroid method.
-- let dpNet5 = circleWithTwoCollinearDipolesInside 12
-- let dpNet5 = circleWithTwoCollinearDipolesInside 11
-- let dpNets = map circleWithTwoCollinearDipolesInside [6..40]
let dpNets = []
let ffNet1 = allLeft 8
ffNet2 <- loadNetwork ("../testsuite/flipflop/inconsistent/inconsistent_01.net") :: IO (Network [String] (Set.Set FlipFlop))
let ffNet3 = indianTent 8
ffNet4 <- loadNetwork ("../testsuite/flipflop/inconsistent/nomatroid.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet5 <- loadNetwork ("../testsuite/flipflop/inconsistent/triskilde.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet6 <- loadNetwork ("../testsuite/flipflop/inconsistent/triskilde_less.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet7 <- loadNetwork ("../testsuite/flipflop/inconsistent/desargues.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet8 <- loadNetwork ("../testsuite/flipflop/inconsistent/minimalStar.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet9 <- loadNetwork ("../testsuite/flipflop/inconsistent/pappos.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet10 <- loadNetwork ("../testsuite/flipflop/inconsistent/pappos_uniform.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet11 <- loadNetwork ("../testsuite/flipflop/inconsistent/tenA.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet12 <- loadNetwork ("../testsuite/flipflop/consistent/triskilde.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet13 <- loadNetwork ("../testsuite/flipflop/consistent/desargues.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet14 <- loadNetwork ("../testsuite/flipflop/consistent/minimalStar.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet15 <- loadNetwork ("../testsuite/flipflop/consistent/minimalStar.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet15 <- loadNetwork ("../testsuite/flipflop/consistent/pappos.net") :: IO (Network [String] (Set.Set FlipFlop))
-- ffNet16 <- loadNetwork ("../testsuite/flipflop/consistent/pappos_uniform.net") :: IO (Network [String] (Set.Set FlipFlop))
-- ffNet1 <- loadNetwork ("./test.net") :: IO (Network [String] (Set.Set FlipFlop))
-- let ffNets = [ffNet1]
let ffNets = [ ffNet1
, ffNet2
, ffNet3
, ffNet4
, ffNet5
, ffNet6
, ffNet7
, ffNet8
, ffNet9
, ffNet10
, ffNet11
, ffNet12
, ffNet13
, ffNet14
, ffNet15
]
let dpAnswers = makeReadable 0 $ dpCheckConsistency dpNets
let ffAnswers = makeReadable (length dpNets) $ ffCheckConsistency ffNets
let showNetworks nets startNumber = foldl
(\acc (net, k) -> acc ++ " === NETWORK No. " ++ show k ++
" ===\n\n" ++ showNonAtomicNet net ++ "\n\n"
) "" $ zip nets [startNumber..]
putStrLn $ "\n === NEW TEST ===\n\n" ++
-- "Networks tested:\n\n" ++
-- showNetworks dpNets 1 ++ showNetworks ffNets (length dpNets + 1) ++
-- " === RESULTS ===\n\n" ++
"Number of Network: " ++
(intercalate " " $ map show [1..length dpNets + length ffNets]) ++
"\n"
start <- getCurrentTime
putStrLn $ "Algebraic Closure: " ++ dpAnswers!!0 ++ ffAnswers!!0
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Algebraic Reasoning: " ++ dpAnswers!!1 ++ ffAnswers!!1
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Triangle Consistency: " ++ dpAnswers!!2 ++ ffAnswers!!2
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Oriented Matroid: " ++ dpAnswers!!3 ++ ffAnswers!!3
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Biquadratic Polynomial: " ++ dpAnswers!!4 ++ ffAnswers!!4
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n\n"
{-
start <- getCurrentTime
putStrLn $ "Algebraic Closure: " ++ ffAnswers!!0
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Algebraic Reasoning: " ++ ffAnswers!!1
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Triangle Consistency: " ++ ffAnswers!!2
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Oriented Matroid: " ++ ffAnswers!!3
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Biquadratic Polynomial: " ++ ffAnswers!!4
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n\n"
-}
return ()
| 5,930
|
checkNetworks = do
-- dpNet0 <- loadBinaryNetwork ("bla2.net") :: IO (Network [String] (Set.Set Dipole72))
-- dpNet1 <- loadBinaryNetwork ("../testsuite/dipole/24/alleq.net") :: IO (Network [String] (Set.Set Dipole72))
-- dpNet2 <- loadBinaryNetwork ("../testsuite/dipole/24/consistent_01.net") :: IO (Network [String] (Set.Set Dipole72))
-- dpNet3 <- loadBinaryNetwork ("../testsuite/dipole/24/inconsistent_01.net") :: IO (Network [String] (Set.Set Dipole72))
-- let dpNet4 = forwardCircle 8
-- -- At a sizo of 12 this network overwhelms the backtracking of the
-- -- oriented matroid method.
-- let dpNet5 = circleWithTwoCollinearDipolesInside 12
-- let dpNet5 = circleWithTwoCollinearDipolesInside 11
-- let dpNets = map circleWithTwoCollinearDipolesInside [6..40]
let dpNets = []
let ffNet1 = allLeft 8
ffNet2 <- loadNetwork ("../testsuite/flipflop/inconsistent/inconsistent_01.net") :: IO (Network [String] (Set.Set FlipFlop))
let ffNet3 = indianTent 8
ffNet4 <- loadNetwork ("../testsuite/flipflop/inconsistent/nomatroid.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet5 <- loadNetwork ("../testsuite/flipflop/inconsistent/triskilde.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet6 <- loadNetwork ("../testsuite/flipflop/inconsistent/triskilde_less.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet7 <- loadNetwork ("../testsuite/flipflop/inconsistent/desargues.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet8 <- loadNetwork ("../testsuite/flipflop/inconsistent/minimalStar.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet9 <- loadNetwork ("../testsuite/flipflop/inconsistent/pappos.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet10 <- loadNetwork ("../testsuite/flipflop/inconsistent/pappos_uniform.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet11 <- loadNetwork ("../testsuite/flipflop/inconsistent/tenA.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet12 <- loadNetwork ("../testsuite/flipflop/consistent/triskilde.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet13 <- loadNetwork ("../testsuite/flipflop/consistent/desargues.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet14 <- loadNetwork ("../testsuite/flipflop/consistent/minimalStar.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet15 <- loadNetwork ("../testsuite/flipflop/consistent/minimalStar.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet15 <- loadNetwork ("../testsuite/flipflop/consistent/pappos.net") :: IO (Network [String] (Set.Set FlipFlop))
-- ffNet16 <- loadNetwork ("../testsuite/flipflop/consistent/pappos_uniform.net") :: IO (Network [String] (Set.Set FlipFlop))
-- ffNet1 <- loadNetwork ("./test.net") :: IO (Network [String] (Set.Set FlipFlop))
-- let ffNets = [ffNet1]
let ffNets = [ ffNet1
, ffNet2
, ffNet3
, ffNet4
, ffNet5
, ffNet6
, ffNet7
, ffNet8
, ffNet9
, ffNet10
, ffNet11
, ffNet12
, ffNet13
, ffNet14
, ffNet15
]
let dpAnswers = makeReadable 0 $ dpCheckConsistency dpNets
let ffAnswers = makeReadable (length dpNets) $ ffCheckConsistency ffNets
let showNetworks nets startNumber = foldl
(\acc (net, k) -> acc ++ " === NETWORK No. " ++ show k ++
" ===\n\n" ++ showNonAtomicNet net ++ "\n\n"
) "" $ zip nets [startNumber..]
putStrLn $ "\n === NEW TEST ===\n\n" ++
-- "Networks tested:\n\n" ++
-- showNetworks dpNets 1 ++ showNetworks ffNets (length dpNets + 1) ++
-- " === RESULTS ===\n\n" ++
"Number of Network: " ++
(intercalate " " $ map show [1..length dpNets + length ffNets]) ++
"\n"
start <- getCurrentTime
putStrLn $ "Algebraic Closure: " ++ dpAnswers!!0 ++ ffAnswers!!0
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Algebraic Reasoning: " ++ dpAnswers!!1 ++ ffAnswers!!1
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Triangle Consistency: " ++ dpAnswers!!2 ++ ffAnswers!!2
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Oriented Matroid: " ++ dpAnswers!!3 ++ ffAnswers!!3
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Biquadratic Polynomial: " ++ dpAnswers!!4 ++ ffAnswers!!4
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n\n"
{-
start <- getCurrentTime
putStrLn $ "Algebraic Closure: " ++ ffAnswers!!0
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Algebraic Reasoning: " ++ ffAnswers!!1
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Triangle Consistency: " ++ ffAnswers!!2
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Oriented Matroid: " ++ ffAnswers!!3
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Biquadratic Polynomial: " ++ ffAnswers!!4
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n\n"
-}
return ()
| 5,930
|
checkNetworks = do
-- dpNet0 <- loadBinaryNetwork ("bla2.net") :: IO (Network [String] (Set.Set Dipole72))
-- dpNet1 <- loadBinaryNetwork ("../testsuite/dipole/24/alleq.net") :: IO (Network [String] (Set.Set Dipole72))
-- dpNet2 <- loadBinaryNetwork ("../testsuite/dipole/24/consistent_01.net") :: IO (Network [String] (Set.Set Dipole72))
-- dpNet3 <- loadBinaryNetwork ("../testsuite/dipole/24/inconsistent_01.net") :: IO (Network [String] (Set.Set Dipole72))
-- let dpNet4 = forwardCircle 8
-- -- At a sizo of 12 this network overwhelms the backtracking of the
-- -- oriented matroid method.
-- let dpNet5 = circleWithTwoCollinearDipolesInside 12
-- let dpNet5 = circleWithTwoCollinearDipolesInside 11
-- let dpNets = map circleWithTwoCollinearDipolesInside [6..40]
let dpNets = []
let ffNet1 = allLeft 8
ffNet2 <- loadNetwork ("../testsuite/flipflop/inconsistent/inconsistent_01.net") :: IO (Network [String] (Set.Set FlipFlop))
let ffNet3 = indianTent 8
ffNet4 <- loadNetwork ("../testsuite/flipflop/inconsistent/nomatroid.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet5 <- loadNetwork ("../testsuite/flipflop/inconsistent/triskilde.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet6 <- loadNetwork ("../testsuite/flipflop/inconsistent/triskilde_less.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet7 <- loadNetwork ("../testsuite/flipflop/inconsistent/desargues.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet8 <- loadNetwork ("../testsuite/flipflop/inconsistent/minimalStar.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet9 <- loadNetwork ("../testsuite/flipflop/inconsistent/pappos.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet10 <- loadNetwork ("../testsuite/flipflop/inconsistent/pappos_uniform.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet11 <- loadNetwork ("../testsuite/flipflop/inconsistent/tenA.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet12 <- loadNetwork ("../testsuite/flipflop/consistent/triskilde.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet13 <- loadNetwork ("../testsuite/flipflop/consistent/desargues.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet14 <- loadNetwork ("../testsuite/flipflop/consistent/minimalStar.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet15 <- loadNetwork ("../testsuite/flipflop/consistent/minimalStar.net") :: IO (Network [String] (Set.Set FlipFlop))
ffNet15 <- loadNetwork ("../testsuite/flipflop/consistent/pappos.net") :: IO (Network [String] (Set.Set FlipFlop))
-- ffNet16 <- loadNetwork ("../testsuite/flipflop/consistent/pappos_uniform.net") :: IO (Network [String] (Set.Set FlipFlop))
-- ffNet1 <- loadNetwork ("./test.net") :: IO (Network [String] (Set.Set FlipFlop))
-- let ffNets = [ffNet1]
let ffNets = [ ffNet1
, ffNet2
, ffNet3
, ffNet4
, ffNet5
, ffNet6
, ffNet7
, ffNet8
, ffNet9
, ffNet10
, ffNet11
, ffNet12
, ffNet13
, ffNet14
, ffNet15
]
let dpAnswers = makeReadable 0 $ dpCheckConsistency dpNets
let ffAnswers = makeReadable (length dpNets) $ ffCheckConsistency ffNets
let showNetworks nets startNumber = foldl
(\acc (net, k) -> acc ++ " === NETWORK No. " ++ show k ++
" ===\n\n" ++ showNonAtomicNet net ++ "\n\n"
) "" $ zip nets [startNumber..]
putStrLn $ "\n === NEW TEST ===\n\n" ++
-- "Networks tested:\n\n" ++
-- showNetworks dpNets 1 ++ showNetworks ffNets (length dpNets + 1) ++
-- " === RESULTS ===\n\n" ++
"Number of Network: " ++
(intercalate " " $ map show [1..length dpNets + length ffNets]) ++
"\n"
start <- getCurrentTime
putStrLn $ "Algebraic Closure: " ++ dpAnswers!!0 ++ ffAnswers!!0
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Algebraic Reasoning: " ++ dpAnswers!!1 ++ ffAnswers!!1
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Triangle Consistency: " ++ dpAnswers!!2 ++ ffAnswers!!2
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Oriented Matroid: " ++ dpAnswers!!3 ++ ffAnswers!!3
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Biquadratic Polynomial: " ++ dpAnswers!!4 ++ ffAnswers!!4
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n\n"
{-
start <- getCurrentTime
putStrLn $ "Algebraic Closure: " ++ ffAnswers!!0
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Algebraic Reasoning: " ++ ffAnswers!!1
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Triangle Consistency: " ++ ffAnswers!!2
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Oriented Matroid: " ++ ffAnswers!!3
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n"
start <- getCurrentTime
putStrLn $ "Biquadratic Polynomial: " ++ ffAnswers!!4
end <- getCurrentTime
putStrLn $ show (end `diffUTCTime` start) ++ " elapsed.\n\n"
-}
return ()
| 5,930
| false
| false
| 1
| 19
| 1,438
| 1,122
| 561
| 561
| null | null |
prt2121/fp101x
|
natOp.hs
|
apache-2.0
|
add n (Succ m) = Succ (add m n)
| 36
|
add n (Succ m) = Succ (add m n)
| 36
|
add n (Succ m) = Succ (add m n)
| 36
| false
| false
| 0
| 6
| 13
| 30
| 13
| 17
| null | null |
kaoskorobase/mescaline
|
resources/hugs/packages/base/Data/IntSet.hs
|
gpl-3.0
|
split :: Int -> IntSet -> (IntSet,IntSet)
split x t
= case t of
Bin p m l r
| m < 0 -> if x >= 0 then let (lt,gt) = split' x l in (union r lt, gt)
else let (lt,gt) = split' x r in (lt, union gt l)
-- handle negative numbers.
| otherwise -> split' x t
Tip y
| x>y -> (t,Nil)
| x<y -> (Nil,t)
| otherwise -> (Nil,Nil)
Nil -> (Nil, Nil)
| 502
|
split :: Int -> IntSet -> (IntSet,IntSet)
split x t
= case t of
Bin p m l r
| m < 0 -> if x >= 0 then let (lt,gt) = split' x l in (union r lt, gt)
else let (lt,gt) = split' x r in (lt, union gt l)
-- handle negative numbers.
| otherwise -> split' x t
Tip y
| x>y -> (t,Nil)
| x<y -> (Nil,t)
| otherwise -> (Nil,Nil)
Nil -> (Nil, Nil)
| 502
|
split x t
= case t of
Bin p m l r
| m < 0 -> if x >= 0 then let (lt,gt) = split' x l in (union r lt, gt)
else let (lt,gt) = split' x r in (lt, union gt l)
-- handle negative numbers.
| otherwise -> split' x t
Tip y
| x>y -> (t,Nil)
| x<y -> (Nil,t)
| otherwise -> (Nil,Nil)
Nil -> (Nil, Nil)
| 460
| false
| true
| 0
| 14
| 248
| 225
| 114
| 111
| null | null |
johanneshilden/liquid-epsilon
|
Util/HTML/Elements.hs
|
bsd-3-clause
|
i = makePar "i"
| 24
|
i = makePar "i"
| 24
|
i = makePar "i"
| 24
| false
| false
| 0
| 5
| 12
| 9
| 4
| 5
| null | null |
cirquit/quizlearner
|
resources/form/n_app_forms.hs
|
mit
|
t3 = ("t3 - true3", True)
| 25
|
t3 = ("t3 - true3", True)
| 25
|
t3 = ("t3 - true3", True)
| 25
| false
| false
| 0
| 5
| 5
| 12
| 7
| 5
| null | null |
jgm/citeproc
|
src/Citeproc/Types.hs
|
bsd-2-clause
|
variableType "PMCID" = StringVariable
| 37
|
variableType "PMCID" = StringVariable
| 37
|
variableType "PMCID" = StringVariable
| 37
| false
| false
| 0
| 5
| 3
| 9
| 4
| 5
| null | null |
spechub/Hets
|
Common/Doc.hs
|
gpl-2.0
|
quote = symbol "\'"
| 19
|
quote = symbol "\'"
| 19
|
quote = symbol "\'"
| 19
| false
| false
| 1
| 5
| 3
| 12
| 4
| 8
| null | null |
wellposed/hblas
|
src/Numerical/HBLAS/BLAS/Internal/Level1.hs
|
bsd-3-clause
|
rotmAbstraction :: (SM.Storable el, PrimMonad m, Show el) => String ->
RotmFunFFI el -> RotmFunFFI el ->
RotmFun el (PrimState m) m
rotmAbstraction rotmName rotmSafeFFI rotmUnsafeFFI = rotm
where
shouldCallFast :: Bool
shouldCallFast = True -- O(1)
rotm n (MutableDenseVector _ adim astride abuff)
(MutableDenseVector _ bdim bstride bbuff)
(MutableDenseVector _ pdim _ pbuff)
| isVectorBadWithNIncrement adim n astride = error $! vectorBadInfo rotmName "first matrix" adim n astride
| isVectorBadWithNIncrement bdim n bstride = error $! vectorBadInfo rotmName "second matrix" bdim n bstride
| pdim /= 5 = error $! rotmName ++ " param dimension is not 5"
| otherwise =
unsafeWithPrim abuff $ \ap ->
unsafeWithPrim bbuff $ \bp ->
unsafeWithPrim pbuff $ \pp ->
do unsafePrimToPrim $! (if shouldCallFast then rotmUnsafeFFI else rotmSafeFFI) (fromIntegral n) ap (fromIntegral astride) bp (fromIntegral bstride) pp
--{-# NOINLINE rotmgAbstraction #-}
--rotmgAbstraction :: (SM.Storable el, PrimMonad m, Show el) => String ->
-- RotmgFunFFI el -> RotmgFunFFI el ->
-- RotmgFun el (PrimState m) m
--rotmgAbstraction rotmgName rotmgSafeFFI rotmgUnsafeFFI = rotmg
-- where
-- shouldCallFast :: Bool
-- shouldCallFast = True -- O(1)
-- rotmg (MutableValue d1)
-- (MutableValue d2)
-- (MutableValue x1)
-- y1
-- (MutableDenseVector _ pdim _ pbuff)
-- | pdim /= 5 = error $! rotmgName ++ " param dimension is not 5"
-- | otherwise =
-- unsafeWithPrim d1 $ \d1p ->
-- unsafeWithPrim d2 $ \d2p ->
-- unsafeWithPrim x1 $ \x1p ->
-- unsafeWithPrim pbuff $ \pp ->
-- do unsafePrimToPrim $! (if shouldCallFast then rotmgUnsafeFFI else rotmgSafeFFI) d1p d2p x1p y1 pp
| 1,844
|
rotmAbstraction :: (SM.Storable el, PrimMonad m, Show el) => String ->
RotmFunFFI el -> RotmFunFFI el ->
RotmFun el (PrimState m) m
rotmAbstraction rotmName rotmSafeFFI rotmUnsafeFFI = rotm
where
shouldCallFast :: Bool
shouldCallFast = True -- O(1)
rotm n (MutableDenseVector _ adim astride abuff)
(MutableDenseVector _ bdim bstride bbuff)
(MutableDenseVector _ pdim _ pbuff)
| isVectorBadWithNIncrement adim n astride = error $! vectorBadInfo rotmName "first matrix" adim n astride
| isVectorBadWithNIncrement bdim n bstride = error $! vectorBadInfo rotmName "second matrix" bdim n bstride
| pdim /= 5 = error $! rotmName ++ " param dimension is not 5"
| otherwise =
unsafeWithPrim abuff $ \ap ->
unsafeWithPrim bbuff $ \bp ->
unsafeWithPrim pbuff $ \pp ->
do unsafePrimToPrim $! (if shouldCallFast then rotmUnsafeFFI else rotmSafeFFI) (fromIntegral n) ap (fromIntegral astride) bp (fromIntegral bstride) pp
--{-# NOINLINE rotmgAbstraction #-}
--rotmgAbstraction :: (SM.Storable el, PrimMonad m, Show el) => String ->
-- RotmgFunFFI el -> RotmgFunFFI el ->
-- RotmgFun el (PrimState m) m
--rotmgAbstraction rotmgName rotmgSafeFFI rotmgUnsafeFFI = rotmg
-- where
-- shouldCallFast :: Bool
-- shouldCallFast = True -- O(1)
-- rotmg (MutableValue d1)
-- (MutableValue d2)
-- (MutableValue x1)
-- y1
-- (MutableDenseVector _ pdim _ pbuff)
-- | pdim /= 5 = error $! rotmgName ++ " param dimension is not 5"
-- | otherwise =
-- unsafeWithPrim d1 $ \d1p ->
-- unsafeWithPrim d2 $ \d2p ->
-- unsafeWithPrim x1 $ \x1p ->
-- unsafeWithPrim pbuff $ \pp ->
-- do unsafePrimToPrim $! (if shouldCallFast then rotmgUnsafeFFI else rotmgSafeFFI) d1p d2p x1p y1 pp
| 1,844
|
rotmAbstraction rotmName rotmSafeFFI rotmUnsafeFFI = rotm
where
shouldCallFast :: Bool
shouldCallFast = True -- O(1)
rotm n (MutableDenseVector _ adim astride abuff)
(MutableDenseVector _ bdim bstride bbuff)
(MutableDenseVector _ pdim _ pbuff)
| isVectorBadWithNIncrement adim n astride = error $! vectorBadInfo rotmName "first matrix" adim n astride
| isVectorBadWithNIncrement bdim n bstride = error $! vectorBadInfo rotmName "second matrix" bdim n bstride
| pdim /= 5 = error $! rotmName ++ " param dimension is not 5"
| otherwise =
unsafeWithPrim abuff $ \ap ->
unsafeWithPrim bbuff $ \bp ->
unsafeWithPrim pbuff $ \pp ->
do unsafePrimToPrim $! (if shouldCallFast then rotmUnsafeFFI else rotmSafeFFI) (fromIntegral n) ap (fromIntegral astride) bp (fromIntegral bstride) pp
--{-# NOINLINE rotmgAbstraction #-}
--rotmgAbstraction :: (SM.Storable el, PrimMonad m, Show el) => String ->
-- RotmgFunFFI el -> RotmgFunFFI el ->
-- RotmgFun el (PrimState m) m
--rotmgAbstraction rotmgName rotmgSafeFFI rotmgUnsafeFFI = rotmg
-- where
-- shouldCallFast :: Bool
-- shouldCallFast = True -- O(1)
-- rotmg (MutableValue d1)
-- (MutableValue d2)
-- (MutableValue x1)
-- y1
-- (MutableDenseVector _ pdim _ pbuff)
-- | pdim /= 5 = error $! rotmgName ++ " param dimension is not 5"
-- | otherwise =
-- unsafeWithPrim d1 $ \d1p ->
-- unsafeWithPrim d2 $ \d2p ->
-- unsafeWithPrim x1 $ \x1p ->
-- unsafeWithPrim pbuff $ \pp ->
-- do unsafePrimToPrim $! (if shouldCallFast then rotmgUnsafeFFI else rotmgSafeFFI) d1p d2p x1p y1 pp
| 1,708
| false
| true
| 0
| 17
| 454
| 330
| 171
| 159
| null | null |
tpsinnem/Idris-dev
|
src/Idris/Reflection.hs
|
bsd-3-clause
|
reifyTTNameType :: Term -> ElabD NameType
reifyTTNameType t@(P _ n _) | n == reflm "Bound" = return $ Bound
| 107
|
reifyTTNameType :: Term -> ElabD NameType
reifyTTNameType t@(P _ n _) | n == reflm "Bound" = return $ Bound
| 107
|
reifyTTNameType t@(P _ n _) | n == reflm "Bound" = return $ Bound
| 65
| false
| true
| 0
| 9
| 19
| 51
| 24
| 27
| null | null |
ekmett/ghc
|
compiler/llvmGen/LlvmCodeGen/CodeGen.hs
|
bsd-3-clause
|
-- -----------------------------------------------------------------------------
-- * Misc
--
-- | Find CmmRegs that get assigned and allocate them on the stack
--
-- Any register that gets written needs to be allcoated on the
-- stack. This avoids having to map a CmmReg to an equivalent SSA form
-- and avoids having to deal with Phi node insertion. This is also
-- the approach recommended by LLVM developers.
--
-- On the other hand, this is unecessarily verbose if the register in
-- question is never written. Therefore we skip it where we can to
-- save a few lines in the output and hopefully speed compilation up a
-- bit.
funPrologue :: LiveGlobalRegs -> [CmmBlock] -> LlvmM StmtData
funPrologue live cmmBlocks = do
trash <- getTrashRegs
let getAssignedRegs :: CmmNode O O -> [CmmReg]
getAssignedRegs (CmmAssign reg _) = [reg]
-- Calls will trash all registers. Unfortunately, this needs them to
-- be stack-allocated in the first place.
getAssignedRegs (CmmUnsafeForeignCall _ rs _) = map CmmGlobal trash ++ map CmmLocal rs
getAssignedRegs _ = []
getRegsBlock (_, body, _) = concatMap getAssignedRegs $ blockToList body
assignedRegs = nub $ concatMap (getRegsBlock . blockSplit) cmmBlocks
isLive r = r `elem` alwaysLive || r `elem` live
dflags <- getDynFlags
stmtss <- flip mapM assignedRegs $ \reg ->
case reg of
CmmLocal (LocalReg un _) -> do
let (newv, stmts) = allocReg reg
varInsert un (pLower $ getVarType newv)
return stmts
CmmGlobal r -> do
let reg = lmGlobalRegVar dflags r
arg = lmGlobalRegArg dflags r
ty = (pLower . getVarType) reg
trash = LMLitVar $ LMUndefLit ty
rval = if isLive r then arg else trash
alloc = Assignment reg $ Alloca (pLower $ getVarType reg) 1
markStackReg r
return $ toOL [alloc, Store rval reg]
return (concatOL stmtss, [])
-- | Function epilogue. Load STG variables to use as argument for call.
-- STG Liveness optimisation done here.
| 2,107
|
funPrologue :: LiveGlobalRegs -> [CmmBlock] -> LlvmM StmtData
funPrologue live cmmBlocks = do
trash <- getTrashRegs
let getAssignedRegs :: CmmNode O O -> [CmmReg]
getAssignedRegs (CmmAssign reg _) = [reg]
-- Calls will trash all registers. Unfortunately, this needs them to
-- be stack-allocated in the first place.
getAssignedRegs (CmmUnsafeForeignCall _ rs _) = map CmmGlobal trash ++ map CmmLocal rs
getAssignedRegs _ = []
getRegsBlock (_, body, _) = concatMap getAssignedRegs $ blockToList body
assignedRegs = nub $ concatMap (getRegsBlock . blockSplit) cmmBlocks
isLive r = r `elem` alwaysLive || r `elem` live
dflags <- getDynFlags
stmtss <- flip mapM assignedRegs $ \reg ->
case reg of
CmmLocal (LocalReg un _) -> do
let (newv, stmts) = allocReg reg
varInsert un (pLower $ getVarType newv)
return stmts
CmmGlobal r -> do
let reg = lmGlobalRegVar dflags r
arg = lmGlobalRegArg dflags r
ty = (pLower . getVarType) reg
trash = LMLitVar $ LMUndefLit ty
rval = if isLive r then arg else trash
alloc = Assignment reg $ Alloca (pLower $ getVarType reg) 1
markStackReg r
return $ toOL [alloc, Store rval reg]
return (concatOL stmtss, [])
-- | Function epilogue. Load STG variables to use as argument for call.
-- STG Liveness optimisation done here.
| 1,473
|
funPrologue live cmmBlocks = do
trash <- getTrashRegs
let getAssignedRegs :: CmmNode O O -> [CmmReg]
getAssignedRegs (CmmAssign reg _) = [reg]
-- Calls will trash all registers. Unfortunately, this needs them to
-- be stack-allocated in the first place.
getAssignedRegs (CmmUnsafeForeignCall _ rs _) = map CmmGlobal trash ++ map CmmLocal rs
getAssignedRegs _ = []
getRegsBlock (_, body, _) = concatMap getAssignedRegs $ blockToList body
assignedRegs = nub $ concatMap (getRegsBlock . blockSplit) cmmBlocks
isLive r = r `elem` alwaysLive || r `elem` live
dflags <- getDynFlags
stmtss <- flip mapM assignedRegs $ \reg ->
case reg of
CmmLocal (LocalReg un _) -> do
let (newv, stmts) = allocReg reg
varInsert un (pLower $ getVarType newv)
return stmts
CmmGlobal r -> do
let reg = lmGlobalRegVar dflags r
arg = lmGlobalRegArg dflags r
ty = (pLower . getVarType) reg
trash = LMLitVar $ LMUndefLit ty
rval = if isLive r then arg else trash
alloc = Assignment reg $ Alloca (pLower $ getVarType reg) 1
markStackReg r
return $ toOL [alloc, Store rval reg]
return (concatOL stmtss, [])
-- | Function epilogue. Load STG variables to use as argument for call.
-- STG Liveness optimisation done here.
| 1,411
| true
| true
| 0
| 22
| 542
| 448
| 228
| 220
| null | null |
kmicklas/pyrec
|
src/Pyrec/Misc.hs
|
mit
|
(<$$$>) :: (Functor f, Functor f1, Functor f2) =>
(a -> b) -> f (f1 (f2 a)) -> f (f1 (f2 b))
(<$$$>) = fmap . fmap . fmap
| 132
|
(<$$$>) :: (Functor f, Functor f1, Functor f2) =>
(a -> b) -> f (f1 (f2 a)) -> f (f1 (f2 b))
(<$$$>) = fmap . fmap . fmap
| 132
|
(<$$$>) = fmap . fmap . fmap
| 28
| false
| true
| 1
| 13
| 39
| 95
| 48
| 47
| null | null |
mightymoose/liquidhaskell
|
tests/todo/AbsRefNameClash.hs
|
bsd-3-clause
|
-@ data Heap a <p :: a -> a -> Prop> =
Empty | Node { pri :: a
, rnk :: Nat
, left :: {v: Heap<p> (a<p pri>) | ValidRank v}
, right :: {v: Heap<p> (a<p pri>) | ValidRank v}
}
@-}
{-@ predicate ValidRank V = okRank V && realRank V = rank V @-}
{-@ type PHeap a = {v:OHeap a | ValidRank v} @-}
{-@ type OHeap a = Heap <{\root v -> root <= v}> a @-}
{-@ measure okRank :: Heap a -> Prop
okRank (Empty) = true
okRank (Node p k l r) = (realRank l >= realRank r && k = 1 + realRank l + realRank r )
@-}
{-@ measure realRank :: Heap a -> Int
realRank (Empty) = 0
realRank (Node p k l r) = (1 + realRank l + realRank r)
@-}
{-@ measure rank @-}
{-@ rank :: h:PHeap a -> {v:Nat | v = realRank h} @-}
rank Empty = 0
| 879
|
rank Empty = 0
| 23
|
rank Empty = 0
| 23
| true
| false
| 41
| 14
| 341
| 413
| 229
| 184
| null | null |
fffej/HS-Poker
|
LookupPatternMatch.hs
|
bsd-3-clause
|
getValueFromProduct 110789 = 2249
| 33
|
getValueFromProduct 110789 = 2249
| 33
|
getValueFromProduct 110789 = 2249
| 33
| false
| false
| 0
| 5
| 3
| 9
| 4
| 5
| null | null |
lueck/htcf
|
src/HTCF/ConfigParser.hs
|
gpl-3.0
|
pcTcfSentenceIdPrefix :: IOSArrow XmlTree Config
pcTcfSentenceIdPrefix =
hasName "tcf" >>> getChildren >>>
hasName "sentenceIdPrefix" >>> getAttrValue "prefix" >>>
arr (TcfSentenceIdPrefix . defaultOnNull defaultTcfSentenceIdPrefix)
| 238
|
pcTcfSentenceIdPrefix :: IOSArrow XmlTree Config
pcTcfSentenceIdPrefix =
hasName "tcf" >>> getChildren >>>
hasName "sentenceIdPrefix" >>> getAttrValue "prefix" >>>
arr (TcfSentenceIdPrefix . defaultOnNull defaultTcfSentenceIdPrefix)
| 238
|
pcTcfSentenceIdPrefix =
hasName "tcf" >>> getChildren >>>
hasName "sentenceIdPrefix" >>> getAttrValue "prefix" >>>
arr (TcfSentenceIdPrefix . defaultOnNull defaultTcfSentenceIdPrefix)
| 189
| false
| true
| 0
| 9
| 28
| 54
| 25
| 29
| null | null |
ghc-android/ghc
|
compiler/codeGen/StgCmmPrim.hs
|
bsd-3-clause
|
shouldInlinePrimOp _ CopySmallMutableArrayOp
[src, src_off, dst, dst_off, (CmmLit (CmmInt n _))] =
Just $ \ [] -> doCopySmallMutableArrayOp src src_off dst dst_off (fromInteger n)
| 191
|
shouldInlinePrimOp _ CopySmallMutableArrayOp
[src, src_off, dst, dst_off, (CmmLit (CmmInt n _))] =
Just $ \ [] -> doCopySmallMutableArrayOp src src_off dst dst_off (fromInteger n)
| 191
|
shouldInlinePrimOp _ CopySmallMutableArrayOp
[src, src_off, dst, dst_off, (CmmLit (CmmInt n _))] =
Just $ \ [] -> doCopySmallMutableArrayOp src src_off dst dst_off (fromInteger n)
| 191
| false
| false
| 0
| 10
| 35
| 70
| 37
| 33
| null | null |
wilbowma/accelerate
|
Data/Array/Accelerate/CUDA/CodeGen.hs
|
bsd-3-clause
|
codeGenIntegralTex (TypeCInt _) = [CTypeDef (internalIdent "TexCInt") internalNode]
| 89
|
codeGenIntegralTex (TypeCInt _) = [CTypeDef (internalIdent "TexCInt") internalNode]
| 89
|
codeGenIntegralTex (TypeCInt _) = [CTypeDef (internalIdent "TexCInt") internalNode]
| 89
| false
| false
| 0
| 8
| 13
| 29
| 14
| 15
| null | null |
SAdams601/HaRe
|
old/refactorer/RefacDupTrans.hs
|
bsd-3-clause
|
pruneCloneClass _ _ = []
| 24
|
pruneCloneClass _ _ = []
| 24
|
pruneCloneClass _ _ = []
| 24
| false
| false
| 1
| 6
| 4
| 14
| 6
| 8
| null | null |
Philonous/pontarius-xmpp
|
source/Network/Xmpp/Lens.hs
|
bsd-3-clause
|
-- SessionConfiguration
-----------------------
streamConfigurationL :: Lens SessionConfiguration StreamConfiguration
streamConfigurationL inj sc@SessionConfiguration{sessionStreamConfiguration = x}
= (\x' -> sc{sessionStreamConfiguration = x'}) <$> inj x
| 259
|
streamConfigurationL :: Lens SessionConfiguration StreamConfiguration
streamConfigurationL inj sc@SessionConfiguration{sessionStreamConfiguration = x}
= (\x' -> sc{sessionStreamConfiguration = x'}) <$> inj x
| 211
|
streamConfigurationL inj sc@SessionConfiguration{sessionStreamConfiguration = x}
= (\x' -> sc{sessionStreamConfiguration = x'}) <$> inj x
| 141
| true
| true
| 0
| 9
| 25
| 58
| 32
| 26
| null | null |
the-real-blackh/hexpat
|
Text/XML/Expat/Internal/Namespaced.hs
|
bsd-3-clause
|
nodeWithQualifiers :: (NodeClass n c, GenericXMLString text, Ord text, Functor c) =>
Int
-> PrefixNsMap text
-> n c (NName text) text
-> n c (QName text) text
nodeWithQualifiers cntr bindings = modifyElement namespaceify
where
namespaceify (nname, nattrs, nchildren) = (qname, qattrs, qchildren)
where
for = flip map
ffor = flip fmap
(nsAtts, otherAtts) = L.partition ((== Just xmlnsUri) . nnNamespace . fst) nattrs
(dfAtt, normalAtts) = L.partition ((== NName Nothing xmlns) . fst) otherAtts
nsMap = M.fromList $ for nsAtts $ \((NName _ lp), uri) -> (Just uri, Just lp)
dfMap = M.fromList $ for dfAtt $ \(_, uri) -> (Just uri, Just xmlns)
chldBs = M.unions [dfMap, nsMap, bindings]
trans (i, bs, as) (NName nspace qual) =
case nspace `M.lookup` bs of
Nothing -> let
pfx = gxFromString $ "ns" ++ show i
bsN = M.insert nspace (Just pfx) bs
asN = (NName (Just xmlnsUri) pfx, DM.fromJust nspace) : as
in trans (i+1, bsN, asN) (NName nspace qual)
Just pfx -> ((i, bs, as), QName pfx qual)
transAt ibs (nn, v) = let (ibs', qn) = trans ibs nn
in (ibs', (qn, v))
((i', bs', as'), qname) = trans (cntr, chldBs, []) nname
((i'', bs'', as''), qNsAtts) = L.mapAccumL transAt (i', bs', as') nsAtts
((i''', bs''', as'''), qDfAtt) = L.mapAccumL transAt (i'', bs'', as'') dfAtt
((i'''', bs'''', as''''), qNormalAtts) = L.mapAccumL transAt (i''', bs''', as''') normalAtts
(_, qas) = L.mapAccumL transAt (i'''', bs'''', as'''') as''''
qattrs = concat [qNsAtts, qDfAtt, qNormalAtts, qas]
qchildren = ffor nchildren $ nodeWithQualifiers i'''' bs''''
| 2,018
|
nodeWithQualifiers :: (NodeClass n c, GenericXMLString text, Ord text, Functor c) =>
Int
-> PrefixNsMap text
-> n c (NName text) text
-> n c (QName text) text
nodeWithQualifiers cntr bindings = modifyElement namespaceify
where
namespaceify (nname, nattrs, nchildren) = (qname, qattrs, qchildren)
where
for = flip map
ffor = flip fmap
(nsAtts, otherAtts) = L.partition ((== Just xmlnsUri) . nnNamespace . fst) nattrs
(dfAtt, normalAtts) = L.partition ((== NName Nothing xmlns) . fst) otherAtts
nsMap = M.fromList $ for nsAtts $ \((NName _ lp), uri) -> (Just uri, Just lp)
dfMap = M.fromList $ for dfAtt $ \(_, uri) -> (Just uri, Just xmlns)
chldBs = M.unions [dfMap, nsMap, bindings]
trans (i, bs, as) (NName nspace qual) =
case nspace `M.lookup` bs of
Nothing -> let
pfx = gxFromString $ "ns" ++ show i
bsN = M.insert nspace (Just pfx) bs
asN = (NName (Just xmlnsUri) pfx, DM.fromJust nspace) : as
in trans (i+1, bsN, asN) (NName nspace qual)
Just pfx -> ((i, bs, as), QName pfx qual)
transAt ibs (nn, v) = let (ibs', qn) = trans ibs nn
in (ibs', (qn, v))
((i', bs', as'), qname) = trans (cntr, chldBs, []) nname
((i'', bs'', as''), qNsAtts) = L.mapAccumL transAt (i', bs', as') nsAtts
((i''', bs''', as'''), qDfAtt) = L.mapAccumL transAt (i'', bs'', as'') dfAtt
((i'''', bs'''', as''''), qNormalAtts) = L.mapAccumL transAt (i''', bs''', as''') normalAtts
(_, qas) = L.mapAccumL transAt (i'''', bs'''', as'''') as''''
qattrs = concat [qNsAtts, qDfAtt, qNormalAtts, qas]
qchildren = ffor nchildren $ nodeWithQualifiers i'''' bs''''
| 2,018
|
nodeWithQualifiers cntr bindings = modifyElement namespaceify
where
namespaceify (nname, nattrs, nchildren) = (qname, qattrs, qchildren)
where
for = flip map
ffor = flip fmap
(nsAtts, otherAtts) = L.partition ((== Just xmlnsUri) . nnNamespace . fst) nattrs
(dfAtt, normalAtts) = L.partition ((== NName Nothing xmlns) . fst) otherAtts
nsMap = M.fromList $ for nsAtts $ \((NName _ lp), uri) -> (Just uri, Just lp)
dfMap = M.fromList $ for dfAtt $ \(_, uri) -> (Just uri, Just xmlns)
chldBs = M.unions [dfMap, nsMap, bindings]
trans (i, bs, as) (NName nspace qual) =
case nspace `M.lookup` bs of
Nothing -> let
pfx = gxFromString $ "ns" ++ show i
bsN = M.insert nspace (Just pfx) bs
asN = (NName (Just xmlnsUri) pfx, DM.fromJust nspace) : as
in trans (i+1, bsN, asN) (NName nspace qual)
Just pfx -> ((i, bs, as), QName pfx qual)
transAt ibs (nn, v) = let (ibs', qn) = trans ibs nn
in (ibs', (qn, v))
((i', bs', as'), qname) = trans (cntr, chldBs, []) nname
((i'', bs'', as''), qNsAtts) = L.mapAccumL transAt (i', bs', as') nsAtts
((i''', bs''', as'''), qDfAtt) = L.mapAccumL transAt (i'', bs'', as'') dfAtt
((i'''', bs'''', as''''), qNormalAtts) = L.mapAccumL transAt (i''', bs''', as''') normalAtts
(_, qas) = L.mapAccumL transAt (i'''', bs'''', as'''') as''''
qattrs = concat [qNsAtts, qDfAtt, qNormalAtts, qas]
qchildren = ffor nchildren $ nodeWithQualifiers i'''' bs''''
| 1,780
| false
| true
| 0
| 18
| 739
| 761
| 414
| 347
| null | null |
JustinUnger/haskell-book
|
ch24/ch24-ipv6.hs
|
mit
|
showAddr6 :: IPAddress6 -> String
showAddr6 = concat . intersperse ":" . map showWord16 . addr6ToWords
| 102
|
showAddr6 :: IPAddress6 -> String
showAddr6 = concat . intersperse ":" . map showWord16 . addr6ToWords
| 102
|
showAddr6 = concat . intersperse ":" . map showWord16 . addr6ToWords
| 68
| false
| true
| 0
| 8
| 15
| 33
| 16
| 17
| null | null |
sorki/odrive
|
src/LDrive/Tests/CANOpen.hs
|
bsd-3-clause
|
app :: (e -> ClockConfig)
-> (e -> TestCAN)
-> (e -> ColoredLEDs)
-> Tower e ()
app tocc totestcan toleds = do
can <- fmap totestcan getEnv
leds <- fmap toleds getEnv
ldriveTowerDeps
(res, req, _, _) <- canTower tocc (testCAN can) 1000000 (testCANRX can) (testCANTX can)
attrs@Cia402Attrs{..} <- towerCia402Attrs initCia402Attrs
od@ObjDict{..} <- objDictTower attrs
canopenTower res req (canOpenLEDs leds) od
periodic <- period (Milliseconds 250)
monitor "simplecontroller" $ do
handler systemInit "init" $ do
callback $ const $ do
let emptyID = CANFilterID32 (fromRep 0) (fromRep 0) False False
canFilterInit (testCANFilters can)
[CANFilterBank CANFIFO0 CANFilterMask $ CANFilter32 emptyID emptyID]
[]
ledSetup $ greenLED leds
ledSetup $ redLED leds
ledOn $ redLED leds
where canOpenLEDs leds =
CANOpenLEDs
{ leds_init = ledSetup (greenLED leds) >> ledSetup (redLED leds)
, leds_module = hw_moduledef
, leds_err_on = ledOn $ redLED leds
, leds_err_off = ledOff $ redLED leds
, leds_run_on = ledOn $ greenLED leds
, leds_run_off = ledOff $ greenLED leds
}
| 1,289
|
app :: (e -> ClockConfig)
-> (e -> TestCAN)
-> (e -> ColoredLEDs)
-> Tower e ()
app tocc totestcan toleds = do
can <- fmap totestcan getEnv
leds <- fmap toleds getEnv
ldriveTowerDeps
(res, req, _, _) <- canTower tocc (testCAN can) 1000000 (testCANRX can) (testCANTX can)
attrs@Cia402Attrs{..} <- towerCia402Attrs initCia402Attrs
od@ObjDict{..} <- objDictTower attrs
canopenTower res req (canOpenLEDs leds) od
periodic <- period (Milliseconds 250)
monitor "simplecontroller" $ do
handler systemInit "init" $ do
callback $ const $ do
let emptyID = CANFilterID32 (fromRep 0) (fromRep 0) False False
canFilterInit (testCANFilters can)
[CANFilterBank CANFIFO0 CANFilterMask $ CANFilter32 emptyID emptyID]
[]
ledSetup $ greenLED leds
ledSetup $ redLED leds
ledOn $ redLED leds
where canOpenLEDs leds =
CANOpenLEDs
{ leds_init = ledSetup (greenLED leds) >> ledSetup (redLED leds)
, leds_module = hw_moduledef
, leds_err_on = ledOn $ redLED leds
, leds_err_off = ledOff $ redLED leds
, leds_run_on = ledOn $ greenLED leds
, leds_run_off = ledOff $ greenLED leds
}
| 1,289
|
app tocc totestcan toleds = do
can <- fmap totestcan getEnv
leds <- fmap toleds getEnv
ldriveTowerDeps
(res, req, _, _) <- canTower tocc (testCAN can) 1000000 (testCANRX can) (testCANTX can)
attrs@Cia402Attrs{..} <- towerCia402Attrs initCia402Attrs
od@ObjDict{..} <- objDictTower attrs
canopenTower res req (canOpenLEDs leds) od
periodic <- period (Milliseconds 250)
monitor "simplecontroller" $ do
handler systemInit "init" $ do
callback $ const $ do
let emptyID = CANFilterID32 (fromRep 0) (fromRep 0) False False
canFilterInit (testCANFilters can)
[CANFilterBank CANFIFO0 CANFilterMask $ CANFilter32 emptyID emptyID]
[]
ledSetup $ greenLED leds
ledSetup $ redLED leds
ledOn $ redLED leds
where canOpenLEDs leds =
CANOpenLEDs
{ leds_init = ledSetup (greenLED leds) >> ledSetup (redLED leds)
, leds_module = hw_moduledef
, leds_err_on = ledOn $ redLED leds
, leds_err_off = ledOff $ redLED leds
, leds_run_on = ledOn $ greenLED leds
, leds_run_off = ledOff $ greenLED leds
}
| 1,197
| false
| true
| 0
| 21
| 395
| 436
| 208
| 228
| null | null |
pparkkin/eta
|
compiler/ETA/Main/DynFlags.hs
|
bsd-3-clause
|
-- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
fLangFlags :: [FlagSpec ExtensionFlag]
fLangFlags = [
-- See Note [Updating flag description in the User's Guide]
-- See Note [Supporting CLI completion]
flagSpec' "th" Opt_TemplateHaskell
(\on -> deprecatedForExtension "TemplateHaskell" on
>> checkTemplateHaskellOk on),
flagSpec' "fi" Opt_ForeignFunctionInterface
(deprecatedForExtension "ForeignFunctionInterface"),
flagSpec' "ffi" Opt_ForeignFunctionInterface
(deprecatedForExtension "ForeignFunctionInterface"),
flagSpec' "arrows" Opt_Arrows
(deprecatedForExtension "Arrows"),
flagSpec' "implicit-prelude" Opt_ImplicitPrelude
(deprecatedForExtension "ImplicitPrelude"),
flagSpec' "bang-patterns" Opt_BangPatterns
(deprecatedForExtension "BangPatterns"),
flagSpec' "monomorphism-restriction" Opt_MonomorphismRestriction
(deprecatedForExtension "MonomorphismRestriction"),
flagSpec' "mono-pat-binds" Opt_MonoPatBinds
(deprecatedForExtension "MonoPatBinds"),
flagSpec' "extended-default-rules" Opt_ExtendedDefaultRules
(deprecatedForExtension "ExtendedDefaultRules"),
flagSpec' "implicit-params" Opt_ImplicitParams
(deprecatedForExtension "ImplicitParams"),
flagSpec' "scoped-type-variables" Opt_ScopedTypeVariables
(deprecatedForExtension "ScopedTypeVariables"),
flagSpec' "parr" Opt_ParallelArrays
(deprecatedForExtension "ParallelArrays"),
flagSpec' "PArr" Opt_ParallelArrays
(deprecatedForExtension "ParallelArrays"),
flagSpec' "allow-overlapping-instances" Opt_OverlappingInstances
(deprecatedForExtension "OverlappingInstances"),
flagSpec' "allow-undecidable-instances" Opt_UndecidableInstances
(deprecatedForExtension "UndecidableInstances"),
flagSpec' "allow-incoherent-instances" Opt_IncoherentInstances
(deprecatedForExtension "IncoherentInstances")
]
| 2,161
|
fLangFlags :: [FlagSpec ExtensionFlag]
fLangFlags = [
-- See Note [Updating flag description in the User's Guide]
-- See Note [Supporting CLI completion]
flagSpec' "th" Opt_TemplateHaskell
(\on -> deprecatedForExtension "TemplateHaskell" on
>> checkTemplateHaskellOk on),
flagSpec' "fi" Opt_ForeignFunctionInterface
(deprecatedForExtension "ForeignFunctionInterface"),
flagSpec' "ffi" Opt_ForeignFunctionInterface
(deprecatedForExtension "ForeignFunctionInterface"),
flagSpec' "arrows" Opt_Arrows
(deprecatedForExtension "Arrows"),
flagSpec' "implicit-prelude" Opt_ImplicitPrelude
(deprecatedForExtension "ImplicitPrelude"),
flagSpec' "bang-patterns" Opt_BangPatterns
(deprecatedForExtension "BangPatterns"),
flagSpec' "monomorphism-restriction" Opt_MonomorphismRestriction
(deprecatedForExtension "MonomorphismRestriction"),
flagSpec' "mono-pat-binds" Opt_MonoPatBinds
(deprecatedForExtension "MonoPatBinds"),
flagSpec' "extended-default-rules" Opt_ExtendedDefaultRules
(deprecatedForExtension "ExtendedDefaultRules"),
flagSpec' "implicit-params" Opt_ImplicitParams
(deprecatedForExtension "ImplicitParams"),
flagSpec' "scoped-type-variables" Opt_ScopedTypeVariables
(deprecatedForExtension "ScopedTypeVariables"),
flagSpec' "parr" Opt_ParallelArrays
(deprecatedForExtension "ParallelArrays"),
flagSpec' "PArr" Opt_ParallelArrays
(deprecatedForExtension "ParallelArrays"),
flagSpec' "allow-overlapping-instances" Opt_OverlappingInstances
(deprecatedForExtension "OverlappingInstances"),
flagSpec' "allow-undecidable-instances" Opt_UndecidableInstances
(deprecatedForExtension "UndecidableInstances"),
flagSpec' "allow-incoherent-instances" Opt_IncoherentInstances
(deprecatedForExtension "IncoherentInstances")
]
| 2,090
|
fLangFlags = [
-- See Note [Updating flag description in the User's Guide]
-- See Note [Supporting CLI completion]
flagSpec' "th" Opt_TemplateHaskell
(\on -> deprecatedForExtension "TemplateHaskell" on
>> checkTemplateHaskellOk on),
flagSpec' "fi" Opt_ForeignFunctionInterface
(deprecatedForExtension "ForeignFunctionInterface"),
flagSpec' "ffi" Opt_ForeignFunctionInterface
(deprecatedForExtension "ForeignFunctionInterface"),
flagSpec' "arrows" Opt_Arrows
(deprecatedForExtension "Arrows"),
flagSpec' "implicit-prelude" Opt_ImplicitPrelude
(deprecatedForExtension "ImplicitPrelude"),
flagSpec' "bang-patterns" Opt_BangPatterns
(deprecatedForExtension "BangPatterns"),
flagSpec' "monomorphism-restriction" Opt_MonomorphismRestriction
(deprecatedForExtension "MonomorphismRestriction"),
flagSpec' "mono-pat-binds" Opt_MonoPatBinds
(deprecatedForExtension "MonoPatBinds"),
flagSpec' "extended-default-rules" Opt_ExtendedDefaultRules
(deprecatedForExtension "ExtendedDefaultRules"),
flagSpec' "implicit-params" Opt_ImplicitParams
(deprecatedForExtension "ImplicitParams"),
flagSpec' "scoped-type-variables" Opt_ScopedTypeVariables
(deprecatedForExtension "ScopedTypeVariables"),
flagSpec' "parr" Opt_ParallelArrays
(deprecatedForExtension "ParallelArrays"),
flagSpec' "PArr" Opt_ParallelArrays
(deprecatedForExtension "ParallelArrays"),
flagSpec' "allow-overlapping-instances" Opt_OverlappingInstances
(deprecatedForExtension "OverlappingInstances"),
flagSpec' "allow-undecidable-instances" Opt_UndecidableInstances
(deprecatedForExtension "UndecidableInstances"),
flagSpec' "allow-incoherent-instances" Opt_IncoherentInstances
(deprecatedForExtension "IncoherentInstances")
]
| 2,051
| true
| true
| 0
| 10
| 497
| 290
| 147
| 143
| null | null |
dmbarbour/awelon
|
hsrc/ABC/Imperative/Operations.hs
|
bsd-3-clause
|
-- | block literals require TWO encodings of the same program.
--
-- The first is the raw ABC code for the program (as a string)
-- The second is the Haskell encoding
--
-- The two encodings must be equivalent up to performance. That is,
-- it must always be possible to interpret the code instead of run
-- the block, and the only difference should be performance. The ABC
-- code can be used to recover performance when composing lots of
-- small blocks.
--
-- The ABC encoding becomes useful for metaprogramming, where
-- a developer composes lots of blocks at runtime. The result
-- can be optimized and JIT'd.
--
--
-- To keep the Haskell encoding tight, the program is
-- provided as a string rather than a bulky list of [Op].
bl :: (Monad m) => String -> Prog m -> Prog m
bl s p = return . (P (B b)) where
b = Block { b_aff = False, b_rel = False, b_prog = p
, b_code = S.fromList (read s) }
-- | text literals are relatively trivial. They quote a text value,
-- which has type `µT.(1+(Chr*T))` where Chr is a small integer in
-- range 0..0x10ffff. We translate the given string into the target
-- text value.
| 1,147
|
bl :: (Monad m) => String -> Prog m -> Prog m
bl s p = return . (P (B b)) where
b = Block { b_aff = False, b_rel = False, b_prog = p
, b_code = S.fromList (read s) }
-- | text literals are relatively trivial. They quote a text value,
-- which has type `µT.(1+(Chr*T))` where Chr is a small integer in
-- range 0..0x10ffff. We translate the given string into the target
-- text value.
| 403
|
bl s p = return . (P (B b)) where
b = Block { b_aff = False, b_rel = False, b_prog = p
, b_code = S.fromList (read s) }
-- | text literals are relatively trivial. They quote a text value,
-- which has type `µT.(1+(Chr*T))` where Chr is a small integer in
-- range 0..0x10ffff. We translate the given string into the target
-- text value.
| 357
| true
| true
| 2
| 10
| 247
| 134
| 77
| 57
| null | null |
drcabana/euler-fp
|
source/hs/P28.hs
|
epl-1.0
|
sumOfCorners n =
4*n*n - 6*n + 6
| 36
|
sumOfCorners n =
4*n*n - 6*n + 6
| 36
|
sumOfCorners n =
4*n*n - 6*n + 6
| 36
| false
| false
| 6
| 5
| 11
| 40
| 14
| 26
| null | null |
fmapfmapfmap/amazonka
|
amazonka-cloudwatch-logs/gen/Network/AWS/CloudWatchLogs/Types/Product.hs
|
mpl-2.0
|
-- | Undocumented member.
mfFilterPattern :: Lens' MetricFilter (Maybe Text)
mfFilterPattern = lens _mfFilterPattern (\ s a -> s{_mfFilterPattern = a})
| 151
|
mfFilterPattern :: Lens' MetricFilter (Maybe Text)
mfFilterPattern = lens _mfFilterPattern (\ s a -> s{_mfFilterPattern = a})
| 125
|
mfFilterPattern = lens _mfFilterPattern (\ s a -> s{_mfFilterPattern = a})
| 74
| true
| true
| 0
| 9
| 20
| 46
| 25
| 21
| null | null |
a143753/AOJ
|
CGL_2_A.hs
|
apache-2.0
|
vnorm (x,y) = x*x+y*y
| 21
|
vnorm (x,y) = x*x+y*y
| 21
|
vnorm (x,y) = x*x+y*y
| 21
| false
| false
| 3
| 5
| 3
| 32
| 14
| 18
| null | null |
plaimi/tempuhs-server
|
src/Tempuhs/Server/Requests/Clock.hs
|
agpl-3.0
|
postClock :: ConnectionPool -> ActionE ()
-- | 'postClock' inserts a 'Clock'.
postClock p = do
n <- paramE "name"
runDatabase p $ liftAE . jsonKey =<< insert (Clock n Nothing)
| 179
|
postClock :: ConnectionPool -> ActionE ()
postClock p = do
n <- paramE "name"
runDatabase p $ liftAE . jsonKey =<< insert (Clock n Nothing)
| 143
|
postClock p = do
n <- paramE "name"
runDatabase p $ liftAE . jsonKey =<< insert (Clock n Nothing)
| 101
| true
| true
| 0
| 11
| 34
| 68
| 30
| 38
| null | null |
nikki-and-the-robots/nikki
|
src/Editor/Menu.hs
|
lgpl-3.0
|
fileExists app save path metaData objects =
menuAppState app menuType (Just save) (
MenuItem (p "no") (const save) :
MenuItem (p "yes") (const writeAnyway) :
[]) 0
where
menuType = NormalMenu (p "saving level") (Just (pVerbatim path <> p " already exists"))
writeAnyway = appState (busyMessage $ p "saving level...") $ io $ do
writeObjectsToDisk path metaData objects
return $ getMainMenu app
| 446
|
fileExists app save path metaData objects =
menuAppState app menuType (Just save) (
MenuItem (p "no") (const save) :
MenuItem (p "yes") (const writeAnyway) :
[]) 0
where
menuType = NormalMenu (p "saving level") (Just (pVerbatim path <> p " already exists"))
writeAnyway = appState (busyMessage $ p "saving level...") $ io $ do
writeObjectsToDisk path metaData objects
return $ getMainMenu app
| 446
|
fileExists app save path metaData objects =
menuAppState app menuType (Just save) (
MenuItem (p "no") (const save) :
MenuItem (p "yes") (const writeAnyway) :
[]) 0
where
menuType = NormalMenu (p "saving level") (Just (pVerbatim path <> p " already exists"))
writeAnyway = appState (busyMessage $ p "saving level...") $ io $ do
writeObjectsToDisk path metaData objects
return $ getMainMenu app
| 446
| false
| false
| 0
| 11
| 115
| 165
| 78
| 87
| null | null |
JoshuaGross/haskell-learning-log
|
Code/Haskellbook/Reader/src/Functions.hs
|
mit
|
frooty :: Num a => [a] -> ([a], Int)
frooty r = bar (foo r) r
| 61
|
frooty :: Num a => [a] -> ([a], Int)
frooty r = bar (foo r) r
| 61
|
frooty r = bar (foo r) r
| 24
| false
| true
| 0
| 8
| 15
| 48
| 25
| 23
| null | null |
ComputationWithBoundedResources/ara-inference
|
doc/tpdb_trs/Haskell/basic_haskell/concat_1.hs
|
mit
|
foldr :: (a -> b -> b) -> b -> (List a) -> b;
foldr f z Nil = z
| 73
|
foldr :: (a -> b -> b) -> b -> (List a) -> b
foldr f z Nil = z
| 72
|
foldr f z Nil = z
| 17
| false
| true
| 0
| 9
| 29
| 48
| 25
| 23
| null | null |
randrade23/html-render
|
src/HTMLRender/HTMLPretty.hs
|
mit
|
ppHTML :: Document -> String
ppHTML (Doc vs) = wrapBold ("% " ++ t) ++ (unlines $ map ppValue vs)
where t = (if null $ findTitle vs then "" else (findTitle vs) !! 0) ++ "\n"
| 177
|
ppHTML :: Document -> String
ppHTML (Doc vs) = wrapBold ("% " ++ t) ++ (unlines $ map ppValue vs)
where t = (if null $ findTitle vs then "" else (findTitle vs) !! 0) ++ "\n"
| 177
|
ppHTML (Doc vs) = wrapBold ("% " ++ t) ++ (unlines $ map ppValue vs)
where t = (if null $ findTitle vs then "" else (findTitle vs) !! 0) ++ "\n"
| 148
| false
| true
| 1
| 10
| 40
| 99
| 47
| 52
| null | null |
ssaavedra/liquidhaskell
|
tests/pos/RelativeComplete.hs
|
bsd-3-clause
|
{-@ LIQUID "--no-termination" @-}
-- Here p and q of `app` will be instantiated to
-- p , q := \v -> i <= v
main i = app (check i) i
| 135
|
main i = app (check i) i
| 24
|
main i = app (check i) i
| 24
| true
| false
| 0
| 7
| 34
| 23
| 12
| 11
| null | null |
bjpop/blip
|
blipcompiler/src/Blip/Compiler/Compile.hs
|
bsd-3-clause
|
compileExpr expr@(AST.Float {}) =
compileConstantEmit $ constantToPyObject expr
| 82
|
compileExpr expr@(AST.Float {}) =
compileConstantEmit $ constantToPyObject expr
| 82
|
compileExpr expr@(AST.Float {}) =
compileConstantEmit $ constantToPyObject expr
| 82
| false
| false
| 0
| 9
| 10
| 28
| 14
| 14
| null | null |
AlexeyRaga/eta
|
compiler/ETA/Main/HscTypes.hs
|
bsd-3-clause
|
hptAnns hsc_env Nothing = hptAllThings (md_anns . hm_details) hsc_env
| 69
|
hptAnns hsc_env Nothing = hptAllThings (md_anns . hm_details) hsc_env
| 69
|
hptAnns hsc_env Nothing = hptAllThings (md_anns . hm_details) hsc_env
| 69
| false
| false
| 0
| 7
| 8
| 23
| 11
| 12
| null | null |
nushio3/ghc
|
compiler/coreSyn/CoreUtils.hs
|
bsd-3-clause
|
exprIsCheap' good_app (Case e _ _ alts) = exprIsCheap' good_app e &&
and [exprIsCheap' good_app rhs | (_,_,rhs) <- alts]
| 162
|
exprIsCheap' good_app (Case e _ _ alts) = exprIsCheap' good_app e &&
and [exprIsCheap' good_app rhs | (_,_,rhs) <- alts]
| 162
|
exprIsCheap' good_app (Case e _ _ alts) = exprIsCheap' good_app e &&
and [exprIsCheap' good_app rhs | (_,_,rhs) <- alts]
| 162
| false
| false
| 0
| 10
| 61
| 60
| 30
| 30
| null | null |
DNoved1/distill
|
src/Distill/Expr/Representation.hs
|
mit
|
parseProduct :: Parser (Type' String)
parseProduct = label' "product type" $ withSource $ do
symbol tokens "(&"
factors <- flip sepBy (symbol tokens "&") $ choice
[ try $ do
x <- identifier tokens
symbol tokens ":"
t <- parseExpr
return (x, t)
, do
t <- parseExpr
return ("%No-Name%", t)
]
symbol tokens "&)"
case length factors of
0 -> return UnitT
1 -> fail "Product must have 0, 2, or more factors."
_ -> do
let tail' = snd (last factors)
let body' = init factors
return (unsplitProduct body' tail')
| 674
|
parseProduct :: Parser (Type' String)
parseProduct = label' "product type" $ withSource $ do
symbol tokens "(&"
factors <- flip sepBy (symbol tokens "&") $ choice
[ try $ do
x <- identifier tokens
symbol tokens ":"
t <- parseExpr
return (x, t)
, do
t <- parseExpr
return ("%No-Name%", t)
]
symbol tokens "&)"
case length factors of
0 -> return UnitT
1 -> fail "Product must have 0, 2, or more factors."
_ -> do
let tail' = snd (last factors)
let body' = init factors
return (unsplitProduct body' tail')
| 674
|
parseProduct = label' "product type" $ withSource $ do
symbol tokens "(&"
factors <- flip sepBy (symbol tokens "&") $ choice
[ try $ do
x <- identifier tokens
symbol tokens ":"
t <- parseExpr
return (x, t)
, do
t <- parseExpr
return ("%No-Name%", t)
]
symbol tokens "&)"
case length factors of
0 -> return UnitT
1 -> fail "Product must have 0, 2, or more factors."
_ -> do
let tail' = snd (last factors)
let body' = init factors
return (unsplitProduct body' tail')
| 636
| false
| true
| 0
| 18
| 263
| 218
| 98
| 120
| null | null |
bitemyapp/ghc
|
compiler/typecheck/TcEvidence.hs
|
bsd-3-clause
|
mkTcNthCo :: Int -> TcCoercion -> TcCoercion
mkTcNthCo n (TcRefl r ty) = TcRefl r (tyConAppArgN n ty)
| 101
|
mkTcNthCo :: Int -> TcCoercion -> TcCoercion
mkTcNthCo n (TcRefl r ty) = TcRefl r (tyConAppArgN n ty)
| 101
|
mkTcNthCo n (TcRefl r ty) = TcRefl r (tyConAppArgN n ty)
| 56
| false
| true
| 0
| 7
| 17
| 45
| 22
| 23
| null | null |
Oscarzhao/haskell
|
functional_program_design/ch05/sudoku_orig.hs
|
apache-2.0
|
cols :: Matrix a -> Matrix a
cols [xs] = [[x] | x <- xs]
| 57
|
cols :: Matrix a -> Matrix a
cols [xs] = [[x] | x <- xs]
| 56
|
cols [xs] = [[x] | x <- xs]
| 27
| false
| true
| 0
| 8
| 15
| 46
| 22
| 24
| null | null |
antalsz/hs-to-coq
|
src/lib/HsToCoq/ConvertHaskell/TypeInfo.hs
|
mit
|
store' lens qid@(Qualified mi _) x = do
TypeInfoT (use (processedModules.contains mi)) >>= \case
False -> liftIO $ do
hPutStrLn stderr $ "Cannot store information about " ++ showP qid
--exitFailure
True -> TypeInfoT $ modify $ lens . at qid ?~ x
| 289
|
store' lens qid@(Qualified mi _) x = do
TypeInfoT (use (processedModules.contains mi)) >>= \case
False -> liftIO $ do
hPutStrLn stderr $ "Cannot store information about " ++ showP qid
--exitFailure
True -> TypeInfoT $ modify $ lens . at qid ?~ x
| 289
|
store' lens qid@(Qualified mi _) x = do
TypeInfoT (use (processedModules.contains mi)) >>= \case
False -> liftIO $ do
hPutStrLn stderr $ "Cannot store information about " ++ showP qid
--exitFailure
True -> TypeInfoT $ modify $ lens . at qid ?~ x
| 289
| false
| false
| 1
| 18
| 86
| 111
| 49
| 62
| null | null |
melted/idris-java
|
src/IRTS/Java/JTypes.hs
|
bsd-3-clause
|
sourceTypes (LExternal n)
| n == sUN "prim__readFile" = [worldType, objectType]
| n == sUN "prim__writeFile" = [worldType, objectType, stringType]
| n == sUN "prim__stdin" = []
| n == sUN "prim__stdout" = []
| n == sUN "prim__stderr" = []
-- see comment below on managed pointers
| n == sUN "prim__eqManagedPtr" = [objectType, objectType]
| n == sUN "prim__eqPtr" = [objectType, objectType]
| n == sUN "prim__vm" = [threadType]
| n == sUN "prim__null" = []
-- @bgaster
-- i can't see any reason to support managed pointers in the Java
-- runtime, infact it seems to be counter to fact that Java is
-- managing our allocations and lifetimes. thus the runtime will raise
-- an exception if called
| n == sUN "prim__registerPtr" = [objectType, integerType]
| otherwise = []
| 960
|
sourceTypes (LExternal n)
| n == sUN "prim__readFile" = [worldType, objectType]
| n == sUN "prim__writeFile" = [worldType, objectType, stringType]
| n == sUN "prim__stdin" = []
| n == sUN "prim__stdout" = []
| n == sUN "prim__stderr" = []
-- see comment below on managed pointers
| n == sUN "prim__eqManagedPtr" = [objectType, objectType]
| n == sUN "prim__eqPtr" = [objectType, objectType]
| n == sUN "prim__vm" = [threadType]
| n == sUN "prim__null" = []
-- @bgaster
-- i can't see any reason to support managed pointers in the Java
-- runtime, infact it seems to be counter to fact that Java is
-- managing our allocations and lifetimes. thus the runtime will raise
-- an exception if called
| n == sUN "prim__registerPtr" = [objectType, integerType]
| otherwise = []
| 960
|
sourceTypes (LExternal n)
| n == sUN "prim__readFile" = [worldType, objectType]
| n == sUN "prim__writeFile" = [worldType, objectType, stringType]
| n == sUN "prim__stdin" = []
| n == sUN "prim__stdout" = []
| n == sUN "prim__stderr" = []
-- see comment below on managed pointers
| n == sUN "prim__eqManagedPtr" = [objectType, objectType]
| n == sUN "prim__eqPtr" = [objectType, objectType]
| n == sUN "prim__vm" = [threadType]
| n == sUN "prim__null" = []
-- @bgaster
-- i can't see any reason to support managed pointers in the Java
-- runtime, infact it seems to be counter to fact that Java is
-- managing our allocations and lifetimes. thus the runtime will raise
-- an exception if called
| n == sUN "prim__registerPtr" = [objectType, integerType]
| otherwise = []
| 960
| false
| false
| 0
| 9
| 323
| 255
| 124
| 131
| null | null |
skeskinen/FTGL
|
Graphics/Rendering/FTGL.hs
|
bsd-2-clause
|
marshalCharMap EncodingBig5= encodeTag 'b' 'i' 'g' '5'
| 54
|
marshalCharMap EncodingBig5= encodeTag 'b' 'i' 'g' '5'
| 54
|
marshalCharMap EncodingBig5= encodeTag 'b' 'i' 'g' '5'
| 54
| false
| false
| 0
| 5
| 6
| 18
| 8
| 10
| null | null |
haskell-tinc/hpack
|
src/Hpack/Render.hs
|
mit
|
renderSystemBuildTool :: (String, VersionConstraint) -> String
renderSystemBuildTool (name, constraint) = name ++ renderVersionConstraint constraint
| 148
|
renderSystemBuildTool :: (String, VersionConstraint) -> String
renderSystemBuildTool (name, constraint) = name ++ renderVersionConstraint constraint
| 148
|
renderSystemBuildTool (name, constraint) = name ++ renderVersionConstraint constraint
| 85
| false
| true
| 0
| 6
| 13
| 37
| 20
| 17
| null | null |
Paow/encore
|
src/types/Typechecker/Typechecker.hs
|
bsd-3-clause
|
checkSubordinateReturn :: Name -> Type -> Type -> TypecheckM ()
checkSubordinateReturn name returnType targetType = do
subordReturn <- isSubordinateType returnType
targetIsEncaps <- isEncapsulatedType targetType
when subordReturn $
unless targetIsEncaps $
tcError $ SubordinateReturnError name
| 320
|
checkSubordinateReturn :: Name -> Type -> Type -> TypecheckM ()
checkSubordinateReturn name returnType targetType = do
subordReturn <- isSubordinateType returnType
targetIsEncaps <- isEncapsulatedType targetType
when subordReturn $
unless targetIsEncaps $
tcError $ SubordinateReturnError name
| 320
|
checkSubordinateReturn name returnType targetType = do
subordReturn <- isSubordinateType returnType
targetIsEncaps <- isEncapsulatedType targetType
when subordReturn $
unless targetIsEncaps $
tcError $ SubordinateReturnError name
| 256
| false
| true
| 0
| 11
| 60
| 84
| 36
| 48
| null | null |
madjestic/b1
|
tests/B1/Data/Price/GoogleTest.hs
|
bsd-3-clause
|
case_parseGoogleCsv_badFormat :: Assertion
case_parseGoogleCsv_badFormat =
let csv = foldl (++) "" ([headers] ++ goodLines ++ [badFormat])
in assertEqual "" (Right "Invalid CSV format") (parseGoogleCsv csv)
| 210
|
case_parseGoogleCsv_badFormat :: Assertion
case_parseGoogleCsv_badFormat =
let csv = foldl (++) "" ([headers] ++ goodLines ++ [badFormat])
in assertEqual "" (Right "Invalid CSV format") (parseGoogleCsv csv)
| 210
|
case_parseGoogleCsv_badFormat =
let csv = foldl (++) "" ([headers] ++ goodLines ++ [badFormat])
in assertEqual "" (Right "Invalid CSV format") (parseGoogleCsv csv)
| 167
| false
| true
| 0
| 13
| 28
| 67
| 35
| 32
| null | null |
tpsinnem/Idris-dev
|
src/Idris/Providers.hs
|
bsd-3-clause
|
ermod :: Name
ermod = sNS (sUN "Error") ["Providers", "Prelude"]
| 64
|
ermod :: Name
ermod = sNS (sUN "Error") ["Providers", "Prelude"]
| 64
|
ermod = sNS (sUN "Error") ["Providers", "Prelude"]
| 50
| false
| true
| 0
| 7
| 9
| 34
| 16
| 18
| null | null |
nfjinjing/miku
|
src/Network/Miku/DSL.hs
|
bsd-3-clause
|
json :: ByteString -> AppMonad'
json x = do
modify - setContentType "text/json"
modify - setBody - x
| 104
|
json :: ByteString -> AppMonad'
json x = do
modify - setContentType "text/json"
modify - setBody - x
| 104
|
json x = do
modify - setContentType "text/json"
modify - setBody - x
| 72
| false
| true
| 0
| 8
| 21
| 45
| 19
| 26
| null | null |
sol/aeson
|
tests/UnitTests.hs
|
bsd-3-clause
|
utcTimeGood :: Assertion
utcTimeGood = do
let ts1 = "2015-01-01T12:13:00.00Z" :: LT.Text
let ts2 = "2015-01-01T12:13:00Z" :: LT.Text
-- 'T' between date and time is not required, can be space
let ts3 = "2015-01-03 12:13:00.00Z" :: LT.Text
let ts4 = "2015-01-03 12:13:00.125Z" :: LT.Text
let (Just (t1 :: UTCTime)) = parseWithAeson ts1
let (Just (t2 :: UTCTime)) = parseWithAeson ts2
let (Just (t3 :: UTCTime)) = parseWithAeson ts3
let (Just (t4 :: UTCTime)) = parseWithAeson ts4
assertEqual "utctime" (parseWithRead "%FT%T%QZ" ts1) t1
assertEqual "utctime" (parseWithRead "%FT%T%QZ" ts2) t2
assertEqual "utctime" (parseWithRead "%F %T%QZ" ts3) t3
assertEqual "utctime" (parseWithRead "%F %T%QZ" ts4) t4
-- Time zones. Both +HHMM and +HH:MM are allowed for timezone
-- offset, and MM may be omitted.
let ts5 = "2015-01-01T12:30:00.00+00" :: LT.Text
let ts6 = "2015-01-01T12:30:00.00+01:15" :: LT.Text
let ts7 = "2015-01-01T12:30:00.00-02" :: LT.Text
let ts8 = "2015-01-01T22:00:00.00-03" :: LT.Text
let ts9 = "2015-01-01T22:00:00.00-04:30" :: LT.Text
let (Just (t5 :: UTCTime)) = parseWithAeson ts5
let (Just (t6 :: UTCTime)) = parseWithAeson ts6
let (Just (t7 :: UTCTime)) = parseWithAeson ts7
let (Just (t8 :: UTCTime)) = parseWithAeson ts8
let (Just (t9 :: UTCTime)) = parseWithAeson ts9
assertEqual "utctime" (parseWithRead "%FT%T%QZ" "2015-01-01T12:30:00.00Z") t5
assertEqual "utctime" (parseWithRead "%FT%T%QZ" "2015-01-01T11:15:00.00Z") t6
assertEqual "utctime" (parseWithRead "%FT%T%QZ" "2015-01-01T14:30:00Z") t7
-- ts8 wraps around to the next day in UTC
assertEqual "utctime" (parseWithRead "%FT%T%QZ" "2015-01-02T01:00:00Z") t8
assertEqual "utctime" (parseWithRead "%FT%T%QZ" "2015-01-02T02:30:00Z") t9
-- Seconds in Time can be omitted
let ts10 = "2015-01-03T12:13Z" :: LT.Text
let ts11 = "2015-01-03 12:13Z" :: LT.Text
let ts12 = "2015-01-01T12:30-02" :: LT.Text
let (Just (t10 :: UTCTime)) = parseWithAeson ts10
let (Just (t11 :: UTCTime)) = parseWithAeson ts11
let (Just (t12 :: UTCTime)) = parseWithAeson ts12
assertEqual "utctime" (parseWithRead "%FT%H:%MZ" ts10) t10
assertEqual "utctime" (parseWithRead "%F %H:%MZ" ts11) t11
assertEqual "utctime" (parseWithRead "%FT%T%QZ" "2015-01-01T14:30:00Z") t12
where
parseWithRead :: String -> LT.Text -> UTCTime
parseWithRead f s =
fromMaybe (error "parseTime input malformed") . parseTime defaultTimeLocale f . LT.unpack $ s
parseWithAeson :: LT.Text -> Maybe UTCTime
parseWithAeson s = decode . LT.encodeUtf8 $ LT.concat ["\"", s, "\""]
-- Test that a few non-timezone qualified timestamp formats get
-- rejected if decoding to UTCTime.
| 2,720
|
utcTimeGood :: Assertion
utcTimeGood = do
let ts1 = "2015-01-01T12:13:00.00Z" :: LT.Text
let ts2 = "2015-01-01T12:13:00Z" :: LT.Text
-- 'T' between date and time is not required, can be space
let ts3 = "2015-01-03 12:13:00.00Z" :: LT.Text
let ts4 = "2015-01-03 12:13:00.125Z" :: LT.Text
let (Just (t1 :: UTCTime)) = parseWithAeson ts1
let (Just (t2 :: UTCTime)) = parseWithAeson ts2
let (Just (t3 :: UTCTime)) = parseWithAeson ts3
let (Just (t4 :: UTCTime)) = parseWithAeson ts4
assertEqual "utctime" (parseWithRead "%FT%T%QZ" ts1) t1
assertEqual "utctime" (parseWithRead "%FT%T%QZ" ts2) t2
assertEqual "utctime" (parseWithRead "%F %T%QZ" ts3) t3
assertEqual "utctime" (parseWithRead "%F %T%QZ" ts4) t4
-- Time zones. Both +HHMM and +HH:MM are allowed for timezone
-- offset, and MM may be omitted.
let ts5 = "2015-01-01T12:30:00.00+00" :: LT.Text
let ts6 = "2015-01-01T12:30:00.00+01:15" :: LT.Text
let ts7 = "2015-01-01T12:30:00.00-02" :: LT.Text
let ts8 = "2015-01-01T22:00:00.00-03" :: LT.Text
let ts9 = "2015-01-01T22:00:00.00-04:30" :: LT.Text
let (Just (t5 :: UTCTime)) = parseWithAeson ts5
let (Just (t6 :: UTCTime)) = parseWithAeson ts6
let (Just (t7 :: UTCTime)) = parseWithAeson ts7
let (Just (t8 :: UTCTime)) = parseWithAeson ts8
let (Just (t9 :: UTCTime)) = parseWithAeson ts9
assertEqual "utctime" (parseWithRead "%FT%T%QZ" "2015-01-01T12:30:00.00Z") t5
assertEqual "utctime" (parseWithRead "%FT%T%QZ" "2015-01-01T11:15:00.00Z") t6
assertEqual "utctime" (parseWithRead "%FT%T%QZ" "2015-01-01T14:30:00Z") t7
-- ts8 wraps around to the next day in UTC
assertEqual "utctime" (parseWithRead "%FT%T%QZ" "2015-01-02T01:00:00Z") t8
assertEqual "utctime" (parseWithRead "%FT%T%QZ" "2015-01-02T02:30:00Z") t9
-- Seconds in Time can be omitted
let ts10 = "2015-01-03T12:13Z" :: LT.Text
let ts11 = "2015-01-03 12:13Z" :: LT.Text
let ts12 = "2015-01-01T12:30-02" :: LT.Text
let (Just (t10 :: UTCTime)) = parseWithAeson ts10
let (Just (t11 :: UTCTime)) = parseWithAeson ts11
let (Just (t12 :: UTCTime)) = parseWithAeson ts12
assertEqual "utctime" (parseWithRead "%FT%H:%MZ" ts10) t10
assertEqual "utctime" (parseWithRead "%F %H:%MZ" ts11) t11
assertEqual "utctime" (parseWithRead "%FT%T%QZ" "2015-01-01T14:30:00Z") t12
where
parseWithRead :: String -> LT.Text -> UTCTime
parseWithRead f s =
fromMaybe (error "parseTime input malformed") . parseTime defaultTimeLocale f . LT.unpack $ s
parseWithAeson :: LT.Text -> Maybe UTCTime
parseWithAeson s = decode . LT.encodeUtf8 $ LT.concat ["\"", s, "\""]
-- Test that a few non-timezone qualified timestamp formats get
-- rejected if decoding to UTCTime.
| 2,720
|
utcTimeGood = do
let ts1 = "2015-01-01T12:13:00.00Z" :: LT.Text
let ts2 = "2015-01-01T12:13:00Z" :: LT.Text
-- 'T' between date and time is not required, can be space
let ts3 = "2015-01-03 12:13:00.00Z" :: LT.Text
let ts4 = "2015-01-03 12:13:00.125Z" :: LT.Text
let (Just (t1 :: UTCTime)) = parseWithAeson ts1
let (Just (t2 :: UTCTime)) = parseWithAeson ts2
let (Just (t3 :: UTCTime)) = parseWithAeson ts3
let (Just (t4 :: UTCTime)) = parseWithAeson ts4
assertEqual "utctime" (parseWithRead "%FT%T%QZ" ts1) t1
assertEqual "utctime" (parseWithRead "%FT%T%QZ" ts2) t2
assertEqual "utctime" (parseWithRead "%F %T%QZ" ts3) t3
assertEqual "utctime" (parseWithRead "%F %T%QZ" ts4) t4
-- Time zones. Both +HHMM and +HH:MM are allowed for timezone
-- offset, and MM may be omitted.
let ts5 = "2015-01-01T12:30:00.00+00" :: LT.Text
let ts6 = "2015-01-01T12:30:00.00+01:15" :: LT.Text
let ts7 = "2015-01-01T12:30:00.00-02" :: LT.Text
let ts8 = "2015-01-01T22:00:00.00-03" :: LT.Text
let ts9 = "2015-01-01T22:00:00.00-04:30" :: LT.Text
let (Just (t5 :: UTCTime)) = parseWithAeson ts5
let (Just (t6 :: UTCTime)) = parseWithAeson ts6
let (Just (t7 :: UTCTime)) = parseWithAeson ts7
let (Just (t8 :: UTCTime)) = parseWithAeson ts8
let (Just (t9 :: UTCTime)) = parseWithAeson ts9
assertEqual "utctime" (parseWithRead "%FT%T%QZ" "2015-01-01T12:30:00.00Z") t5
assertEqual "utctime" (parseWithRead "%FT%T%QZ" "2015-01-01T11:15:00.00Z") t6
assertEqual "utctime" (parseWithRead "%FT%T%QZ" "2015-01-01T14:30:00Z") t7
-- ts8 wraps around to the next day in UTC
assertEqual "utctime" (parseWithRead "%FT%T%QZ" "2015-01-02T01:00:00Z") t8
assertEqual "utctime" (parseWithRead "%FT%T%QZ" "2015-01-02T02:30:00Z") t9
-- Seconds in Time can be omitted
let ts10 = "2015-01-03T12:13Z" :: LT.Text
let ts11 = "2015-01-03 12:13Z" :: LT.Text
let ts12 = "2015-01-01T12:30-02" :: LT.Text
let (Just (t10 :: UTCTime)) = parseWithAeson ts10
let (Just (t11 :: UTCTime)) = parseWithAeson ts11
let (Just (t12 :: UTCTime)) = parseWithAeson ts12
assertEqual "utctime" (parseWithRead "%FT%H:%MZ" ts10) t10
assertEqual "utctime" (parseWithRead "%F %H:%MZ" ts11) t11
assertEqual "utctime" (parseWithRead "%FT%T%QZ" "2015-01-01T14:30:00Z") t12
where
parseWithRead :: String -> LT.Text -> UTCTime
parseWithRead f s =
fromMaybe (error "parseTime input malformed") . parseTime defaultTimeLocale f . LT.unpack $ s
parseWithAeson :: LT.Text -> Maybe UTCTime
parseWithAeson s = decode . LT.encodeUtf8 $ LT.concat ["\"", s, "\""]
-- Test that a few non-timezone qualified timestamp formats get
-- rejected if decoding to UTCTime.
| 2,695
| false
| true
| 0
| 13
| 478
| 816
| 388
| 428
| null | null |
capitanbatata/marlows-parconc-exercises
|
parconc-ch07/test/ChanSpec.hs
|
gpl-3.0
|
spec :: Spec
spec = do
let testList = [0..100]
describe "Unbounded channels" $ do
it "buffers items" $ do
ch <- newChan
a <- async $ mapM_ (writeChan ch) testList
receivedList <- mapM (const (readChan ch)) testList
wait a
receivedList `shouldBe` testList
it "supports multiple readers/writers" $ do
ch <- newChan
a0 <- async $ mapM_ (writeChan ch) (filter even testList)
a1 <- async $ mapM_ (writeChan ch) (filter (not . even) testList)
a2 <- async $ mapM (const (readChan ch)) (filter even testList)
receivedList <- mapM (const (readChan ch)) (filter (not . even) testList)
wait a0; wait a1; wait a2
let receivedSet = Set.fromList receivedList
testSet = Set.fromList testList
receivedSet `shouldSatisfy` (`Set.isSubsetOf` testSet)
describe "Multicast channels" $ do
it "allows two processes to read the same items" $ do
ch <- newChan
chDup <- dupChan ch
a0 <- async $ mapM_ (writeChan ch) testList
a1 <- async $ mapM (const (readChan ch)) testList
receivedList <- mapM (const (readChan chDup)) testList
wait a0; wait a1
receivedList `shouldBe` testList
describe "unGetChan" $ do
it "puts back a values at the front of the channel" $ do
let val = 33
ch <- newChan
a0 <- async $ mapM_ (writeChan ch) [val, val]
rVal <- readChan ch
wait a0
unGetChan ch val
rVal `shouldBe` val
--expectationFailure "TODO: write this unit test"
rVal2 <- readChan ch
rVal2 `shouldBe` val
-- There is no known implementation of 'unGetChan' based on the
-- representation of Chan given in chapter 7 that avoids this problem.
it "deadlocks on an empty channel when other process is waiting\
\ (see page 139 for further explanation)" $
(do
let val = 10
ch <- newChan :: IO (Chan Int)
forkIO $ do readChan ch; return ()
-- Yield the control to the other thread to allow `readChan` to occur
-- first.
yield
unGetChan ch val
)
`shouldThrow` deadlockException
| 2,159
|
spec :: Spec
spec = do
let testList = [0..100]
describe "Unbounded channels" $ do
it "buffers items" $ do
ch <- newChan
a <- async $ mapM_ (writeChan ch) testList
receivedList <- mapM (const (readChan ch)) testList
wait a
receivedList `shouldBe` testList
it "supports multiple readers/writers" $ do
ch <- newChan
a0 <- async $ mapM_ (writeChan ch) (filter even testList)
a1 <- async $ mapM_ (writeChan ch) (filter (not . even) testList)
a2 <- async $ mapM (const (readChan ch)) (filter even testList)
receivedList <- mapM (const (readChan ch)) (filter (not . even) testList)
wait a0; wait a1; wait a2
let receivedSet = Set.fromList receivedList
testSet = Set.fromList testList
receivedSet `shouldSatisfy` (`Set.isSubsetOf` testSet)
describe "Multicast channels" $ do
it "allows two processes to read the same items" $ do
ch <- newChan
chDup <- dupChan ch
a0 <- async $ mapM_ (writeChan ch) testList
a1 <- async $ mapM (const (readChan ch)) testList
receivedList <- mapM (const (readChan chDup)) testList
wait a0; wait a1
receivedList `shouldBe` testList
describe "unGetChan" $ do
it "puts back a values at the front of the channel" $ do
let val = 33
ch <- newChan
a0 <- async $ mapM_ (writeChan ch) [val, val]
rVal <- readChan ch
wait a0
unGetChan ch val
rVal `shouldBe` val
--expectationFailure "TODO: write this unit test"
rVal2 <- readChan ch
rVal2 `shouldBe` val
-- There is no known implementation of 'unGetChan' based on the
-- representation of Chan given in chapter 7 that avoids this problem.
it "deadlocks on an empty channel when other process is waiting\
\ (see page 139 for further explanation)" $
(do
let val = 10
ch <- newChan :: IO (Chan Int)
forkIO $ do readChan ch; return ()
-- Yield the control to the other thread to allow `readChan` to occur
-- first.
yield
unGetChan ch val
)
`shouldThrow` deadlockException
| 2,159
|
spec = do
let testList = [0..100]
describe "Unbounded channels" $ do
it "buffers items" $ do
ch <- newChan
a <- async $ mapM_ (writeChan ch) testList
receivedList <- mapM (const (readChan ch)) testList
wait a
receivedList `shouldBe` testList
it "supports multiple readers/writers" $ do
ch <- newChan
a0 <- async $ mapM_ (writeChan ch) (filter even testList)
a1 <- async $ mapM_ (writeChan ch) (filter (not . even) testList)
a2 <- async $ mapM (const (readChan ch)) (filter even testList)
receivedList <- mapM (const (readChan ch)) (filter (not . even) testList)
wait a0; wait a1; wait a2
let receivedSet = Set.fromList receivedList
testSet = Set.fromList testList
receivedSet `shouldSatisfy` (`Set.isSubsetOf` testSet)
describe "Multicast channels" $ do
it "allows two processes to read the same items" $ do
ch <- newChan
chDup <- dupChan ch
a0 <- async $ mapM_ (writeChan ch) testList
a1 <- async $ mapM (const (readChan ch)) testList
receivedList <- mapM (const (readChan chDup)) testList
wait a0; wait a1
receivedList `shouldBe` testList
describe "unGetChan" $ do
it "puts back a values at the front of the channel" $ do
let val = 33
ch <- newChan
a0 <- async $ mapM_ (writeChan ch) [val, val]
rVal <- readChan ch
wait a0
unGetChan ch val
rVal `shouldBe` val
--expectationFailure "TODO: write this unit test"
rVal2 <- readChan ch
rVal2 `shouldBe` val
-- There is no known implementation of 'unGetChan' based on the
-- representation of Chan given in chapter 7 that avoids this problem.
it "deadlocks on an empty channel when other process is waiting\
\ (see page 139 for further explanation)" $
(do
let val = 10
ch <- newChan :: IO (Chan Int)
forkIO $ do readChan ch; return ()
-- Yield the control to the other thread to allow `readChan` to occur
-- first.
yield
unGetChan ch val
)
`shouldThrow` deadlockException
| 2,146
| false
| true
| 0
| 19
| 638
| 674
| 310
| 364
| null | null |
ezyang/ghc
|
testsuite/tests/codeGen/should_run/CmmSwitchTest64.hs
|
bsd-3-clause
|
ah 2# = 43#
| 11
|
ah 2# = 43#
| 11
|
ah 2# = 43#
| 11
| false
| false
| 0
| 5
| 3
| 9
| 4
| 5
| null | null |
intolerable/GroupProject
|
src/Emulator/CPU/Instructions/THUMB/Opcodes.hs
|
bsd-2-clause
|
functionFromOpcode :: IsSystem s m => ThumbOpcode -> (RegisterName -> RegisterName -> m ())
functionFromOpcode op = case op of
T_AND -> tAnd
T_EOR -> tEor
T_LSL -> tLsl
T_LSR -> tLsr
T_ASR -> tAsr
T_ADC -> tAdc
T_SBC -> tSbc
T_ROR -> tRor
T_TST -> tTst
T_NEG -> tNeg
T_CMP -> tCmp
T_CMN -> tCmn
T_ORR -> tOrr
T_MUL -> tMul
T_BIC -> tBic
T_MVN -> tMvn
T_MOV -> error "Mov passed to THUMB ALU operation"
T_ADD -> error "Add passed to THUMB ALU operation"
| 488
|
functionFromOpcode :: IsSystem s m => ThumbOpcode -> (RegisterName -> RegisterName -> m ())
functionFromOpcode op = case op of
T_AND -> tAnd
T_EOR -> tEor
T_LSL -> tLsl
T_LSR -> tLsr
T_ASR -> tAsr
T_ADC -> tAdc
T_SBC -> tSbc
T_ROR -> tRor
T_TST -> tTst
T_NEG -> tNeg
T_CMP -> tCmp
T_CMN -> tCmn
T_ORR -> tOrr
T_MUL -> tMul
T_BIC -> tBic
T_MVN -> tMvn
T_MOV -> error "Mov passed to THUMB ALU operation"
T_ADD -> error "Add passed to THUMB ALU operation"
| 488
|
functionFromOpcode op = case op of
T_AND -> tAnd
T_EOR -> tEor
T_LSL -> tLsl
T_LSR -> tLsr
T_ASR -> tAsr
T_ADC -> tAdc
T_SBC -> tSbc
T_ROR -> tRor
T_TST -> tTst
T_NEG -> tNeg
T_CMP -> tCmp
T_CMN -> tCmn
T_ORR -> tOrr
T_MUL -> tMul
T_BIC -> tBic
T_MVN -> tMvn
T_MOV -> error "Mov passed to THUMB ALU operation"
T_ADD -> error "Add passed to THUMB ALU operation"
| 396
| false
| true
| 0
| 11
| 121
| 161
| 79
| 82
| null | null |
nh2/haskell-ordnub
|
MiniSet.hs
|
mit
|
ordNubStrictAcc :: Ord a => [a] -> [a]
ordNubStrictAcc = go empty
where
go !_ [] = []
go !s (x : xs) =
if member x s
then go s xs
else x : go (insert x s) xs
| 189
|
ordNubStrictAcc :: Ord a => [a] -> [a]
ordNubStrictAcc = go empty
where
go !_ [] = []
go !s (x : xs) =
if member x s
then go s xs
else x : go (insert x s) xs
| 189
|
ordNubStrictAcc = go empty
where
go !_ [] = []
go !s (x : xs) =
if member x s
then go s xs
else x : go (insert x s) xs
| 150
| false
| true
| 3
| 9
| 71
| 114
| 52
| 62
| null | null |
fffej/HS-Poker
|
LookupPatternMatch.hs
|
bsd-3-clause
|
getValueFromProduct 83030 = 4609
| 32
|
getValueFromProduct 83030 = 4609
| 32
|
getValueFromProduct 83030 = 4609
| 32
| false
| false
| 0
| 5
| 3
| 9
| 4
| 5
| null | null |
wavewave/lhc-analysis-collection
|
lib/HEP/Physics/Analysis/ATLAS/SUSY/SUSY_1to2L2to6JMET_8TeV.hs
|
gpl-3.0
|
-- | preselection object for hard lepton analysis
preselectionHard :: PhyEventNoTau -> PhyEventNoTauNoBJet
preselectionHard ev =
let alljs = (map (\case JO_Jet j ->j ; JO_BJet b -> bJet2Jet b) . view jetBJets) ev
es = filter (\e -> pt e > 10 && abs (eta e) < 2.47) . view electrons $ ev
ms = filter (\m -> pt m > 10 && abs (eta m) < 2.4) . view muons $ ev
js = filter (\j -> pt j > 20 && abs (eta j) < 2.8) alljs
in ( set electrons es
. set muons ms
. set jets js
. set eventId (view eventId ev)
. set photons (view photons ev)
. set missingET (view missingET ev) ) def
| 629
|
preselectionHard :: PhyEventNoTau -> PhyEventNoTauNoBJet
preselectionHard ev =
let alljs = (map (\case JO_Jet j ->j ; JO_BJet b -> bJet2Jet b) . view jetBJets) ev
es = filter (\e -> pt e > 10 && abs (eta e) < 2.47) . view electrons $ ev
ms = filter (\m -> pt m > 10 && abs (eta m) < 2.4) . view muons $ ev
js = filter (\j -> pt j > 20 && abs (eta j) < 2.8) alljs
in ( set electrons es
. set muons ms
. set jets js
. set eventId (view eventId ev)
. set photons (view photons ev)
. set missingET (view missingET ev) ) def
| 579
|
preselectionHard ev =
let alljs = (map (\case JO_Jet j ->j ; JO_BJet b -> bJet2Jet b) . view jetBJets) ev
es = filter (\e -> pt e > 10 && abs (eta e) < 2.47) . view electrons $ ev
ms = filter (\m -> pt m > 10 && abs (eta m) < 2.4) . view muons $ ev
js = filter (\j -> pt j > 20 && abs (eta j) < 2.8) alljs
in ( set electrons es
. set muons ms
. set jets js
. set eventId (view eventId ev)
. set photons (view photons ev)
. set missingET (view missingET ev) ) def
| 522
| true
| true
| 0
| 18
| 182
| 302
| 144
| 158
| null | null |
ArthurClune/pastewatch
|
src/PasteWatch/Sites.hs
|
gpl-3.0
|
getNewPastes Slexy =
getNewPastes' "http://slexy.org/recent"
(css "div[class=main] tr a" ! "href")
(\u -> "http://slexy.org/raw/" ++ drop 6 u)
| 182
|
getNewPastes Slexy =
getNewPastes' "http://slexy.org/recent"
(css "div[class=main] tr a" ! "href")
(\u -> "http://slexy.org/raw/" ++ drop 6 u)
| 182
|
getNewPastes Slexy =
getNewPastes' "http://slexy.org/recent"
(css "div[class=main] tr a" ! "href")
(\u -> "http://slexy.org/raw/" ++ drop 6 u)
| 182
| false
| false
| 0
| 9
| 57
| 43
| 21
| 22
| null | null |
uuhan/Idris-dev
|
src/Idris/Unlit.hs
|
bsd-3-clause
|
check :: FilePath -> Int -> [(LineType, String)] -> TC ()
check f l (a:b:cs) = do chkAdj f l (fst a) (fst b)
check f (l+1) (b:cs)
| 153
|
check :: FilePath -> Int -> [(LineType, String)] -> TC ()
check f l (a:b:cs) = do chkAdj f l (fst a) (fst b)
check f (l+1) (b:cs)
| 153
|
check f l (a:b:cs) = do chkAdj f l (fst a) (fst b)
check f (l+1) (b:cs)
| 95
| false
| true
| 0
| 9
| 51
| 103
| 52
| 51
| null | null |
ideas-edu/ideas
|
src/Ideas/Common/Exercise.hs
|
apache-2.0
|
diffEnvironment :: HasEnvironment a => Derivation s a -> Derivation (s, Environment) a
diffEnvironment = updateSteps $ \old a new ->
let keep x = not (getId x == newId "location" || x `elem` list)
list = bindings old
in (a, makeEnvironment $ filter keep $ bindings new)
| 286
|
diffEnvironment :: HasEnvironment a => Derivation s a -> Derivation (s, Environment) a
diffEnvironment = updateSteps $ \old a new ->
let keep x = not (getId x == newId "location" || x `elem` list)
list = bindings old
in (a, makeEnvironment $ filter keep $ bindings new)
| 285
|
diffEnvironment = updateSteps $ \old a new ->
let keep x = not (getId x == newId "location" || x `elem` list)
list = bindings old
in (a, makeEnvironment $ filter keep $ bindings new)
| 198
| false
| true
| 0
| 16
| 64
| 125
| 60
| 65
| null | null |
energyflowanalysis/efa-2.1
|
test/EFA/Test/Signal.hs
|
bsd-3-clause
|
-------------------------------------------------------------------
prop_functor_identity :: Val Double -> Bool
prop_functor_identity x = fmap id x == x
| 154
|
prop_functor_identity :: Val Double -> Bool
prop_functor_identity x = fmap id x == x
| 84
|
prop_functor_identity x = fmap id x == x
| 40
| true
| true
| 1
| 7
| 16
| 41
| 17
| 24
| null | null |
Michaelt293/Lipid-Haskell
|
src/Lipid/Parsers/CombinedRadyl/Glycerophospholipid.hs
|
gpl-3.0
|
pgP :: Parser a -> Parser (PG a)
pgP p = PG <$> (string "PG " *> twoCombinedRadylsP p)
| 86
|
pgP :: Parser a -> Parser (PG a)
pgP p = PG <$> (string "PG " *> twoCombinedRadylsP p)
| 86
|
pgP p = PG <$> (string "PG " *> twoCombinedRadylsP p)
| 53
| false
| true
| 0
| 9
| 18
| 51
| 23
| 28
| null | null |
martijnbastiaan/sprockell
|
src/Sprockell/System.hs
|
mit
|
memDevice mem (addr, WriteReq value) = return (mem <~= (addr, value), Nothing)
| 78
|
memDevice mem (addr, WriteReq value) = return (mem <~= (addr, value), Nothing)
| 78
|
memDevice mem (addr, WriteReq value) = return (mem <~= (addr, value), Nothing)
| 78
| false
| false
| 0
| 8
| 11
| 39
| 21
| 18
| null | null |
Deewiant/haschoo
|
Haschoo/Evaluator/Standard/Numeric.hs
|
bsd-3-clause
|
isInteger (ScmComplex (a:+b)) = b == 0 && a == fromInteger (round a)
| 68
|
isInteger (ScmComplex (a:+b)) = b == 0 && a == fromInteger (round a)
| 68
|
isInteger (ScmComplex (a:+b)) = b == 0 && a == fromInteger (round a)
| 68
| false
| false
| 0
| 8
| 12
| 44
| 21
| 23
| null | null |
CloudI/CloudI
|
src/api/haskell/external/binary-0.8.7.0/tests/Action.hs
|
mit
|
gen_actions :: Bool -> Gen [Action]
gen_actions genFail = do
acts <- sized (go False)
return acts
where
go :: Bool -> Int -> Gen [Action]
go _ 0 = return []
go inTry s = oneof $ [ do n <- choose (0,10)
(:) (GetByteString n) <$> go inTry (s-1)
, do n <- choose (0,10)
(:) (GetByteStringL n) <$> go inTry (s-1)
, do n <- choose (0,10)
(:) (Skip n) <$> go inTry (s-1)
, do (:) BytesRead <$> go inTry (s-1)
, do t1 <- go True (s `div` 2)
t2 <- go inTry (s `div` 2)
(:) (Try t1 t2) <$> go inTry (s `div` 2)
, do t <- go inTry (s`div`2)
(:) (LookAhead t) <$> go inTry (s-1)
, do t <- go inTry (s`div`2)
b <- arbitrary
(:) (LookAheadM b t) <$> go inTry (s-1)
, do t <- go inTry (s`div`2)
b <- arbitrary
(:) (LookAheadE b t) <$> go inTry (s-1)
, do t <- go inTry (s`div`2)
Positive n <- arbitrary :: Gen (Positive Int)
(:) (Label ("some label: " ++ show n) t) <$> go inTry (s-1)
, do t <- resize (s`div`2) (gen_isolate (genFail || inTry))
(:) t <$> go inTry (s-1)
] ++ [frequency [(if inTry || genFail then 1 else 0, return [Fail])
,(9 , go inTry s)]]
| 1,723
|
gen_actions :: Bool -> Gen [Action]
gen_actions genFail = do
acts <- sized (go False)
return acts
where
go :: Bool -> Int -> Gen [Action]
go _ 0 = return []
go inTry s = oneof $ [ do n <- choose (0,10)
(:) (GetByteString n) <$> go inTry (s-1)
, do n <- choose (0,10)
(:) (GetByteStringL n) <$> go inTry (s-1)
, do n <- choose (0,10)
(:) (Skip n) <$> go inTry (s-1)
, do (:) BytesRead <$> go inTry (s-1)
, do t1 <- go True (s `div` 2)
t2 <- go inTry (s `div` 2)
(:) (Try t1 t2) <$> go inTry (s `div` 2)
, do t <- go inTry (s`div`2)
(:) (LookAhead t) <$> go inTry (s-1)
, do t <- go inTry (s`div`2)
b <- arbitrary
(:) (LookAheadM b t) <$> go inTry (s-1)
, do t <- go inTry (s`div`2)
b <- arbitrary
(:) (LookAheadE b t) <$> go inTry (s-1)
, do t <- go inTry (s`div`2)
Positive n <- arbitrary :: Gen (Positive Int)
(:) (Label ("some label: " ++ show n) t) <$> go inTry (s-1)
, do t <- resize (s`div`2) (gen_isolate (genFail || inTry))
(:) t <$> go inTry (s-1)
] ++ [frequency [(if inTry || genFail then 1 else 0, return [Fail])
,(9 , go inTry s)]]
| 1,723
|
gen_actions genFail = do
acts <- sized (go False)
return acts
where
go :: Bool -> Int -> Gen [Action]
go _ 0 = return []
go inTry s = oneof $ [ do n <- choose (0,10)
(:) (GetByteString n) <$> go inTry (s-1)
, do n <- choose (0,10)
(:) (GetByteStringL n) <$> go inTry (s-1)
, do n <- choose (0,10)
(:) (Skip n) <$> go inTry (s-1)
, do (:) BytesRead <$> go inTry (s-1)
, do t1 <- go True (s `div` 2)
t2 <- go inTry (s `div` 2)
(:) (Try t1 t2) <$> go inTry (s `div` 2)
, do t <- go inTry (s`div`2)
(:) (LookAhead t) <$> go inTry (s-1)
, do t <- go inTry (s`div`2)
b <- arbitrary
(:) (LookAheadM b t) <$> go inTry (s-1)
, do t <- go inTry (s`div`2)
b <- arbitrary
(:) (LookAheadE b t) <$> go inTry (s-1)
, do t <- go inTry (s`div`2)
Positive n <- arbitrary :: Gen (Positive Int)
(:) (Label ("some label: " ++ show n) t) <$> go inTry (s-1)
, do t <- resize (s`div`2) (gen_isolate (genFail || inTry))
(:) t <$> go inTry (s-1)
] ++ [frequency [(if inTry || genFail then 1 else 0, return [Fail])
,(9 , go inTry s)]]
| 1,687
| false
| true
| 0
| 16
| 902
| 730
| 374
| 356
| null | null |
ancientlanguage/haskell-analysis
|
prepare/src/Prepare/Decompose.hs
|
mit
|
decomposeChar '\x1E9B' = "\x017F\x0307"
| 39
|
decomposeChar '\x1E9B' = "\x017F\x0307"
| 39
|
decomposeChar '\x1E9B' = "\x017F\x0307"
| 39
| false
| false
| 1
| 5
| 3
| 13
| 4
| 9
| null | null |
shadwstalkr/GrahamScanDemo
|
test.hs
|
gpl-3.0
|
evaluate points = do
start <- getCurrentTime
grahamScan points `deepseq` return ()
end <- getCurrentTime
hPutStrLn stderr . show $ diffUTCTime end start
| 160
|
evaluate points = do
start <- getCurrentTime
grahamScan points `deepseq` return ()
end <- getCurrentTime
hPutStrLn stderr . show $ diffUTCTime end start
| 160
|
evaluate points = do
start <- getCurrentTime
grahamScan points `deepseq` return ()
end <- getCurrentTime
hPutStrLn stderr . show $ diffUTCTime end start
| 160
| false
| false
| 1
| 10
| 30
| 63
| 26
| 37
| null | null |
phischu/fragnix
|
tests/packages/scotty/Data.Vector.Primitive.hs
|
bsd-3-clause
|
dropWhile = G.dropWhile
| 23
|
dropWhile = G.dropWhile
| 23
|
dropWhile = G.dropWhile
| 23
| false
| false
| 1
| 6
| 2
| 12
| 4
| 8
| null | null |
cdparks/mini-core
|
src/MiniCore/Template.hs
|
mit
|
-- Convert a binary arithmetic function into a function on nodes
fromBinary :: (Int -> Int -> Int) -> (Node -> Node -> Node)
fromBinary f (NNum x) (NNum y) = NNum $ f x y
| 170
|
fromBinary :: (Int -> Int -> Int) -> (Node -> Node -> Node)
fromBinary f (NNum x) (NNum y) = NNum $ f x y
| 105
|
fromBinary f (NNum x) (NNum y) = NNum $ f x y
| 45
| true
| true
| 0
| 10
| 35
| 71
| 35
| 36
| null | null |
vizziv/qsim
|
src/Job.hs
|
bsd-3-clause
|
repeated :: Int -> (a -> a) -> a -> a
repeated n f x = foldl' (flip ($)) x (replicate n f)
| 90
|
repeated :: Int -> (a -> a) -> a -> a
repeated n f x = foldl' (flip ($)) x (replicate n f)
| 90
|
repeated n f x = foldl' (flip ($)) x (replicate n f)
| 52
| false
| true
| 0
| 8
| 22
| 60
| 31
| 29
| null | null |
haskell/haddock
|
haddock-api/src/Haddock/Backends/Xhtml/Layout.hs
|
bsd-2-clause
|
divContent = sectionDiv "content"
| 42
|
divContent = sectionDiv "content"
| 42
|
divContent = sectionDiv "content"
| 42
| false
| false
| 0
| 5
| 12
| 9
| 4
| 5
| null | null |
narurien/ganeti-ceph
|
src/Ganeti/Utils.hs
|
gpl-2.0
|
recombineEithers :: (Show a, Show b) =>
[a] -> [b] -> [Bool] -> Result [Either a b]
recombineEithers lefts rights trail =
foldM recombiner ([], lefts, rights) trail >>= checker
where checker (eithers, [], []) = Ok eithers
checker (_, lefts', rights') =
Bad $ "Inconsistent results after recombination, l'=" ++
show lefts' ++ ", r'=" ++ show rights'
recombiner (es, l:ls, rs) False = Ok (Left l:es, ls, rs)
recombiner (es, ls, r:rs) True = Ok (Right r:es, ls, rs)
recombiner (_, ls, rs) t = Bad $ "Inconsistent trail log: l=" ++
show ls ++ ", r=" ++ show rs ++ ",t=" ++
show t
-- | Default hints for the resolver
| 785
|
recombineEithers :: (Show a, Show b) =>
[a] -> [b] -> [Bool] -> Result [Either a b]
recombineEithers lefts rights trail =
foldM recombiner ([], lefts, rights) trail >>= checker
where checker (eithers, [], []) = Ok eithers
checker (_, lefts', rights') =
Bad $ "Inconsistent results after recombination, l'=" ++
show lefts' ++ ", r'=" ++ show rights'
recombiner (es, l:ls, rs) False = Ok (Left l:es, ls, rs)
recombiner (es, ls, r:rs) True = Ok (Right r:es, ls, rs)
recombiner (_, ls, rs) t = Bad $ "Inconsistent trail log: l=" ++
show ls ++ ", r=" ++ show rs ++ ",t=" ++
show t
-- | Default hints for the resolver
| 785
|
recombineEithers lefts rights trail =
foldM recombiner ([], lefts, rights) trail >>= checker
where checker (eithers, [], []) = Ok eithers
checker (_, lefts', rights') =
Bad $ "Inconsistent results after recombination, l'=" ++
show lefts' ++ ", r'=" ++ show rights'
recombiner (es, l:ls, rs) False = Ok (Left l:es, ls, rs)
recombiner (es, ls, r:rs) True = Ok (Right r:es, ls, rs)
recombiner (_, ls, rs) t = Bad $ "Inconsistent trail log: l=" ++
show ls ++ ", r=" ++ show rs ++ ",t=" ++
show t
-- | Default hints for the resolver
| 681
| false
| true
| 0
| 12
| 287
| 289
| 153
| 136
| null | null |
timtylin/scholdoc
|
src/Text/Pandoc/Readers/Markdown.hs
|
gpl-2.0
|
atxClosing :: MarkdownParser Attr
atxClosing = try $ do
attr' <- option nullAttr
(guardEnabled Ext_mmd_header_identifiers >> mmdHeaderIdentifier)
skipMany (char '#')
skipSpaces
attr <- option attr'
(guardEnabled Ext_header_attributes >> attributes)
blanklines
return attr
| 309
|
atxClosing :: MarkdownParser Attr
atxClosing = try $ do
attr' <- option nullAttr
(guardEnabled Ext_mmd_header_identifiers >> mmdHeaderIdentifier)
skipMany (char '#')
skipSpaces
attr <- option attr'
(guardEnabled Ext_header_attributes >> attributes)
blanklines
return attr
| 309
|
atxClosing = try $ do
attr' <- option nullAttr
(guardEnabled Ext_mmd_header_identifiers >> mmdHeaderIdentifier)
skipMany (char '#')
skipSpaces
attr <- option attr'
(guardEnabled Ext_header_attributes >> attributes)
blanklines
return attr
| 275
| false
| true
| 0
| 12
| 69
| 86
| 38
| 48
| null | null |
wavewave/madgraph-auto-dataset
|
src/HEP/Automation/MadGraph/Dataset/Set20110330set2.hs
|
gpl-3.0
|
sets :: [Int]
sets = [1]
| 24
|
sets :: [Int]
sets = [1]
| 24
|
sets = [1]
| 10
| false
| true
| 0
| 5
| 5
| 17
| 10
| 7
| null | null |
rahulmutt/ghcvm
|
compiler/Eta/DeSugar/Coverage.hs
|
bsd-3-clause
|
addTickLStmts' :: (Maybe (Bool -> BoxLabel)) -> [ExprLStmt Id] -> TM a
-> TM ([ExprLStmt Id], a)
addTickLStmts' isGuard lstmts res
= bindLocals (collectLStmtsBinders lstmts) $
do { lstmts' <- mapM (liftL (addTickStmt isGuard)) lstmts
; a <- res
; return (lstmts', a) }
| 303
|
addTickLStmts' :: (Maybe (Bool -> BoxLabel)) -> [ExprLStmt Id] -> TM a
-> TM ([ExprLStmt Id], a)
addTickLStmts' isGuard lstmts res
= bindLocals (collectLStmtsBinders lstmts) $
do { lstmts' <- mapM (liftL (addTickStmt isGuard)) lstmts
; a <- res
; return (lstmts', a) }
| 303
|
addTickLStmts' isGuard lstmts res
= bindLocals (collectLStmtsBinders lstmts) $
do { lstmts' <- mapM (liftL (addTickStmt isGuard)) lstmts
; a <- res
; return (lstmts', a) }
| 191
| false
| true
| 0
| 13
| 78
| 127
| 64
| 63
| null | null |
peteg/ADHOC
|
Apps/Cache/Tests/030_cache_bugfinder.hs
|
gpl-2.0
|
proc_writeP i = "pw" ++ show i
| 30
|
proc_writeP i = "pw" ++ show i
| 30
|
proc_writeP i = "pw" ++ show i
| 30
| false
| false
| 0
| 6
| 6
| 16
| 7
| 9
| null | null |
kawu/dawg-new
|
src/Data/DAWG/Dynamic/State/Trans/Vect.hs
|
bsd-2-clause
|
printTrans' :: Trans' -> IO ()
printTrans' Trans'{..} = forM_ [0..size'-1] $ \i -> do
print (symv' I.! i, stiv' I.! i)
------------------------------------------------------------------
-- Conversion
------------------------------------------------------------------
-- | Translate map to its pure version.
| 314
|
printTrans' :: Trans' -> IO ()
printTrans' Trans'{..} = forM_ [0..size'-1] $ \i -> do
print (symv' I.! i, stiv' I.! i)
------------------------------------------------------------------
-- Conversion
------------------------------------------------------------------
-- | Translate map to its pure version.
| 314
|
printTrans' Trans'{..} = forM_ [0..size'-1] $ \i -> do
print (symv' I.! i, stiv' I.! i)
------------------------------------------------------------------
-- Conversion
------------------------------------------------------------------
-- | Translate map to its pure version.
| 283
| false
| true
| 0
| 11
| 41
| 78
| 41
| 37
| null | null |
Bodigrim/arithmoi
|
test-suite/Math/NumberTheory/Moduli/ClassTests.hs
|
mit
|
someModAbsSignumProperty :: Integer -> Positive Natural -> Bool
someModAbsSignumProperty x (Positive m) = z == abs z * signum z
where
z = x `modulo` m
| 156
|
someModAbsSignumProperty :: Integer -> Positive Natural -> Bool
someModAbsSignumProperty x (Positive m) = z == abs z * signum z
where
z = x `modulo` m
| 156
|
someModAbsSignumProperty x (Positive m) = z == abs z * signum z
where
z = x `modulo` m
| 92
| false
| true
| 1
| 7
| 31
| 64
| 30
| 34
| null | null |
christiaanb/ghc
|
compiler/prelude/PrelNames.hs
|
bsd-3-clause
|
monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
monadPlusClassKey = mkPreludeClassUnique 30
| 112
|
monadPlusClassKey, randomClassKey, randomGenClassKey :: Unique
monadPlusClassKey = mkPreludeClassUnique 30
| 112
|
monadPlusClassKey = mkPreludeClassUnique 30
| 49
| false
| true
| 0
| 5
| 14
| 18
| 11
| 7
| null | null |
HIPERFIT/language-c-quote
|
Language/C/Parser/Tokens.hs
|
bsd-3-clause
|
tokenStrings :: [(Token, String)]
tokenStrings = [(Tlparen, "("),
(Trparen, ")"),
(Tlbrack, "["),
(Trbrack, "]"),
(Tlbrace, "{"),
(Trbrace, "}"),
(Tcomma, ","),
(Tsemi, ";"),
(Tcolon, ":"),
(Tquestion, "?"),
(Tdot, "."),
(Tarrow, "->"),
(Tellipses, "..."),
(Tplus, "+"),
(Tminus, "-"),
(Tstar, "*"),
(Tdiv, "/"),
(Tmod, "%"),
(Tnot, "~"),
(Tand, "&"),
(Tor, "|"),
(Txor, "^"),
(Tlsh, "<<"),
(Trsh, ">>"),
(Tinc, "++"),
(Tdec, "--"),
(Tlnot, "!"),
(Tland, "&&"),
(Tlor, "||"),
(Teq, "=="),
(Tne, "!="),
(Tlt, "<"),
(Tgt, ">"),
(Tle, "<="),
(Tge, ">="),
(Tassign, "="),
(Tadd_assign, "+="),
(Tsub_assign, "-="),
(Tmul_assign, "*="),
(Tdiv_assign, "/="),
(Tmod_assign, "%="),
(Tlsh_assign, "<<="),
(Trsh_assign, ">>="),
(Tand_assign, "&="),
(Tor_assign, "|="),
(Txor_assign, "^="),
--
-- Keywords
--
(Tauto, "auto"),
(Tbreak, "break"),
(Tcase, "case"),
(Tchar, "char"),
(Tconst, "const"),
(Tcontinue, "continue"),
(Tdefault, "default"),
(Tdo, "do"),
(Tdouble, "double"),
(Telse, "else"),
(Tenum, "enum"),
(Textern, "extern"),
(Tfloat, "float"),
(Tfor, "for"),
(Tgoto, "goto"),
(Tif, "if"),
(Tinline, "inline"),
(Tint, "int"),
(Tlong, "long"),
(Tregister, "register"),
(Trestrict, "restrict"),
(Treturn, "return"),
(Tshort, "short"),
(Tsigned, "signed"),
(Tsizeof, "sizeof"),
(Tstatic, "static"),
(Tstruct, "struct"),
(Tswitch, "switch"),
(Ttypedef, "typedef"),
(Tunion, "union"),
(Tunsigned, "unsigned"),
(Tvoid, "void"),
(Tvolatile, "volatile"),
(Twhile, "while"),
(TBool, "_Bool"),
(TComplex, "_TComplex"),
(TImaginary, "_TImaginary"),
--
-- GCC extensions
--
(Tasm, "asm"),
(Tattribute, "__attribute__"),
(Tbuiltin_va_arg, "__builtin_va_arg"),
(Tbuiltin_va_list, "__builtin_va_list"),
(Textension, "__extension__"),
(Ttypeof, "typeof"),
--
-- CUDA extensions
--
(Tdevice, "__device__"),
(Tglobal, "__global__"),
(Thost, "__host__"),
(Tconstant, "__constant__"),
(Tshared, "__shared__"),
(Tnoinline, "__noinline__")
]
| 3,976
|
tokenStrings :: [(Token, String)]
tokenStrings = [(Tlparen, "("),
(Trparen, ")"),
(Tlbrack, "["),
(Trbrack, "]"),
(Tlbrace, "{"),
(Trbrace, "}"),
(Tcomma, ","),
(Tsemi, ";"),
(Tcolon, ":"),
(Tquestion, "?"),
(Tdot, "."),
(Tarrow, "->"),
(Tellipses, "..."),
(Tplus, "+"),
(Tminus, "-"),
(Tstar, "*"),
(Tdiv, "/"),
(Tmod, "%"),
(Tnot, "~"),
(Tand, "&"),
(Tor, "|"),
(Txor, "^"),
(Tlsh, "<<"),
(Trsh, ">>"),
(Tinc, "++"),
(Tdec, "--"),
(Tlnot, "!"),
(Tland, "&&"),
(Tlor, "||"),
(Teq, "=="),
(Tne, "!="),
(Tlt, "<"),
(Tgt, ">"),
(Tle, "<="),
(Tge, ">="),
(Tassign, "="),
(Tadd_assign, "+="),
(Tsub_assign, "-="),
(Tmul_assign, "*="),
(Tdiv_assign, "/="),
(Tmod_assign, "%="),
(Tlsh_assign, "<<="),
(Trsh_assign, ">>="),
(Tand_assign, "&="),
(Tor_assign, "|="),
(Txor_assign, "^="),
--
-- Keywords
--
(Tauto, "auto"),
(Tbreak, "break"),
(Tcase, "case"),
(Tchar, "char"),
(Tconst, "const"),
(Tcontinue, "continue"),
(Tdefault, "default"),
(Tdo, "do"),
(Tdouble, "double"),
(Telse, "else"),
(Tenum, "enum"),
(Textern, "extern"),
(Tfloat, "float"),
(Tfor, "for"),
(Tgoto, "goto"),
(Tif, "if"),
(Tinline, "inline"),
(Tint, "int"),
(Tlong, "long"),
(Tregister, "register"),
(Trestrict, "restrict"),
(Treturn, "return"),
(Tshort, "short"),
(Tsigned, "signed"),
(Tsizeof, "sizeof"),
(Tstatic, "static"),
(Tstruct, "struct"),
(Tswitch, "switch"),
(Ttypedef, "typedef"),
(Tunion, "union"),
(Tunsigned, "unsigned"),
(Tvoid, "void"),
(Tvolatile, "volatile"),
(Twhile, "while"),
(TBool, "_Bool"),
(TComplex, "_TComplex"),
(TImaginary, "_TImaginary"),
--
-- GCC extensions
--
(Tasm, "asm"),
(Tattribute, "__attribute__"),
(Tbuiltin_va_arg, "__builtin_va_arg"),
(Tbuiltin_va_list, "__builtin_va_list"),
(Textension, "__extension__"),
(Ttypeof, "typeof"),
--
-- CUDA extensions
--
(Tdevice, "__device__"),
(Tglobal, "__global__"),
(Thost, "__host__"),
(Tconstant, "__constant__"),
(Tshared, "__shared__"),
(Tnoinline, "__noinline__")
]
| 3,976
|
tokenStrings = [(Tlparen, "("),
(Trparen, ")"),
(Tlbrack, "["),
(Trbrack, "]"),
(Tlbrace, "{"),
(Trbrace, "}"),
(Tcomma, ","),
(Tsemi, ";"),
(Tcolon, ":"),
(Tquestion, "?"),
(Tdot, "."),
(Tarrow, "->"),
(Tellipses, "..."),
(Tplus, "+"),
(Tminus, "-"),
(Tstar, "*"),
(Tdiv, "/"),
(Tmod, "%"),
(Tnot, "~"),
(Tand, "&"),
(Tor, "|"),
(Txor, "^"),
(Tlsh, "<<"),
(Trsh, ">>"),
(Tinc, "++"),
(Tdec, "--"),
(Tlnot, "!"),
(Tland, "&&"),
(Tlor, "||"),
(Teq, "=="),
(Tne, "!="),
(Tlt, "<"),
(Tgt, ">"),
(Tle, "<="),
(Tge, ">="),
(Tassign, "="),
(Tadd_assign, "+="),
(Tsub_assign, "-="),
(Tmul_assign, "*="),
(Tdiv_assign, "/="),
(Tmod_assign, "%="),
(Tlsh_assign, "<<="),
(Trsh_assign, ">>="),
(Tand_assign, "&="),
(Tor_assign, "|="),
(Txor_assign, "^="),
--
-- Keywords
--
(Tauto, "auto"),
(Tbreak, "break"),
(Tcase, "case"),
(Tchar, "char"),
(Tconst, "const"),
(Tcontinue, "continue"),
(Tdefault, "default"),
(Tdo, "do"),
(Tdouble, "double"),
(Telse, "else"),
(Tenum, "enum"),
(Textern, "extern"),
(Tfloat, "float"),
(Tfor, "for"),
(Tgoto, "goto"),
(Tif, "if"),
(Tinline, "inline"),
(Tint, "int"),
(Tlong, "long"),
(Tregister, "register"),
(Trestrict, "restrict"),
(Treturn, "return"),
(Tshort, "short"),
(Tsigned, "signed"),
(Tsizeof, "sizeof"),
(Tstatic, "static"),
(Tstruct, "struct"),
(Tswitch, "switch"),
(Ttypedef, "typedef"),
(Tunion, "union"),
(Tunsigned, "unsigned"),
(Tvoid, "void"),
(Tvolatile, "volatile"),
(Twhile, "while"),
(TBool, "_Bool"),
(TComplex, "_TComplex"),
(TImaginary, "_TImaginary"),
--
-- GCC extensions
--
(Tasm, "asm"),
(Tattribute, "__attribute__"),
(Tbuiltin_va_arg, "__builtin_va_arg"),
(Tbuiltin_va_list, "__builtin_va_list"),
(Textension, "__extension__"),
(Ttypeof, "typeof"),
--
-- CUDA extensions
--
(Tdevice, "__device__"),
(Tglobal, "__global__"),
(Thost, "__host__"),
(Tconstant, "__constant__"),
(Tshared, "__shared__"),
(Tnoinline, "__noinline__")
]
| 3,942
| false
| true
| 0
| 8
| 2,270
| 891
| 592
| 299
| null | null |
ekmett/ghc
|
includes/CodeGen.Platform.hs
|
bsd-3-clause
|
callerSaves CurrentNursery = True
| 36
|
callerSaves CurrentNursery = True
| 36
|
callerSaves CurrentNursery = True
| 36
| false
| false
| 0
| 5
| 6
| 9
| 4
| 5
| null | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.