lang
stringclasses 10
values | seed
stringlengths 5
2.12k
|
|---|---|
haskell | {-# LANGUAGE RankNTypes, OverloadedStrings #-}
{-# LANGUAGE CPP #-}
module Test.Tasty.Silver.Advanced
( -- * Constructing golden tests
goldenTest1,
goldenTestIO,
goldenTestIO1, |
haskell | import qualified Tunebank.Model.AbcMetadataSubmission as NewTune (AbcMetadataSubmission(..))
import Tunebank.Model.Comment (CommentId(..), Comment(..))
import qualified Tunebank.Model.CommentSubmission as CommentMsg (Submission(..))
import Data.Abc.Validator (normaliseKeySignature, normaliseRhythm)
import Debug.Trace (traceM)
-- | This is just a simple newtype wrapper for our 'IORef'.
newtype DBConfig = DBConfig {
_getPool :: Pool Connection
}
-- | This is also a simple newtype wrapper for our DB Monad. This is very
-- similar to Persistent's 'SqlPersistT' type.
newtype PostgresT m a = PostgresT (ReaderT DBConfig m a) |
haskell | module Main where
mathTables :: [(Integer, Integer, Integer)]
mathTables = [(x,y,x*y) | x <- [1..12], y <- [1..12]]
|
haskell | clearHeistCache :: Heist b -> IO ()
clearHeistCache = clearCacheTagState . _heistCTS
-----------------------------
-- SnapletSplice functions --
-----------------------------
------------------------------------------------------------------------------ |
haskell |
import Data.Functor ((<&>))
import Data.Foldable (traverse_)
import qualified Paths_aoc as Paths
import Challenge
main :: IO ()
main = do
traverse_ (\(challenge, num) -> do
fileLines <- Paths.getDataFileName ("data/" ++ _dataFile challenge) >>= readFile <&> lines
putStrLn $ show num ++ ".1: " ++ (_part1 challenge $ fileLines)
putStrLn $ show num ++ ".2: " ++ (_part2 challenge $ fileLines)
) (zip challenges [1..])
|
haskell | PrettyPC(..),
ShowPC(..),
drawSubTrees,
drawAnnotations,
drawGroup,
shift,
terminalShift,
nonTerminalShift,
wrap,
indent, |
haskell | return (Just dstAddress)
getDstAddress (DstFile dstFile) addressesPath = do
maddress <- getAddress dstFile
case maddress of
Just address -> do
let dstAddress = fromJust maddress |
haskell | networkTest1 = testCase "Simple call" $ do
t <- tcpServer port
let server = serve t $ \ "mod" "f" [IntTerm a] -> return $ Success $ IntTerm (a+1)
withAsync server $ \_ -> do
delay
c <- tcpClient "localhost" port
result <- call c "mod" "f" [IntTerm 3]
result @?= Right (IntTerm 4)
|
haskell | ktokens = tokens where
tokens = spaces >> (end <|> more)
more = (:) <$> (numToken <|> wordToken) <*> tokens
end = eof >> return []
wordToken = do word <- many1 (noneOf " \t\r\n\f\v")
case word of "def" -> return KtDef
"extern" -> return KtExtern |
haskell |
type GenIdentPartEnabled p =
(GenIdentPartPrefix p ~ A Ident, GenIdentPartNum p ~ P Natural)
data EGenIdentPart p m a where
GetGenIdentPart :: GenIdentPartEnabled p => EGenIdentPart p m (Ident p)
makeSem ''EGenIdentPart
genIdentPart :: (GenIdentPartEnabled p, Member (EGenIdentPart p) r)
=> Sem r (Ident p)
genIdentPart = getGenIdentPart
|
haskell | deriving (Eq, Ord, Show)
addPlayers :: IO Players
addPlayers = addPlayers' PlayersInfo { _p1 = "", _p2 = "", _p3 = "", _p4 = "" }
addPlayers' :: PlayersInfo -> IO Players |
haskell | module Kadena.Types
( module X
) where
-- NB: This is really the Consensus Service's type module but as consensus is all encompassing, it's also the primary types file
-- NB: this is evil, please remove
import Kadena.Types.Base as X
import Kadena.Types.Comms as X
import Kadena.Types.Command as X
import Kadena.Types.Config as X
import Kadena.Types.ConfigChange as X
import Kadena.Types.Dispatch as X
import Kadena.Types.Event as X
import Kadena.Types.Evidence as X |
haskell | ZeroD == ZeroD = True
(SuccD a) == (SuccD b) = a == b
_ == _ = False;
equalDC :: D [] -> D [] -> Bool;
equalDC = (==);
foo :: D []
foo = SuccD [SuccD [ZeroD], ZeroD]
|
haskell | foldOrientation :: a -> a -> Orientation -> a
foldOrientation l _ Horizontal = l
foldOrientation _ r Vertical = r
-- | get the point before the given point, vertically or horizontally
beforeByOrientationP :: Orientation -> Point -> Point
beforeByOrientationP = foldOrientation leftOfP aboveP
-- | get the point after the given point, vertically or horizontally
afterByOrientationP :: Orientation -> Point -> Point |
haskell | module Domain.Model.Actor,
module Domain.Model.Character,
module Domain.Model.Country,
module Domain.Model.Work
)
where
import Domain.Model.Actor
import Domain.Model.Character
import Domain.Model.Country |
haskell | module Models.HomeContext.From
( fromPosts
) where
import qualified Hakyll
import qualified Models.PostContext.Main as PostContext
fromPosts :: [Hakyll.Item String] -> Hakyll.Tags -> Hakyll.Context String
fromPosts posts tags =
Hakyll.listField "posts" (PostContext.fromTags tags) (take 10 <$> Hakyll.recentFirst posts)
|
haskell | _ -> json noMatch
checkCycle3 :: MatchingRequestChecker
checkCycle3 _ MatchingRequest { cycle3Dataset = Just (Cycle3Dataset (NinoAttribute "goodvalue")) } = json match
checkCycle3 nextCheck request = nextCheck request
checkMatchingDataset :: MatchingRequestChecker |
haskell | class Monad m =>
MonadHandle h m
| m -> h
where
openFile :: FilePath -> IOMode -> m h
hPutStr :: h -> String -> m ()
hClose :: h -> m ()
hGetContents :: h -> m String
hPutStrLn :: h -> String -> m ()
hPutStrLn h s = hPutStr h s >> hPutStr h "\n" |
haskell |
import Graphics.Vty (Vty (nextEvent, update), mkVty, userConfig, text, shutdown, horizCat, Image, picForImage, defAttr, withForeColor, red)
-- TODO: This won't take care of background and cursor
-- We don't use the existing Monoid instance for Images
type View = [Image]
initConcur :: IO ()
initConcur = return ()
|
haskell |
import Statix.Regex as Re
data Path n l t = End n | Via (n, l, Maybe t) (Path n l t)
deriving (Eq)
type CriticalEdge n l = (n , Regex l)
{- A Graph monad interface -}
class (Monad m, Eq l, Ord n) => MonadGraph n l d m | m -> n l d where
newNode :: d -> m n |
haskell | import System.Environment (getArgs)
import Lib
main :: IO ()
main = head <$> getArgs >>= startApp
|
haskell | Run . flip Battery 50 $
concat
[ ["--template", onClick (const "~/scripts/powercontrol.sh menu") "\61457 <acstatus>"],
["--Low", "30"],
["--High", "80"],
["--low", danger],
["--normal", fg],
["--high", fg],
["--"],
["-o", "<left>%"], -- (<timeleft>)
["-O", "<left>% Charging"],
["-i", "<left>%"]
]
] |
haskell | -- the file's magic number is as follows:
--
-- 0x89 - high bit set, to check for 8 bit transmission errors and to avoid being treated as a text file
-- 3 bytes - identifies the particular file format. i.e. 'PNG' or 'JHC'
-- 0x0D 0x0A - DOS style line ending, to detect errors.
-- 0x1A - EOF marker, to avoid corrupting the screen when typed under dos/windows |
haskell | TestTree (insert (7 :: Int) (fromList [1 .. 6])) `shouldBe` TestTree (fromList [1 .. 7])
invariantBinatyTree (insert (8 :: Int) (fromList [1 .. 7])) `shouldBe` True
TestTree (insert (8 :: Int) (fromList [1 .. 7])) `shouldBe` TestTree (fromList [1 .. 8])
invariantBinatyTree (insert (9 :: Int) (fromList [1 .. 8])) `shouldBe` True
TestTree (insert (9 :: Int) (fromList [1 .. 8])) `shouldBe` TestTree (fromList [1 .. 9])
invariantBinatyTree (insert (1 :: Int) Leaf) `shouldBe` True
TestTree (insert (1 :: Int) Leaf) `shouldBe` TestTree (Node Leaf (1 NL.:| []) Leaf)
invariantBinatyTree (insert (1 :: Int) example2) `shouldBe` True
TestTree (insert (1 :: Int) example2) `shouldBe` TestTree example1 where
example1 = Node Leaf (1 NL.:| [1, 1, 1]) Leaf
example2 = Node Leaf (1 NL.:| [1, 1]) Leaf
testFromList :: SpecWith () |
haskell | <gh_stars>1-10
{-# LANGUAGE OverloadedStrings #-}
module GlobInString ( script ) where
import Prelude
import Shell
-- This test ensures that we escape string literals properly if they
-- have an embedded glob.
script :: ShellM ()
script = do
run $ command "echo" ["*"] |
haskell | {-# LANGUAGE MonoLocalBinds #-}
{-# LANGUAGE AllowAmbiguousTypes #-}
-- | A module describing error paths
module Rhodium.Blamer.Path where
import Data.List
import Data.Maybe
import qualified Data.Map as M
import Rhodium.TypeGraphs.Graph
import Rhodium.TypeGraphs.GraphReset
import Rhodium.TypeGraphs.GraphProperties
import Rhodium.TypeGraphs.GraphUtils
import Rhodium.TypeGraphs.Touchables
import Rhodium.Solver.Rules
|
haskell | app = do
rate <- option auto $ long "rate" <> help "sampling rate" <> value 44100
buf <- option auto $ long "buffer" <> help "number of samples for the buffer" <> value 1024
device <- option auto $ long "device" <> help "device index" <> value (-1)
helper
pure $ withPortAudio $ do
(_, devs) <- getDevices
if device < 0
then forM_ (zip [0 :: Int ..] devs) $ \(i, dev) ->
putStrLn $ show i ++ ": " ++ deviceName dev
else do
let dev = devs !! device
phase <- newMVar 0 |
haskell |
rng :: RNG
rng = mkRNG rng_periph_base
rccenable rccdisable
L476.RNG_HASH
where
rccenable = modifyReg rcc_reg_ahb2enr $ setBit rcc_ahb2enr_rngen
rccdisable = modifyReg rcc_reg_ahb2enr $ clearBit rcc_ahb2enr_rngen |
haskell |
playMuFourPlayersWithUpdates ::
(MonadRandom m, Bind m)
=> Updates m NOfFour (Tuple4 Score)
-> Dependencies m NOfFour
-> EndCondition
-> m (Tuple4 Score)
playMuFourPlayersWithUpdates (Updates dealUpdate biddingResultUpdate trickWinnerUpdate scoresUpdate) (Dependencies getBid getViceTrump getChiefTrump getPartner getCard) endCondition =
playMuWithUpdate scoresUpdate getCardPositions stages endCondition OneOfFour |
haskell | bob = reexport2 `seq` usedFunction1
class MyClass1 a where myClass1 :: a
class MyClass2 a where myClass2 :: a
class MyClass3 a where myClass3 :: a
foo _ = (myClass2, classWithFunc)
[quasi| hello |]
coerced = coerce coerceValue :: Int
|
haskell | )
where
largestFactor :: Integer -> Integer
largestFactor n = maximum $ factor n
factor :: Integer -> [Integer]
factor 1 = []
factor n =
let divisors =
dropWhile ((/= 0) . mod n) [2 .. ceiling $ sqrt $ fromIntegral n]
in let prime = if null divisors then n else head divisors
in (prime :) $ factor $ div n prime
main :: IO () |
haskell |
typeDecl :: ClosTypingEnvironment ()
typeDecl = do
declare (undefined :: DiffCrap)
declare (undefined :: TRecord)
declare (undefined :: TFunctions) |
haskell | {-# LANGUAGE StandaloneKindSignatures #-}
{-# LANGUAGE PolyKinds, ExplicitForAll #-}
module SAKS_Fail009 where
import Data.Kind (Type)
type T :: forall j -> j -> Type
data T (k :: Type -> Type) (a :: k)
|
haskell | import T3449A
class Foo a where
f1 :: a
f2 :: a
instance Foo Char where
f1 = f2
f2 = aChar |
haskell |
module Main where
import Text.HTML.TagSoup hiding (parseTags, renderTags)
import Text.HTML.TagSoup.Fast.Utf8Only
import Text.HTML.TagSoup.Entity
import Text.HTML.TagSoup.Match
import Control.Monad
import Data.List |
haskell | import Day1 (expenseReport)
ans :: IO Int
ans = calc <$> expenseReport
calc :: [Int] -> Int |
haskell | where
import Q.Currency
-- | Canadian dollar
cad :: Currency
cad = Currency {
cName = "Canadian dollar"
, cCode = "CAD"
, cIsoCode = 124
, cFracsPerUnit = 100
} |
haskell | noCacheP :: Parser Option
noCacheP = lexeme $ string "--no-cache" $> Cache Nothing
cacheP :: Parser Option
cacheP = lexeme $ Cache . Just <$> (string "--cache" *> char '\n' *> decimal)
intervalP :: Parser Option
intervalP = lexeme $ Interval <$> (string "--interval" *> char '\n' *> decimal)
urlP :: Parser Text
urlP = lexeme url |
haskell |
-- | Creates a list of temperaments.
tempList :: [Temp] -> TempList
tempList xs = TempList $ tabList $ fmap unTemp xs
-- | Selects one of the temperaments by index.
fromTempList :: TempList -> Sig -> Temp
fromTempList (TempList tab) asig = Temp $ fromTabList tab asig
-- | Selects one of the temperaments by index. Works at the time of instrument initialization (remains constant).
fromTempListD :: TempList -> D -> Temp |
haskell | {-# htermination truncate :: Float -> Int #-}
|
haskell |
pushBit :: Bit -> State Register32 Bit
pushBit bit = do
register <- get
put $ BitsExt.apply0Bit bit $ BitsExt.shiftl1 register
return $ BitsExt.testLeftBit register |
haskell | module Modules.Modules.Modules.Modules.Modules.Modules.M140 () where
|
haskell | import qualified Database.Redis as Redis
import Network.Wai.Middleware.Static
import System.Environment (lookupEnv)
import Web.Scotty.Hastache (scottyH', setTemplatesDir)
import Web.Scotty.Trans (file, get, middleware)
import qualified Controllers.Urls as UrlsCtrl (loadRoutes)
|
haskell | :<|> GetAllTodos
todoHandlers :: ServerT API App
todoHandlers =
newTodo
:<|> completeTodo
:<|> updateTodo
:<|> deleteTodo
:<|> getTodo
:<|> getTodos
-- | API
type API = "todo" :> TodoAPI
|
haskell | <> P.progDesc "Generate a single-elimination tournament bracket from new-line separated contestant names provided in stdin."
<> P.header "pingpongmageddon")
optParser :: P.Parser CmdArgs
optParser = CmdArgs
<$> P.flag GraphViz JSON (P.long "json"
<> P.short 'j'
<> P.help "Output JSON format tournament instead of GraphViz")
<*> P.option P.auto (P.long "seed"
<> P.short 's'
<> P.value defaultSeed
<> P.metavar "INTEGER"
<> P.help "Specify a fixed random seed") |
haskell | module Reverse where
rvrs :: String -> String
rvrs x = concat [awesome, is, curry]
where awesome = drop 9 x
is = take 4 (drop 5 x)
curry = take 5 x
main :: IO ()
main = print $ rvrs "Curry is awesome"
|
haskell | import OCI.Pass.Manager
import Data.TypeDesc
-- === Definition === --
newtype UnresolvedConses = UnresolvedConses [Expr Cons]
newtype NegativeConses = NegativeConses [Expr Cons]
makeLenses ''UnresolvedConses |
haskell |
-- This function takes a list of values and returns the list of zscores
-- Order is maintained
allZScores :: (Floating a) => [a] -> [a]
allZScores [] = []
allZScores [a] = [a]
allZScores xs = map getZ xs
where getZ = zScore (mean xs) (standardDeviation xs)
-- This will take a Score, a Mean, and a Standard Deviation and return the |
haskell | afew :: Test
afew = testGroup "Mixed, AFew" [testCase "AFew: C1" c1
,testCase "AFew: C2" c2
,testCase "AFew: C3" c3
,testCase "AFew: C4" c4]
where c1 = C1 @?= fromChurch (\ c _ _ _ -> c)
c2 = C2 1 'a' @?= fromChurch (\ _ f _ _ -> f 1 'a')
c3 = C3 True True @?= fromChurch (\ _ _ f _ -> f True True)
c4 = C4 @?= fromChurch (\ _ _ _ c -> c)
|
haskell | posType <- string "fen" <|> string "startpos"
spaces
(FEN pos _ _) <- if posType == "fen"
then fenParser
else return $ FEN initialBoard 0 0
spaces
liftM CmdPosition $ option pos (string "moves" >> parserMoveList pos)
where
parserMoveList pos = do
mm <- optionMaybe (spaces >> moveParser pos)
case mm of
Just m -> parserMoveList $ makeMove m pos |
haskell | , reserved
, whiteSpace
, withinBraces
, withinBrackets
, withinParens )
import Text.Parsec
import Text.Parsec.String (Parser)
import qualified Data.Text as T
-- | Parse a ghost module definition. I.e. the main structure for a
-- ghost-lang module. |
haskell | serversFull :: Int -> [(ServerCfg, Maybe Int)] -> Bool
serversFull max = all (isStoppedOrFull . snd)
where isStoppedOrFull (Just cnt) = cnt >= max
isStoppedOrFull Nothing = True
firstDown :: [(ServerCfg, Maybe Int)] -> Maybe ServerCfg
firstDown = (fst <$>) . find (isNothing . snd)
needToStop :: Int -> [(ServerCfg, Maybe Int)] -> [ServerCfg]
needToStop max srvs = map fst $ case nonEmpty of
[] -> drop 1 empty
_ -> empty
where running = map (fmap fromJust) $ filter (isJust . snd) srvs
nonFull = filter ((< max) . snd) running
(nonEmpty, empty) = partition ((> 0) . snd) nonFull |
haskell |
{-|
Constructs a 'Clause' from a list of 'Literal's
-}
mkClauseFromLits :: [Literal] -> Clause
mkClauseFromLits =
foldl clauseAddLiteral emptyClause |
haskell | , " </div>"
, " <div align='center'>"
, " <div class='textareas'>"
, " <textarea id='tree1' rows='1'></textarea>"
, " <textarea id='code1' rows='1'></textarea>"
, " </div>"
, " </div>"
, " </div>"
, " <div id='col2' class='col'>"
, " <div align='center'>"
, " <input class='dna' type='text' value='FF' id='input2' autocomplete='off' autocorrect='off' autocapitalize='off' spellcheck='false'>"
, " </div>" |
haskell | go [] n = (one,n)
go (p : ps) n =
if n <= 1 then (one,n)
else (multiply f (primePower p r), m)
where
(r,s) = factorOut p n
(f,m) = go ps s
destSmooth :: [Natural] -> Natural -> Maybe Factor
destSmooth ps n =
if m == 1 then Just f else Nothing
where
(f,m) = trialDivision ps n |
haskell | TokPipe -> "|"
TokTick -> "`"
TokDot -> "."
TokComma -> ","
TokUnderscore -> "_"
TokBackslash -> "\\"
TokLowerName qual name -> printQual qual <> name
TokUpperName qual name -> printQual qual <> name
TokOperator qual sym -> printQual qual <> sym
TokSymbolName qual sym -> printQual qual <> "(" <> sym <> ")" |
haskell | -- Exercise#5
-- Quicksort of numbers.
-- What would be the effect of replacing <= by < in the original definition of qsort? Hint: consider the example qsort1 [2,2,3,1,1].
-- Exercise on page#13: 1.7.5 -- PIH, Second Edition.
-- <NAME> V V :: 01st Oct, 2016.
qsort1 :: Ord a => [a] -> [a]
qsort1 [] = [] |
haskell | module Barbies.Internal
( -- * Functor
Internal.gbmapDefault
, Generics.GFunctor(..)
, Internal.CanDeriveFunctorB
, Internal.CanDeriveFunctorT
-- * Traversable |
haskell | part1 :: (Gen, Gen) -> Int
part1 (a,b) = length $ filter (==0) $ take (40*10^6) $ zipWith bitcount ga gb
where
ga = generator $ a { _filter = 1 }
gb = generator $ b { _filter = 1}
part2 :: (Gen, Gen) -> Int
part2 (a,b) = length $ filter (==0) $ take ( 5*10^6) $ zipWith bitcount ga gb
where
ga = generator a
gb = generator b |
haskell | , diversifyN
-- ** Inverse Injection
, Reinterpret
-- , Reinterpreted
, reinterpret
, Reinterpret'
, reinterpret'
, ReinterpretL
-- , ReinterpretedL
, reinterpretL
, ReinterpretL'
, reinterpretL'
, ReinterpretN'
, reinterpretN'
|
haskell | , secureHandshake
, module Oscoin.P2P.Handshake.Simple
, module Oscoin.P2P.Handshake.Noise
, Types.Handshake
, Types.HandshakeRole(..)
, Types.HandshakeResult
, Types.hrPeerInfo
, Types.hrPreSend
, Types.hrPostRecv
, Types.HandshakeT |
haskell | {-# LANGUAGE TemplateHaskell #-}
-- | Static files.
module HL.Static where
import Yesod.Static
staticFiles "static/"
|
haskell |
module Y2020.AOC23 where
import AOC (Solution (PureSolution))
import Data.List (foldl') |
haskell |
Maintainer : <EMAIL>
-}
module Camfort.Input
(
-- * Classes
Default(..)
-- * Datatypes and Aliases
, ProgramFile |
haskell |
data Parappa f g a = DaWrappa (f a) (g a)
instance (Functor f, Functor g) => Functor (Parappa f g) where
fmap f (DaWrappa fa ga) = DaWrappa (fmap f fa) (fmap f ga)
data IgnoreOne f g a b = IgnoringSomething (f a) (g b)
instance Functor g => Functor (IgnoreOne f g a) where
fmap f (IgnoringSomething fa gb) = IgnoringSomething fa (fmap f gb)
data Notorious g o a t = Notorious (g o) (g a) (g t)
instance Functor g => Functor (Notorious g o a) where |
haskell | => IndexEntry
-> FilePath
-> HMGitT m ()
putLs _ fp = liftIO $ putStrLn fp
putLsDetail :: MonadIO m
=> IndexEntry
-> FilePath
-> HMGitT m ()
putLsDetail idx fp = liftIO |
haskell | mydrop _ [] = []
mydrop 0 xs = xs
mydrop n (x:xs) = mydrop (n-1) xs
-- mydrop 3 [1,2,3,4,5]
-- mydrop 2 [2,3,4,5]
-- mydrop 1 [3,4,5]
-- mydrop 0 [4,5]
-- [4,5]
myinit :: [a] -> [a] |
haskell | <gh_stars>10-100
-- Lucas numbers
-- http://www.codewars.com/kata/55a7de09273f6652b200002e/
module Codewars.Exercise.Lucas where
lucasnum :: Int -> Integer
lucasnum n = (if (n<0) then (-1)^n' else 1) * (fibS n' + 2 * fibS (n'-1))
where n' = abs n
fib = (map fibS [0 ..] !!)
fibS 0 = 0
fibS 1 = 1
fibS k | k > 0 = fib (k-2) + fib (k-1) |
haskell | module FluentTest
(
) where
data Fluent a = Fluent a
|
haskell | , 0xFB1E
, 0x8BF9
, 0x9BD8
, 0xABBB
, 0xBB9A
, 0x4A75 |
haskell | bin2dec' _ x = trace ( "the value is expected binary value composed of '0' or '1'. The written value is incorrect") undefined
hexNumP = hex2dec <$> (string "0x" *> many alphaNum) where
hex2dec nums = toDecimal hex2dec' nums
hex2dec' c x = case lookup (toUpper c) $ zip "0123456789ABCDEF" [0..] of
Just v -> v * 16^x |
haskell | newtype TMVar a = TMVar (TVar (Maybe a))
newTMVar :: a -> STM (TMVar a)
newTMVar a = do
t <- newTVar (Just a)
return $ TMVar t |
haskell | {-# LANGUAGE Safe #-}
module Data.UTC.Class.Epoch
( Epoch(..)
) where
-- | The instant in time also known as __the epoch__: 1970-01-01T00:00:00Z
class Epoch t where
epoch :: t
|
haskell | isNothing' = not . isJust'
mayybee :: b -> (a -> b) -> Maybe a -> b
mayybee x f y = fromMaybe x (f <$> y)
fromMaybe' :: a -> Maybe a -> a
fromMaybe' x Nothing = x
fromMaybe' _ (Just x') = x'
data BinaryTree a =
Leaf |
haskell | instance QqStyleOptionMenuItem ((QStyleOptionMenuItem t1)) where
qStyleOptionMenuItem (x1)
= withQStyleOptionMenuItemResult $
withObjectPtr x1 $ \cobj_x1 ->
qtc_QStyleOptionMenuItem1 cobj_x1
foreign import ccall "qtc_QStyleOptionMenuItem1" qtc_QStyleOptionMenuItem1 :: Ptr (TQStyleOptionMenuItem t1) -> IO (Ptr (TQStyleOptionMenuItem ()))
|
haskell | , ft_Get_Sfnt_LangTag'
) where
import FreeType.Core.Base.Types
import FreeType.Core.Types.Types
import FreeType.Format.SFNT.Types
import Foreign.Ptr
|
haskell | let out = \s -> writer ((), s)
inp = return "42"
run = register (Money 0) inp out
result = lines (snd (runWriter run))
result `shouldBe` ["42.00"]
it "can add amounts, printing the total" $ do |
haskell | move' = foldl' move1'
origin' :: (Int, Int)
origin' = (3, 1)
positions' :: [[Direction]] -> [(Int, Int)]
positions' ds = scanl move' origin' ds
buttons' :: [[Direction]] -> [Char]
buttons' ds = map button' $ positions' ds
result2 =
do t <- input
-- t <- pure test :: IO Text
case parseOnly directionSet t of |
haskell | data Ctxt = Ctxt { _req :: FnRequest
, db :: Pool Connection
, library :: Library
, pushover :: Maybe (Push.APIToken, Push.UserKey)
, siteurl :: Text
}
instance RequestContext Ctxt where |
haskell | Lua.callFunc "table.pack" True (23 :: Lua.Integer) (Char8.pack "moin")
, "failing lua procedure call" =:
"foo" `shouldBeErrorMessageOf` do
Lua.openlibs
Lua.callFunc "error" (Char8.pack "foo") :: Lua ()
, "Error when Lua-to-Haskell result conversion fails" =:
"expected string, got 'false' (boolean)" `shouldBeErrorMessageOf` do
Lua.openlibs
Lua.callFunc "rawequal" (Char8.pack "a") () :: Lua String
]
-- The following test case will hang if there's a problem with garbage
-- collection. |
haskell |
import DB.Model.Convert.Value.Native (encode, decodeMaybe)
-- import LibPrelude.Types
import LibPrelude
import qualified Network.Google.Datastore as DS
import Data.Typeable
import Data.Text (Text)
import qualified Data.Scientific as Sci |
haskell |
{-# INLINE modify #-}
modify :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> (a -> a) -> Int -> m ()
modify = MG.modify
{-# INLINE unsafeRead #-}
unsafeRead :: (PrimMonad m, Storable a) => MVector (PrimState m) a -> Int -> m a
unsafeRead = MG.unsafeRead
{-# INLINE unsafeWrite #-} |
haskell | import qualified Data.Set as Set
-- import Data.Time
-- import GHC.Exts
import System.Directory
import Network.POP3.SSLClient |
haskell |
-- | obtain pointer to the underlying data if applicable
array'data'ptr ::
forall m r.
(MonadPlus m) =>
f a ->
(Storable a => ForeignPtr a -> m r) ->
m r
data DeviceArray a = (Storable a, EdhXchg a, Typeable a) =>
DeviceArray
{ device'array'cap :: !Int,
device'array'ref :: !(ForeignPtr a) |
haskell | import GHC.TypeLits (Nat, natVal, KnownNat)
data Foo = Bar Nat
data SFoo = SBar Int
deriving (Show)
type family ExtractNat (a :: Foo) :: Nat where
ExtractNat (Bar x) = x
sing :: forall a. KnownNat (ExtractNat a) => Proxy a -> SFoo |
haskell | module Main where
import SmackMyBitch
main :: IO ()
main = sendMsg |
haskell | initVal = toReal $ Fraction num den
in valSimplified == initVal
-- | Tests addition of fractions
prop_addition :: Fraction -> Fraction -> Bool
prop_addition fracA fracB = let
eval1 = toReal (fracA + fracB)
eval2 = (toReal fracA) + (toReal fracB)
in abs(eval1 - eval2) < marginErr -- Can't test for equality due to floating point errors |
haskell | import Classifier
import Data.Set (Set)
import qualified Data.Set as Set
import System.IO.Unsafe (unsafePerformIO)
import qualified System.Random as R |
haskell | findAppointments :: Day -> (Appointment -> Bool) -> WD [Appointment]
findAppointments lastDay p = do
appts <- findFirstAppointments lastDay
if null appts
then return []
else do
let appts'
= filter
(allP [ (<= nextDayStartTime lastDay) . time, p ]) |
haskell | -- and one actual. These sets of alerts can either be pushed to us by
-- Prometheus, or we can poll for them from AlertManager. The mode of operation
-- can be specified on a per-source basis.
--
-- In the case of alerts being pushed to us, we use a PushSource to keep a
-- reference to some mutable state (the latest list of alerts) so that we have
-- something to compare against when we are asked to perform a comparison.
--
-- In the case of us having to pull alerts, we use a PullSource to store the
-- URL of the AlertManager from which to pull, and an optional token with which |
haskell | import Control.Monad.Fix (fix)
import Control.Monad.IO.Class (MonadIO, liftIO)
import Control.Monad.Trace
import Control.Monad.Trans.Control (MonadBaseControl)
import Data.IORef (modifyIORef', newIORef, readIORef)
-- | Runs a 'TraceT' action, returning any collected samples alongside its output. The samples are
-- sorted chronologically by completion time (e.g. the head is the first span to complete).
-- |
haskell | <gh_stars>0
-- See https://hspec.github.io/hspec-discover.html for details
{-# OPTIONS_GHC -F -pgmF hspec-discover #-} |
haskell | next res
evalMemoryMonad state (ModifyBitfield mut next) = do
modifyTVar' (torrentStateBitField state) (force . mut)
next
evalMemoryMonad state (ReadRequestablePieces next) = do
res <- readTVar (torrentStateRequestablePieces state)
next res
evalMemoryMonad state (ModifyRequestablePieces mut next) = do
modifyTVar' (torrentStateRequestablePieces state) (force . mut)
next
evalMemoryMonad state (RecordDownloaded s b next) = do |
haskell | ( OctrcArgs(..)
, getOctrcArgs
) where
import Data.List ( isSuffixOf )
import Data.Maybe ( fromMaybe )
import Data.Semigroup ( (<>) )
import Data.Typeable ( Typeable )
import Options.Applicative
import System.Directory ( createDirectoryIfMissing )
import Octrc.Common |
haskell |
perms treat ctrl = (less,total) where
total = binomial (length ctrl + length treat) (length treat)
less = length $ filter (<= sum treat)
$ sums (treat ++ ctrl) (length treat)
sums x n
| l < n || n < 0 = [] |
haskell | else take 1 cShownReducedExp ++ "." ++ drop 1 cShownReducedExp
| c == 0 = "0"
| otherwise = dropZerosFromRight $
if read cShownReducedExp > (-10 :: Integer)
then cShownReducedExp
else take 2 cShownReducedExp ++ "." ++ drop 2 cShownReducedExp
in c' ++ "e" ++ (if e >= 0 then "+" else "") ++ show e |
haskell | mcx_circ :: QbIn
-> Circ QbOut
mcx_circ = unpack template_mcx
mcx_reversible :: (QbIn,QbOut)
-> Circ (QbIn,QbOut)
mcx_reversible = classical_to_reversible mcx_circ
build_circuit
mcx_m :: (Bool,Bool,Bool,Bool,Bool,Bool,Bool,Bool,Bool) -> Bool
mcx_m (a0,a1, a2, a3, a4, a5, a6, a7, a8) =
a0 && a1 && a2 && a3 && a4 && a5 && a6 && a7 && a8
|
haskell | ---
data ListZipper a = LZ a [a] [a] -- LZ(a) = a * L(a)^2
left :: ListZipper a -> ListZipper a
left (LZ _ [] _) = error "already on the left end"
left (LZ a (x:l) r) = LZ x l (a:r) |
haskell | -- Copyright : (C) 2015-2016, <NAME>
-- License : None
-- Maintainer : <NAME> <<EMAIL>>
-- Stability : experimental
--
-- Types for the ParodyBot, including some very simple access to Spotify.
----------------------------------------------------------------------------
module SpotTypes where
|
haskell | -- just recursively go through the list of primes to compute the factors of n
primeFactors n = factor n primes
where factor n (p:ps)
| p*p > n = [n]
| n `mod` p == 0 = p : factor (n `div` p) (p:ps)
| otherwise = factor n ps
ans = last (primeFactors 600851475143) |