lang stringclasses 10
values | seed stringlengths 5 2.12k |
|---|---|
haskell | Var -> " variable."
Fun -> " function."
Data -> " datatype."
Constr -> " constructor."
Array -> "n array."
ArgNum expected found -> "Incorrect number of arguments, found " ++ show found ++ " but was expecting " ++ show expected
DimNum expected found -> "Incorrect nu... |
haskell | module Math.Equal(equal) where
equal :: (Eq a, Num a, Ord a, Fractional a) => a -> a -> Bool
equal a b
| (abs (a - b)) <= 0.011 = True
| otherwise = False
|
haskell | {-# LANGUAGE DataKinds #-}
{-# LANGUAGE TypeOperators #-}
module ApiType where
import Data.Text
import Data.Time (UTCTime)
import Servant.API
|
haskell | module Fib where
-- | Calculate Fibonacci numbers.
--
-- >>> putStrLn "foo"
-- foo |
haskell | unlines $ [
"Wuss poppin' B?",
"/start",
"/say &(echo|gangsta) <text>",
"/quiz",
"/register" |
haskell |
ponziSchemeMagnitude :: PonziScheme -> Integer
ponziSchemeMagnitude scheme =
case scheme of
Victim _ -> 1
Fraudster _ victims ->
case victims of
[] -> |
haskell | ticksUpdateRate (NonZero x) = label "updating rate and ticking once returns current rate" $ deltaEq 0.005 (rate run) x
where
run = tick $ update x $ empty 5 1
constantRates :: Property
constantRates = label "constant rates" $ \(NonZero x) -> forAll smallNumbers $ \t ->
deltaEq 0.005 x $ rate (iterate (tick . ... |
haskell | import qualified Data.ByteString.Lazy as L
import Data.Int
import qualified Control.Exception as E
type ChunkSize = Maybe Int64
{- Gets a remote's configured chunk size. -}
chunkSize :: RemoteConfig -> ChunkSize
chunkSize m =
case M.lookup "chunksize" m of
Nothing -> Nothing
Just v -> case readSize dataUnits v o... |
haskell | -- catsup setup
-- Simple .hs setup
--
-- this is only a test
import Distribution.Simple
main = defaultMain
|
haskell |
burgerEmoji :: Burger -> Text
burgerEmoji _ = " 🍔 "
toppingMenu :: [Topping] |
haskell | module Main where
import Dhall.JSON (Conversion(..))
import Test.Tasty (TestTree)
import qualified Control.Exception as Exception
import qualified Data.Aeson as Aeson
import qualified Data.ByteString.Lazy
import qualified Data.Text
import qualified Data.Text.IO
import qualified Dhall.Core as Co... |
haskell | , D.vcat
[ D.fillSep [D.cyan "import","Html"]
, ""
, D.fillSep [D.green "main","="]
, D.indent 2 $ D.fillSep [D.cyan "Html" <> ".text",D.dullyellow "\"Hello!\""]
]
, D.reflow $
"Try adding something like that!"
, D.toSimpleNote $
"I recommend looking t... |
haskell | fs <- runIO $ getFilesInDir dir
describe ("successfully typechecks files in " ++ dir) $ do
forM_ fs $ \f -> do
it ((takeFileName f) ++ " typechecks.") $ do
res <- parseFromFile (thrillParser <* eof) f
shouldSucceed res |
haskell | , "ugml (68) -> gyxo, ebii, jptl"
, "gyxo (61)"
, "cntj (57)"
]
spec :: Spec
spec = do
describe "part 1" $
it "examples" $
day7a example `shouldBe` Just "tknk"
describe "part 2" $
it "examples" $ |
haskell | module Main where
import Linear
import Maze
import System.Environment
import System.Random
main :: IO ()
main = do |
haskell | _ /\ _ = E
mustBeType :: TT Relevance -> Ver ()
mustBeType ty = conv ty (V typeOfTypes)
verify :: Program Relevance -> Either VerFailure ()
verify prog = runVer (builtins relOfType) $ verProg prog
verProg :: Program Relevance -> Ver ()
verProg prog = do
_ <- verTm R prog
return ()
verDefs :: [Def Relevance]... |
haskell | let (bus, m) = firstBus minutes $ parseInput $ last xs
in bus * m
where
minutes = read $ head xs
extendedEuclid :: (Integral a) => a -> a -> (a, a, a)
extendedEuclid 0 b = (b, 0, 1)
extendedEuclid a b = |
haskell | raw <- getEnv "MANDRILL_API_KEY"
resp <- runMandrill (ApiKey $ Text.pack raw) $
let met = Metadata { _metadata_name = "hello"
, _metadata_state = STATE_active
, _metadata_view_template = "bla"
}
in Metadata... |
haskell | } deriving (Show, Generic)
instance FromJSON NtpConfiguration where
parseJSON = genericParseJSON defaultOptions
instance ToJSON NtpConfiguration where
toJSON = genericToJSON defaultOptions
|
haskell |
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-- for Data.Semigroup
-----------------------------------------------------------------------------
-- |
-- Module : Diagrams.Transform
-- Copyright : (c) 2011-15 diagrams-lib team (see LICENSE) |
haskell | {-- snippet third --}
third (a, b, c) = c
{-- /snippet third --}
{-- snippet complicated --}
complicated (True, a, x:xs, 5) = (a, xs)
{-- /snippet complicated --}
|
haskell |
-- log 0 is -Infinity, that's right out
-- log 1 is perfectly fine, but let's avoid it anyway for symmetry
clipProb = min (1-epsilon) . max epsilon
-- TODO: Currently, when finding the gradient at player X, we compute the
-- objective function over all games in X's component. But actually the
-- gradient for X onl... |
haskell | data FundEx1 = FundConEx1 {z1 :: Integer, y1 :: String}
data FundEx2 = FundConEx2 {z3 :: Integer -> String, z4 :: String}
--add :: Int -> Int -> Int
--add x y = x + y
--func = Fund1 {}
|
haskell | readTodoFile filename = do
contents <- readFile filename
return $ parseTodoFile filename contents
-- XXX: Move to some utility class
expandUser :: FilePath -> IO FilePath
-- "~" => "/home/foo"
expandUser "~" = getHomeDirectory
-- "~/bar" => "/home/foo/bar" |
haskell | <gh_stars>10-100
module Animate.Preview.Mode where
data Mode
= Mode'Playback
| Mode'Stepper
deriving (Show, Eq) |
haskell | Datatypes.Coq_nil (LntT.Id_pfc Datatypes.O)) (Datatypes.Coq_pair
(Datatypes.Coq_cons (LntT.Var Datatypes.O) Datatypes.Coq_nil) (Datatypes.Coq_cons
(LntT.Var Datatypes.O) Datatypes.Coq_nil)))))
seq :: Datatypes.Coq_list
(Datatypes.Coq_prod
(Datatypes.Coq_prod (Datatypes.Coq... |
haskell | translate :: Char -> Either Char Char
translate 'G' = Right 'C'
translate 'C' = Right 'G'
translate 'T' = Right 'A'
translate 'A' = Right 'U'
translate c = Left c |
haskell | withoutHeader :: Proxy (Get '[JSON] (Headers '[] Body))
withoutHeader = Proxy
toApp :: (HasMock api '[]) => Proxy api -> IO Application
toApp api = return $ serve api (mock api (Proxy :: Proxy '[]))
with (toApp withHeader) $ do
it "serves arbitrary response bodies" ... |
haskell | Nothing -> left $ ServantErr 400 "User not found" "" []
checkAuth :: Maybe Text -> EitherT ServantErr IO (JWT VerifiedJWT)
checkAuth = maybe unauthorized (runCheck . decodeAndVerifySignature jwtSecret)
where
runCheck Nothing = unauthorized
runCheck (Just verifiedJWT) = return verifiedJWT
unauthorized =
... |
haskell | -- https://www.codewars.com/kata/609eee71109f860006c377d1/train/haskell
lastSurvivor :: String -> [Int] -> Char
lastSurvivor text indices = head survivors
where
survivors = foldl remove text indices :: String
remove :: String -> Int -> String
remove text 0 = tail text |
haskell | map classifySingleVec
.
toRows
where
classifySingleVec :: Vector -> Label
classifySingleVec vec =
snd $
maximumBy (\x y -> fst x `compare` fst y) $
map `flip` param $ mapToFst $
\Class{ class_min = center, class_cov = cov } ->
mahalanobis center cov vec
infoStringForParam :: ClassificationParam... |
haskell |
partializeTargets cset us = (cset, fmap (partialize cset . U) us)
ppBindings size vars vals =
let nonZero 0 = Nothing
nonZero n = Just n
in Pretty.prettyPrint $ sizedPpVals (nonZero size) (zip vars vals) |
haskell | <style>
body { margin: 0; padding: 0; }
</style>
<script>
// Force Strict-URL Routing for assets relative paths
(function onload() {
if (!window.location.href.endsWith("/")) {
window.location.href += "/";
} |
haskell | parseUrlPiece _ = Left "Invalid side (should be BUY or SELL)"
data OrderType
= LIMIT
| MARKET |
haskell | -- * Crypto
, SL.OptimumCrypto
, StandardCrypto
-- * CannotForge
, TOptimumCannotForge (..)
, toptimumCheckCanForge
-- * Type instances
, ConsensusConfig (..) |
haskell | someFunc = unsafePerformIO $ printHelp
mainAct [] = do
putStrLn "Needs a greeting!"
printHelp
exitFailure
mainAct args = do
let greeting = unwords args
name <- lookupEnv "USER"
putStrLn $ maybe "no user to greet!" (\name -> greeting ++ "" ++ name) name
|
haskell |
import GHC.Generics
import Data.Map (Map)
type Dependency = Map StackName [StackName] -- list of nodes with outgoing edge targets
data Stack = Stack {sStackId :: StackId,
sStackName :: StackName,
sExports :: [Export]} deriving Show
newtype Stacks = Stacks { sStacks :: [St... |
haskell | if (y`mod`3) == 0
then m * 20
else (m`div`2) * 39 + (m`mod`2) * 20
days :: [Int] -> Int
days [y,m,d] =
let yd = y2d (y - 1)
md = m2d y (m - 1)
dd = d - 1
in
yd+md+dd
|
haskell | walkInside m old d = if inside then new else old
where
new = walk old d
inside = Map.member new m
square = Map.fromList [((x, y), toNum x y) | x <- [0..2], y <- [0..2]]
where
toNum x y = x + y * 3 + 1
diamond = Map.fromList $ row0 ++ row1 ++ row2 ++ row3 ++ row4
where
row0 = [((2, 0), 1)]
r... |
haskell | -- n.b. ndays IS NOT diffDays to from (weekends and holidays don't count)
top5sRuns :: Archive Top5s -> Map Symbol [Run]
top5sRuns top5s = undefined
-- there!
-- 2. Now, let's do more focused runs. If a stock is hi-lo-hi-lo that's one
-- thing but if it's hi-hi-hi-hi, that's quite another thing. We're going to
-- ... |
haskell | import Pid
import MPlayer
import Test.Hspec
|
haskell |
-- 2. Now we post the form with all of our credentials.
let form' = form <> ["identity" := _email, "credential" := _password]
Just code <- fmap (xcode . BC.unpack) <$> findRedirect authURL (fopts
& params .~ gparams |
haskell | PrepareSSH -> [ "_init_", methodArg m ]
DockerChroot -> [ "_chroot_", methodArg m ]
(DockerBuild x) -> [ "_docker_", show x, methodArg m ]
Root -> [ methodArg m ]
parseRecipes :: [String] -> (Recipes, Method)
parseRecipes = \case
("_init_":arg:[]) -> (PrepareSSH, appMethod ar... |
haskell |
-- 3.
myFst = fst
-- Match the function names to their types
|
haskell |
data Buffer = Buffer {
context :: (Integer, Integer),
config :: Configuration,
contents :: String,
cursorPos :: Integer
} deriving Show
moveCursor' :: Buffer -> Integer -> Update () |
haskell | it "iso8859_4" $ test @"enc-pkg/encoding:iso8859_4" encString decString
it "iso8859_10" $ test @"enc-pkg/encoding:iso8859_10" encString decString
it "iso8859_13" $ test @"enc-pkg/encoding:iso8859_13" encString decString
it "cp1257" $ test @"enc-pkg/en... |
haskell |
module ListZip where
import Language.Haskell.Liquid.Synthesize.Error
{-@ zip' :: xs: [a] -> {ys:[b] | len ys == len xs} -> {v:[(a, b)] | len v == len xs} @-}
zip' :: [a] -> [b] -> [(a, b)]
zip' x_S0 x_S1 =
case x_S0 of
[] -> [], b)
(:) x_Sl x_Sm ->
case x_S1 of
[] -> ... |
haskell | writeFiles schnorr6
writeFiles checkSigHashAllTx1
noJetSubst :: (TyC a, TyC b) => Simplicity.Elements.Dag.NoJetDag a b -> WrappedSimplicity a b
noJetSubst = Simplicity.Elements.Dag.jetSubst
example_hashBlock :: ExampleNoJets (Hash, Block) Hash |
haskell | instance Convertible' a b => Convertible (NonEmpty a) [b] where
convert (a:|as) = convert' a : fmap convert' as
instance Convertible' a b => PartialConvertible [a] (NonEmpty b) where
type ConversionError [a] (NonEmpty b) = SimpleConversionError
convertAssert = \case
[] -> Just SimpleConversionError... |
haskell | import qualified Bool
name1 = "Point'"
data T1 a b = C4 a b
d1 = ()
name4 = "mkPoint"
name5 = "getX"
d5 = d5_1
where d5_1 (Point.C4 v0 _) = cast v0 |
haskell | <gh_stars>10-100
-- !!! Exporting unknown constructor
module M(T(K1,K2)) where
data T = K1
|
haskell | <gh_stars>0
import Distribution.Simple
import System.Process
main = defaultMainWithHooks simpleUserHooks{ postBuild = gfPostBuild }
where
gfPostBuild _ _ _ _ = callCommand "gf -make AnnaEngQ.gf AnnaEngR.gf AnnaAct.gf" |
haskell | --
--
module E'12'18 where
|
haskell | ( tests
) where
import Cardano.Prelude
import Data.Aeson
|
haskell |
import System.FilePath (FilePath, (</>), (<.>))
--------------------------------------------------------------------------------
-- PATHS
--------------------------------------------------------------------------------
cssFilePath :: String -> FilePath
cssFilePath cssName = "/static/css/" </> cssName <.> "css"
|
haskell | , swapTVar
)
import Pregame.GhcPrim
writeTVarIO :: TVar a -> a -> IO ()
writeTVarIO tvar a = atomically (writeTVar tvar a)
modifyTVarIO :: TVar a -> (a -> a) -> IO ()
modifyTVarIO tvar f = atomically (modifyTVar tvar f)
modifyTVarIO' :: TVar a -> (a -> a) -> IO () |
haskell | import qualified Text.Pretty.Note as N
import Text.Pretty.Semantic
import Hedgehog
result :: String -> T.Text -> T.Text
result file contents =
case parseStmts (SourcePos name 1 1) (L.fromStrict contents) of
Right res-> displayPlain $ Right <$> vsep (map pretty res)
Left e -> displayPlain $ prettyErr e
wh... |
haskell | parseLine :: String -> [Float]
parseLine s = map read $ words $ replace ',' ' ' s
parseTriangle :: (Fractional a, Ord a) => [a] -> ((a, a), (a, a), (a, a))
parseTriangle xs = let (x1:y1:x2:y2:x3:y3:[]) = xs |
haskell | module IHP.Breadcrumb.Types where
import IHP.Prelude
import Text.Blaze.Html (Html)
import Text.Blaze.Html.Renderer.String (renderHtml)
import ClassyPrelude |
haskell | putStrLn $ intercalate "\n" $ map formatReference references
formatReference reference =
(Github.gitObjectSha $ Github.gitReferenceObject reference) ++
"\t" ++ (Github.gitReferenceRef reference) |
haskell |
import MathlibBench.Config
-- A secret is a string of printable ASCII chars excluding DEL (ASCII char 127).
-- This means it may contain characters between 32 and 126 (inclusive).
newtype Secret = Secret { fromSecret :: ByteString } |
haskell |
citingDomain :: MState -> CitingUpdateUnit -> [Setting CitingUpdateUnit]
citingDomain ms uu = do
s <- [Own, Shared]
t <- M.keys $ stPhis ms
case s of
Shared -> do c <- S.toList $ uuCites uu
return $ SharedSetting t c |
haskell | fibs1 = [ fib x | x <- [1 ..] ]
fibs2' = 0 : 1 : cont fibs2'
where
cont [] = []
cont (a : b : cs) = a + b : cont (b : cs)
-- or the super simple
fibs2 = 1 : 1 : zipWith (+) fibs2 (tail fibs2)
data Stream a = Cons a (Stream a)
streamToList :: Stream a -> [a]
streamToList (Cons x xs) = x : streamT... |
haskell | import qualified Data.Text.Lazy.IO as LazyText
import qualified Nix.Derivation as Nix
import qualified MemoIO
loadDerivation :: FilePath -> IO Nix.Derivation
loadDerivation =
MemoIO.memoIO go
|
haskell | SMkProduct :: Sing a -> Sing b -> Sing (MkProduct a b)
-----
class Generic (a :: Type) where
type Rep a :: Type
from :: a -> Rep a
to :: Rep a -> a
class PGeneric (a :: Type) where
type PFrom (x :: a) :: Rep a
type PTo (x :: Rep a) :: a
class SGeneric k where |
haskell | pretty (Var n) = char 'v' <> int n
-- ---------------------------------------------------------------------------
v0, v1, v2, v3 :: Var
v0 = Var 0
v1 = Var 1
v2 = Var 2
v3 = Var 3
|
haskell | ++ concatMap (\a -> show a ++ " ") vars
++ "="
++ "\n"
++ concatMap
(\(name, tys) -> show name
++ " " |
haskell | , toggler
) where
import Control.Lens
import Control.Monad.Fix
import Control.Monad.IO.Class |
haskell | (obj .:? "DisplayName") <*>
(obj .:? "DomainJoinInfo") <*>
fmap (fmap (fmap unBool')) (obj .:? "EnableDefaultInternetAccess") <*>
(obj .:? "ImageArn") <*>
(obj .:? "ImageName") <*>
(obj .: "InstanceType") <*>
(obj .:? "Name") <*>
(obj .:? "VpcConfig")
parseJSON _ = memp... |
haskell |
renderDot (Declaration t ats) = do
indent
renderDecType t
renderAttributes ats
finishCommand
newline
renderDot (Subgraph name content) = do
indent
tell "subgraph" |
haskell | ) where
import Prelude hiding (seq)
import Control.Monad (void)
import Data.Text (Text)
import qualified Data.Text as Text
import qualified Data.Char as Char |
haskell | where d = x `div` 100
d2 = d `mod` 10
foldBool :: a -> a -> Bool -> a
foldBool x y bool =
case bool of
True -> x
False -> y
foldBool' :: a -> a -> Bool -> a
foldBool' x y bool
| bool == True = x
| bool == False = y
g :: (a -> b) -> (a, c) -> (b, c) |
haskell | <> " flashMessages <- IHP.Controller.Session.getAndClearFlashMessages\n"
<> " let viewContext = ViewContext {\n"
<> " requestContext = ?requestContext,\n"
<> " -- user = currentUserOrNothing,\n"
<> " f... |
haskell | <gh_stars>0
{-# LANGUAGE MultiParamTypeClasses, DeriveGeneric #-}
module Main where
import Flow.Net |
haskell |
-- for Farey of order n
fordCircles :: Integer -> [(Float, Float, Float)]
fordCircles = fmap fordCircle . farey
fordCirclesScaled :: Float -> Integer -> [(Float, Float, Float)]
fordCirclesScaled scale = fmap (fordCircleScaled scale) . farey
midFirst :: (Eq a) => [a] -> [a]
midFirst xs = nub (mid:xs) where
mid =... |
haskell | Nothing -> (tileMatrix, edgeMap, found, tileMap)
Just tile -> foldl (placeTile tileId coords) (tileMatrix, edgeMap, found, tileMap) (zip [STop, SRight, SBottom, SLeft] (tileToEdges tile))
placeTile :: Int -> (Int, Int) -> (TileMatrix, EdgeMap, HS.HashSet Int, TileMap) -> (Side, (Int, Int64)) -> (TileMa... |
haskell |
processParser :: Parser Process
processParser = nullParser
<|> prefixParser
<|> parallelParser
-- null process
nullParser :: Parser Process
nullParser = do
reserved "word"
name <- identifier
return $ Lexeme name
prefixParser :: Parser Process |
haskell | {-# language OverloadedStrings #-}
{-# language FlexibleContexts #-}
{-# language RankNTypes #-}
{-# language ViewPatterns #-}
module Web.Firefly.Handler
( route
) where
import Web.Firefly.Types
import Web.Firefly.Request
import Web.Firefly.Response
import Control.Monad
-- | Run a handler on a matching route. |
haskell | | TArrow (Type, Type)
| TApp (Type, Type)
deriving (Show{-,Read-})
data DataDecl |
haskell | <gh_stars>0
-- | Este módulo define funções comuns da Tarefa 4 do trabalho prático.
module Tarefa4_2019li1g044 where
import LI11920
import Tarefa0_2019li1g044
import Tarefa1_2019li1g044
import Tarefa2_2019li1g044
import Tarefa3_2019li1g044
|
haskell | vectorCmEfs n = VS.foldl' (+) 0 $ VS.concatMap (\(!x) -> VS.enumFromStepN 1 1 x) $ VS.enumFromStepN 1 1 n
{-# NOINLINE vectorCmEfs #-}
flattenCmEfs :: Int -> Int
flattenCmEfs n = VS.foldl' (+) 0 $ VS.flatten mk step Unknown $ VS.enumFromStepN 1 1 n where
mk x = (x,1)
step (x,k)
| k>x = VS.Done
| ot... |
haskell | = flip catch handleTLSHandshakeFailed $
flip catch handleIOException $
http request manager
where
handleIOException (e :: IOException) = throwIO
$ FailedConnectionException
(unpack $ decodeUtf8 $ host request)
(port request)
handleTLSHandshakeFailed (e :: TLS.Hands... |
haskell | import Test.QuickCheck
import Web.HttpApiData
import Cardano.Wallet.API.Types.UnitOfMeasure (MeasuredIn (..), UnitOfMeasure (..))
import Cardano.Wallet.Orphans.Aeson ()
-- V0 logic
import Pos.Util.BackupPhrase (BackupPhrase (..))
import qualified Data.ByteArray as B... |
haskell | --------------------------------------------------------------------------------
-- |
-- Module : Algorithms.Geometry.SmallestEnclosingBall.RandomizedIncrementalConstruction
-- Copyright : (C) <NAME>
-- License : see the LICENSE file |
haskell | mode = (reserved "linear" >> return makeLinear)
<|>
(reserved "local" >> return makeLocal)
<|>
(reserved "active" >> return makeActive)
<|>
(reserved "shared" >> return makeShared)
<|>
(reserved "sharable" >> return makeSharable)
<|>
(reserved "unsaf... |
haskell |
import Control.Lens
import Control.Monad (mzero)
import Data.Aeson
import qualified Data.HashMap.Strict as HM
import qualified Data.HashSet as HS
import Data.Maybe (fromMaybe)
import Data.Text (Text)
im... |
haskell | config <- fmap mailConfig (ask :: (ReaderT a IO) a)
liftIO $ forkIO $ ML.sendMailWithLogin' (server config) (fromInteger (port config)) (login config) (password config) mail
from = Address (Just "Code Qualified") "<EMAIL>"
to = [Address (Just "<NAME>") "<EMAIL>"]
cc = []
bcc = [] |
haskell |
instance Ord a => Eq (Set a) where
set1 == set2 = toAscList set1 == toAscList set2
instance Semigroup (Set a) where
set1 <> set2 = set1 `union` set2
|
haskell | <gh_stars>1000+
import StackTest
import System.Directory
import Control.Monad (unless)
main :: IO ()
main = do
removeDirIgnore "somename"
stack ["new", "somename", "./template.hsfiles"]
exists <- doesFileExist "somename/somename.cabal"
unless exists $ error "does not exist"
|
haskell | (y:ys) -> r $ (toNaked y : ys) :| xs
where
(x:|xs) = r xs'
r = NE.reverse . fmap reverse
isParagraph = \case
OrderedList _ _ -> False
UnorderedList _ -> False
Naked _ -> False |
haskell | {-# LANGUAGE TypeApplications #-}
module E where
import A
import B
import C
import D
c :: F (a, C) -> Bool
c = id
e :: () -> Bool
e = c . b @ C
|
haskell |
main = defaultMain
|
haskell |
{-# OPTIONS_GHC -Wall #-}
{-# OPTIONS_GHC -Werror #-}
-- #3261
module Foo where
foo :: Int
foo = ceiling 6.3
|
haskell |
import Compiler.Syntax (Lit)
data Pattern
= PatVar String |
haskell |
type LineInfo = Int
data Identifier = IdExpr IdentifierName TypeName LineInfo -- parsed - eval
|
haskell | module Day2.Types where
data Policy = Policy Int Int Char
type Password = String
|
haskell | import Level.DangerValue
import Util
data EnemySpawnWaveChoiceRule
= MaxOneAnyTurretRule
| MaxOneBombRule
| MaxOneBubbleTurretRule
| MaxOneFlyingRule
| MaxTwoFlyingRule |
haskell | import Servant
import Server
-- API for values of type 'a'
-- indexed by values of type 'i'
type APIFor a i =
Get '[JSON] [Entity a] -- list 'a's
:<|> ReqBody '[JSON] a :> Post '[JSON] (Maybe i) -- add an 'a'
:<|> Capture "id" i
:> ( Get '[JSON] (Entity a) -- view an 'a' given its "identifier" of type ... |
haskell |
-- | Log the MidiHeader in the Table monad (cf. Writer).
--
tellMidiHeader :: MidiHeader -> Table ()
tellMidiHeader (MidiHeader fmt tcount td) =
localColumns midi_header_columns $ do
tellRow $ \_ _ -> [ text "MIDI Format", ppFormat fmt ] |
haskell | arg <- getArgs
strM <- newEmptyMVar
sock <- listenOn $ PortNumber (read (arg!!0) :: PortNumber)
forkIO (do
forkIO (forever $ do |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.