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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
haskell/haddock
|
haddock-api/src/Haddock/Interface/Rename.hs
|
bsd-2-clause
|
renameForD (ForeignExport _ lname ltype x) = do
lname' <- renameL lname
ltype' <- renameLSigType ltype
return (ForeignExport noExtField lname' ltype' x)
| 158
|
renameForD (ForeignExport _ lname ltype x) = do
lname' <- renameL lname
ltype' <- renameLSigType ltype
return (ForeignExport noExtField lname' ltype' x)
| 158
|
renameForD (ForeignExport _ lname ltype x) = do
lname' <- renameL lname
ltype' <- renameLSigType ltype
return (ForeignExport noExtField lname' ltype' x)
| 158
| false
| false
| 0
| 9
| 27
| 59
| 26
| 33
| null | null |
thomie/cabal
|
cabal-install/Distribution/Client/Sandbox.hs
|
bsd-3-clause
|
-- | Try to read the most recently configured compiler from the
-- 'localBuildInfoFile', falling back on 'configCompilerAuxEx' if it
-- cannot be read.
getPersistOrConfigCompiler :: ConfigFlags
-> IO (Compiler, Platform, ProgramConfiguration)
getPersistOrConfigCompiler configFlags = do
distPref <- findDistPrefOrDefault (configDistPref configFlags)
mlbi <- maybeGetPersistBuildConfig distPref
case mlbi of
Nothing -> do configCompilerAux' configFlags
Just lbi -> return ( LocalBuildInfo.compiler lbi
, LocalBuildInfo.hostPlatform lbi
, LocalBuildInfo.withPrograms lbi
)
| 681
|
getPersistOrConfigCompiler :: ConfigFlags
-> IO (Compiler, Platform, ProgramConfiguration)
getPersistOrConfigCompiler configFlags = do
distPref <- findDistPrefOrDefault (configDistPref configFlags)
mlbi <- maybeGetPersistBuildConfig distPref
case mlbi of
Nothing -> do configCompilerAux' configFlags
Just lbi -> return ( LocalBuildInfo.compiler lbi
, LocalBuildInfo.hostPlatform lbi
, LocalBuildInfo.withPrograms lbi
)
| 529
|
getPersistOrConfigCompiler configFlags = do
distPref <- findDistPrefOrDefault (configDistPref configFlags)
mlbi <- maybeGetPersistBuildConfig distPref
case mlbi of
Nothing -> do configCompilerAux' configFlags
Just lbi -> return ( LocalBuildInfo.compiler lbi
, LocalBuildInfo.hostPlatform lbi
, LocalBuildInfo.withPrograms lbi
)
| 411
| true
| true
| 0
| 13
| 177
| 114
| 55
| 59
| null | null |
vTurbine/ghc
|
compiler/basicTypes/NameEnv.hs
|
bsd-3-clause
|
alterDNameEnv :: (Maybe a -> Maybe a) -> DNameEnv a -> Name -> DNameEnv a
alterDNameEnv = alterUDFM
| 99
|
alterDNameEnv :: (Maybe a -> Maybe a) -> DNameEnv a -> Name -> DNameEnv a
alterDNameEnv = alterUDFM
| 99
|
alterDNameEnv = alterUDFM
| 25
| false
| true
| 0
| 9
| 17
| 48
| 21
| 27
| null | null |
d-rive/rivers
|
Data/Rivers/Streams.hs
|
bsd-3-clause
|
-- | The 'splitAt' function takes an integer @n@ and a stream @xs@
-- and returns a pair consisting of the prefix of @xs@ of length
-- @n@ and the remaining stream immediately following this prefix.
--
-- /Beware/: passing a negative integer as the first argument will
-- cause an error.
ssplitAt n xs
| n == 0 = ([],xs)
| n > 0 = let (prefix,rest) = ssplitAt (n-1) (stail xs)
in (shead xs : prefix, rest)
| otherwise = error "S.splitAt negative argument."
| 485
|
ssplitAt n xs
| n == 0 = ([],xs)
| n > 0 = let (prefix,rest) = ssplitAt (n-1) (stail xs)
in (shead xs : prefix, rest)
| otherwise = error "S.splitAt negative argument."
| 197
|
ssplitAt n xs
| n == 0 = ([],xs)
| n > 0 = let (prefix,rest) = ssplitAt (n-1) (stail xs)
in (shead xs : prefix, rest)
| otherwise = error "S.splitAt negative argument."
| 197
| true
| false
| 2
| 11
| 114
| 107
| 56
| 51
| null | null |
anchor/servant-purescript
|
examples/todo/ToDo.hs
|
bsd-3-clause
|
tmp :: FilePath
tmp = appPath </> "temp"
| 40
|
tmp :: FilePath
tmp = appPath </> "temp"
| 40
|
tmp = appPath </> "temp"
| 24
| false
| true
| 0
| 6
| 7
| 22
| 9
| 13
| null | null |
ckaestne/CIDE
|
other/CaseStudies/fgl/CIDEfgl/Data/Graph/Inductive/Query/ArtPoint.hs
|
gpl-3.0
|
lowTree (B (v, n, bcks) trs) = Brc (v, n, lowv) ts
where { lowv = min (minbckEdge n bcks) lowChild;
lowChild = minimum (map getLow ts);
ts = map lowTree trs}
| 185
|
lowTree (B (v, n, bcks) trs) = Brc (v, n, lowv) ts
where { lowv = min (minbckEdge n bcks) lowChild;
lowChild = minimum (map getLow ts);
ts = map lowTree trs}
| 185
|
lowTree (B (v, n, bcks) trs) = Brc (v, n, lowv) ts
where { lowv = min (minbckEdge n bcks) lowChild;
lowChild = minimum (map getLow ts);
ts = map lowTree trs}
| 185
| false
| false
| 0
| 9
| 59
| 90
| 49
| 41
| null | null |
fffej/HS-Poker
|
LookupPatternMatch.hs
|
bsd-3-clause
|
getValueFromProduct 20452727 = 215
| 34
|
getValueFromProduct 20452727 = 215
| 34
|
getValueFromProduct 20452727 = 215
| 34
| false
| false
| 0
| 5
| 3
| 9
| 4
| 5
| null | null |
zaxtax/hakaru
|
haskell/Language/Hakaru/Expect.hs
|
bsd-3-clause
|
pushIntegrate
:: (ABT Term abt)
=> abt '[] 'HReal
-> abt '[] 'HReal
-> Expect abt (Variable 'HReal)
pushIntegrate lo hi = do
x <- freshVar Text.empty SReal
unsafePush (SStuff1 (Location x) (\c ->
syn (Integrate :$ lo :* hi :* bind x c :* End)) [])
return x
{-
-- BUG: we assume the arguments are emissible!
emitIntegrate lo hi =
emit Text.empty SReal (\c ->
syn (Integrate :$ lo :* hi :* c :* End))
-}
-- Needs to be more polymorphic
| 482
|
pushIntegrate
:: (ABT Term abt)
=> abt '[] 'HReal
-> abt '[] 'HReal
-> Expect abt (Variable 'HReal)
pushIntegrate lo hi = do
x <- freshVar Text.empty SReal
unsafePush (SStuff1 (Location x) (\c ->
syn (Integrate :$ lo :* hi :* bind x c :* End)) [])
return x
{-
-- BUG: we assume the arguments are emissible!
emitIntegrate lo hi =
emit Text.empty SReal (\c ->
syn (Integrate :$ lo :* hi :* c :* End))
-}
-- Needs to be more polymorphic
| 482
|
pushIntegrate lo hi = do
x <- freshVar Text.empty SReal
unsafePush (SStuff1 (Location x) (\c ->
syn (Integrate :$ lo :* hi :* bind x c :* End)) [])
return x
{-
-- BUG: we assume the arguments are emissible!
emitIntegrate lo hi =
emit Text.empty SReal (\c ->
syn (Integrate :$ lo :* hi :* c :* End))
-}
-- Needs to be more polymorphic
| 366
| false
| true
| 0
| 17
| 132
| 151
| 73
| 78
| null | null |
nightscape/platform
|
node/tests/Unison/Test/ResourcePool.hs
|
mit
|
decrement :: IORef Int -> IO Int
decrement ref = IORef.atomicModifyIORef' ref (\n -> (n-1, n))
| 94
|
decrement :: IORef Int -> IO Int
decrement ref = IORef.atomicModifyIORef' ref (\n -> (n-1, n))
| 94
|
decrement ref = IORef.atomicModifyIORef' ref (\n -> (n-1, n))
| 61
| false
| true
| 0
| 9
| 15
| 49
| 25
| 24
| null | null |
joelwilliamson/validator
|
Maker.hs
|
agpl-3.0
|
(/@@) :: Maker a → Label → Maker [a]
f /@@ k = filterSubForest ((/= Label k) . rootLabel) $ mapSubForest f
| 106
|
(/@@) :: Maker a → Label → Maker [a]
f /@@ k = filterSubForest ((/= Label k) . rootLabel) $ mapSubForest f
| 106
|
f /@@ k = filterSubForest ((/= Label k) . rootLabel) $ mapSubForest f
| 69
| false
| true
| 0
| 10
| 21
| 63
| 31
| 32
| null | null |
christiaanb/ghc
|
compiler/prelude/PrelNames.hs
|
bsd-3-clause
|
unpackCString_RDR = nameRdrName unpackCStringName
| 55
|
unpackCString_RDR = nameRdrName unpackCStringName
| 55
|
unpackCString_RDR = nameRdrName unpackCStringName
| 55
| false
| false
| 0
| 5
| 9
| 9
| 4
| 5
| null | null |
raventid/coursera_learning
|
haskell/will_kurt/15_rot.hs
|
mit
|
rotEncoder :: String -> String
rotEncoder text = map rotChar text
where alphaSize = 1 + fromEnum (maxBound :: Char)
| 117
|
rotEncoder :: String -> String
rotEncoder text = map rotChar text
where alphaSize = 1 + fromEnum (maxBound :: Char)
| 117
|
rotEncoder text = map rotChar text
where alphaSize = 1 + fromEnum (maxBound :: Char)
| 86
| false
| true
| 0
| 7
| 21
| 44
| 22
| 22
| null | null |
haskell-game/fungen
|
examples/worms/worms.hs
|
bsd-3-clause
|
findLastTail (t1:t2:ts) = do (Tail na) <- getObjectAttribute t1
(Tail nb) <- getObjectAttribute t2
if (na > nb)
then findLastTail (t1:ts)
else findLastTail (t2:ts)
| 289
|
findLastTail (t1:t2:ts) = do (Tail na) <- getObjectAttribute t1
(Tail nb) <- getObjectAttribute t2
if (na > nb)
then findLastTail (t1:ts)
else findLastTail (t2:ts)
| 289
|
findLastTail (t1:t2:ts) = do (Tail na) <- getObjectAttribute t1
(Tail nb) <- getObjectAttribute t2
if (na > nb)
then findLastTail (t1:ts)
else findLastTail (t2:ts)
| 289
| false
| false
| 0
| 10
| 149
| 90
| 44
| 46
| null | null |
ocramz/petsc-hs
|
src/Numerical/PETSc/Internal/InlineC.hs
|
gpl-3.0
|
-- PETSC_EXTERN PetscErrorCode DMDAGetInfo(DM,PetscInt*,PetscInt*,PetscInt*,PetscInt*,PetscInt*,PetscInt*,PetscInt*,PetscInt*,PetscInt*,DMBoundaryType*,DMBoundaryType*,DMBoundaryType*,DMDAStencilType*);
-- PETSC_EXTERN PetscErrorCode DMDAGetProcessorSubset(DM,DMDADirection,PetscInt,MPI_Comm*);
-- PETSC_EXTERN PetscErrorCode DMDAGetProcessorSubsets(DM,DMDADirection,MPI_Comm*);
-- PETSC_EXTERN PetscErrorCode DMDAGetRay(DM,DMDADirection,PetscInt,Vec*,VecScatter*)
-- PetscErrorCode DMDASetUniformCoordinates(DM da,PetscReal xmin,PetscReal xmax,PetscReal ymin,PetscReal ymax,PetscReal zmin,PetscReal zmax)
-- Collective on DMDA
-- Input Parameters
-- da - the distributed array object
-- xmin,xmax - extremes in the x direction
-- ymin,ymax - extremes in the y direction (value ignored for 1 dimensional problems)
-- zmin,zmax - extremes in the z direction (value ignored for 1 or 2 dimensional problems)
dmdaSetUniformCoordinates' :: DM
-> PetscReal_
-> PetscReal_
-> PetscReal_
-> PetscReal_
-> PetscReal_
-> PetscReal_
-> IO CInt
dmdaSetUniformCoordinates' da xmin xmax ymin ymax zmin zmax =
[C.exp|int{DMDASetUniformCoordinates($(DM da),$(PetscReal xmin),$(PetscReal xmax),$(PetscReal ymin),$(PetscReal ymax),$(PetscReal zmin),$(PetscReal zmax))}|]
| 1,511
|
dmdaSetUniformCoordinates' :: DM
-> PetscReal_
-> PetscReal_
-> PetscReal_
-> PetscReal_
-> PetscReal_
-> PetscReal_
-> IO CInt
dmdaSetUniformCoordinates' da xmin xmax ymin ymax zmin zmax =
[C.exp|int{DMDASetUniformCoordinates($(DM da),$(PetscReal xmin),$(PetscReal xmax),$(PetscReal ymin),$(PetscReal ymax),$(PetscReal zmin),$(PetscReal zmax))}|]
| 601
|
dmdaSetUniformCoordinates' da xmin xmax ymin ymax zmin zmax =
[C.exp|int{DMDASetUniformCoordinates($(DM da),$(PetscReal xmin),$(PetscReal xmax),$(PetscReal ymin),$(PetscReal ymax),$(PetscReal zmin),$(PetscReal zmax))}|]
| 221
| true
| true
| 0
| 12
| 371
| 74
| 44
| 30
| null | null |
bacchanalia/KitchenSink
|
KitchenSink/Qualified.hs
|
gpl-3.0
|
-- |'Seq.zip'
seq_zip = Seq.zip
| 31
|
seq_zip = Seq.zip
| 17
|
seq_zip = Seq.zip
| 17
| true
| false
| 0
| 5
| 4
| 9
| 5
| 4
| null | null |
imeckler/proof
|
Parse/Tex.hs
|
mit
|
-- TODO: Simple proof
proof = fmap (Steps . snd) . env "proof" $ many step
| 74
|
proof = fmap (Steps . snd) . env "proof" $ many step
| 52
|
proof = fmap (Steps . snd) . env "proof" $ many step
| 52
| true
| false
| 0
| 9
| 15
| 31
| 15
| 16
| null | null |
ghc-android/ghc
|
compiler/prelude/PrelNames.hs
|
bsd-3-clause
|
fromRationalClassOpKey = mkPreludeMiscIdUnique 162
| 57
|
fromRationalClassOpKey = mkPreludeMiscIdUnique 162
| 57
|
fromRationalClassOpKey = mkPreludeMiscIdUnique 162
| 57
| false
| false
| 0
| 5
| 10
| 9
| 4
| 5
| null | null |
prl-tokyo/bigul-configuration-adaptation
|
Transformations/src/BiFlux/XPath/HXT/XPathParser.hs
|
mit
|
relLocPath :: XPathParser [XStep]
relLocPath
= do
s1 <- step
s2 <- many (step')
return ([s1] ++ (concat s2))
<?> "relLocPath"
| 153
|
relLocPath :: XPathParser [XStep]
relLocPath
= do
s1 <- step
s2 <- many (step')
return ([s1] ++ (concat s2))
<?> "relLocPath"
| 153
|
relLocPath
= do
s1 <- step
s2 <- many (step')
return ([s1] ++ (concat s2))
<?> "relLocPath"
| 119
| false
| true
| 2
| 11
| 48
| 70
| 32
| 38
| null | null |
deweyvm/kayvee
|
src/Database/Kayvee/Common.hs
|
mit
|
valuePut :: String -> String -> Put
valuePut s v = do
let ss = toPointer $ (genericLength s)
uLogAll ("Putting value: " ++ show ss) $ putWord64be ss
let ps = pack s
uLogAll ("Putting value: " ++ show ps) $ putByteString ps
let sv = toPointer $ (genericLength v)
uLogAll ("Putting value: " ++ show sv) $ putWord64be sv
let pv = pack v
uLogAll ("Putting value: " ++ show pv) $ putByteString pv
| 423
|
valuePut :: String -> String -> Put
valuePut s v = do
let ss = toPointer $ (genericLength s)
uLogAll ("Putting value: " ++ show ss) $ putWord64be ss
let ps = pack s
uLogAll ("Putting value: " ++ show ps) $ putByteString ps
let sv = toPointer $ (genericLength v)
uLogAll ("Putting value: " ++ show sv) $ putWord64be sv
let pv = pack v
uLogAll ("Putting value: " ++ show pv) $ putByteString pv
| 423
|
valuePut s v = do
let ss = toPointer $ (genericLength s)
uLogAll ("Putting value: " ++ show ss) $ putWord64be ss
let ps = pack s
uLogAll ("Putting value: " ++ show ps) $ putByteString ps
let sv = toPointer $ (genericLength v)
uLogAll ("Putting value: " ++ show sv) $ putWord64be sv
let pv = pack v
uLogAll ("Putting value: " ++ show pv) $ putByteString pv
| 387
| false
| true
| 0
| 12
| 107
| 178
| 80
| 98
| null | null |
coolhacks/scripts-hacks
|
examples/shellcheck-master/ShellCheck/Analytics.hs
|
mit
|
getVariableFlow shell parents t =
let (_, stack) = runState (doStackAnalysis startScope endScope t) []
in reverse stack
where
startScope t =
let scopeType = leadType shell parents t
in do
when (scopeType /= NoneScope) $ modify (StackScope scopeType:)
when (assignFirst t) $ setWritten t
endScope t =
let scopeType = leadType shell parents t
in do
setRead t
unless (assignFirst t) $ setWritten t
when (scopeType /= NoneScope) $ modify (StackScopeEnd:)
assignFirst (T_ForIn {}) = True
assignFirst (T_SelectIn {}) = True
assignFirst _ = False
setRead t =
let read = getReferencedVariables t
in mapM_ (\v -> modify (Reference v:)) read
setWritten t =
let written = getModifiedVariables t
in mapM_ (\v -> modify (Assignment v:)) written
| 900
|
getVariableFlow shell parents t =
let (_, stack) = runState (doStackAnalysis startScope endScope t) []
in reverse stack
where
startScope t =
let scopeType = leadType shell parents t
in do
when (scopeType /= NoneScope) $ modify (StackScope scopeType:)
when (assignFirst t) $ setWritten t
endScope t =
let scopeType = leadType shell parents t
in do
setRead t
unless (assignFirst t) $ setWritten t
when (scopeType /= NoneScope) $ modify (StackScopeEnd:)
assignFirst (T_ForIn {}) = True
assignFirst (T_SelectIn {}) = True
assignFirst _ = False
setRead t =
let read = getReferencedVariables t
in mapM_ (\v -> modify (Reference v:)) read
setWritten t =
let written = getModifiedVariables t
in mapM_ (\v -> modify (Assignment v:)) written
| 900
|
getVariableFlow shell parents t =
let (_, stack) = runState (doStackAnalysis startScope endScope t) []
in reverse stack
where
startScope t =
let scopeType = leadType shell parents t
in do
when (scopeType /= NoneScope) $ modify (StackScope scopeType:)
when (assignFirst t) $ setWritten t
endScope t =
let scopeType = leadType shell parents t
in do
setRead t
unless (assignFirst t) $ setWritten t
when (scopeType /= NoneScope) $ modify (StackScopeEnd:)
assignFirst (T_ForIn {}) = True
assignFirst (T_SelectIn {}) = True
assignFirst _ = False
setRead t =
let read = getReferencedVariables t
in mapM_ (\v -> modify (Reference v:)) read
setWritten t =
let written = getModifiedVariables t
in mapM_ (\v -> modify (Assignment v:)) written
| 900
| false
| false
| 4
| 12
| 286
| 347
| 156
| 191
| null | null |
karamaan/karamaan-plankton
|
Karamaan/Plankton/Date.hs
|
bsd-3-clause
|
todayLocal :: IO Day
todayLocal = (return . zonedTimeToDay) =<< getZonedTime
| 76
|
todayLocal :: IO Day
todayLocal = (return . zonedTimeToDay) =<< getZonedTime
| 76
|
todayLocal = (return . zonedTimeToDay) =<< getZonedTime
| 55
| false
| true
| 0
| 7
| 10
| 25
| 13
| 12
| null | null |
ezyang/ghc
|
compiler/typecheck/TcGenDeriv.hs
|
bsd-3-clause
|
eqResult OrdGE = true_Expr
| 31
|
eqResult OrdGE = true_Expr
| 31
|
eqResult OrdGE = true_Expr
| 31
| false
| false
| 0
| 5
| 8
| 9
| 4
| 5
| null | null |
wavewave/HROOT
|
HROOT-generate/lib/HROOT/Data/Hist/Class.hs
|
gpl-3.0
|
tH2F :: Class
tH2F = histclass "TH2F" [tH2, tArrayF] (Protected ["fill1"])
[ Constructor [cstring "name",cstring "title",int "nbinsx",double "xlow",double "xup"
,int "nbinsy", double "ylow", double "yup"] Nothing
]
| 258
|
tH2F :: Class
tH2F = histclass "TH2F" [tH2, tArrayF] (Protected ["fill1"])
[ Constructor [cstring "name",cstring "title",int "nbinsx",double "xlow",double "xup"
,int "nbinsy", double "ylow", double "yup"] Nothing
]
| 258
|
tH2F = histclass "TH2F" [tH2, tArrayF] (Protected ["fill1"])
[ Constructor [cstring "name",cstring "title",int "nbinsx",double "xlow",double "xup"
,int "nbinsy", double "ylow", double "yup"] Nothing
]
| 244
| false
| true
| 0
| 9
| 70
| 91
| 47
| 44
| null | null |
kavigupta/Infsabot
|
Infsabot/Board/Logic.hs
|
gpl-3.0
|
startingBoard :: Parameters -> (Team -> RobotProgram) -> Board
startingBoard p programOf
= setRobot (0, unNatural (paramBoardSize p) - 1) (bot B) $
setRobot (unNatural (paramBoardSize p) - 1, 0) (bot A)
Board {
boardContents = startingSpots,
boardRobots = M.fromList [],
boardSize = unNatural $ paramBoardSize p,
boardTime = 0
}
where
startingSpots :: (RAL (RAL GameSpot))
startingSpots = ys <$> fromList [0..unNatural (paramBoardSize p)]
where
ys x = initialColor <$> fromList [0..unNatural (paramBoardSize p)]
where
initialColor :: Int -> GameSpot
initialColor y =
if isPrime (x * x + y * y)
then GameSpot SpotMaterial Nothing
else GameSpot SpotEmpty Nothing
bot team = Just $ defaultRobot p team (programOf team)
-- Sets the robot at the given spot to the given value, or deletes it.
-- 1. places the robot at the gamespot at the given coordinates
-- 2. Adds the robot to the list of robots
| 1,122
|
startingBoard :: Parameters -> (Team -> RobotProgram) -> Board
startingBoard p programOf
= setRobot (0, unNatural (paramBoardSize p) - 1) (bot B) $
setRobot (unNatural (paramBoardSize p) - 1, 0) (bot A)
Board {
boardContents = startingSpots,
boardRobots = M.fromList [],
boardSize = unNatural $ paramBoardSize p,
boardTime = 0
}
where
startingSpots :: (RAL (RAL GameSpot))
startingSpots = ys <$> fromList [0..unNatural (paramBoardSize p)]
where
ys x = initialColor <$> fromList [0..unNatural (paramBoardSize p)]
where
initialColor :: Int -> GameSpot
initialColor y =
if isPrime (x * x + y * y)
then GameSpot SpotMaterial Nothing
else GameSpot SpotEmpty Nothing
bot team = Just $ defaultRobot p team (programOf team)
-- Sets the robot at the given spot to the given value, or deletes it.
-- 1. places the robot at the gamespot at the given coordinates
-- 2. Adds the robot to the list of robots
| 1,122
|
startingBoard p programOf
= setRobot (0, unNatural (paramBoardSize p) - 1) (bot B) $
setRobot (unNatural (paramBoardSize p) - 1, 0) (bot A)
Board {
boardContents = startingSpots,
boardRobots = M.fromList [],
boardSize = unNatural $ paramBoardSize p,
boardTime = 0
}
where
startingSpots :: (RAL (RAL GameSpot))
startingSpots = ys <$> fromList [0..unNatural (paramBoardSize p)]
where
ys x = initialColor <$> fromList [0..unNatural (paramBoardSize p)]
where
initialColor :: Int -> GameSpot
initialColor y =
if isPrime (x * x + y * y)
then GameSpot SpotMaterial Nothing
else GameSpot SpotEmpty Nothing
bot team = Just $ defaultRobot p team (programOf team)
-- Sets the robot at the given spot to the given value, or deletes it.
-- 1. places the robot at the gamespot at the given coordinates
-- 2. Adds the robot to the list of robots
| 1,059
| false
| true
| 0
| 16
| 376
| 296
| 153
| 143
| null | null |
GaloisInc/saw-script
|
rme/src/Data/RME/Base.hs
|
bsd-3-clause
|
depth R1 = 0
| 12
|
depth R1 = 0
| 12
|
depth R1 = 0
| 12
| false
| false
| 1
| 5
| 3
| 13
| 4
| 9
| null | null |
nomeata/ghc
|
compiler/cmm/OldCmmUtils.hs
|
bsd-3-clause
|
cheapEqExpr (CmmRegOff r n) (CmmRegOff r' n') = r==r' && n==n'
| 62
|
cheapEqExpr (CmmRegOff r n) (CmmRegOff r' n') = r==r' && n==n'
| 62
|
cheapEqExpr (CmmRegOff r n) (CmmRegOff r' n') = r==r' && n==n'
| 62
| false
| false
| 0
| 7
| 10
| 39
| 19
| 20
| null | null |
mbakke/ganeti
|
src/Ganeti/WConfd/ConfigModifications.hs
|
bsd-2-clause
|
updateDisk :: Disk -> WConfdMonad (MaybeForJSON (Int, TimeAsDoubleJSON))
updateDisk disk = do
ct <- liftIO getClockTime
let dL = csConfigDataL . configDisksL
r <- modifyConfigAndReturnWithLock (\_ -> updateConfigIfNecessary ct disk
(^. dL) (\cs -> do
dC <- toError $ replaceIn ct disk (cs ^. dL)
return ((serialOf disk + 1, ct), (dL .~ dC) cs)))
. T.releaseDRBDMinors . UTF8.fromString $ uuidOf disk
return . MaybeForJSON $ fmap (_2 %~ TimeAsDoubleJSON) r
-- * The list of functions exported to RPC.
| 528
|
updateDisk :: Disk -> WConfdMonad (MaybeForJSON (Int, TimeAsDoubleJSON))
updateDisk disk = do
ct <- liftIO getClockTime
let dL = csConfigDataL . configDisksL
r <- modifyConfigAndReturnWithLock (\_ -> updateConfigIfNecessary ct disk
(^. dL) (\cs -> do
dC <- toError $ replaceIn ct disk (cs ^. dL)
return ((serialOf disk + 1, ct), (dL .~ dC) cs)))
. T.releaseDRBDMinors . UTF8.fromString $ uuidOf disk
return . MaybeForJSON $ fmap (_2 %~ TimeAsDoubleJSON) r
-- * The list of functions exported to RPC.
| 528
|
updateDisk disk = do
ct <- liftIO getClockTime
let dL = csConfigDataL . configDisksL
r <- modifyConfigAndReturnWithLock (\_ -> updateConfigIfNecessary ct disk
(^. dL) (\cs -> do
dC <- toError $ replaceIn ct disk (cs ^. dL)
return ((serialOf disk + 1, ct), (dL .~ dC) cs)))
. T.releaseDRBDMinors . UTF8.fromString $ uuidOf disk
return . MaybeForJSON $ fmap (_2 %~ TimeAsDoubleJSON) r
-- * The list of functions exported to RPC.
| 455
| false
| true
| 0
| 23
| 108
| 198
| 99
| 99
| null | null |
tphyahoo/haskoin
|
haskoin-core/Network/Haskoin/Crypto/Mnemonic.hs
|
unlicense
|
getIndices :: [ByteString] -> Either String [Int]
getIndices ws
| null n = return $ catMaybes i
| otherwise = Left $ "getIndices: words not found: " ++ cs w
where
i = map (`M.lookup` wl') ws
n = elemIndices Nothing i
w = C.unwords $ map (ws!!) n
| 267
|
getIndices :: [ByteString] -> Either String [Int]
getIndices ws
| null n = return $ catMaybes i
| otherwise = Left $ "getIndices: words not found: " ++ cs w
where
i = map (`M.lookup` wl') ws
n = elemIndices Nothing i
w = C.unwords $ map (ws!!) n
| 267
|
getIndices ws
| null n = return $ catMaybes i
| otherwise = Left $ "getIndices: words not found: " ++ cs w
where
i = map (`M.lookup` wl') ws
n = elemIndices Nothing i
w = C.unwords $ map (ws!!) n
| 217
| false
| true
| 9
| 8
| 70
| 138
| 60
| 78
| null | null |
ndmitchell/hogle-dead
|
src/Input/Type.hs
|
bsd-3-clause
|
isIModule IModule{} = True
| 26
|
isIModule IModule{} = True
| 26
|
isIModule IModule{} = True
| 26
| false
| false
| 0
| 6
| 3
| 13
| 6
| 7
| null | null |
themoritz/cabal
|
cabal-install/tests/IntegrationTests2.hs
|
bsd-3-clause
|
testSetupScriptStyles :: ProjectConfig -> (String -> IO ()) -> Assertion
testSetupScriptStyles config reportSubCase = do
reportSubCase (show SetupCustomExplicitDeps)
plan0@(_,_,sharedConfig) <- planProject testdir1 config
let isOSX (Platform _ OSX) = True
isOSX _ = False
-- Skip the Custom tests when the shipped Cabal library is buggy
unless (isOSX (pkgConfigPlatform sharedConfig)
&& compilerVersion (pkgConfigCompiler sharedConfig) < mkVersion [7,10]) $ do
(plan1, res1) <- executePlan plan0
(pkg1, _) <- expectPackageInstalled plan1 res1 pkgidA
elabSetupScriptStyle pkg1 @?= SetupCustomExplicitDeps
hasDefaultSetupDeps pkg1 @?= Just False
marker1 <- readFile (basedir </> testdir1 </> "marker")
marker1 @?= "ok"
removeFile (basedir </> testdir1 </> "marker")
reportSubCase (show SetupCustomImplicitDeps)
(plan2, res2) <- executePlan =<< planProject testdir2 config
(pkg2, _) <- expectPackageInstalled plan2 res2 pkgidA
elabSetupScriptStyle pkg2 @?= SetupCustomImplicitDeps
hasDefaultSetupDeps pkg2 @?= Just True
marker2 <- readFile (basedir </> testdir2 </> "marker")
marker2 @?= "ok"
removeFile (basedir </> testdir2 </> "marker")
reportSubCase (show SetupNonCustomInternalLib)
(plan3, res3) <- executePlan =<< planProject testdir3 config
(pkg3, _) <- expectPackageInstalled plan3 res3 pkgidA
elabSetupScriptStyle pkg3 @?= SetupNonCustomInternalLib
{-
--TODO: the SetupNonCustomExternalLib case is hard to test since it
-- requires a version of Cabal that's later than the one we're testing
-- e.g. needs a .cabal file that specifies cabal-version: >= 2.0
-- and a corresponding Cabal package that we can use to try and build a
-- default Setup.hs.
reportSubCase (show SetupNonCustomExternalLib)
(plan4, res4) <- executePlan =<< planProject testdir4 config
(pkg4, _) <- expectPackageInstalled plan4 res4 pkgidA
pkgSetupScriptStyle pkg4 @?= SetupNonCustomExternalLib
-}
where
testdir1 = "build/setup-custom1"
testdir2 = "build/setup-custom2"
testdir3 = "build/setup-simple"
pkgidA = PackageIdentifier "a" (mkVersion [0,1])
-- The solver fills in default setup deps explicitly, but marks them as such
hasDefaultSetupDeps = fmap defaultSetupDepends
. setupBuildInfo . elabPkgDescription
-- | Test the behaviour with and without @--keep-going@
--
| 2,458
|
testSetupScriptStyles :: ProjectConfig -> (String -> IO ()) -> Assertion
testSetupScriptStyles config reportSubCase = do
reportSubCase (show SetupCustomExplicitDeps)
plan0@(_,_,sharedConfig) <- planProject testdir1 config
let isOSX (Platform _ OSX) = True
isOSX _ = False
-- Skip the Custom tests when the shipped Cabal library is buggy
unless (isOSX (pkgConfigPlatform sharedConfig)
&& compilerVersion (pkgConfigCompiler sharedConfig) < mkVersion [7,10]) $ do
(plan1, res1) <- executePlan plan0
(pkg1, _) <- expectPackageInstalled plan1 res1 pkgidA
elabSetupScriptStyle pkg1 @?= SetupCustomExplicitDeps
hasDefaultSetupDeps pkg1 @?= Just False
marker1 <- readFile (basedir </> testdir1 </> "marker")
marker1 @?= "ok"
removeFile (basedir </> testdir1 </> "marker")
reportSubCase (show SetupCustomImplicitDeps)
(plan2, res2) <- executePlan =<< planProject testdir2 config
(pkg2, _) <- expectPackageInstalled plan2 res2 pkgidA
elabSetupScriptStyle pkg2 @?= SetupCustomImplicitDeps
hasDefaultSetupDeps pkg2 @?= Just True
marker2 <- readFile (basedir </> testdir2 </> "marker")
marker2 @?= "ok"
removeFile (basedir </> testdir2 </> "marker")
reportSubCase (show SetupNonCustomInternalLib)
(plan3, res3) <- executePlan =<< planProject testdir3 config
(pkg3, _) <- expectPackageInstalled plan3 res3 pkgidA
elabSetupScriptStyle pkg3 @?= SetupNonCustomInternalLib
{-
--TODO: the SetupNonCustomExternalLib case is hard to test since it
-- requires a version of Cabal that's later than the one we're testing
-- e.g. needs a .cabal file that specifies cabal-version: >= 2.0
-- and a corresponding Cabal package that we can use to try and build a
-- default Setup.hs.
reportSubCase (show SetupNonCustomExternalLib)
(plan4, res4) <- executePlan =<< planProject testdir4 config
(pkg4, _) <- expectPackageInstalled plan4 res4 pkgidA
pkgSetupScriptStyle pkg4 @?= SetupNonCustomExternalLib
-}
where
testdir1 = "build/setup-custom1"
testdir2 = "build/setup-custom2"
testdir3 = "build/setup-simple"
pkgidA = PackageIdentifier "a" (mkVersion [0,1])
-- The solver fills in default setup deps explicitly, but marks them as such
hasDefaultSetupDeps = fmap defaultSetupDepends
. setupBuildInfo . elabPkgDescription
-- | Test the behaviour with and without @--keep-going@
--
| 2,458
|
testSetupScriptStyles config reportSubCase = do
reportSubCase (show SetupCustomExplicitDeps)
plan0@(_,_,sharedConfig) <- planProject testdir1 config
let isOSX (Platform _ OSX) = True
isOSX _ = False
-- Skip the Custom tests when the shipped Cabal library is buggy
unless (isOSX (pkgConfigPlatform sharedConfig)
&& compilerVersion (pkgConfigCompiler sharedConfig) < mkVersion [7,10]) $ do
(plan1, res1) <- executePlan plan0
(pkg1, _) <- expectPackageInstalled plan1 res1 pkgidA
elabSetupScriptStyle pkg1 @?= SetupCustomExplicitDeps
hasDefaultSetupDeps pkg1 @?= Just False
marker1 <- readFile (basedir </> testdir1 </> "marker")
marker1 @?= "ok"
removeFile (basedir </> testdir1 </> "marker")
reportSubCase (show SetupCustomImplicitDeps)
(plan2, res2) <- executePlan =<< planProject testdir2 config
(pkg2, _) <- expectPackageInstalled plan2 res2 pkgidA
elabSetupScriptStyle pkg2 @?= SetupCustomImplicitDeps
hasDefaultSetupDeps pkg2 @?= Just True
marker2 <- readFile (basedir </> testdir2 </> "marker")
marker2 @?= "ok"
removeFile (basedir </> testdir2 </> "marker")
reportSubCase (show SetupNonCustomInternalLib)
(plan3, res3) <- executePlan =<< planProject testdir3 config
(pkg3, _) <- expectPackageInstalled plan3 res3 pkgidA
elabSetupScriptStyle pkg3 @?= SetupNonCustomInternalLib
{-
--TODO: the SetupNonCustomExternalLib case is hard to test since it
-- requires a version of Cabal that's later than the one we're testing
-- e.g. needs a .cabal file that specifies cabal-version: >= 2.0
-- and a corresponding Cabal package that we can use to try and build a
-- default Setup.hs.
reportSubCase (show SetupNonCustomExternalLib)
(plan4, res4) <- executePlan =<< planProject testdir4 config
(pkg4, _) <- expectPackageInstalled plan4 res4 pkgidA
pkgSetupScriptStyle pkg4 @?= SetupNonCustomExternalLib
-}
where
testdir1 = "build/setup-custom1"
testdir2 = "build/setup-custom2"
testdir3 = "build/setup-simple"
pkgidA = PackageIdentifier "a" (mkVersion [0,1])
-- The solver fills in default setup deps explicitly, but marks them as such
hasDefaultSetupDeps = fmap defaultSetupDepends
. setupBuildInfo . elabPkgDescription
-- | Test the behaviour with and without @--keep-going@
--
| 2,385
| false
| true
| 0
| 14
| 496
| 499
| 241
| 258
| null | null |
alasconnect/auth0
|
src/Auth0/Management/Users.hs
|
apache-2.0
|
usersApi :: Proxy UsersApi
usersApi = Proxy
| 43
|
usersApi :: Proxy UsersApi
usersApi = Proxy
| 43
|
usersApi = Proxy
| 16
| false
| true
| 1
| 5
| 6
| 18
| 7
| 11
| null | null |
IreneKnapp/ozweb
|
Haskell/Schema.hs
|
mit
|
evaluate context expression@(ConstantExpression { }) _ = do
let dynamicResult = constantExpressionValue expression
case fromDynamic dynamicResult of
Nothing -> throwError $ "Expression of unexpected type."
Just result -> return result
| 246
|
evaluate context expression@(ConstantExpression { }) _ = do
let dynamicResult = constantExpressionValue expression
case fromDynamic dynamicResult of
Nothing -> throwError $ "Expression of unexpected type."
Just result -> return result
| 246
|
evaluate context expression@(ConstantExpression { }) _ = do
let dynamicResult = constantExpressionValue expression
case fromDynamic dynamicResult of
Nothing -> throwError $ "Expression of unexpected type."
Just result -> return result
| 246
| false
| false
| 2
| 11
| 41
| 72
| 31
| 41
| null | null |
gbataille/pandoc
|
src/Text/Pandoc/Writers/MediaWiki.hs
|
gpl-2.0
|
listAttribsToString :: ListAttributes -> String
listAttribsToString (startnum, numstyle, _) =
let numstyle' = camelCaseToHyphenated $ show numstyle
in (if startnum /= 1
then " start=\"" ++ show startnum ++ "\""
else "") ++
(if numstyle /= DefaultStyle
then " style=\"list-style-type: " ++ numstyle' ++ ";\""
else "")
| 367
|
listAttribsToString :: ListAttributes -> String
listAttribsToString (startnum, numstyle, _) =
let numstyle' = camelCaseToHyphenated $ show numstyle
in (if startnum /= 1
then " start=\"" ++ show startnum ++ "\""
else "") ++
(if numstyle /= DefaultStyle
then " style=\"list-style-type: " ++ numstyle' ++ ";\""
else "")
| 367
|
listAttribsToString (startnum, numstyle, _) =
let numstyle' = camelCaseToHyphenated $ show numstyle
in (if startnum /= 1
then " start=\"" ++ show startnum ++ "\""
else "") ++
(if numstyle /= DefaultStyle
then " style=\"list-style-type: " ++ numstyle' ++ ";\""
else "")
| 319
| false
| true
| 0
| 12
| 97
| 98
| 52
| 46
| null | null |
kallisti-dev/discordian-calendar
|
src/Data/Time/Calendar/Discordian.hs
|
bsd-3-clause
|
stTibsDay :: Integer -> Maybe Day
stTibsDay dYear
| isLeapYear gYear = Just (fromGregorian gYear 2 29)
| otherwise = Nothing
where
gYear = dYear - 1166
-- |Show the name of a Discordian season. Input values are clipped to valid ranges.
| 250
|
stTibsDay :: Integer -> Maybe Day
stTibsDay dYear
| isLeapYear gYear = Just (fromGregorian gYear 2 29)
| otherwise = Nothing
where
gYear = dYear - 1166
-- |Show the name of a Discordian season. Input values are clipped to valid ranges.
| 250
|
stTibsDay dYear
| isLeapYear gYear = Just (fromGregorian gYear 2 29)
| otherwise = Nothing
where
gYear = dYear - 1166
-- |Show the name of a Discordian season. Input values are clipped to valid ranges.
| 216
| false
| true
| 1
| 8
| 56
| 75
| 32
| 43
| null | null |
sleepomeno/TForth
|
src/TF/Util.hs
|
apache-2.0
|
for = flip map
| 14
|
for = flip map
| 14
|
for = flip map
| 14
| false
| false
| 1
| 5
| 3
| 12
| 4
| 8
| null | null |
xmonad/xmonad-contrib
|
XMonad/Layout/SortedLayout.hs
|
bsd-3-clause
|
-- $usage
-- You can use this module with the following in your
-- @~\/.xmonad\/xmonad.hs@:
--
-- > import XMonad.Layout.SortedLayout
--
-- Then edit your @layoutHook@ to sort another layout (in this case, 'XMonad.Layout.Grid.Grid'):
--
-- > myLayout = sorted [ClassName "Firefox", ClassName "URxvt"] Grid
-- > main = xmonad def { layoutHook = myLayout }
--
-- For more detailed instructions on editing the layoutHook see:
--
-- "XMonad.Doc.Extending#Editing_the_layout_hook"
-- | Modify a layout using a list of properties to sort its windows.
sorted :: [Property]
-> l a
-> ModifiedLayout SortedLayout l a
sorted props = ModifiedLayout . SortedLayout $ props ++ [Const True]
| 692
|
sorted :: [Property]
-> l a
-> ModifiedLayout SortedLayout l a
sorted props = ModifiedLayout . SortedLayout $ props ++ [Const True]
| 145
|
sorted props = ModifiedLayout . SortedLayout $ props ++ [Const True]
| 68
| true
| true
| 0
| 8
| 121
| 73
| 42
| 31
| null | null |
snapframework/snap-core
|
test/Snap/Core/Tests.hs
|
bsd-3-clause
|
testEvalSnap :: Test
testEvalSnap = testCase "core/evalSnap-exception" $ do
rq <- mkZomgRq
expectExceptionH (evalSnap f logerr tout rq >> return ())
where
f = do
logError "zzz"
v <- withResponse (return . rspStatus)
liftIO $ assertEqual "evalSnap rsp status" 200 v
finishWith emptyResponse
------------------------------------------------------------------------------
| 416
|
testEvalSnap :: Test
testEvalSnap = testCase "core/evalSnap-exception" $ do
rq <- mkZomgRq
expectExceptionH (evalSnap f logerr tout rq >> return ())
where
f = do
logError "zzz"
v <- withResponse (return . rspStatus)
liftIO $ assertEqual "evalSnap rsp status" 200 v
finishWith emptyResponse
------------------------------------------------------------------------------
| 416
|
testEvalSnap = testCase "core/evalSnap-exception" $ do
rq <- mkZomgRq
expectExceptionH (evalSnap f logerr tout rq >> return ())
where
f = do
logError "zzz"
v <- withResponse (return . rspStatus)
liftIO $ assertEqual "evalSnap rsp status" 200 v
finishWith emptyResponse
------------------------------------------------------------------------------
| 395
| false
| true
| 0
| 12
| 91
| 104
| 47
| 57
| null | null |
sirius94/lambdai
|
src/Reducer/Renderer.hs
|
gpl-3.0
|
alignLeft :: Int -> String -> String
alignLeft n s = s ++ replicate (n - (length s)) ' '
| 88
|
alignLeft :: Int -> String -> String
alignLeft n s = s ++ replicate (n - (length s)) ' '
| 88
|
alignLeft n s = s ++ replicate (n - (length s)) ' '
| 51
| false
| true
| 0
| 10
| 19
| 46
| 23
| 23
| null | null |
fcostantini/QuickFuzz
|
src/Lua.hs
|
gpl-3.0
|
popId :: Name -> VState Name ()
popId i = do st <- get
put $ st {vars = delete i (vars st)}
| 104
|
popId :: Name -> VState Name ()
popId i = do st <- get
put $ st {vars = delete i (vars st)}
| 104
|
popId i = do st <- get
put $ st {vars = delete i (vars st)}
| 72
| false
| true
| 0
| 13
| 35
| 63
| 29
| 34
| null | null |
WSCU/JSEuterpea
|
Euterpea Examples/Random.hs
|
gpl-3.0
|
rand1 = (marimba sixteenths) * (flute eighths)
| 46
|
rand1 = (marimba sixteenths) * (flute eighths)
| 46
|
rand1 = (marimba sixteenths) * (flute eighths)
| 46
| false
| false
| 0
| 7
| 6
| 22
| 11
| 11
| null | null |
fmapfmapfmap/amazonka
|
amazonka-kms/gen/Network/AWS/KMS/Encrypt.hs
|
mpl-2.0
|
-- | The response status code.
ersResponseStatus :: Lens' EncryptResponse Int
ersResponseStatus = lens _ersResponseStatus (\ s a -> s{_ersResponseStatus = a})
| 158
|
ersResponseStatus :: Lens' EncryptResponse Int
ersResponseStatus = lens _ersResponseStatus (\ s a -> s{_ersResponseStatus = a})
| 127
|
ersResponseStatus = lens _ersResponseStatus (\ s a -> s{_ersResponseStatus = a})
| 80
| true
| true
| 1
| 9
| 21
| 44
| 22
| 22
| null | null |
avieth/postgresql-simple
|
src/Database/PostgreSQL/Simple/FromField.hs
|
bsd-3-clause
|
typeInfoByOid :: PQ.Oid -> Conversion TypeInfo
typeInfoByOid oid = Conversion $ \conn -> do
Ok <$> (getTypeInfo conn oid)
-- | Returns the name of the column. This is often determined by a table
-- definition, but it can be set using an @as@ clause.
| 276
|
typeInfoByOid :: PQ.Oid -> Conversion TypeInfo
typeInfoByOid oid = Conversion $ \conn -> do
Ok <$> (getTypeInfo conn oid)
-- | Returns the name of the column. This is often determined by a table
-- definition, but it can be set using an @as@ clause.
| 276
|
typeInfoByOid oid = Conversion $ \conn -> do
Ok <$> (getTypeInfo conn oid)
-- | Returns the name of the column. This is often determined by a table
-- definition, but it can be set using an @as@ clause.
| 229
| false
| true
| 0
| 11
| 71
| 49
| 25
| 24
| null | null |
alexander-at-github/eta
|
compiler/ETA/CodeGen/ArgRep.hs
|
bsd-3-clause
|
slowCallPattern (F: _) = ("ap_f", 1, [jfloat])
| 61
|
slowCallPattern (F: _) = ("ap_f", 1, [jfloat])
| 61
|
slowCallPattern (F: _) = ("ap_f", 1, [jfloat])
| 61
| false
| false
| 0
| 7
| 21
| 28
| 16
| 12
| null | null |
edom/sound
|
src/Sound/InfList.hs
|
bsd-3-clause
|
-- * Continuation-based transformation
{- $
The functions in this section follow this pattern:
@
lcfff n ... x0 x1 ... c ~ 'take' n (fff x0 x1 ...) '++' c ('drop' n x0) ('drop' n x1) ...
@
The first argument, which can be a number or a predicate,
determines the length of the prefix that is being manipulated.
The last argument is the continuation.
-}
-- ** Mapping
{- |
@
lcmap n f x c ~ 'take' n ('map' f x) '++' c ('drop' n x)
@
-}
lcmap :: Int -> (a -> b) -> L a -> (L a -> L b) -> L b
lcmap n_ f_ x_ c_ =
loop n_ x_
where
loop n (MkL h t) | n > 0 = MkL (f_ h) (loop (n - 1) t)
loop _ x = c_ x
{- |
@
lcid n x c = 'lcmap' n 'id' x c
lcid n x c ~ 'take' n x '++' c ('drop' n x)
@
-}
| 718
|
lcmap :: Int -> (a -> b) -> L a -> (L a -> L b) -> L b
lcmap n_ f_ x_ c_ =
loop n_ x_
where
loop n (MkL h t) | n > 0 = MkL (f_ h) (loop (n - 1) t)
loop _ x = c_ x
{- |
@
lcid n x c = 'lcmap' n 'id' x c
lcid n x c ~ 'take' n x '++' c ('drop' n x)
@
-}
| 275
|
lcmap n_ f_ x_ c_ =
loop n_ x_
where
loop n (MkL h t) | n > 0 = MkL (f_ h) (loop (n - 1) t)
loop _ x = c_ x
{- |
@
lcid n x c = 'lcmap' n 'id' x c
lcid n x c ~ 'take' n x '++' c ('drop' n x)
@
-}
| 220
| true
| true
| 1
| 12
| 204
| 150
| 71
| 79
| null | null |
ribag/ganeti-experiments
|
src/Ganeti/Query/Node.hs
|
gpl-2.0
|
-- | The node fields map.
fieldsMap :: FieldMap Node Runtime
fieldsMap = fieldListToFieldMap nodeFields
| 103
|
fieldsMap :: FieldMap Node Runtime
fieldsMap = fieldListToFieldMap nodeFields
| 77
|
fieldsMap = fieldListToFieldMap nodeFields
| 42
| true
| true
| 0
| 5
| 14
| 20
| 10
| 10
| null | null |
tittoassini/flat
|
test/Core.hs
|
bsd-3-clause
|
sz32 = getSize E32_13
| 21
|
sz32 = getSize E32_13
| 21
|
sz32 = getSize E32_13
| 21
| false
| false
| 1
| 5
| 3
| 13
| 4
| 9
| null | null |
jasonrbriggs/proton
|
haskell/testsuite/TestXml.hs
|
apache-2.0
|
xmlTests = [TestLabel "Basic Parse Test" basicParseTest,
TestLabel "Contains Attribute Test1" containsAttributeTest1,
TestLabel "Copy Elements Test" copyElementsTest,
TestLabel "Copy Element Test" copyElementTest,
TestLabel "Find Attribute Test1" findAttributeTest1,
TestLabel "Find Attribute Test2" findAttributeTest2]
| 429
|
xmlTests = [TestLabel "Basic Parse Test" basicParseTest,
TestLabel "Contains Attribute Test1" containsAttributeTest1,
TestLabel "Copy Elements Test" copyElementsTest,
TestLabel "Copy Element Test" copyElementTest,
TestLabel "Find Attribute Test1" findAttributeTest1,
TestLabel "Find Attribute Test2" findAttributeTest2]
| 429
|
xmlTests = [TestLabel "Basic Parse Test" basicParseTest,
TestLabel "Contains Attribute Test1" containsAttributeTest1,
TestLabel "Copy Elements Test" copyElementsTest,
TestLabel "Copy Element Test" copyElementTest,
TestLabel "Find Attribute Test1" findAttributeTest1,
TestLabel "Find Attribute Test2" findAttributeTest2]
| 429
| false
| false
| 0
| 6
| 141
| 54
| 27
| 27
| null | null |
yuvallanger/threepenny-gui
|
samples/Paths.hs
|
bsd-3-clause
|
getStaticDir :: IO FilePath
getStaticDir = (</> "wwwroot") `liftM` Paths_threepenny_gui.getDataDir
| 98
|
getStaticDir :: IO FilePath
getStaticDir = (</> "wwwroot") `liftM` Paths_threepenny_gui.getDataDir
| 98
|
getStaticDir = (</> "wwwroot") `liftM` Paths_threepenny_gui.getDataDir
| 70
| false
| true
| 0
| 6
| 9
| 26
| 15
| 11
| null | null |
worksap-ate/aws-sdk
|
Cloud/AWS/RDS/OptionGroup.hs
|
bsd-3-clause
|
optionGroupOptionSink
:: (MonadThrow m, Applicative m)
=> XmlElement -> m OptionGroupOption
optionGroupOptionSink xml = OptionGroupOption
<$> xml .< "MajorEngineVersion"
<*> xml .< "Persistent"
<*> xml .< "PortRequired"
<*> elements' "OptionsDependedOn" "OptionName" content xml
<*> xml .< "Description"
<*> xml .< "DefaultPort"
<*> xml .< "Name"
<*> elements "OptionGroupOptionSetting" optionGroupOptionSettingSink xml
<*> xml .< "EngineName"
<*> xml .< "MinimumRequiredMinorEngineVersion"
| 538
|
optionGroupOptionSink
:: (MonadThrow m, Applicative m)
=> XmlElement -> m OptionGroupOption
optionGroupOptionSink xml = OptionGroupOption
<$> xml .< "MajorEngineVersion"
<*> xml .< "Persistent"
<*> xml .< "PortRequired"
<*> elements' "OptionsDependedOn" "OptionName" content xml
<*> xml .< "Description"
<*> xml .< "DefaultPort"
<*> xml .< "Name"
<*> elements "OptionGroupOptionSetting" optionGroupOptionSettingSink xml
<*> xml .< "EngineName"
<*> xml .< "MinimumRequiredMinorEngineVersion"
| 538
|
optionGroupOptionSink xml = OptionGroupOption
<$> xml .< "MajorEngineVersion"
<*> xml .< "Persistent"
<*> xml .< "PortRequired"
<*> elements' "OptionsDependedOn" "OptionName" content xml
<*> xml .< "Description"
<*> xml .< "DefaultPort"
<*> xml .< "Name"
<*> elements "OptionGroupOptionSetting" optionGroupOptionSettingSink xml
<*> xml .< "EngineName"
<*> xml .< "MinimumRequiredMinorEngineVersion"
| 438
| false
| true
| 45
| 8
| 105
| 175
| 88
| 87
| null | null |
mishun/tangles
|
src/Math/Topology/KnotTh/Algebra/Homology.hs
|
lgpl-3.0
|
smithNormalForm :: (Integral a, Eq g) => V.Vector g -> V.Vector g -> Matrix.Matrix a -> (V.Vector (g, a), V.Vector g)
smithNormalForm colGrading rowGrading matrix = ST.runST $ do
let rows = Matrix.nrows matrix
cols = Matrix.ncols matrix
idx i j = i * cols + j
when (V.length colGrading /= cols) $ error "bad colGrading length"
when (V.length rowGrading /= rows) $ error "bad rowGrading length"
rg <- V.thaw rowGrading
cg <- V.thaw colGrading
v <- V.thaw $ Matrix.getMatrixAsVector matrix
let get row col = do
x <- MV.read v (idx row col)
when (x /= 0) $ do
g <- MV.read rg row
g' <- MV.read cg col
when (g /= g') $ error "non-zero element between different gradings"
return x
negateRow row =
forM_ [0 .. cols - 1] $ \ !k ->
MV.modify v negate (idx row k)
transformRows !a00 !a01 !a10 !a11 !row0 !row1 = do
do
g0 <- MV.read rg row0
g1 <- MV.read rg row1
when (g0 /= g1) $ error "different row gradings"
forM_ [0 .. cols - 1] $ \ !k -> do
x0 <- MV.read v (idx row0 k)
x1 <- MV.read v (idx row1 k)
MV.write v (idx row0 k) $! a00 * x0 + a01 * x1
MV.write v (idx row1 k) $! a10 * x0 + a11 * x1
transformCols !a00 !a01 !a10 !a11 !col0 !col1 = do
do
g0 <- MV.read cg col0
g1 <- MV.read cg col1
when (g0 /= g1) $ error "different col gradings"
forM_ [0 .. rows - 1] $ \ !k -> do
x0 <- MV.read v (idx k col0)
x1 <- MV.read v (idx k col1)
MV.write v (idx k col0) $! a00 * x0 + a01 * x1
MV.write v (idx k col1) $! a10 * x0 + a11 * x1
swapRows rowA rowB =
when (rowA /= rowB) $ do
MV.swap rg rowA rowB
forM_ [0 .. cols - 1] $ \ k ->
MV.swap v (idx rowA k) (idx rowB k)
swapCols colA colB =
when (colA /= colB) $ do
MV.swap cg colA colB
forM_ [0 .. rows - 1] $ \ k ->
MV.swap v (idx k colA) (idx k colB)
findPivot !t !row !col | col >= cols = return False
| row >= rows = findPivot t t (col + 1)
| otherwise = do
pivot <- get row col
if pivot == 0
then findPivot t (row + 1) col
else do
swapRows t row
swapCols t col
when (pivot < 0) $ negateRow t
return True
eliminate !t = do
ok <- findPivot t t t
if ok
then do
get t t >>= clearCorner t
eliminate $ t + 1
else liftM2 (,) (V.generateM t $ \ i -> liftM2 (,) (MV.read rg i) (get i i))
(V.generateM (cols - t) $ \ i -> MV.read cg (t + i))
clearCorner !t !pivot = do
pivot' <- clearRow t (t + 1) pivot >>= clearCol t (t + 1)
when (pivot' /= pivot) $
clearCorner t pivot'
clearRow !t !i !pivot =
if i >= rows
then return pivot
else do
x <- get i t
case divMod x pivot of
(quotient, 0) -> do
when (quotient /= 0) $
transformRows 1 0 (-quotient) 1 t i
clearRow t (i + 1) pivot
_ -> do
let (g, sigma, tau) = extendedGCD pivot x
transformRows sigma tau (-x `div` g) (pivot `div` g) t i
clearRow t (i + 1) g
clearCol !t !i !pivot =
if i >= cols
then return pivot
else do
x <- get t i
case divMod x pivot of
(quotient, 0) -> do
when (quotient /= 0) $
transformCols 1 0 (-quotient) 1 t i
clearCol t (i + 1) pivot
_ -> do
let (g, sigma, tau) = extendedGCD pivot x
transformCols sigma tau (-x `div` g) (pivot `div` g) t i
clearCol t (i + 1) g
eliminate 0
| 4,641
|
smithNormalForm :: (Integral a, Eq g) => V.Vector g -> V.Vector g -> Matrix.Matrix a -> (V.Vector (g, a), V.Vector g)
smithNormalForm colGrading rowGrading matrix = ST.runST $ do
let rows = Matrix.nrows matrix
cols = Matrix.ncols matrix
idx i j = i * cols + j
when (V.length colGrading /= cols) $ error "bad colGrading length"
when (V.length rowGrading /= rows) $ error "bad rowGrading length"
rg <- V.thaw rowGrading
cg <- V.thaw colGrading
v <- V.thaw $ Matrix.getMatrixAsVector matrix
let get row col = do
x <- MV.read v (idx row col)
when (x /= 0) $ do
g <- MV.read rg row
g' <- MV.read cg col
when (g /= g') $ error "non-zero element between different gradings"
return x
negateRow row =
forM_ [0 .. cols - 1] $ \ !k ->
MV.modify v negate (idx row k)
transformRows !a00 !a01 !a10 !a11 !row0 !row1 = do
do
g0 <- MV.read rg row0
g1 <- MV.read rg row1
when (g0 /= g1) $ error "different row gradings"
forM_ [0 .. cols - 1] $ \ !k -> do
x0 <- MV.read v (idx row0 k)
x1 <- MV.read v (idx row1 k)
MV.write v (idx row0 k) $! a00 * x0 + a01 * x1
MV.write v (idx row1 k) $! a10 * x0 + a11 * x1
transformCols !a00 !a01 !a10 !a11 !col0 !col1 = do
do
g0 <- MV.read cg col0
g1 <- MV.read cg col1
when (g0 /= g1) $ error "different col gradings"
forM_ [0 .. rows - 1] $ \ !k -> do
x0 <- MV.read v (idx k col0)
x1 <- MV.read v (idx k col1)
MV.write v (idx k col0) $! a00 * x0 + a01 * x1
MV.write v (idx k col1) $! a10 * x0 + a11 * x1
swapRows rowA rowB =
when (rowA /= rowB) $ do
MV.swap rg rowA rowB
forM_ [0 .. cols - 1] $ \ k ->
MV.swap v (idx rowA k) (idx rowB k)
swapCols colA colB =
when (colA /= colB) $ do
MV.swap cg colA colB
forM_ [0 .. rows - 1] $ \ k ->
MV.swap v (idx k colA) (idx k colB)
findPivot !t !row !col | col >= cols = return False
| row >= rows = findPivot t t (col + 1)
| otherwise = do
pivot <- get row col
if pivot == 0
then findPivot t (row + 1) col
else do
swapRows t row
swapCols t col
when (pivot < 0) $ negateRow t
return True
eliminate !t = do
ok <- findPivot t t t
if ok
then do
get t t >>= clearCorner t
eliminate $ t + 1
else liftM2 (,) (V.generateM t $ \ i -> liftM2 (,) (MV.read rg i) (get i i))
(V.generateM (cols - t) $ \ i -> MV.read cg (t + i))
clearCorner !t !pivot = do
pivot' <- clearRow t (t + 1) pivot >>= clearCol t (t + 1)
when (pivot' /= pivot) $
clearCorner t pivot'
clearRow !t !i !pivot =
if i >= rows
then return pivot
else do
x <- get i t
case divMod x pivot of
(quotient, 0) -> do
when (quotient /= 0) $
transformRows 1 0 (-quotient) 1 t i
clearRow t (i + 1) pivot
_ -> do
let (g, sigma, tau) = extendedGCD pivot x
transformRows sigma tau (-x `div` g) (pivot `div` g) t i
clearRow t (i + 1) g
clearCol !t !i !pivot =
if i >= cols
then return pivot
else do
x <- get t i
case divMod x pivot of
(quotient, 0) -> do
when (quotient /= 0) $
transformCols 1 0 (-quotient) 1 t i
clearCol t (i + 1) pivot
_ -> do
let (g, sigma, tau) = extendedGCD pivot x
transformCols sigma tau (-x `div` g) (pivot `div` g) t i
clearCol t (i + 1) g
eliminate 0
| 4,641
|
smithNormalForm colGrading rowGrading matrix = ST.runST $ do
let rows = Matrix.nrows matrix
cols = Matrix.ncols matrix
idx i j = i * cols + j
when (V.length colGrading /= cols) $ error "bad colGrading length"
when (V.length rowGrading /= rows) $ error "bad rowGrading length"
rg <- V.thaw rowGrading
cg <- V.thaw colGrading
v <- V.thaw $ Matrix.getMatrixAsVector matrix
let get row col = do
x <- MV.read v (idx row col)
when (x /= 0) $ do
g <- MV.read rg row
g' <- MV.read cg col
when (g /= g') $ error "non-zero element between different gradings"
return x
negateRow row =
forM_ [0 .. cols - 1] $ \ !k ->
MV.modify v negate (idx row k)
transformRows !a00 !a01 !a10 !a11 !row0 !row1 = do
do
g0 <- MV.read rg row0
g1 <- MV.read rg row1
when (g0 /= g1) $ error "different row gradings"
forM_ [0 .. cols - 1] $ \ !k -> do
x0 <- MV.read v (idx row0 k)
x1 <- MV.read v (idx row1 k)
MV.write v (idx row0 k) $! a00 * x0 + a01 * x1
MV.write v (idx row1 k) $! a10 * x0 + a11 * x1
transformCols !a00 !a01 !a10 !a11 !col0 !col1 = do
do
g0 <- MV.read cg col0
g1 <- MV.read cg col1
when (g0 /= g1) $ error "different col gradings"
forM_ [0 .. rows - 1] $ \ !k -> do
x0 <- MV.read v (idx k col0)
x1 <- MV.read v (idx k col1)
MV.write v (idx k col0) $! a00 * x0 + a01 * x1
MV.write v (idx k col1) $! a10 * x0 + a11 * x1
swapRows rowA rowB =
when (rowA /= rowB) $ do
MV.swap rg rowA rowB
forM_ [0 .. cols - 1] $ \ k ->
MV.swap v (idx rowA k) (idx rowB k)
swapCols colA colB =
when (colA /= colB) $ do
MV.swap cg colA colB
forM_ [0 .. rows - 1] $ \ k ->
MV.swap v (idx k colA) (idx k colB)
findPivot !t !row !col | col >= cols = return False
| row >= rows = findPivot t t (col + 1)
| otherwise = do
pivot <- get row col
if pivot == 0
then findPivot t (row + 1) col
else do
swapRows t row
swapCols t col
when (pivot < 0) $ negateRow t
return True
eliminate !t = do
ok <- findPivot t t t
if ok
then do
get t t >>= clearCorner t
eliminate $ t + 1
else liftM2 (,) (V.generateM t $ \ i -> liftM2 (,) (MV.read rg i) (get i i))
(V.generateM (cols - t) $ \ i -> MV.read cg (t + i))
clearCorner !t !pivot = do
pivot' <- clearRow t (t + 1) pivot >>= clearCol t (t + 1)
when (pivot' /= pivot) $
clearCorner t pivot'
clearRow !t !i !pivot =
if i >= rows
then return pivot
else do
x <- get i t
case divMod x pivot of
(quotient, 0) -> do
when (quotient /= 0) $
transformRows 1 0 (-quotient) 1 t i
clearRow t (i + 1) pivot
_ -> do
let (g, sigma, tau) = extendedGCD pivot x
transformRows sigma tau (-x `div` g) (pivot `div` g) t i
clearRow t (i + 1) g
clearCol !t !i !pivot =
if i >= cols
then return pivot
else do
x <- get t i
case divMod x pivot of
(quotient, 0) -> do
when (quotient /= 0) $
transformCols 1 0 (-quotient) 1 t i
clearCol t (i + 1) pivot
_ -> do
let (g, sigma, tau) = extendedGCD pivot x
transformCols sigma tau (-x `div` g) (pivot `div` g) t i
clearCol t (i + 1) g
eliminate 0
| 4,523
| false
| true
| 3
| 28
| 2,318
| 1,771
| 832
| 939
| null | null |
ekmett/wxHaskell
|
wxcore/src/haskell/Graphics/UI/WXCore/Types.hs
|
lgpl-2.1
|
-- | Return the height. (see also 'sizeH').
sizeHeight :: (Num a) => Size2D a -> a
sizeHeight (Size w h)
= h
| 110
|
sizeHeight :: (Num a) => Size2D a -> a
sizeHeight (Size w h)
= h
| 66
|
sizeHeight (Size w h)
= h
| 27
| true
| true
| 0
| 7
| 24
| 39
| 20
| 19
| null | null |
fffej/HS-Poker
|
LookupPatternMatch.hs
|
bsd-3-clause
|
getValueFromProduct 1103414 = 3635
| 34
|
getValueFromProduct 1103414 = 3635
| 34
|
getValueFromProduct 1103414 = 3635
| 34
| false
| false
| 0
| 5
| 3
| 9
| 4
| 5
| null | null |
onponomarev/ganeti
|
test/hs/Test/Ganeti/OpCodes.hs
|
bsd-2-clause
|
-- | Generates list of disk indices.
genDiskIndices :: Gen [DiskIndex]
genDiskIndices = do
cnt <- choose (0, C.maxDisks)
genUniquesList cnt arbitrary
-- | Generates a list of node names.
| 191
|
genDiskIndices :: Gen [DiskIndex]
genDiskIndices = do
cnt <- choose (0, C.maxDisks)
genUniquesList cnt arbitrary
-- | Generates a list of node names.
| 154
|
genDiskIndices = do
cnt <- choose (0, C.maxDisks)
genUniquesList cnt arbitrary
-- | Generates a list of node names.
| 120
| true
| true
| 0
| 10
| 34
| 45
| 23
| 22
| null | null |
andorp/hs-bluesnap
|
test/Bluesnap/Test/Parser.hs
|
gpl-3.0
|
testParamDecryptionRspParser = testXMLParser Response.elementParam_decryption
| 77
|
testParamDecryptionRspParser = testXMLParser Response.elementParam_decryption
| 77
|
testParamDecryptionRspParser = testXMLParser Response.elementParam_decryption
| 77
| false
| false
| 0
| 6
| 3
| 11
| 5
| 6
| null | null |
GaloisInc/haskell-tor
|
src/Tor/DataFormat/TorCell.hs
|
bsd-3-clause
|
putDestroyReason ORConnectionClosed = putWord8 8
| 56
|
putDestroyReason ORConnectionClosed = putWord8 8
| 56
|
putDestroyReason ORConnectionClosed = putWord8 8
| 56
| false
| false
| 0
| 5
| 12
| 13
| 5
| 8
| null | null |
garetxe/cabal
|
cabal-install/tests/UnitTests/Distribution/Client/Sandbox/Timestamp.hs
|
bsd-3-clause
|
timestampRecord_v2 :: String
timestampRecord_v2 =
"2\n" ++
"[(\"i386-linux-ghc-8.0.0.20160204\",[(\"/foo/bar/Baz\",1455350946)])" ++
",(\"i386-linux-ghc-7.10.3\",[(\"/foo/bar/Baz\",1455484719)])]"
| 202
|
timestampRecord_v2 :: String
timestampRecord_v2 =
"2\n" ++
"[(\"i386-linux-ghc-8.0.0.20160204\",[(\"/foo/bar/Baz\",1455350946)])" ++
",(\"i386-linux-ghc-7.10.3\",[(\"/foo/bar/Baz\",1455484719)])]"
| 202
|
timestampRecord_v2 =
"2\n" ++
"[(\"i386-linux-ghc-8.0.0.20160204\",[(\"/foo/bar/Baz\",1455350946)])" ++
",(\"i386-linux-ghc-7.10.3\",[(\"/foo/bar/Baz\",1455484719)])]"
| 173
| false
| true
| 0
| 6
| 15
| 19
| 10
| 9
| null | null |
jameshsmith/HRL
|
Server/Abyss/Spell.hs
|
mit
|
fizzleEffect :: Effect
fizzleEffect = Effect Nothing (Ana (\s -> lift (message s) >> mzero) "*Fizzle*")
| 103
|
fizzleEffect :: Effect
fizzleEffect = Effect Nothing (Ana (\s -> lift (message s) >> mzero) "*Fizzle*")
| 103
|
fizzleEffect = Effect Nothing (Ana (\s -> lift (message s) >> mzero) "*Fizzle*")
| 80
| false
| true
| 0
| 13
| 15
| 51
| 24
| 27
| null | null |
beloglazov/haskell-course
|
hw1.hs
|
apache-2.0
|
doubleEveryOtherRev (x:y:rest) = x : (y * 2) : doubleEveryOtherRev rest
| 71
|
doubleEveryOtherRev (x:y:rest) = x : (y * 2) : doubleEveryOtherRev rest
| 71
|
doubleEveryOtherRev (x:y:rest) = x : (y * 2) : doubleEveryOtherRev rest
| 71
| false
| false
| 0
| 8
| 10
| 38
| 19
| 19
| null | null |
ocean0yohsuke/Scheme
|
src/Scheme/Evaluator/Eval.hs
|
bsd-3-clause
|
eagerApply (CLOS (CELL params seq msp) mlenv) args = localMSP msp $ do
lenv <- newLEnv mlenv
params <- bind lenv params args
case params of
NIL -> localMLEnv (Just lenv) $ seqM eval seq
_ -> (*:) $ RETURN $ CLOS (CELL params seq msp) (Just lenv)
| 271
|
eagerApply (CLOS (CELL params seq msp) mlenv) args = localMSP msp $ do
lenv <- newLEnv mlenv
params <- bind lenv params args
case params of
NIL -> localMLEnv (Just lenv) $ seqM eval seq
_ -> (*:) $ RETURN $ CLOS (CELL params seq msp) (Just lenv)
| 271
|
eagerApply (CLOS (CELL params seq msp) mlenv) args = localMSP msp $ do
lenv <- newLEnv mlenv
params <- bind lenv params args
case params of
NIL -> localMLEnv (Just lenv) $ seqM eval seq
_ -> (*:) $ RETURN $ CLOS (CELL params seq msp) (Just lenv)
| 271
| false
| false
| 0
| 14
| 73
| 128
| 60
| 68
| null | null |
NCrashed/servant-auth-token
|
servant-auth-token-leveldb/src/Servant/Server/Auth/Token/LevelDB/Schema.hs
|
bsd-3-clause
|
storeModel :: MonadResource m => LevelDBEnv -> Model -> m ()
storeModel db = store db modelId
| 93
|
storeModel :: MonadResource m => LevelDBEnv -> Model -> m ()
storeModel db = store db modelId
| 93
|
storeModel db = store db modelId
| 32
| false
| true
| 0
| 9
| 16
| 39
| 18
| 21
| null | null |
emmanueldenloye/manifoldRNC
|
src/Utils.hs
|
bsd-3-clause
|
errorMsg1 :: String
errorMsg1 = "You did not enter two positive integers.\n"
| 76
|
errorMsg1 :: String
errorMsg1 = "You did not enter two positive integers.\n"
| 76
|
errorMsg1 = "You did not enter two positive integers.\n"
| 56
| false
| true
| 0
| 4
| 11
| 11
| 6
| 5
| null | null |
Persi/shellcheck
|
ShellCheck/Parser.hs
|
gpl-3.0
|
prop_readDollarBraced3 = isOk readDollarBraced "${foo%%$(echo cow\\})}"
| 71
|
prop_readDollarBraced3 = isOk readDollarBraced "${foo%%$(echo cow\\})}"
| 71
|
prop_readDollarBraced3 = isOk readDollarBraced "${foo%%$(echo cow\\})}"
| 71
| false
| false
| 0
| 5
| 5
| 11
| 5
| 6
| null | null |
cirquit/hjc
|
src/TypeCheck/TypeCheck.hs
|
mit
|
checkReturnType rtype = do
let id = showJC rtype
exists <- classExists id
when (not exists) $ appendError typeNotDefinedError
where
typeNotDefinedError = do
let id = showJC rtype
return $ printf "Undefined type \"%s\" in the return type" id
| 274
|
checkReturnType rtype = do
let id = showJC rtype
exists <- classExists id
when (not exists) $ appendError typeNotDefinedError
where
typeNotDefinedError = do
let id = showJC rtype
return $ printf "Undefined type \"%s\" in the return type" id
| 274
|
checkReturnType rtype = do
let id = showJC rtype
exists <- classExists id
when (not exists) $ appendError typeNotDefinedError
where
typeNotDefinedError = do
let id = showJC rtype
return $ printf "Undefined type \"%s\" in the return type" id
| 274
| false
| false
| 0
| 10
| 72
| 82
| 35
| 47
| null | null |
TomMD/ghc
|
compiler/prelude/PrelNames.hs
|
bsd-3-clause
|
geIntegerPrimIdKey = mkPreludeMiscIdUnique 77
| 56
|
geIntegerPrimIdKey = mkPreludeMiscIdUnique 77
| 56
|
geIntegerPrimIdKey = mkPreludeMiscIdUnique 77
| 56
| false
| false
| 0
| 5
| 14
| 9
| 4
| 5
| null | null |
TOSPIO/yi
|
src/library/Yi/Rectangle.hs
|
gpl-2.0
|
killRectangle :: EditorM ()
killRectangle = do
cutted <- withCurrentBuffer $ do
(reg, l, r) <- getRectangle
text <- readRegionB reg
let (cutted, rest) = unzip $ fmap cut $ R.lines' text
cut :: R.YiString -> (R.YiString, R.YiString)
cut line = let [left,mid,right] = multiSplit [l,r] line
in (mid, left <> right)
replaceRegionB reg (R.unlines rest)
return cutted
setRegE (R.unlines cutted)
| 464
|
killRectangle :: EditorM ()
killRectangle = do
cutted <- withCurrentBuffer $ do
(reg, l, r) <- getRectangle
text <- readRegionB reg
let (cutted, rest) = unzip $ fmap cut $ R.lines' text
cut :: R.YiString -> (R.YiString, R.YiString)
cut line = let [left,mid,right] = multiSplit [l,r] line
in (mid, left <> right)
replaceRegionB reg (R.unlines rest)
return cutted
setRegE (R.unlines cutted)
| 464
|
killRectangle = do
cutted <- withCurrentBuffer $ do
(reg, l, r) <- getRectangle
text <- readRegionB reg
let (cutted, rest) = unzip $ fmap cut $ R.lines' text
cut :: R.YiString -> (R.YiString, R.YiString)
cut line = let [left,mid,right] = multiSplit [l,r] line
in (mid, left <> right)
replaceRegionB reg (R.unlines rest)
return cutted
setRegE (R.unlines cutted)
| 436
| false
| true
| 0
| 19
| 136
| 192
| 95
| 97
| null | null |
jwiegley/ghc-release
|
utils/haddock/test/Haddock/ParserSpec.hs
|
gpl-3.0
|
spec :: Spec
spec = before initStaticOpts $ do
describe "parseString" $ do
let infix 1 `shouldParseTo`
shouldParseTo :: String -> Doc RdrName -> Expectation
shouldParseTo input ast = parseString input `shouldBe` ast
it "is total" $ do
property $ \xs ->
(length . show . parseString) xs `shouldSatisfy` (> 0)
context "when parsing text" $ do
it "can handle unicode" $ do
"灼眼のシャナ" `shouldParseTo` "灼眼のシャナ"
it "accepts numeric character references" $ do
"foo bar baz λ" `shouldParseTo` "foo bar baz λ"
it "accepts hexadecimal character references" $ do
"e" `shouldParseTo` "e"
it "allows to backslash-escape characters" $ do
property $ \x -> ['\\', x] `shouldParseTo` DocString [x]
context "when parsing strings contaning numeric character references" $ do
it "will implicitly convert digits to characters" $ do
"AAAA" `shouldParseTo` "AAAA"
"灼眼のシャナ"
`shouldParseTo` "灼眼のシャナ"
it "will implicitly convert hex encoded characters" $ do
"eeee" `shouldParseTo` "eeee"
context "when parsing identifiers" $ do
it "parses identifiers enclosed within single ticks" $ do
"'foo'" `shouldParseTo` DocIdentifier "foo"
it "parses identifiers enclosed within backticks" $ do
"`foo`" `shouldParseTo` DocIdentifier "foo"
it "parses a word with an one of the delimiters in it as DocString" $ do
"don't" `shouldParseTo` "don't"
it "doesn't pass pairs of delimiters with spaces between them" $ do
"hel'lo w'orld" `shouldParseTo` "hel'lo w'orld"
it "don't use apostrophe's in the wrong place's" $ do
" don't use apostrophe's in the wrong place's" `shouldParseTo`
"don't use apostrophe's in the wrong place's"
context "when parsing URLs" $ do
let hyperlink :: String -> Maybe String -> Doc RdrName
hyperlink url = DocHyperlink . Hyperlink url
it "parses a URL" $ do
"<http://example.com/>" `shouldParseTo` hyperlink "http://example.com/" Nothing
it "accepts an optional label" $ do
"<http://example.com/ some link>" `shouldParseTo` hyperlink "http://example.com/" "some link"
it "does not accept newlines in label" $ do
"<foo bar\nbaz>" `shouldParseTo` "<foo bar\nbaz>"
-- new behaviour test, this will be now consistent with other markup
it "allows us to escape > inside the URL" $ do
"<http://examp\\>le.com>" `shouldParseTo`
hyperlink "http://examp>le.com" Nothing
"<http://exa\\>mp\\>le.com>" `shouldParseTo`
hyperlink "http://exa>mp>le.com" Nothing
-- Likewise in label
"<http://example.com f\\>oo>" `shouldParseTo`
hyperlink "http://example.com" "f>oo"
it "parses inline URLs" $ do
"foo <http://example.com/> bar" `shouldParseTo`
"foo " <> hyperlink "http://example.com/" Nothing <> " bar"
it "doesn't allow for multi-line link tags" $ do
"<ba\nz aar>" `shouldParseTo` "<ba\nz aar>"
context "when autolinking URLs" $ do
it "autolinks HTTP URLs" $ do
"http://example.com/" `shouldParseTo` hyperlink "http://example.com/" Nothing
it "autolinks HTTPS URLs" $ do
"https://www.example.com/" `shouldParseTo` hyperlink "https://www.example.com/" Nothing
it "autolinks FTP URLs" $ do
"ftp://example.com/" `shouldParseTo` hyperlink "ftp://example.com/" Nothing
it "does not include a trailing comma" $ do
"http://example.com/, Some other sentence." `shouldParseTo`
hyperlink "http://example.com/" Nothing <> ", Some other sentence."
it "does not include a trailing dot" $ do
"http://example.com/. Some other sentence." `shouldParseTo`
hyperlink "http://example.com/" Nothing <> ". Some other sentence."
it "does not include a trailing exclamation mark" $ do
"http://example.com/! Some other sentence." `shouldParseTo`
hyperlink "http://example.com/" Nothing <> "! Some other sentence."
it "does not include a trailing question mark" $ do
"http://example.com/? Some other sentence." `shouldParseTo`
hyperlink "http://example.com/" Nothing <> "? Some other sentence."
context "when parsing pictures" $ do
let picture :: String -> Maybe String -> Doc RdrName
picture uri = DocPic . Picture uri
it "parses a simple picture" $ do
"<<baz>>" `shouldParseTo` picture "baz" Nothing
it "parses a picture with a title" $ do
"<<b a z>>" `shouldParseTo` picture "b" (Just "a z")
it "parses a picture with unicode" $ do
"<<灼眼のシャナ>>" `shouldParseTo` picture "灼眼のシャナ" Nothing
it "allows for escaping of the closing tags" $ do
"<<ba\\>>z>>" `shouldParseTo` picture "ba>>z" Nothing
it "doesn't allow for multi-line picture tags" $ do
"<<ba\nz aar>>" `shouldParseTo` "<<ba\nz aar>>"
context "when parsing anchors" $ do
it "parses a single word anchor" $ do
"#foo#" `shouldParseTo` DocAName "foo"
it "parses a multi word anchor" $ do
"#foo bar#" `shouldParseTo` DocAName "foo bar"
it "parses a unicode anchor" $ do
"#灼眼のシャナ#" `shouldParseTo` DocAName "灼眼のシャナ"
it "does not accept newlines in anchors" $ do
"#foo\nbar#" `shouldParseTo` "#foo\nbar#"
it "accepts anchors mid-paragraph" $ do
"Hello #someAnchor# world!"
`shouldParseTo` "Hello " <> DocAName "someAnchor" <> " world!"
it "does not accept empty anchors" $ do
"##" `shouldParseTo` "##"
context "when parsing emphasised text" $ do
it "emphasises a word on its own" $ do
"/foo/" `shouldParseTo` DocEmphasis "foo"
it "emphasises inline correctly" $ do
"foo /bar/ baz" `shouldParseTo` "foo " <> DocEmphasis "bar" <> " baz"
it "emphasises unicode" $ do
"/灼眼のシャナ/" `shouldParseTo` DocEmphasis "灼眼のシャナ"
it "does not emphasise multi-line strings" $ do
" /foo\nbar/" `shouldParseTo` "/foo\nbar/"
it "does not emphasise the empty string" $ do
"//" `shouldParseTo` "//"
it "parses escaped slashes literally" $ do
"/foo\\/bar/" `shouldParseTo` DocEmphasis "foo/bar"
it "recognizes other markup constructs within emphasised text" $ do
"/foo @bar@ baz/" `shouldParseTo`
DocEmphasis ("foo " <> DocMonospaced "bar" <> " baz")
it "allows other markup inside of emphasis" $ do
"/__inner bold__/" `shouldParseTo` DocEmphasis (DocBold "inner bold")
it "doesn't mangle inner markup unicode" $ do
"/__灼眼のシャナ A__/" `shouldParseTo` DocEmphasis (DocBold "灼眼のシャナ A")
it "properly converts HTML escape sequences" $ do
"/AAAA/" `shouldParseTo` DocEmphasis "AAAA"
it "allows to escape the emphasis delimiter inside of emphasis" $ do
"/empha\\/sis/" `shouldParseTo` DocEmphasis "empha/sis"
context "when parsing monospaced text" $ do
it "parses simple monospaced text" $ do
"@foo@" `shouldParseTo` DocMonospaced "foo"
it "parses inline monospaced text" $ do
"foo @bar@ baz" `shouldParseTo` "foo " <> DocMonospaced "bar" <> " baz"
it "allows to escape @" $ do
"@foo \\@ bar@" `shouldParseTo` DocMonospaced "foo @ bar"
it "accepts unicode" $ do
"@foo 灼眼のシャナ bar@" `shouldParseTo` DocMonospaced "foo 灼眼のシャナ bar"
it "accepts other markup in monospaced text" $ do
"@/foo/@" `shouldParseTo` DocMonospaced (DocEmphasis "foo")
it "requires the closing @" $ do
"@foo /bar/ baz" `shouldParseTo` "@foo " <> DocEmphasis "bar" <> " baz"
context "when parsing bold strings" $ do
it "allows for a bold string on its own" $ do
"__bold string__" `shouldParseTo`
DocBold "bold string"
it "bolds inline correctly" $ do
"hello __everyone__ there" `shouldParseTo`
"hello "
<> DocBold "everyone" <> " there"
it "bolds unicode" $ do
"__灼眼のシャナ__" `shouldParseTo`
DocBold "灼眼のシャナ"
it "does not do __multi-line\\n bold__" $ do
" __multi-line\n bold__" `shouldParseTo` "__multi-line\n bold__"
it "allows other markup inside of bold" $ do
"__/inner emphasis/__" `shouldParseTo`
(DocBold $ DocEmphasis "inner emphasis")
it "doesn't mangle inner markup unicode" $ do
"__/灼眼のシャナ A/__" `shouldParseTo`
(DocBold $ DocEmphasis "灼眼のシャナ A")
it "properly converts HTML escape sequences" $ do
"__AAAA__" `shouldParseTo`
DocBold "AAAA"
it "allows to escape the bold delimiter inside of bold" $ do
"__bo\\__ld__" `shouldParseTo`
DocBold "bo__ld"
it "doesn't allow for empty bold" $ do
"____" `shouldParseTo` "____"
context "when parsing module strings" $ do
it "should parse a module on its own" $ do
"\"Module\"" `shouldParseTo`
DocModule "Module"
it "should parse a module inline" $ do
"This is a \"Module\"." `shouldParseTo`
"This is a " <> DocModule "Module" <> "."
it "can accept a simple module name" $ do
"\"Hello\"" `shouldParseTo` DocModule "Hello"
it "can accept a module name with dots" $ do
"\"Hello.World\"" `shouldParseTo` DocModule "Hello.World"
it "can accept a module name with unicode" $ do
"\"Hello.Worldλ\"" `shouldParseTo` DocModule "Hello.Worldλ"
it "parses a module name with a trailing dot as regular quoted string" $ do
"\"Hello.\"" `shouldParseTo` "\"Hello.\""
it "parses a module name with a space as regular quoted string" $ do
"\"Hello World\"" `shouldParseTo` "\"Hello World\""
it "parses a module name with invalid characters as regular quoted string" $ do
"\"Hello&[{}(=*)+]!\"" `shouldParseTo` "\"Hello&[{}(=*)+]!\""
it "accepts a module name with unicode" $ do
"\"Foo.Barλ\"" `shouldParseTo` DocModule "Foo.Barλ"
it "treats empty module name as regular double quotes" $ do
"\"\"" `shouldParseTo` "\"\""
it "accepts anchor reference syntax as DocModule" $ do
"\"Foo#bar\"" `shouldParseTo` DocModule "Foo#bar"
it "accepts old anchor reference syntax as DocModule" $ do
"\"Foo\\#bar\"" `shouldParseTo` DocModule "Foo\\#bar"
describe "parseParas" $ do
let infix 1 `shouldParseTo`
shouldParseTo :: String -> Doc RdrName -> Expectation
shouldParseTo input ast = parseParas input `shouldBe` ast
it "is total" $ do
property $ \xs ->
(length . show . parseParas) xs `shouldSatisfy` (> 0)
context "when parsing text paragraphs" $ do
let filterSpecial = filter (`notElem` (".(=#-[*`\v\f\n\t\r\\\"'_/@<> " :: String))
it "parses an empty paragraph" $ do
"" `shouldParseTo` DocEmpty
it "parses a simple text paragraph" $ do
"foo bar baz" `shouldParseTo` DocParagraph "foo bar baz"
it "accepts markup in text paragraphs" $ do
"foo /bar/ baz" `shouldParseTo` DocParagraph ("foo " <> DocEmphasis "bar" <> " baz")
it "preserve all regular characters" $ do
property $ \xs -> let input = filterSpecial xs in (not . null) input ==>
input `shouldParseTo` DocParagraph (DocString input)
it "separates paragraphs by empty lines" $ do
unlines [
"foo"
, " \t "
, "bar"
] `shouldParseTo` DocParagraph "foo" <> DocParagraph "bar"
context "when a pragraph only contains monospaced text" $ do
it "turns it into a code block" $ do
"@foo@" `shouldParseTo` DocCodeBlock "foo"
context "when parsing birdtracks" $ do
it "parses them as a code block" $ do
unlines [
">foo"
, ">bar"
, ">baz"
] `shouldParseTo` DocCodeBlock "foo\nbar\nbaz"
it "ignores leading whitespace" $ do
unlines [
" >foo"
, " \t >bar"
, " >baz"
]
`shouldParseTo` DocCodeBlock "foo\nbar\nbaz"
it "strips one leading space from each line of the block" $ do
unlines [
"> foo"
, "> bar"
, "> baz"
] `shouldParseTo` DocCodeBlock "foo\n bar\nbaz"
it "ignores empty lines when stripping spaces" $ do
unlines [
"> foo"
, ">"
, "> bar"
] `shouldParseTo` DocCodeBlock "foo\n\nbar"
context "when any non-empty line does not start with a space" $ do
it "does not strip any spaces" $ do
unlines [
">foo"
, "> bar"
] `shouldParseTo` DocCodeBlock "foo\n bar"
it "ignores nested markup" $ do
unlines [
">/foo/"
] `shouldParseTo` DocCodeBlock "/foo/"
it "treats them as regular text inside text paragraphs" $ do
unlines [
"foo"
, ">bar"
] `shouldParseTo` DocParagraph "foo\n>bar"
context "when parsing code blocks" $ do
it "accepts a simple code block" $ do
unlines [
"@"
, "foo"
, "bar"
, "baz"
, "@"
] `shouldParseTo` DocCodeBlock "foo\nbar\nbaz\n"
it "ignores trailing whitespace after the opening @" $ do
unlines [
"@ "
, "foo"
, "@"
] `shouldParseTo` DocCodeBlock "foo\n"
it "rejects code blocks that are not closed" $ do
unlines [
"@"
, "foo"
] `shouldParseTo` DocParagraph "@\nfoo"
it "accepts nested markup" $ do
unlines [
"@"
, "/foo/"
, "@"
] `shouldParseTo` DocCodeBlock (DocEmphasis "foo" <> "\n")
it "allows to escape the @" $ do
unlines [
"@"
, "foo"
, "\\@"
, "bar"
, "@"
] `shouldParseTo` DocCodeBlock "foo\n@\nbar\n"
it "accepts horizontal space before the @" $ do
unlines [ " @"
, "foo"
, ""
, "bar"
, "@"
] `shouldParseTo` DocCodeBlock "foo\n\nbar\n"
it "strips a leading space from a @ block if present" $ do
unlines [ " @"
, " hello"
, " world"
, " @"
] `shouldParseTo` DocCodeBlock "hello\nworld\n"
unlines [ " @"
, " hello"
, ""
, " world"
, " @"
] `shouldParseTo` DocCodeBlock "hello\n\nworld\n"
it "only drops whitespace if there's some before closing @" $ do
unlines [ "@"
, " Formatting"
, " matters."
, "@"
]
`shouldParseTo` DocCodeBlock " Formatting\n matters.\n"
it "accepts unicode" $ do
"@foo 灼眼のシャナ bar@" `shouldParseTo` DocCodeBlock "foo 灼眼のシャナ bar"
it "requires the closing @" $ do
"@foo /bar/ baz"
`shouldParseTo` DocParagraph ("@foo " <> DocEmphasis "bar" <> " baz")
context "when parsing examples" $ do
it "parses a simple example" $ do
">>> foo" `shouldParseTo` DocExamples [Example "foo" []]
it "parses an example with result" $ do
unlines [
">>> foo"
, "bar"
, "baz"
] `shouldParseTo` DocExamples [Example "foo" ["bar", "baz"]]
it "parses consecutive examples" $ do
unlines [
">>> fib 5"
, "5"
, ">>> fib 10"
, "55"
] `shouldParseTo` DocExamples [
Example "fib 5" ["5"]
, Example "fib 10" ["55"]
]
it ("requires an example to be separated"
++ " from a previous paragraph by an empty line") $ do
"foobar\n\n>>> fib 10\n55" `shouldParseTo`
DocParagraph "foobar"
<> DocExamples [Example "fib 10" ["55"]]
it "parses bird-tracks inside of paragraphs as plain strings" $ do
let xs = "foo\n>>> bar"
xs `shouldParseTo` DocParagraph (DocString xs)
it "skips empty lines in front of an example" $ do
"\n \n\n>>> foo" `shouldParseTo` DocExamples [Example "foo" []]
it "terminates example on empty line" $ do
unlines [
">>> foo"
, "bar"
, " "
, "baz"
]
`shouldParseTo`
DocExamples [Example "foo" ["bar"]] <> DocParagraph "baz"
it "parses a <BLANKLINE> result as an empty result" $ do
unlines [
">>> foo"
, "bar"
, "<BLANKLINE>"
, "baz"
]
`shouldParseTo` DocExamples [Example "foo" ["bar", "", "baz"]]
it "accepts unicode in examples" $ do
">>> 灼眼\nシャナ" `shouldParseTo` DocExamples [Example "灼眼" ["シャナ"]]
context "when prompt is prefixed by whitespace" $ do
it "strips the exact same amount of whitespace from result lines" $ do
unlines [
" >>> foo"
, " bar"
, " baz"
] `shouldParseTo` DocExamples [Example "foo" ["bar", "baz"]]
it "preserves additional whitespace" $ do
unlines [
" >>> foo"
, " bar"
] `shouldParseTo` DocExamples [Example "foo" [" bar"]]
it "keeps original if stripping is not possible" $ do
unlines [
" >>> foo"
, " bar"
] `shouldParseTo` DocExamples [Example "foo" [" bar"]]
context "when parsing paragraphs nested in lists" $ do
it "can nest the same type of list" $ do
"* foo\n\n * bar" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocUnorderedList [DocParagraph "bar"]]
it "can nest another type of list inside" $ do
"* foo\n\n 1. bar" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocOrderedList [DocParagraph "bar"]]
it "can nest a code block inside" $ do
"* foo\n\n @foo bar baz@" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocCodeBlock "foo bar baz"]
"* foo\n\n @\n foo bar baz\n @" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocCodeBlock "foo bar baz\n"]
it "can nest more than one level" $ do
"* foo\n\n * bar\n\n * baz\n qux" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocUnorderedList [ DocParagraph $ "bar"
<> DocUnorderedList [DocParagraph "baz\nqux"]
]
]
it "won't fail on not fully indented paragraph" $ do
"* foo\n\n * bar\n\n * qux\nquux" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocUnorderedList [ DocParagraph "bar" ]
, DocParagraph "qux\nquux"]
it "can nest definition lists" $ do
"[a] foo\n\n [b] bar\n\n [c] baz\n qux" `shouldParseTo`
DocDefList [ ("a", "foo"
<> DocDefList [ ("b", "bar"
<> DocDefList [("c", "baz\nqux")])
])
]
it "can come back to top level with a different list" $ do
"* foo\n\n * bar\n\n1. baz" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocUnorderedList [ DocParagraph "bar" ]
]
<> DocOrderedList [ DocParagraph "baz" ]
it "definition lists can come back to top level with a different list" $ do
"[foo] foov\n\n [bar] barv\n\n1. baz" `shouldParseTo`
DocDefList [ ("foo", "foov"
<> DocDefList [ ("bar", "barv") ])
]
<> DocOrderedList [ DocParagraph "baz" ]
context "when parsing properties" $ do
it "can parse a single property" $ do
"prop> 23 == 23" `shouldParseTo` DocProperty "23 == 23"
it "can parse multiple subsequent properties" $ do
unlines [
"prop> 23 == 23"
, "prop> 42 == 42"
]
`shouldParseTo`
DocProperty "23 == 23" <> DocProperty "42 == 42"
it "accepts unicode in properties" $ do
"prop> 灼眼のシャナ ≡ 愛" `shouldParseTo`
DocProperty "灼眼のシャナ ≡ 愛"
it "can deal with whitespace before and after the prop> prompt" $ do
" prop> xs == (reverse $ reverse xs) " `shouldParseTo`
DocProperty "xs == (reverse $ reverse xs)"
context "when parsing unordered lists" $ do
it "parses a simple list" $ do
unlines [
" * one"
, " * two"
, " * three"
]
`shouldParseTo` DocUnorderedList [
DocParagraph "one"
, DocParagraph "two"
, DocParagraph "three"
]
it "ignores empty lines between list items" $ do
unlines [
"* one"
, ""
, "* two"
]
`shouldParseTo` DocUnorderedList [
DocParagraph "one"
, DocParagraph "two"
]
it "accepts an empty list item" $ do
"*" `shouldParseTo` DocUnorderedList [DocParagraph DocEmpty]
it "accepts multi-line list items" $ do
unlines [
"* point one"
, " more one"
, "* point two"
, "more two"
]
`shouldParseTo` DocUnorderedList [
DocParagraph "point one\n more one"
, DocParagraph "point two\nmore two"
]
it "accepts markup in list items" $ do
"* /foo/" `shouldParseTo` DocUnorderedList [DocParagraph (DocEmphasis "foo")]
it "requires empty lines between list and other paragraphs" $ do
unlines [
"foo"
, ""
, "* bar"
, ""
, "baz"
]
`shouldParseTo` DocParagraph "foo" <> DocUnorderedList [DocParagraph "bar"] <> DocParagraph "baz"
context "when parsing ordered lists" $ do
it "parses a simple list" $ do
unlines [
" 1. one"
, " (1) two"
, " 3. three"
]
`shouldParseTo` DocOrderedList [
DocParagraph "one"
, DocParagraph "two"
, DocParagraph "three"
]
it "ignores empty lines between list items" $ do
unlines [
"1. one"
, ""
, "2. two"
]
`shouldParseTo` DocOrderedList [
DocParagraph "one"
, DocParagraph "two"
]
it "accepts an empty list item" $ do
"1." `shouldParseTo` DocOrderedList [DocParagraph DocEmpty]
it "accepts multi-line list items" $ do
unlines [
"1. point one"
, " more one"
, "1. point two"
, "more two"
]
`shouldParseTo` DocOrderedList [
DocParagraph "point one\n more one"
, DocParagraph "point two\nmore two"
]
it "accepts markup in list items" $ do
"1. /foo/" `shouldParseTo` DocOrderedList [DocParagraph (DocEmphasis "foo")]
it "requires empty lines between list and other paragraphs" $ do
unlines [
"foo"
, ""
, "1. bar"
, ""
, "baz"
]
`shouldParseTo` DocParagraph "foo" <> DocOrderedList [DocParagraph "bar"] <> DocParagraph "baz"
context "when parsing definition lists" $ do
it "parses a simple list" $ do
unlines [
" [foo] one"
, " [bar] two"
, " [baz] three"
]
`shouldParseTo` DocDefList [
("foo", "one")
, ("bar", "two")
, ("baz", "three")
]
it "ignores empty lines between list items" $ do
unlines [
"[foo] one"
, ""
, "[bar] two"
]
`shouldParseTo` DocDefList [
("foo", "one")
, ("bar", "two")
]
it "accepts an empty list item" $ do
"[foo]" `shouldParseTo` DocDefList [("foo", DocEmpty)]
it "accepts multi-line list items" $ do
unlines [
"[foo] point one"
, " more one"
, "[bar] point two"
, "more two"
]
`shouldParseTo` DocDefList [
("foo", "point one\n more one")
, ("bar", "point two\nmore two")
]
it "accepts markup in list items" $ do
"[foo] /foo/" `shouldParseTo` DocDefList [("foo", DocEmphasis "foo")]
it "accepts markup for the label" $ do
"[/foo/] bar" `shouldParseTo` DocDefList [(DocEmphasis "foo", "bar")]
it "requires empty lines between list and other paragraphs" $ do
unlines [
"foo"
, ""
, "[foo] bar"
, ""
, "baz"
]
`shouldParseTo` DocParagraph "foo" <> DocDefList [("foo", "bar")] <> DocParagraph "baz"
context "when parsing consecutive paragraphs" $ do
it "will not capture irrelevant consecutive lists" $ do
unlines [ " * bullet"
, ""
, ""
, " - different bullet"
, ""
, ""
, " (1) ordered"
, " "
, " 2. different bullet"
, " "
, " [cat] kitten"
, " "
, " [pineapple] fruit"
] `shouldParseTo`
DocUnorderedList [ DocParagraph "bullet"
, DocParagraph "different bullet"]
<> DocOrderedList [ DocParagraph "ordered"
, DocParagraph "different bullet"
]
<> DocDefList [ ("cat", "kitten")
, ("pineapple", "fruit")
]
context "when parsing function documentation headers" $ do
it "can parse a simple header" $ do
"= Header 1\nHello." `shouldParseTo`
DocParagraph (DocHeader (Header 1 "Header 1"))
<> DocParagraph "Hello."
it "allow consecutive headers" $ do
"= Header 1\n== Header 2" `shouldParseTo`
DocParagraph (DocHeader (Header 1 "Header 1"))
<> DocParagraph (DocHeader (Header 2 "Header 2"))
it "accepts markup in the header" $ do
"= /Header/ __1__\nFoo" `shouldParseTo`
DocParagraph (DocHeader
(Header 1 (DocEmphasis "Header" <> " " <> DocBold "1")))
<> DocParagraph "Foo"
| 27,355
|
spec :: Spec
spec = before initStaticOpts $ do
describe "parseString" $ do
let infix 1 `shouldParseTo`
shouldParseTo :: String -> Doc RdrName -> Expectation
shouldParseTo input ast = parseString input `shouldBe` ast
it "is total" $ do
property $ \xs ->
(length . show . parseString) xs `shouldSatisfy` (> 0)
context "when parsing text" $ do
it "can handle unicode" $ do
"灼眼のシャナ" `shouldParseTo` "灼眼のシャナ"
it "accepts numeric character references" $ do
"foo bar baz λ" `shouldParseTo` "foo bar baz λ"
it "accepts hexadecimal character references" $ do
"e" `shouldParseTo` "e"
it "allows to backslash-escape characters" $ do
property $ \x -> ['\\', x] `shouldParseTo` DocString [x]
context "when parsing strings contaning numeric character references" $ do
it "will implicitly convert digits to characters" $ do
"AAAA" `shouldParseTo` "AAAA"
"灼眼のシャナ"
`shouldParseTo` "灼眼のシャナ"
it "will implicitly convert hex encoded characters" $ do
"eeee" `shouldParseTo` "eeee"
context "when parsing identifiers" $ do
it "parses identifiers enclosed within single ticks" $ do
"'foo'" `shouldParseTo` DocIdentifier "foo"
it "parses identifiers enclosed within backticks" $ do
"`foo`" `shouldParseTo` DocIdentifier "foo"
it "parses a word with an one of the delimiters in it as DocString" $ do
"don't" `shouldParseTo` "don't"
it "doesn't pass pairs of delimiters with spaces between them" $ do
"hel'lo w'orld" `shouldParseTo` "hel'lo w'orld"
it "don't use apostrophe's in the wrong place's" $ do
" don't use apostrophe's in the wrong place's" `shouldParseTo`
"don't use apostrophe's in the wrong place's"
context "when parsing URLs" $ do
let hyperlink :: String -> Maybe String -> Doc RdrName
hyperlink url = DocHyperlink . Hyperlink url
it "parses a URL" $ do
"<http://example.com/>" `shouldParseTo` hyperlink "http://example.com/" Nothing
it "accepts an optional label" $ do
"<http://example.com/ some link>" `shouldParseTo` hyperlink "http://example.com/" "some link"
it "does not accept newlines in label" $ do
"<foo bar\nbaz>" `shouldParseTo` "<foo bar\nbaz>"
-- new behaviour test, this will be now consistent with other markup
it "allows us to escape > inside the URL" $ do
"<http://examp\\>le.com>" `shouldParseTo`
hyperlink "http://examp>le.com" Nothing
"<http://exa\\>mp\\>le.com>" `shouldParseTo`
hyperlink "http://exa>mp>le.com" Nothing
-- Likewise in label
"<http://example.com f\\>oo>" `shouldParseTo`
hyperlink "http://example.com" "f>oo"
it "parses inline URLs" $ do
"foo <http://example.com/> bar" `shouldParseTo`
"foo " <> hyperlink "http://example.com/" Nothing <> " bar"
it "doesn't allow for multi-line link tags" $ do
"<ba\nz aar>" `shouldParseTo` "<ba\nz aar>"
context "when autolinking URLs" $ do
it "autolinks HTTP URLs" $ do
"http://example.com/" `shouldParseTo` hyperlink "http://example.com/" Nothing
it "autolinks HTTPS URLs" $ do
"https://www.example.com/" `shouldParseTo` hyperlink "https://www.example.com/" Nothing
it "autolinks FTP URLs" $ do
"ftp://example.com/" `shouldParseTo` hyperlink "ftp://example.com/" Nothing
it "does not include a trailing comma" $ do
"http://example.com/, Some other sentence." `shouldParseTo`
hyperlink "http://example.com/" Nothing <> ", Some other sentence."
it "does not include a trailing dot" $ do
"http://example.com/. Some other sentence." `shouldParseTo`
hyperlink "http://example.com/" Nothing <> ". Some other sentence."
it "does not include a trailing exclamation mark" $ do
"http://example.com/! Some other sentence." `shouldParseTo`
hyperlink "http://example.com/" Nothing <> "! Some other sentence."
it "does not include a trailing question mark" $ do
"http://example.com/? Some other sentence." `shouldParseTo`
hyperlink "http://example.com/" Nothing <> "? Some other sentence."
context "when parsing pictures" $ do
let picture :: String -> Maybe String -> Doc RdrName
picture uri = DocPic . Picture uri
it "parses a simple picture" $ do
"<<baz>>" `shouldParseTo` picture "baz" Nothing
it "parses a picture with a title" $ do
"<<b a z>>" `shouldParseTo` picture "b" (Just "a z")
it "parses a picture with unicode" $ do
"<<灼眼のシャナ>>" `shouldParseTo` picture "灼眼のシャナ" Nothing
it "allows for escaping of the closing tags" $ do
"<<ba\\>>z>>" `shouldParseTo` picture "ba>>z" Nothing
it "doesn't allow for multi-line picture tags" $ do
"<<ba\nz aar>>" `shouldParseTo` "<<ba\nz aar>>"
context "when parsing anchors" $ do
it "parses a single word anchor" $ do
"#foo#" `shouldParseTo` DocAName "foo"
it "parses a multi word anchor" $ do
"#foo bar#" `shouldParseTo` DocAName "foo bar"
it "parses a unicode anchor" $ do
"#灼眼のシャナ#" `shouldParseTo` DocAName "灼眼のシャナ"
it "does not accept newlines in anchors" $ do
"#foo\nbar#" `shouldParseTo` "#foo\nbar#"
it "accepts anchors mid-paragraph" $ do
"Hello #someAnchor# world!"
`shouldParseTo` "Hello " <> DocAName "someAnchor" <> " world!"
it "does not accept empty anchors" $ do
"##" `shouldParseTo` "##"
context "when parsing emphasised text" $ do
it "emphasises a word on its own" $ do
"/foo/" `shouldParseTo` DocEmphasis "foo"
it "emphasises inline correctly" $ do
"foo /bar/ baz" `shouldParseTo` "foo " <> DocEmphasis "bar" <> " baz"
it "emphasises unicode" $ do
"/灼眼のシャナ/" `shouldParseTo` DocEmphasis "灼眼のシャナ"
it "does not emphasise multi-line strings" $ do
" /foo\nbar/" `shouldParseTo` "/foo\nbar/"
it "does not emphasise the empty string" $ do
"//" `shouldParseTo` "//"
it "parses escaped slashes literally" $ do
"/foo\\/bar/" `shouldParseTo` DocEmphasis "foo/bar"
it "recognizes other markup constructs within emphasised text" $ do
"/foo @bar@ baz/" `shouldParseTo`
DocEmphasis ("foo " <> DocMonospaced "bar" <> " baz")
it "allows other markup inside of emphasis" $ do
"/__inner bold__/" `shouldParseTo` DocEmphasis (DocBold "inner bold")
it "doesn't mangle inner markup unicode" $ do
"/__灼眼のシャナ A__/" `shouldParseTo` DocEmphasis (DocBold "灼眼のシャナ A")
it "properly converts HTML escape sequences" $ do
"/AAAA/" `shouldParseTo` DocEmphasis "AAAA"
it "allows to escape the emphasis delimiter inside of emphasis" $ do
"/empha\\/sis/" `shouldParseTo` DocEmphasis "empha/sis"
context "when parsing monospaced text" $ do
it "parses simple monospaced text" $ do
"@foo@" `shouldParseTo` DocMonospaced "foo"
it "parses inline monospaced text" $ do
"foo @bar@ baz" `shouldParseTo` "foo " <> DocMonospaced "bar" <> " baz"
it "allows to escape @" $ do
"@foo \\@ bar@" `shouldParseTo` DocMonospaced "foo @ bar"
it "accepts unicode" $ do
"@foo 灼眼のシャナ bar@" `shouldParseTo` DocMonospaced "foo 灼眼のシャナ bar"
it "accepts other markup in monospaced text" $ do
"@/foo/@" `shouldParseTo` DocMonospaced (DocEmphasis "foo")
it "requires the closing @" $ do
"@foo /bar/ baz" `shouldParseTo` "@foo " <> DocEmphasis "bar" <> " baz"
context "when parsing bold strings" $ do
it "allows for a bold string on its own" $ do
"__bold string__" `shouldParseTo`
DocBold "bold string"
it "bolds inline correctly" $ do
"hello __everyone__ there" `shouldParseTo`
"hello "
<> DocBold "everyone" <> " there"
it "bolds unicode" $ do
"__灼眼のシャナ__" `shouldParseTo`
DocBold "灼眼のシャナ"
it "does not do __multi-line\\n bold__" $ do
" __multi-line\n bold__" `shouldParseTo` "__multi-line\n bold__"
it "allows other markup inside of bold" $ do
"__/inner emphasis/__" `shouldParseTo`
(DocBold $ DocEmphasis "inner emphasis")
it "doesn't mangle inner markup unicode" $ do
"__/灼眼のシャナ A/__" `shouldParseTo`
(DocBold $ DocEmphasis "灼眼のシャナ A")
it "properly converts HTML escape sequences" $ do
"__AAAA__" `shouldParseTo`
DocBold "AAAA"
it "allows to escape the bold delimiter inside of bold" $ do
"__bo\\__ld__" `shouldParseTo`
DocBold "bo__ld"
it "doesn't allow for empty bold" $ do
"____" `shouldParseTo` "____"
context "when parsing module strings" $ do
it "should parse a module on its own" $ do
"\"Module\"" `shouldParseTo`
DocModule "Module"
it "should parse a module inline" $ do
"This is a \"Module\"." `shouldParseTo`
"This is a " <> DocModule "Module" <> "."
it "can accept a simple module name" $ do
"\"Hello\"" `shouldParseTo` DocModule "Hello"
it "can accept a module name with dots" $ do
"\"Hello.World\"" `shouldParseTo` DocModule "Hello.World"
it "can accept a module name with unicode" $ do
"\"Hello.Worldλ\"" `shouldParseTo` DocModule "Hello.Worldλ"
it "parses a module name with a trailing dot as regular quoted string" $ do
"\"Hello.\"" `shouldParseTo` "\"Hello.\""
it "parses a module name with a space as regular quoted string" $ do
"\"Hello World\"" `shouldParseTo` "\"Hello World\""
it "parses a module name with invalid characters as regular quoted string" $ do
"\"Hello&[{}(=*)+]!\"" `shouldParseTo` "\"Hello&[{}(=*)+]!\""
it "accepts a module name with unicode" $ do
"\"Foo.Barλ\"" `shouldParseTo` DocModule "Foo.Barλ"
it "treats empty module name as regular double quotes" $ do
"\"\"" `shouldParseTo` "\"\""
it "accepts anchor reference syntax as DocModule" $ do
"\"Foo#bar\"" `shouldParseTo` DocModule "Foo#bar"
it "accepts old anchor reference syntax as DocModule" $ do
"\"Foo\\#bar\"" `shouldParseTo` DocModule "Foo\\#bar"
describe "parseParas" $ do
let infix 1 `shouldParseTo`
shouldParseTo :: String -> Doc RdrName -> Expectation
shouldParseTo input ast = parseParas input `shouldBe` ast
it "is total" $ do
property $ \xs ->
(length . show . parseParas) xs `shouldSatisfy` (> 0)
context "when parsing text paragraphs" $ do
let filterSpecial = filter (`notElem` (".(=#-[*`\v\f\n\t\r\\\"'_/@<> " :: String))
it "parses an empty paragraph" $ do
"" `shouldParseTo` DocEmpty
it "parses a simple text paragraph" $ do
"foo bar baz" `shouldParseTo` DocParagraph "foo bar baz"
it "accepts markup in text paragraphs" $ do
"foo /bar/ baz" `shouldParseTo` DocParagraph ("foo " <> DocEmphasis "bar" <> " baz")
it "preserve all regular characters" $ do
property $ \xs -> let input = filterSpecial xs in (not . null) input ==>
input `shouldParseTo` DocParagraph (DocString input)
it "separates paragraphs by empty lines" $ do
unlines [
"foo"
, " \t "
, "bar"
] `shouldParseTo` DocParagraph "foo" <> DocParagraph "bar"
context "when a pragraph only contains monospaced text" $ do
it "turns it into a code block" $ do
"@foo@" `shouldParseTo` DocCodeBlock "foo"
context "when parsing birdtracks" $ do
it "parses them as a code block" $ do
unlines [
">foo"
, ">bar"
, ">baz"
] `shouldParseTo` DocCodeBlock "foo\nbar\nbaz"
it "ignores leading whitespace" $ do
unlines [
" >foo"
, " \t >bar"
, " >baz"
]
`shouldParseTo` DocCodeBlock "foo\nbar\nbaz"
it "strips one leading space from each line of the block" $ do
unlines [
"> foo"
, "> bar"
, "> baz"
] `shouldParseTo` DocCodeBlock "foo\n bar\nbaz"
it "ignores empty lines when stripping spaces" $ do
unlines [
"> foo"
, ">"
, "> bar"
] `shouldParseTo` DocCodeBlock "foo\n\nbar"
context "when any non-empty line does not start with a space" $ do
it "does not strip any spaces" $ do
unlines [
">foo"
, "> bar"
] `shouldParseTo` DocCodeBlock "foo\n bar"
it "ignores nested markup" $ do
unlines [
">/foo/"
] `shouldParseTo` DocCodeBlock "/foo/"
it "treats them as regular text inside text paragraphs" $ do
unlines [
"foo"
, ">bar"
] `shouldParseTo` DocParagraph "foo\n>bar"
context "when parsing code blocks" $ do
it "accepts a simple code block" $ do
unlines [
"@"
, "foo"
, "bar"
, "baz"
, "@"
] `shouldParseTo` DocCodeBlock "foo\nbar\nbaz\n"
it "ignores trailing whitespace after the opening @" $ do
unlines [
"@ "
, "foo"
, "@"
] `shouldParseTo` DocCodeBlock "foo\n"
it "rejects code blocks that are not closed" $ do
unlines [
"@"
, "foo"
] `shouldParseTo` DocParagraph "@\nfoo"
it "accepts nested markup" $ do
unlines [
"@"
, "/foo/"
, "@"
] `shouldParseTo` DocCodeBlock (DocEmphasis "foo" <> "\n")
it "allows to escape the @" $ do
unlines [
"@"
, "foo"
, "\\@"
, "bar"
, "@"
] `shouldParseTo` DocCodeBlock "foo\n@\nbar\n"
it "accepts horizontal space before the @" $ do
unlines [ " @"
, "foo"
, ""
, "bar"
, "@"
] `shouldParseTo` DocCodeBlock "foo\n\nbar\n"
it "strips a leading space from a @ block if present" $ do
unlines [ " @"
, " hello"
, " world"
, " @"
] `shouldParseTo` DocCodeBlock "hello\nworld\n"
unlines [ " @"
, " hello"
, ""
, " world"
, " @"
] `shouldParseTo` DocCodeBlock "hello\n\nworld\n"
it "only drops whitespace if there's some before closing @" $ do
unlines [ "@"
, " Formatting"
, " matters."
, "@"
]
`shouldParseTo` DocCodeBlock " Formatting\n matters.\n"
it "accepts unicode" $ do
"@foo 灼眼のシャナ bar@" `shouldParseTo` DocCodeBlock "foo 灼眼のシャナ bar"
it "requires the closing @" $ do
"@foo /bar/ baz"
`shouldParseTo` DocParagraph ("@foo " <> DocEmphasis "bar" <> " baz")
context "when parsing examples" $ do
it "parses a simple example" $ do
">>> foo" `shouldParseTo` DocExamples [Example "foo" []]
it "parses an example with result" $ do
unlines [
">>> foo"
, "bar"
, "baz"
] `shouldParseTo` DocExamples [Example "foo" ["bar", "baz"]]
it "parses consecutive examples" $ do
unlines [
">>> fib 5"
, "5"
, ">>> fib 10"
, "55"
] `shouldParseTo` DocExamples [
Example "fib 5" ["5"]
, Example "fib 10" ["55"]
]
it ("requires an example to be separated"
++ " from a previous paragraph by an empty line") $ do
"foobar\n\n>>> fib 10\n55" `shouldParseTo`
DocParagraph "foobar"
<> DocExamples [Example "fib 10" ["55"]]
it "parses bird-tracks inside of paragraphs as plain strings" $ do
let xs = "foo\n>>> bar"
xs `shouldParseTo` DocParagraph (DocString xs)
it "skips empty lines in front of an example" $ do
"\n \n\n>>> foo" `shouldParseTo` DocExamples [Example "foo" []]
it "terminates example on empty line" $ do
unlines [
">>> foo"
, "bar"
, " "
, "baz"
]
`shouldParseTo`
DocExamples [Example "foo" ["bar"]] <> DocParagraph "baz"
it "parses a <BLANKLINE> result as an empty result" $ do
unlines [
">>> foo"
, "bar"
, "<BLANKLINE>"
, "baz"
]
`shouldParseTo` DocExamples [Example "foo" ["bar", "", "baz"]]
it "accepts unicode in examples" $ do
">>> 灼眼\nシャナ" `shouldParseTo` DocExamples [Example "灼眼" ["シャナ"]]
context "when prompt is prefixed by whitespace" $ do
it "strips the exact same amount of whitespace from result lines" $ do
unlines [
" >>> foo"
, " bar"
, " baz"
] `shouldParseTo` DocExamples [Example "foo" ["bar", "baz"]]
it "preserves additional whitespace" $ do
unlines [
" >>> foo"
, " bar"
] `shouldParseTo` DocExamples [Example "foo" [" bar"]]
it "keeps original if stripping is not possible" $ do
unlines [
" >>> foo"
, " bar"
] `shouldParseTo` DocExamples [Example "foo" [" bar"]]
context "when parsing paragraphs nested in lists" $ do
it "can nest the same type of list" $ do
"* foo\n\n * bar" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocUnorderedList [DocParagraph "bar"]]
it "can nest another type of list inside" $ do
"* foo\n\n 1. bar" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocOrderedList [DocParagraph "bar"]]
it "can nest a code block inside" $ do
"* foo\n\n @foo bar baz@" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocCodeBlock "foo bar baz"]
"* foo\n\n @\n foo bar baz\n @" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocCodeBlock "foo bar baz\n"]
it "can nest more than one level" $ do
"* foo\n\n * bar\n\n * baz\n qux" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocUnorderedList [ DocParagraph $ "bar"
<> DocUnorderedList [DocParagraph "baz\nqux"]
]
]
it "won't fail on not fully indented paragraph" $ do
"* foo\n\n * bar\n\n * qux\nquux" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocUnorderedList [ DocParagraph "bar" ]
, DocParagraph "qux\nquux"]
it "can nest definition lists" $ do
"[a] foo\n\n [b] bar\n\n [c] baz\n qux" `shouldParseTo`
DocDefList [ ("a", "foo"
<> DocDefList [ ("b", "bar"
<> DocDefList [("c", "baz\nqux")])
])
]
it "can come back to top level with a different list" $ do
"* foo\n\n * bar\n\n1. baz" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocUnorderedList [ DocParagraph "bar" ]
]
<> DocOrderedList [ DocParagraph "baz" ]
it "definition lists can come back to top level with a different list" $ do
"[foo] foov\n\n [bar] barv\n\n1. baz" `shouldParseTo`
DocDefList [ ("foo", "foov"
<> DocDefList [ ("bar", "barv") ])
]
<> DocOrderedList [ DocParagraph "baz" ]
context "when parsing properties" $ do
it "can parse a single property" $ do
"prop> 23 == 23" `shouldParseTo` DocProperty "23 == 23"
it "can parse multiple subsequent properties" $ do
unlines [
"prop> 23 == 23"
, "prop> 42 == 42"
]
`shouldParseTo`
DocProperty "23 == 23" <> DocProperty "42 == 42"
it "accepts unicode in properties" $ do
"prop> 灼眼のシャナ ≡ 愛" `shouldParseTo`
DocProperty "灼眼のシャナ ≡ 愛"
it "can deal with whitespace before and after the prop> prompt" $ do
" prop> xs == (reverse $ reverse xs) " `shouldParseTo`
DocProperty "xs == (reverse $ reverse xs)"
context "when parsing unordered lists" $ do
it "parses a simple list" $ do
unlines [
" * one"
, " * two"
, " * three"
]
`shouldParseTo` DocUnorderedList [
DocParagraph "one"
, DocParagraph "two"
, DocParagraph "three"
]
it "ignores empty lines between list items" $ do
unlines [
"* one"
, ""
, "* two"
]
`shouldParseTo` DocUnorderedList [
DocParagraph "one"
, DocParagraph "two"
]
it "accepts an empty list item" $ do
"*" `shouldParseTo` DocUnorderedList [DocParagraph DocEmpty]
it "accepts multi-line list items" $ do
unlines [
"* point one"
, " more one"
, "* point two"
, "more two"
]
`shouldParseTo` DocUnorderedList [
DocParagraph "point one\n more one"
, DocParagraph "point two\nmore two"
]
it "accepts markup in list items" $ do
"* /foo/" `shouldParseTo` DocUnorderedList [DocParagraph (DocEmphasis "foo")]
it "requires empty lines between list and other paragraphs" $ do
unlines [
"foo"
, ""
, "* bar"
, ""
, "baz"
]
`shouldParseTo` DocParagraph "foo" <> DocUnorderedList [DocParagraph "bar"] <> DocParagraph "baz"
context "when parsing ordered lists" $ do
it "parses a simple list" $ do
unlines [
" 1. one"
, " (1) two"
, " 3. three"
]
`shouldParseTo` DocOrderedList [
DocParagraph "one"
, DocParagraph "two"
, DocParagraph "three"
]
it "ignores empty lines between list items" $ do
unlines [
"1. one"
, ""
, "2. two"
]
`shouldParseTo` DocOrderedList [
DocParagraph "one"
, DocParagraph "two"
]
it "accepts an empty list item" $ do
"1." `shouldParseTo` DocOrderedList [DocParagraph DocEmpty]
it "accepts multi-line list items" $ do
unlines [
"1. point one"
, " more one"
, "1. point two"
, "more two"
]
`shouldParseTo` DocOrderedList [
DocParagraph "point one\n more one"
, DocParagraph "point two\nmore two"
]
it "accepts markup in list items" $ do
"1. /foo/" `shouldParseTo` DocOrderedList [DocParagraph (DocEmphasis "foo")]
it "requires empty lines between list and other paragraphs" $ do
unlines [
"foo"
, ""
, "1. bar"
, ""
, "baz"
]
`shouldParseTo` DocParagraph "foo" <> DocOrderedList [DocParagraph "bar"] <> DocParagraph "baz"
context "when parsing definition lists" $ do
it "parses a simple list" $ do
unlines [
" [foo] one"
, " [bar] two"
, " [baz] three"
]
`shouldParseTo` DocDefList [
("foo", "one")
, ("bar", "two")
, ("baz", "three")
]
it "ignores empty lines between list items" $ do
unlines [
"[foo] one"
, ""
, "[bar] two"
]
`shouldParseTo` DocDefList [
("foo", "one")
, ("bar", "two")
]
it "accepts an empty list item" $ do
"[foo]" `shouldParseTo` DocDefList [("foo", DocEmpty)]
it "accepts multi-line list items" $ do
unlines [
"[foo] point one"
, " more one"
, "[bar] point two"
, "more two"
]
`shouldParseTo` DocDefList [
("foo", "point one\n more one")
, ("bar", "point two\nmore two")
]
it "accepts markup in list items" $ do
"[foo] /foo/" `shouldParseTo` DocDefList [("foo", DocEmphasis "foo")]
it "accepts markup for the label" $ do
"[/foo/] bar" `shouldParseTo` DocDefList [(DocEmphasis "foo", "bar")]
it "requires empty lines between list and other paragraphs" $ do
unlines [
"foo"
, ""
, "[foo] bar"
, ""
, "baz"
]
`shouldParseTo` DocParagraph "foo" <> DocDefList [("foo", "bar")] <> DocParagraph "baz"
context "when parsing consecutive paragraphs" $ do
it "will not capture irrelevant consecutive lists" $ do
unlines [ " * bullet"
, ""
, ""
, " - different bullet"
, ""
, ""
, " (1) ordered"
, " "
, " 2. different bullet"
, " "
, " [cat] kitten"
, " "
, " [pineapple] fruit"
] `shouldParseTo`
DocUnorderedList [ DocParagraph "bullet"
, DocParagraph "different bullet"]
<> DocOrderedList [ DocParagraph "ordered"
, DocParagraph "different bullet"
]
<> DocDefList [ ("cat", "kitten")
, ("pineapple", "fruit")
]
context "when parsing function documentation headers" $ do
it "can parse a simple header" $ do
"= Header 1\nHello." `shouldParseTo`
DocParagraph (DocHeader (Header 1 "Header 1"))
<> DocParagraph "Hello."
it "allow consecutive headers" $ do
"= Header 1\n== Header 2" `shouldParseTo`
DocParagraph (DocHeader (Header 1 "Header 1"))
<> DocParagraph (DocHeader (Header 2 "Header 2"))
it "accepts markup in the header" $ do
"= /Header/ __1__\nFoo" `shouldParseTo`
DocParagraph (DocHeader
(Header 1 (DocEmphasis "Header" <> " " <> DocBold "1")))
<> DocParagraph "Foo"
| 27,355
|
spec = before initStaticOpts $ do
describe "parseString" $ do
let infix 1 `shouldParseTo`
shouldParseTo :: String -> Doc RdrName -> Expectation
shouldParseTo input ast = parseString input `shouldBe` ast
it "is total" $ do
property $ \xs ->
(length . show . parseString) xs `shouldSatisfy` (> 0)
context "when parsing text" $ do
it "can handle unicode" $ do
"灼眼のシャナ" `shouldParseTo` "灼眼のシャナ"
it "accepts numeric character references" $ do
"foo bar baz λ" `shouldParseTo` "foo bar baz λ"
it "accepts hexadecimal character references" $ do
"e" `shouldParseTo` "e"
it "allows to backslash-escape characters" $ do
property $ \x -> ['\\', x] `shouldParseTo` DocString [x]
context "when parsing strings contaning numeric character references" $ do
it "will implicitly convert digits to characters" $ do
"AAAA" `shouldParseTo` "AAAA"
"灼眼のシャナ"
`shouldParseTo` "灼眼のシャナ"
it "will implicitly convert hex encoded characters" $ do
"eeee" `shouldParseTo` "eeee"
context "when parsing identifiers" $ do
it "parses identifiers enclosed within single ticks" $ do
"'foo'" `shouldParseTo` DocIdentifier "foo"
it "parses identifiers enclosed within backticks" $ do
"`foo`" `shouldParseTo` DocIdentifier "foo"
it "parses a word with an one of the delimiters in it as DocString" $ do
"don't" `shouldParseTo` "don't"
it "doesn't pass pairs of delimiters with spaces between them" $ do
"hel'lo w'orld" `shouldParseTo` "hel'lo w'orld"
it "don't use apostrophe's in the wrong place's" $ do
" don't use apostrophe's in the wrong place's" `shouldParseTo`
"don't use apostrophe's in the wrong place's"
context "when parsing URLs" $ do
let hyperlink :: String -> Maybe String -> Doc RdrName
hyperlink url = DocHyperlink . Hyperlink url
it "parses a URL" $ do
"<http://example.com/>" `shouldParseTo` hyperlink "http://example.com/" Nothing
it "accepts an optional label" $ do
"<http://example.com/ some link>" `shouldParseTo` hyperlink "http://example.com/" "some link"
it "does not accept newlines in label" $ do
"<foo bar\nbaz>" `shouldParseTo` "<foo bar\nbaz>"
-- new behaviour test, this will be now consistent with other markup
it "allows us to escape > inside the URL" $ do
"<http://examp\\>le.com>" `shouldParseTo`
hyperlink "http://examp>le.com" Nothing
"<http://exa\\>mp\\>le.com>" `shouldParseTo`
hyperlink "http://exa>mp>le.com" Nothing
-- Likewise in label
"<http://example.com f\\>oo>" `shouldParseTo`
hyperlink "http://example.com" "f>oo"
it "parses inline URLs" $ do
"foo <http://example.com/> bar" `shouldParseTo`
"foo " <> hyperlink "http://example.com/" Nothing <> " bar"
it "doesn't allow for multi-line link tags" $ do
"<ba\nz aar>" `shouldParseTo` "<ba\nz aar>"
context "when autolinking URLs" $ do
it "autolinks HTTP URLs" $ do
"http://example.com/" `shouldParseTo` hyperlink "http://example.com/" Nothing
it "autolinks HTTPS URLs" $ do
"https://www.example.com/" `shouldParseTo` hyperlink "https://www.example.com/" Nothing
it "autolinks FTP URLs" $ do
"ftp://example.com/" `shouldParseTo` hyperlink "ftp://example.com/" Nothing
it "does not include a trailing comma" $ do
"http://example.com/, Some other sentence." `shouldParseTo`
hyperlink "http://example.com/" Nothing <> ", Some other sentence."
it "does not include a trailing dot" $ do
"http://example.com/. Some other sentence." `shouldParseTo`
hyperlink "http://example.com/" Nothing <> ". Some other sentence."
it "does not include a trailing exclamation mark" $ do
"http://example.com/! Some other sentence." `shouldParseTo`
hyperlink "http://example.com/" Nothing <> "! Some other sentence."
it "does not include a trailing question mark" $ do
"http://example.com/? Some other sentence." `shouldParseTo`
hyperlink "http://example.com/" Nothing <> "? Some other sentence."
context "when parsing pictures" $ do
let picture :: String -> Maybe String -> Doc RdrName
picture uri = DocPic . Picture uri
it "parses a simple picture" $ do
"<<baz>>" `shouldParseTo` picture "baz" Nothing
it "parses a picture with a title" $ do
"<<b a z>>" `shouldParseTo` picture "b" (Just "a z")
it "parses a picture with unicode" $ do
"<<灼眼のシャナ>>" `shouldParseTo` picture "灼眼のシャナ" Nothing
it "allows for escaping of the closing tags" $ do
"<<ba\\>>z>>" `shouldParseTo` picture "ba>>z" Nothing
it "doesn't allow for multi-line picture tags" $ do
"<<ba\nz aar>>" `shouldParseTo` "<<ba\nz aar>>"
context "when parsing anchors" $ do
it "parses a single word anchor" $ do
"#foo#" `shouldParseTo` DocAName "foo"
it "parses a multi word anchor" $ do
"#foo bar#" `shouldParseTo` DocAName "foo bar"
it "parses a unicode anchor" $ do
"#灼眼のシャナ#" `shouldParseTo` DocAName "灼眼のシャナ"
it "does not accept newlines in anchors" $ do
"#foo\nbar#" `shouldParseTo` "#foo\nbar#"
it "accepts anchors mid-paragraph" $ do
"Hello #someAnchor# world!"
`shouldParseTo` "Hello " <> DocAName "someAnchor" <> " world!"
it "does not accept empty anchors" $ do
"##" `shouldParseTo` "##"
context "when parsing emphasised text" $ do
it "emphasises a word on its own" $ do
"/foo/" `shouldParseTo` DocEmphasis "foo"
it "emphasises inline correctly" $ do
"foo /bar/ baz" `shouldParseTo` "foo " <> DocEmphasis "bar" <> " baz"
it "emphasises unicode" $ do
"/灼眼のシャナ/" `shouldParseTo` DocEmphasis "灼眼のシャナ"
it "does not emphasise multi-line strings" $ do
" /foo\nbar/" `shouldParseTo` "/foo\nbar/"
it "does not emphasise the empty string" $ do
"//" `shouldParseTo` "//"
it "parses escaped slashes literally" $ do
"/foo\\/bar/" `shouldParseTo` DocEmphasis "foo/bar"
it "recognizes other markup constructs within emphasised text" $ do
"/foo @bar@ baz/" `shouldParseTo`
DocEmphasis ("foo " <> DocMonospaced "bar" <> " baz")
it "allows other markup inside of emphasis" $ do
"/__inner bold__/" `shouldParseTo` DocEmphasis (DocBold "inner bold")
it "doesn't mangle inner markup unicode" $ do
"/__灼眼のシャナ A__/" `shouldParseTo` DocEmphasis (DocBold "灼眼のシャナ A")
it "properly converts HTML escape sequences" $ do
"/AAAA/" `shouldParseTo` DocEmphasis "AAAA"
it "allows to escape the emphasis delimiter inside of emphasis" $ do
"/empha\\/sis/" `shouldParseTo` DocEmphasis "empha/sis"
context "when parsing monospaced text" $ do
it "parses simple monospaced text" $ do
"@foo@" `shouldParseTo` DocMonospaced "foo"
it "parses inline monospaced text" $ do
"foo @bar@ baz" `shouldParseTo` "foo " <> DocMonospaced "bar" <> " baz"
it "allows to escape @" $ do
"@foo \\@ bar@" `shouldParseTo` DocMonospaced "foo @ bar"
it "accepts unicode" $ do
"@foo 灼眼のシャナ bar@" `shouldParseTo` DocMonospaced "foo 灼眼のシャナ bar"
it "accepts other markup in monospaced text" $ do
"@/foo/@" `shouldParseTo` DocMonospaced (DocEmphasis "foo")
it "requires the closing @" $ do
"@foo /bar/ baz" `shouldParseTo` "@foo " <> DocEmphasis "bar" <> " baz"
context "when parsing bold strings" $ do
it "allows for a bold string on its own" $ do
"__bold string__" `shouldParseTo`
DocBold "bold string"
it "bolds inline correctly" $ do
"hello __everyone__ there" `shouldParseTo`
"hello "
<> DocBold "everyone" <> " there"
it "bolds unicode" $ do
"__灼眼のシャナ__" `shouldParseTo`
DocBold "灼眼のシャナ"
it "does not do __multi-line\\n bold__" $ do
" __multi-line\n bold__" `shouldParseTo` "__multi-line\n bold__"
it "allows other markup inside of bold" $ do
"__/inner emphasis/__" `shouldParseTo`
(DocBold $ DocEmphasis "inner emphasis")
it "doesn't mangle inner markup unicode" $ do
"__/灼眼のシャナ A/__" `shouldParseTo`
(DocBold $ DocEmphasis "灼眼のシャナ A")
it "properly converts HTML escape sequences" $ do
"__AAAA__" `shouldParseTo`
DocBold "AAAA"
it "allows to escape the bold delimiter inside of bold" $ do
"__bo\\__ld__" `shouldParseTo`
DocBold "bo__ld"
it "doesn't allow for empty bold" $ do
"____" `shouldParseTo` "____"
context "when parsing module strings" $ do
it "should parse a module on its own" $ do
"\"Module\"" `shouldParseTo`
DocModule "Module"
it "should parse a module inline" $ do
"This is a \"Module\"." `shouldParseTo`
"This is a " <> DocModule "Module" <> "."
it "can accept a simple module name" $ do
"\"Hello\"" `shouldParseTo` DocModule "Hello"
it "can accept a module name with dots" $ do
"\"Hello.World\"" `shouldParseTo` DocModule "Hello.World"
it "can accept a module name with unicode" $ do
"\"Hello.Worldλ\"" `shouldParseTo` DocModule "Hello.Worldλ"
it "parses a module name with a trailing dot as regular quoted string" $ do
"\"Hello.\"" `shouldParseTo` "\"Hello.\""
it "parses a module name with a space as regular quoted string" $ do
"\"Hello World\"" `shouldParseTo` "\"Hello World\""
it "parses a module name with invalid characters as regular quoted string" $ do
"\"Hello&[{}(=*)+]!\"" `shouldParseTo` "\"Hello&[{}(=*)+]!\""
it "accepts a module name with unicode" $ do
"\"Foo.Barλ\"" `shouldParseTo` DocModule "Foo.Barλ"
it "treats empty module name as regular double quotes" $ do
"\"\"" `shouldParseTo` "\"\""
it "accepts anchor reference syntax as DocModule" $ do
"\"Foo#bar\"" `shouldParseTo` DocModule "Foo#bar"
it "accepts old anchor reference syntax as DocModule" $ do
"\"Foo\\#bar\"" `shouldParseTo` DocModule "Foo\\#bar"
describe "parseParas" $ do
let infix 1 `shouldParseTo`
shouldParseTo :: String -> Doc RdrName -> Expectation
shouldParseTo input ast = parseParas input `shouldBe` ast
it "is total" $ do
property $ \xs ->
(length . show . parseParas) xs `shouldSatisfy` (> 0)
context "when parsing text paragraphs" $ do
let filterSpecial = filter (`notElem` (".(=#-[*`\v\f\n\t\r\\\"'_/@<> " :: String))
it "parses an empty paragraph" $ do
"" `shouldParseTo` DocEmpty
it "parses a simple text paragraph" $ do
"foo bar baz" `shouldParseTo` DocParagraph "foo bar baz"
it "accepts markup in text paragraphs" $ do
"foo /bar/ baz" `shouldParseTo` DocParagraph ("foo " <> DocEmphasis "bar" <> " baz")
it "preserve all regular characters" $ do
property $ \xs -> let input = filterSpecial xs in (not . null) input ==>
input `shouldParseTo` DocParagraph (DocString input)
it "separates paragraphs by empty lines" $ do
unlines [
"foo"
, " \t "
, "bar"
] `shouldParseTo` DocParagraph "foo" <> DocParagraph "bar"
context "when a pragraph only contains monospaced text" $ do
it "turns it into a code block" $ do
"@foo@" `shouldParseTo` DocCodeBlock "foo"
context "when parsing birdtracks" $ do
it "parses them as a code block" $ do
unlines [
">foo"
, ">bar"
, ">baz"
] `shouldParseTo` DocCodeBlock "foo\nbar\nbaz"
it "ignores leading whitespace" $ do
unlines [
" >foo"
, " \t >bar"
, " >baz"
]
`shouldParseTo` DocCodeBlock "foo\nbar\nbaz"
it "strips one leading space from each line of the block" $ do
unlines [
"> foo"
, "> bar"
, "> baz"
] `shouldParseTo` DocCodeBlock "foo\n bar\nbaz"
it "ignores empty lines when stripping spaces" $ do
unlines [
"> foo"
, ">"
, "> bar"
] `shouldParseTo` DocCodeBlock "foo\n\nbar"
context "when any non-empty line does not start with a space" $ do
it "does not strip any spaces" $ do
unlines [
">foo"
, "> bar"
] `shouldParseTo` DocCodeBlock "foo\n bar"
it "ignores nested markup" $ do
unlines [
">/foo/"
] `shouldParseTo` DocCodeBlock "/foo/"
it "treats them as regular text inside text paragraphs" $ do
unlines [
"foo"
, ">bar"
] `shouldParseTo` DocParagraph "foo\n>bar"
context "when parsing code blocks" $ do
it "accepts a simple code block" $ do
unlines [
"@"
, "foo"
, "bar"
, "baz"
, "@"
] `shouldParseTo` DocCodeBlock "foo\nbar\nbaz\n"
it "ignores trailing whitespace after the opening @" $ do
unlines [
"@ "
, "foo"
, "@"
] `shouldParseTo` DocCodeBlock "foo\n"
it "rejects code blocks that are not closed" $ do
unlines [
"@"
, "foo"
] `shouldParseTo` DocParagraph "@\nfoo"
it "accepts nested markup" $ do
unlines [
"@"
, "/foo/"
, "@"
] `shouldParseTo` DocCodeBlock (DocEmphasis "foo" <> "\n")
it "allows to escape the @" $ do
unlines [
"@"
, "foo"
, "\\@"
, "bar"
, "@"
] `shouldParseTo` DocCodeBlock "foo\n@\nbar\n"
it "accepts horizontal space before the @" $ do
unlines [ " @"
, "foo"
, ""
, "bar"
, "@"
] `shouldParseTo` DocCodeBlock "foo\n\nbar\n"
it "strips a leading space from a @ block if present" $ do
unlines [ " @"
, " hello"
, " world"
, " @"
] `shouldParseTo` DocCodeBlock "hello\nworld\n"
unlines [ " @"
, " hello"
, ""
, " world"
, " @"
] `shouldParseTo` DocCodeBlock "hello\n\nworld\n"
it "only drops whitespace if there's some before closing @" $ do
unlines [ "@"
, " Formatting"
, " matters."
, "@"
]
`shouldParseTo` DocCodeBlock " Formatting\n matters.\n"
it "accepts unicode" $ do
"@foo 灼眼のシャナ bar@" `shouldParseTo` DocCodeBlock "foo 灼眼のシャナ bar"
it "requires the closing @" $ do
"@foo /bar/ baz"
`shouldParseTo` DocParagraph ("@foo " <> DocEmphasis "bar" <> " baz")
context "when parsing examples" $ do
it "parses a simple example" $ do
">>> foo" `shouldParseTo` DocExamples [Example "foo" []]
it "parses an example with result" $ do
unlines [
">>> foo"
, "bar"
, "baz"
] `shouldParseTo` DocExamples [Example "foo" ["bar", "baz"]]
it "parses consecutive examples" $ do
unlines [
">>> fib 5"
, "5"
, ">>> fib 10"
, "55"
] `shouldParseTo` DocExamples [
Example "fib 5" ["5"]
, Example "fib 10" ["55"]
]
it ("requires an example to be separated"
++ " from a previous paragraph by an empty line") $ do
"foobar\n\n>>> fib 10\n55" `shouldParseTo`
DocParagraph "foobar"
<> DocExamples [Example "fib 10" ["55"]]
it "parses bird-tracks inside of paragraphs as plain strings" $ do
let xs = "foo\n>>> bar"
xs `shouldParseTo` DocParagraph (DocString xs)
it "skips empty lines in front of an example" $ do
"\n \n\n>>> foo" `shouldParseTo` DocExamples [Example "foo" []]
it "terminates example on empty line" $ do
unlines [
">>> foo"
, "bar"
, " "
, "baz"
]
`shouldParseTo`
DocExamples [Example "foo" ["bar"]] <> DocParagraph "baz"
it "parses a <BLANKLINE> result as an empty result" $ do
unlines [
">>> foo"
, "bar"
, "<BLANKLINE>"
, "baz"
]
`shouldParseTo` DocExamples [Example "foo" ["bar", "", "baz"]]
it "accepts unicode in examples" $ do
">>> 灼眼\nシャナ" `shouldParseTo` DocExamples [Example "灼眼" ["シャナ"]]
context "when prompt is prefixed by whitespace" $ do
it "strips the exact same amount of whitespace from result lines" $ do
unlines [
" >>> foo"
, " bar"
, " baz"
] `shouldParseTo` DocExamples [Example "foo" ["bar", "baz"]]
it "preserves additional whitespace" $ do
unlines [
" >>> foo"
, " bar"
] `shouldParseTo` DocExamples [Example "foo" [" bar"]]
it "keeps original if stripping is not possible" $ do
unlines [
" >>> foo"
, " bar"
] `shouldParseTo` DocExamples [Example "foo" [" bar"]]
context "when parsing paragraphs nested in lists" $ do
it "can nest the same type of list" $ do
"* foo\n\n * bar" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocUnorderedList [DocParagraph "bar"]]
it "can nest another type of list inside" $ do
"* foo\n\n 1. bar" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocOrderedList [DocParagraph "bar"]]
it "can nest a code block inside" $ do
"* foo\n\n @foo bar baz@" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocCodeBlock "foo bar baz"]
"* foo\n\n @\n foo bar baz\n @" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocCodeBlock "foo bar baz\n"]
it "can nest more than one level" $ do
"* foo\n\n * bar\n\n * baz\n qux" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocUnorderedList [ DocParagraph $ "bar"
<> DocUnorderedList [DocParagraph "baz\nqux"]
]
]
it "won't fail on not fully indented paragraph" $ do
"* foo\n\n * bar\n\n * qux\nquux" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocUnorderedList [ DocParagraph "bar" ]
, DocParagraph "qux\nquux"]
it "can nest definition lists" $ do
"[a] foo\n\n [b] bar\n\n [c] baz\n qux" `shouldParseTo`
DocDefList [ ("a", "foo"
<> DocDefList [ ("b", "bar"
<> DocDefList [("c", "baz\nqux")])
])
]
it "can come back to top level with a different list" $ do
"* foo\n\n * bar\n\n1. baz" `shouldParseTo`
DocUnorderedList [ DocParagraph $ "foo"
<> DocUnorderedList [ DocParagraph "bar" ]
]
<> DocOrderedList [ DocParagraph "baz" ]
it "definition lists can come back to top level with a different list" $ do
"[foo] foov\n\n [bar] barv\n\n1. baz" `shouldParseTo`
DocDefList [ ("foo", "foov"
<> DocDefList [ ("bar", "barv") ])
]
<> DocOrderedList [ DocParagraph "baz" ]
context "when parsing properties" $ do
it "can parse a single property" $ do
"prop> 23 == 23" `shouldParseTo` DocProperty "23 == 23"
it "can parse multiple subsequent properties" $ do
unlines [
"prop> 23 == 23"
, "prop> 42 == 42"
]
`shouldParseTo`
DocProperty "23 == 23" <> DocProperty "42 == 42"
it "accepts unicode in properties" $ do
"prop> 灼眼のシャナ ≡ 愛" `shouldParseTo`
DocProperty "灼眼のシャナ ≡ 愛"
it "can deal with whitespace before and after the prop> prompt" $ do
" prop> xs == (reverse $ reverse xs) " `shouldParseTo`
DocProperty "xs == (reverse $ reverse xs)"
context "when parsing unordered lists" $ do
it "parses a simple list" $ do
unlines [
" * one"
, " * two"
, " * three"
]
`shouldParseTo` DocUnorderedList [
DocParagraph "one"
, DocParagraph "two"
, DocParagraph "three"
]
it "ignores empty lines between list items" $ do
unlines [
"* one"
, ""
, "* two"
]
`shouldParseTo` DocUnorderedList [
DocParagraph "one"
, DocParagraph "two"
]
it "accepts an empty list item" $ do
"*" `shouldParseTo` DocUnorderedList [DocParagraph DocEmpty]
it "accepts multi-line list items" $ do
unlines [
"* point one"
, " more one"
, "* point two"
, "more two"
]
`shouldParseTo` DocUnorderedList [
DocParagraph "point one\n more one"
, DocParagraph "point two\nmore two"
]
it "accepts markup in list items" $ do
"* /foo/" `shouldParseTo` DocUnorderedList [DocParagraph (DocEmphasis "foo")]
it "requires empty lines between list and other paragraphs" $ do
unlines [
"foo"
, ""
, "* bar"
, ""
, "baz"
]
`shouldParseTo` DocParagraph "foo" <> DocUnorderedList [DocParagraph "bar"] <> DocParagraph "baz"
context "when parsing ordered lists" $ do
it "parses a simple list" $ do
unlines [
" 1. one"
, " (1) two"
, " 3. three"
]
`shouldParseTo` DocOrderedList [
DocParagraph "one"
, DocParagraph "two"
, DocParagraph "three"
]
it "ignores empty lines between list items" $ do
unlines [
"1. one"
, ""
, "2. two"
]
`shouldParseTo` DocOrderedList [
DocParagraph "one"
, DocParagraph "two"
]
it "accepts an empty list item" $ do
"1." `shouldParseTo` DocOrderedList [DocParagraph DocEmpty]
it "accepts multi-line list items" $ do
unlines [
"1. point one"
, " more one"
, "1. point two"
, "more two"
]
`shouldParseTo` DocOrderedList [
DocParagraph "point one\n more one"
, DocParagraph "point two\nmore two"
]
it "accepts markup in list items" $ do
"1. /foo/" `shouldParseTo` DocOrderedList [DocParagraph (DocEmphasis "foo")]
it "requires empty lines between list and other paragraphs" $ do
unlines [
"foo"
, ""
, "1. bar"
, ""
, "baz"
]
`shouldParseTo` DocParagraph "foo" <> DocOrderedList [DocParagraph "bar"] <> DocParagraph "baz"
context "when parsing definition lists" $ do
it "parses a simple list" $ do
unlines [
" [foo] one"
, " [bar] two"
, " [baz] three"
]
`shouldParseTo` DocDefList [
("foo", "one")
, ("bar", "two")
, ("baz", "three")
]
it "ignores empty lines between list items" $ do
unlines [
"[foo] one"
, ""
, "[bar] two"
]
`shouldParseTo` DocDefList [
("foo", "one")
, ("bar", "two")
]
it "accepts an empty list item" $ do
"[foo]" `shouldParseTo` DocDefList [("foo", DocEmpty)]
it "accepts multi-line list items" $ do
unlines [
"[foo] point one"
, " more one"
, "[bar] point two"
, "more two"
]
`shouldParseTo` DocDefList [
("foo", "point one\n more one")
, ("bar", "point two\nmore two")
]
it "accepts markup in list items" $ do
"[foo] /foo/" `shouldParseTo` DocDefList [("foo", DocEmphasis "foo")]
it "accepts markup for the label" $ do
"[/foo/] bar" `shouldParseTo` DocDefList [(DocEmphasis "foo", "bar")]
it "requires empty lines between list and other paragraphs" $ do
unlines [
"foo"
, ""
, "[foo] bar"
, ""
, "baz"
]
`shouldParseTo` DocParagraph "foo" <> DocDefList [("foo", "bar")] <> DocParagraph "baz"
context "when parsing consecutive paragraphs" $ do
it "will not capture irrelevant consecutive lists" $ do
unlines [ " * bullet"
, ""
, ""
, " - different bullet"
, ""
, ""
, " (1) ordered"
, " "
, " 2. different bullet"
, " "
, " [cat] kitten"
, " "
, " [pineapple] fruit"
] `shouldParseTo`
DocUnorderedList [ DocParagraph "bullet"
, DocParagraph "different bullet"]
<> DocOrderedList [ DocParagraph "ordered"
, DocParagraph "different bullet"
]
<> DocDefList [ ("cat", "kitten")
, ("pineapple", "fruit")
]
context "when parsing function documentation headers" $ do
it "can parse a simple header" $ do
"= Header 1\nHello." `shouldParseTo`
DocParagraph (DocHeader (Header 1 "Header 1"))
<> DocParagraph "Hello."
it "allow consecutive headers" $ do
"= Header 1\n== Header 2" `shouldParseTo`
DocParagraph (DocHeader (Header 1 "Header 1"))
<> DocParagraph (DocHeader (Header 2 "Header 2"))
it "accepts markup in the header" $ do
"= /Header/ __1__\nFoo" `shouldParseTo`
DocParagraph (DocHeader
(Header 1 (DocEmphasis "Header" <> " " <> DocBold "1")))
<> DocParagraph "Foo"
| 27,342
| false
| true
| 0
| 111
| 9,624
| 5,385
| 2,599
| 2,786
| null | null |
vikraman/ghc
|
compiler/hsSyn/HsUtils.hs
|
bsd-3-clause
|
mkNPlusKPat id lit = NPlusKPat id lit (unLoc lit) noSyntaxExpr noSyntaxExpr placeHolderType
| 91
|
mkNPlusKPat id lit = NPlusKPat id lit (unLoc lit) noSyntaxExpr noSyntaxExpr placeHolderType
| 91
|
mkNPlusKPat id lit = NPlusKPat id lit (unLoc lit) noSyntaxExpr noSyntaxExpr placeHolderType
| 91
| false
| false
| 1
| 7
| 11
| 37
| 14
| 23
| null | null |
TueHaulund/ROOPLC
|
src/MacroExpander.hs
|
mit
|
meMacro (AddressMacro l) = getAddress l
| 39
|
meMacro (AddressMacro l) = getAddress l
| 39
|
meMacro (AddressMacro l) = getAddress l
| 39
| false
| false
| 0
| 6
| 5
| 19
| 8
| 11
| null | null |
CloudI/CloudI
|
src/api/haskell/external/bytestring-0.10.10.0/Data/ByteString/Builder/Prim/ASCII.hs
|
mit
|
int8HexFixed :: FixedPrim Int8
int8HexFixed = fromIntegral >$< word8HexFixed
| 76
|
int8HexFixed :: FixedPrim Int8
int8HexFixed = fromIntegral >$< word8HexFixed
| 76
|
int8HexFixed = fromIntegral >$< word8HexFixed
| 45
| false
| true
| 1
| 6
| 8
| 22
| 9
| 13
| null | null |
wtetzner/hatemail
|
haskell/src/Parse.hs
|
gpl-3.0
|
bodyExtMPart = choice [bodyExtLoc bodyFieldPrm,
bodyExtLang bodyFieldPrm,
bodyExtDsp bodyFieldPrm,
prm]
where prm = do params <- bodyFieldPrm
return $ BodyExt params
| 257
|
bodyExtMPart = choice [bodyExtLoc bodyFieldPrm,
bodyExtLang bodyFieldPrm,
bodyExtDsp bodyFieldPrm,
prm]
where prm = do params <- bodyFieldPrm
return $ BodyExt params
| 257
|
bodyExtMPart = choice [bodyExtLoc bodyFieldPrm,
bodyExtLang bodyFieldPrm,
bodyExtDsp bodyFieldPrm,
prm]
where prm = do params <- bodyFieldPrm
return $ BodyExt params
| 257
| false
| false
| 2
| 9
| 112
| 62
| 26
| 36
| null | null |
wxwxwwxxx/ghc
|
compiler/cmm/SMRep.hs
|
bsd-3-clause
|
hALF_WORD_SIZE_IN_BITS :: DynFlags -> Int
hALF_WORD_SIZE_IN_BITS dflags = platformWordSize (targetPlatform dflags) `shiftL` 2
| 125
|
hALF_WORD_SIZE_IN_BITS :: DynFlags -> Int
hALF_WORD_SIZE_IN_BITS dflags = platformWordSize (targetPlatform dflags) `shiftL` 2
| 125
|
hALF_WORD_SIZE_IN_BITS dflags = platformWordSize (targetPlatform dflags) `shiftL` 2
| 83
| false
| true
| 0
| 8
| 12
| 37
| 18
| 19
| null | null |
jsnajder/counts
|
src/Data/Counts.hs
|
bsd-3-clause
|
inc :: (Ord a) => a -> Counts a -> Counts a
inc x cs = Counts {
counts_ = M.insertWith (+) x 1 (counts_ cs),
total = total cs + 1}
| 136
|
inc :: (Ord a) => a -> Counts a -> Counts a
inc x cs = Counts {
counts_ = M.insertWith (+) x 1 (counts_ cs),
total = total cs + 1}
| 136
|
inc x cs = Counts {
counts_ = M.insertWith (+) x 1 (counts_ cs),
total = total cs + 1}
| 92
| false
| true
| 0
| 10
| 37
| 84
| 42
| 42
| null | null |
kolmodin/cabal
|
Cabal/tests/PackageTests/PackageTester.hs
|
bsd-3-clause
|
ghcProg :: SuiteConfig -> ConfiguredProgram
ghcProg suite = getBootProgram suite ghcProgram
| 91
|
ghcProg :: SuiteConfig -> ConfiguredProgram
ghcProg suite = getBootProgram suite ghcProgram
| 91
|
ghcProg suite = getBootProgram suite ghcProgram
| 47
| false
| true
| 0
| 5
| 10
| 23
| 11
| 12
| null | null |
AaronFriel/eff-experiments
|
src/Data/Iota/Tagged/OpenUnion51.hs
|
bsd-3-clause
|
decomp :: Union (t ': r) v -> Either (Union r v) (t v)
decomp (Union0 v) = Right $ unsafeCoerce v
| 97
|
decomp :: Union (t ': r) v -> Either (Union r v) (t v)
decomp (Union0 v) = Right $ unsafeCoerce v
| 97
|
decomp (Union0 v) = Right $ unsafeCoerce v
| 42
| false
| true
| 0
| 8
| 21
| 64
| 31
| 33
| null | null |
osa1/toylisp
|
src/Parser.hs
|
bsd-3-clause
|
symbol :: Parser Char
symbol = oneOf "!$%&|*+-/:<=?>@^_~#"
| 58
|
symbol :: Parser Char
symbol = oneOf "!$%&|*+-/:<=?>@^_~#"
| 58
|
symbol = oneOf "!$%&|*+-/:<=?>@^_~#"
| 36
| false
| true
| 0
| 5
| 7
| 17
| 8
| 9
| null | null |
ajnsit/luachunk
|
src/Scripting/Lua/Chunk/Reader.hs
|
gpl-3.0
|
local :: Header -> A.Parser Local
local h = do
s <- str h
case s of
Nothing -> error "Unnamed local variable encountered!"
Just si -> do
startpc <- intP $ sizeOfInt h
endpc <- intP $ sizeOfInt h
return $ Local si startpc endpc
-- List of Upvals
| 275
|
local :: Header -> A.Parser Local
local h = do
s <- str h
case s of
Nothing -> error "Unnamed local variable encountered!"
Just si -> do
startpc <- intP $ sizeOfInt h
endpc <- intP $ sizeOfInt h
return $ Local si startpc endpc
-- List of Upvals
| 275
|
local h = do
s <- str h
case s of
Nothing -> error "Unnamed local variable encountered!"
Just si -> do
startpc <- intP $ sizeOfInt h
endpc <- intP $ sizeOfInt h
return $ Local si startpc endpc
-- List of Upvals
| 241
| false
| true
| 0
| 14
| 80
| 101
| 45
| 56
| null | null |
alphalambda/codeworld
|
funblocks-client/src/Blocks/Types.hs
|
apache-2.0
|
typePicture = Picture
| 21
|
typePicture = Picture
| 21
|
typePicture = Picture
| 21
| false
| false
| 0
| 4
| 2
| 6
| 3
| 3
| null | null |
glhrmfrts/lusk
|
Lusk/Parser.hs
|
mit
|
getOpType "-" = Sub
| 19
|
getOpType "-" = Sub
| 19
|
getOpType "-" = Sub
| 19
| false
| false
| 1
| 5
| 3
| 13
| 4
| 9
| null | null |
nevrenato/Hets_Fork
|
Common/Keywords.hs
|
gpl-2.0
|
-- | two percent signs (for line comments)
percents :: String
percents = percentS ++ percentS
| 93
|
percents :: String
percents = percentS ++ percentS
| 50
|
percents = percentS ++ percentS
| 31
| true
| true
| 0
| 5
| 15
| 16
| 9
| 7
| null | null |
krgn/leo
|
src/Web/Leo.hs
|
bsd-3-clause
|
query :: String -- ^ search term to translate
-> Language -- ^ language to translate to (e.g. 'En', 'Es' ...)
-> Int -- ^ maximum number of results to fetch
-> IO [QueryResult] -- ^ returns a list of QueryResult
query term l num = do
result <- fetch term (l, De) num
let categories = processRaw result
return $ map toQueryResult categories
-- take a query string, some options and fetches a response from the webservice
| 485
|
query :: String -- ^ search term to translate
-> Language -- ^ language to translate to (e.g. 'En', 'Es' ...)
-> Int -- ^ maximum number of results to fetch
-> IO [QueryResult]
query term l num = do
result <- fetch term (l, De) num
let categories = processRaw result
return $ map toQueryResult categories
-- take a query string, some options and fetches a response from the webservice
| 449
|
query term l num = do
result <- fetch term (l, De) num
let categories = processRaw result
return $ map toQueryResult categories
-- take a query string, some options and fetches a response from the webservice
| 220
| true
| true
| 0
| 10
| 143
| 85
| 43
| 42
| null | null |
hsyl20/ViperVM
|
haskus-system/src/lib/Haskus/System/Linux/Sound/Pcm.hs
|
bsd-3-clause
|
-- | Any mask
anyMask :: Mask
anyMask = Mask (complement zeroBits)
| 66
|
anyMask :: Mask
anyMask = Mask (complement zeroBits)
| 52
|
anyMask = Mask (complement zeroBits)
| 36
| true
| true
| 0
| 7
| 11
| 21
| 11
| 10
| null | null |
forked-upstream-packages-for-ghcjs/ghc
|
compiler/llvmGen/Llvm/PpLlvm.hs
|
bsd-3-clause
|
ppReturn :: Maybe LlvmVar -> SDoc
ppReturn (Just var) = text "ret" <+> ppr var
| 78
|
ppReturn :: Maybe LlvmVar -> SDoc
ppReturn (Just var) = text "ret" <+> ppr var
| 78
|
ppReturn (Just var) = text "ret" <+> ppr var
| 44
| false
| true
| 0
| 7
| 14
| 37
| 17
| 20
| null | null |
silky/csound-expression
|
src/Csound/Air/Wav.hs
|
bsd-3-clause
|
- Stereo
-- | Reads stereo signal from the sound-file (wav or mp3 or aiff).
readSnd :: String -> (Sig, Sig)
readSnd fileName
| isMp3 fileName = mp3in (text fileName)
| otherwise = diskin2 (text fileName) 1
| 228
|
readSnd :: String -> (Sig, Sig)
readSnd fileName
| isMp3 fileName = mp3in (text fileName)
| otherwise = diskin2 (text fileName) 1
| 150
|
readSnd fileName
| isMp3 fileName = mp3in (text fileName)
| otherwise = diskin2 (text fileName) 1
| 118
| true
| true
| 1
| 8
| 59
| 66
| 32
| 34
| null | null |
kajigor/uKanren_transformations
|
test/auto/Test/VarNormalization.hs
|
bsd-3-clause
|
y = V "y"
| 9
|
y = V "y"
| 9
|
y = V "y"
| 9
| false
| false
| 1
| 5
| 3
| 12
| 4
| 8
| null | null |
siddhanathan/ghc
|
compiler/hsSyn/HsTypes.hs
|
bsd-3-clause
|
ignoreParens ty = ty
| 36
|
ignoreParens ty = ty
| 36
|
ignoreParens ty = ty
| 36
| false
| false
| 0
| 5
| 19
| 9
| 4
| 5
| null | null |
pbl64k/HackerRank-Contests
|
2014-10-10-FP/SequenceFullOfColors/sfoc.accepted.hs
|
bsd-2-clause
|
tst = do
cs <- getLine
putStrLn $ show $ slv (0, 0, 0, 0) cs
| 68
|
tst = do
cs <- getLine
putStrLn $ show $ slv (0, 0, 0, 0) cs
| 68
|
tst = do
cs <- getLine
putStrLn $ show $ slv (0, 0, 0, 0) cs
| 68
| false
| false
| 1
| 10
| 23
| 45
| 21
| 24
| null | null |
Southern-Exposure-Seed-Exchange/Order-Manager-Prototypes
|
spock/src/App.hs
|
gpl-3.0
|
omApp :: OM a
omApp = do
subcomponent "categories" categoryHandlers
subcomponent "products" productHandlers
| 115
|
omApp :: OM a
omApp = do
subcomponent "categories" categoryHandlers
subcomponent "products" productHandlers
| 115
|
omApp = do
subcomponent "categories" categoryHandlers
subcomponent "products" productHandlers
| 101
| false
| true
| 1
| 8
| 20
| 34
| 13
| 21
| null | null |
bos/statistics
|
Statistics/Distribution/Transform.hs
|
bsd-2-clause
|
-- | Get fixed point of linear transformation
linTransFixedPoint :: LinearTransform d -> Double
linTransFixedPoint (LinearTransform loc sc _) = loc / (1 - sc)
| 158
|
linTransFixedPoint :: LinearTransform d -> Double
linTransFixedPoint (LinearTransform loc sc _) = loc / (1 - sc)
| 112
|
linTransFixedPoint (LinearTransform loc sc _) = loc / (1 - sc)
| 62
| true
| true
| 0
| 7
| 24
| 43
| 22
| 21
| null | null |
olorin/amazonka
|
amazonka-iam/gen/Network/AWS/IAM/SimulatePrincipalPolicy.hs
|
mpl-2.0
|
-- | Use this only when paginating results to indicate the maximum number of
-- items you want in the response. If there are additional items beyond the
-- maximum you specify, the 'IsTruncated' response element is 'true'.
--
-- This parameter is optional. If you do not include it, it defaults to
-- 100. Note that IAM might return fewer results, even when there are more
-- results available. If this is the case, the 'IsTruncated' response
-- element returns 'true' and 'Marker' contains a value to include in the
-- subsequent call that tells the service where to continue from.
sppMaxItems :: Lens' SimulatePrincipalPolicy (Maybe Natural)
sppMaxItems = lens _sppMaxItems (\ s a -> s{_sppMaxItems = a}) . mapping _Nat
| 721
|
sppMaxItems :: Lens' SimulatePrincipalPolicy (Maybe Natural)
sppMaxItems = lens _sppMaxItems (\ s a -> s{_sppMaxItems = a}) . mapping _Nat
| 138
|
sppMaxItems = lens _sppMaxItems (\ s a -> s{_sppMaxItems = a}) . mapping _Nat
| 77
| true
| true
| 0
| 10
| 121
| 61
| 36
| 25
| null | null |
scslab/iterIO
|
Examples/httpsEcho.hs
|
bsd-3-clause
|
parmsI :: (Monad m) => HttpReq s -> Iter L m Parms
parmsI req = foldForm req getPart []
where
getPart parts mp = do
front <- takeI 50
backLen <- countI
return ((mp,front,backLen):parts)
| 200
|
parmsI :: (Monad m) => HttpReq s -> Iter L m Parms
parmsI req = foldForm req getPart []
where
getPart parts mp = do
front <- takeI 50
backLen <- countI
return ((mp,front,backLen):parts)
| 200
|
parmsI req = foldForm req getPart []
where
getPart parts mp = do
front <- takeI 50
backLen <- countI
return ((mp,front,backLen):parts)
| 149
| false
| true
| 0
| 10
| 48
| 98
| 47
| 51
| null | null |
ygale/yesod
|
yesod-form/Yesod/Form/Bootstrap3.hs
|
mit
|
withLargeInput :: FieldSettings site -> FieldSettings site
withLargeInput fs = fs { fsAttrs = newAttrs }
where newAttrs = addClass "input-lg" (fsAttrs fs)
-- | Add the @input-sm@ CSS class to a field.
--
-- Since: yesod-form 1.3.8
| 236
|
withLargeInput :: FieldSettings site -> FieldSettings site
withLargeInput fs = fs { fsAttrs = newAttrs }
where newAttrs = addClass "input-lg" (fsAttrs fs)
-- | Add the @input-sm@ CSS class to a field.
--
-- Since: yesod-form 1.3.8
| 236
|
withLargeInput fs = fs { fsAttrs = newAttrs }
where newAttrs = addClass "input-lg" (fsAttrs fs)
-- | Add the @input-sm@ CSS class to a field.
--
-- Since: yesod-form 1.3.8
| 177
| false
| true
| 0
| 7
| 43
| 54
| 28
| 26
| null | null |
GregorySchwartz/tree-fun
|
src/Math/TreeFun/Tree.hs
|
gpl-3.0
|
-- | Return the list of properties in a property map for a tree
getProperties :: (Eq b) => PropertyMap a b -> [b]
getProperties = nub . F.toList . F.foldl' (S.><) S.empty . M.elems
| 180
|
getProperties :: (Eq b) => PropertyMap a b -> [b]
getProperties = nub . F.toList . F.foldl' (S.><) S.empty . M.elems
| 116
|
getProperties = nub . F.toList . F.foldl' (S.><) S.empty . M.elems
| 66
| true
| true
| 0
| 8
| 34
| 62
| 33
| 29
| null | null |
sdiehl/ghc
|
compiler/utils/Outputable.hs
|
bsd-3-clause
|
cat ds = SDoc $ \sty -> Pretty.cat [runSDoc d sty | d <- ds]
| 62
|
cat ds = SDoc $ \sty -> Pretty.cat [runSDoc d sty | d <- ds]
| 62
|
cat ds = SDoc $ \sty -> Pretty.cat [runSDoc d sty | d <- ds]
| 62
| false
| false
| 0
| 10
| 16
| 39
| 19
| 20
| null | null |
Mathnerd314/lamdu
|
bottlelib/Data/Cache.hs
|
gpl-3.0
|
lookupHelper :: Key k => (KeyBS -> r) -> (KeyBS -> ValEntry -> r) -> k -> Cache -> r
lookupHelper onMiss onHit key cache =
maybe (onMiss bsKey) (onHit bsKey) .
Map.lookup bsKey $ cache ^. cEntries
where
bsKey = bsOfKey key
| 232
|
lookupHelper :: Key k => (KeyBS -> r) -> (KeyBS -> ValEntry -> r) -> k -> Cache -> r
lookupHelper onMiss onHit key cache =
maybe (onMiss bsKey) (onHit bsKey) .
Map.lookup bsKey $ cache ^. cEntries
where
bsKey = bsOfKey key
| 232
|
lookupHelper onMiss onHit key cache =
maybe (onMiss bsKey) (onHit bsKey) .
Map.lookup bsKey $ cache ^. cEntries
where
bsKey = bsOfKey key
| 147
| false
| true
| 3
| 11
| 52
| 117
| 53
| 64
| null | null |
charles-cooper/postgresql-orm
|
examples.hs
|
gpl-3.0
|
bar :: Bar
bar = Bar NullKey (Just 44) "hi" Nothing
| 51
|
bar :: Bar
bar = Bar NullKey (Just 44) "hi" Nothing
| 51
|
bar = Bar NullKey (Just 44) "hi" Nothing
| 40
| false
| true
| 0
| 7
| 10
| 32
| 14
| 18
| null | null |
brendanhay/gogol
|
gogol-servicenetworking/gen/Network/Google/Resource/ServiceNetworking/Services/Roles/Add.hs
|
mpl-2.0
|
-- | JSONP
sraCallback :: Lens' ServicesRolesAdd (Maybe Text)
sraCallback
= lens _sraCallback (\ s a -> s{_sraCallback = a})
| 126
|
sraCallback :: Lens' ServicesRolesAdd (Maybe Text)
sraCallback
= lens _sraCallback (\ s a -> s{_sraCallback = a})
| 115
|
sraCallback
= lens _sraCallback (\ s a -> s{_sraCallback = a})
| 64
| true
| true
| 0
| 9
| 21
| 48
| 25
| 23
| null | null |
aisamanra/config-ini
|
src/Data/Ini/Config/Bidir.hs
|
bsd-3-clause
|
-- | If the field is not found in parsing, simply skip instead of
-- raising an error or setting anything.
optional :: FieldDescription t -> FieldDescription t
optional fd = fd {fdSkipIfMissing = True}
| 203
|
optional :: FieldDescription t -> FieldDescription t
optional fd = fd {fdSkipIfMissing = True}
| 94
|
optional fd = fd {fdSkipIfMissing = True}
| 41
| true
| true
| 0
| 6
| 36
| 34
| 18
| 16
| null | null |
danr/hipspec
|
src/HipSpec/Utils.hs
|
gpl-3.0
|
-- | Pretty show
ppShow :: Show a => a -> String
ppShow = Pretty.ppShow
| 71
|
ppShow :: Show a => a -> String
ppShow = Pretty.ppShow
| 54
|
ppShow = Pretty.ppShow
| 22
| true
| true
| 0
| 6
| 14
| 25
| 13
| 12
| null | null |
creichert/persistent
|
persistent-sqlite/Database/Persist/Sqlite.hs
|
mit
|
escape :: DBName -> Text
escape (DBName s) =
T.concat [q, T.concatMap go s, q]
where
q = T.singleton '"'
go '"' = "\"\""
go c = T.singleton c
| 159
|
escape :: DBName -> Text
escape (DBName s) =
T.concat [q, T.concatMap go s, q]
where
q = T.singleton '"'
go '"' = "\"\""
go c = T.singleton c
| 159
|
escape (DBName s) =
T.concat [q, T.concatMap go s, q]
where
q = T.singleton '"'
go '"' = "\"\""
go c = T.singleton c
| 134
| false
| true
| 3
| 9
| 46
| 94
| 40
| 54
| null | null |
tamarin-prover/tamarin-prover
|
lib/theory/src/Theory/Model/Formula.hs
|
gpl-3.0
|
-- | Change the representation of atoms.
mapAtoms :: (Integer -> ProtoAtom syn (VTerm c (BVar v))
-> ProtoAtom syn1 (VTerm c1 (BVar v1)))
-> ProtoFormula syn s c v -> ProtoFormula syn1 s c1 v1
mapAtoms f = foldFormulaScope (\i a -> Ato $ f i a) TF Not Conn Qua
| 278
|
mapAtoms :: (Integer -> ProtoAtom syn (VTerm c (BVar v))
-> ProtoAtom syn1 (VTerm c1 (BVar v1)))
-> ProtoFormula syn s c v -> ProtoFormula syn1 s c1 v1
mapAtoms f = foldFormulaScope (\i a -> Ato $ f i a) TF Not Conn Qua
| 237
|
mapAtoms f = foldFormulaScope (\i a -> Ato $ f i a) TF Not Conn Qua
| 67
| true
| true
| 0
| 13
| 69
| 120
| 59
| 61
| null | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.