code
stringlengths 5
1.03M
| repo_name
stringlengths 5
90
| path
stringlengths 4
158
| license
stringclasses 15
values | size
int64 5
1.03M
| n_ast_errors
int64 0
53.9k
| ast_max_depth
int64 2
4.17k
| n_whitespaces
int64 0
365k
| n_ast_nodes
int64 3
317k
| n_ast_terminals
int64 1
171k
| n_ast_nonterminals
int64 1
146k
| loc
int64 -1
37.3k
| cycloplexity
int64 -1
1.31k
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|
-- Copyright (c) 2016-present, Facebook, Inc.
-- All rights reserved.
--
-- This source code is licensed under the BSD-style license found in the
-- LICENSE file in the root directory of this source tree. An additional grant
-- of patent rights can be found in the PATENTS file in the same directory.
{-# LANGUAGE OverloadedStrings #-}
module Duckling.Numeral.PT.Corpus
( corpus ) where
import Prelude
import Data.String
import Duckling.Lang
import Duckling.Numeral.Types
import Duckling.Resolve
import Duckling.Testing.Types
corpus :: Corpus
corpus = (testContext {lang = PT}, allExamples)
allExamples :: [Example]
allExamples = concat
[ examples (NumeralValue 1)
[ "1"
, "um"
, "Uma"
]
, examples (NumeralValue 2)
[ "2"
, "dois"
, "duas"
]
, examples (NumeralValue 3)
[ "3"
, "três"
, "tres"
]
, examples (NumeralValue 6)
[ "6"
, "seis"
]
, examples (NumeralValue 11)
[ "11"
, "onze"
]
, examples (NumeralValue 12)
[ "12"
, "doze"
, "uma dúzia"
, "uma duzia"
]
, examples (NumeralValue 14)
[ "14"
, "Catorze"
, "quatorze"
]
, examples (NumeralValue 16)
[ "16"
, "dezesseis"
, "dezasseis"
]
, examples (NumeralValue 17)
[ "17"
, "dezessete"
, "dezassete"
]
, examples (NumeralValue 18)
[ "18"
, "dezoito"
]
, examples (NumeralValue 19)
[ "19"
, "dezenove"
, "dezanove"
]
, examples (NumeralValue 21)
[ "21"
, "vinte e um"
]
, examples (NumeralValue 23)
[ "23"
, "vinte e tres"
, "vinte e três"
]
, examples (NumeralValue 24)
[ "24"
, "vinte e quatro"
, "duas dúzias"
, "duas duzias"
]
, examples (NumeralValue 50)
[ "50"
, "cinquenta"
, "cinqüenta"
, "cincoenta"
]
, examples (NumeralValue 70)
[ "setenta"
]
, examples (NumeralValue 78)
[ "setenta e oito"
]
, examples (NumeralValue 80)
[ "oitenta"
]
, examples (NumeralValue 33)
[ "33"
, "trinta e três"
, "trinta e tres"
]
, examples (NumeralValue 1.1)
[ "1,1"
, "1,10"
, "01,10"
]
, examples (NumeralValue 0.77)
[ "0,77"
, ",77"
]
, examples (NumeralValue 100000)
[ "100.000"
, "100000"
, "100K"
, "100k"
]
, examples (NumeralValue 100)
[ "100"
, "Cem"
]
, examples (NumeralValue 243)
[ "243"
]
, examples (NumeralValue 300)
[ "trezentos"
]
, examples (NumeralValue 3000000)
[ "3M"
, "3000K"
, "3000000"
, "3.000.000"
]
, examples (NumeralValue 1200000)
[ "1.200.000"
, "1200000"
, "1,2M"
, "1200K"
, ",0012G"
]
, examples (NumeralValue (-1200000))
[ "- 1.200.000"
, "-1200000"
, "menos 1.200.000"
, "-1,2M"
, "-1200K"
, "-,0012G"
]
, examples (NumeralValue 1.5)
[ "1 ponto cinco"
, "um ponto cinco"
, "1,5"
]
]
| rfranek/duckling | Duckling/Numeral/PT/Corpus.hs | bsd-3-clause | 3,971 | 0 | 11 | 1,922 | 744 | 427 | 317 | 123 | 1 |
--
-- Copyright © 2013-2014 Anchor Systems, Pty Ltd and Others
--
-- The code in this file, and the program it is a part of, is
-- made available to you by its authors as open source software:
-- you can redistribute it and/or modify it under the terms of
-- the 3-clause BSD licence.
--
{-# LANGUAGE CPP #-}
module Main where
import Options.Applicative
#if defined(RADOS)
import qualified Data.ByteString.Char8 as S
#endif
import TimeStore
data Options
= Options { _pool :: String
, _user :: Maybe String
, _ns :: NameSpace
, _cmd :: Action }
data Action
= Register { simpleBuckets :: Bucket
, extendedBuckets :: Bucket
}
-- | Command line option parsing
helpfulParser :: ParserInfo Options
helpfulParser = info (helper <*> optionsParser) fullDesc
optionsParser :: Parser Options
optionsParser = Options <$> parsePool
<*> parseUser
<*> parseNS
<*> parseAction
where
parsePool = strOption $
long "pool"
<> short 'p'
<> metavar "POOL"
<> help "Ceph pool name for storage"
parseUser = optional . strOption $
long "user"
<> short 'u'
<> metavar "USER"
<> help "Ceph user for access to storage"
parseNS = option auto $
long "origin"
<> short 'o'
<> help "Origin (namespace)"
parseAction = subparser parseRegisterAction
parseRegisterAction =
componentHelper "register" registerActionParser "Register a namespace (origin)"
componentHelper cmd_name parser desc =
command cmd_name (info (helper <*> parser) (progDesc desc))
registerActionParser :: Parser Action
registerActionParser = Register <$> parseSimpleBuckets
<*> parseExtendedBuckets
where
parseSimpleBuckets = option auto $
long "simple_buckets"
<> short 's'
<> value 0
<> showDefault
<> help "Number of simple buckets"
parseExtendedBuckets = option auto $
long "extendend_buckets"
<> short 'e'
<> value 0
<> showDefault
<> help "Number of extended buckets"
main :: IO ()
main =
#if defined(RADOS)
do
Options pool user ns cmd <- execParser helpfulParser
case cmd of
Register s_buckets e_buckets -> do
s <- radosStore (fmap S.pack user)
"/etc/ceph/ceph.conf"
(S.pack pool)
0
registered <- isRegistered s ns
if registered
then putStrLn "Origin already registered"
else registerNamespace s ns s_buckets e_buckets
#else
putStrLn "No CEPH"
#endif
| anchor/rados-timestore | src/Store.hs | bsd-3-clause | 2,848 | 0 | 16 | 991 | 530 | 272 | 258 | 56 | 1 |
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE OverloadedLists #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE NoImplicitPrelude #-}
-- | Converts an OFX file to Copper transactions.
--
-- Typically all you wil need is 'ofxImportProgram' and the types it
-- uses as its arguments. Use 'ofxImportProgram' as your @Main.main@
-- function, as it will handle all command-line parsing.
--
-- Some terminology:
--
-- [@foreign posting@] A Penny posting corresponding to the posting on
-- the financial institution statement. For example, if importing an
-- OFX from a checking account, this posting might have the account
-- @[\"Assets\", \"Checking\"]@.
--
-- [@offsetting posting@] A Penny posting whose amount offsets the
-- foreign posting. For example, if importing an OFX from a checking
-- account, this posting might have the account
-- @[\"Expenses\", \"Bank Fees\"]@.
module Penny.OfxToCopper where
import Penny.Account
import Penny.Amount (Amount)
import qualified Penny.Amount as Amount
import Penny.Arrangement
import qualified Penny.Commodity as Cy
import Penny.Copper
(ParseConvertProofError, parseProduction, parseConvertProofFiles)
import Penny.Copper.Copperize
import Penny.Copper.Decopperize
import Penny.Copper.Formatter
import Penny.Copper.Productions
import Penny.Copper.Terminalizers (t'WholeFile)
import Penny.Copper.Tracompri
import Penny.Copper.Types (WholeFile)
import Penny.Decimal
import Penny.Ents
import qualified Penny.Fields as Fields
import Penny.Prelude
import Penny.SeqUtil
import Penny.Tranche (Postline)
import qualified Penny.Tranche as Tranche
import Penny.Transaction
import qualified Accuerr
import qualified Control.Exception as Exception
import qualified Control.Lens as Lens
import qualified Data.Map as Map
import qualified Data.OFX as OFX
import qualified Data.Sequence as Seq
import qualified Data.Sequence.NonEmpty as NE
import qualified Data.Set as Set
import qualified Data.Text as X
import qualified Data.Time as Time
import qualified Data.Time.Timelens as Timelens
import qualified Pinchot
-- * Data types
-- | Inputs from the OFX file.
data OfxIn = OfxIn
{ _ofxTxn :: OFX.Transaction
, _qty :: Decimal
}
Lens.makeLenses ''OfxIn
data Flag = Cleared | Reconciled
deriving (Eq, Ord, Show)
-- | Data used to create the resulting Penny transaction.
data OfxOut = OfxOut
{ _payee :: Text
-- ^ Payee. This applies to both postings.
, _flag :: Maybe Flag
-- ^ Whether the foreign posting is cleared, reconciled, or neither.
-- This applies only to the foreign posting.
, _foreignAccount :: Account
-- ^ Account for the foreign posting.
, _flipSign :: Bool
-- ^ If this is False, the amount from the OFX transaction is copied
-- to the foreign posting as-is. If this is True, the amount from the
-- OFX transaction is copied to the foreign posting, but its sign is
-- reversed (so that a debit becomes a credit, and vice versa.)
-- Arbitrarily (as set forth in "Penny.Polar", a debit is equivalent
-- to a positive, and a credit is equal to a negative. For example,
-- if the OFX file is from a credit card, typically charges are
-- positive, which in Penny corresponds to a debit. However,
-- typically in Penny you will record charges in a liability
-- account, where they would be credits. So in such a case you
-- would use 'True' here.
, _offsettingAccount :: Account
-- ^ Account to use for the offsetting posting.
, _commodity :: Cy.Commodity
-- ^ Commodity. Used for both the foreign and offsetting posting.
, _arrangement :: Arrangement
-- ^ How to arrange the foreign posting.
, _zonedTime :: ZonedTime
} deriving Show
Lens.makeLenses ''OfxOut
-- * Helpers for dealing with OFX data
-- | Given an OfxIn, make a default OfxOut.
defaultOfxOut :: OfxIn -> OfxOut
defaultOfxOut ofxIn = OfxOut
{ _payee = case OFX.txPayeeInfo . _ofxTxn $ ofxIn of
Nothing -> ""
Just (Left str) -> X.pack str
Just (Right pye) -> X.pack . OFX.peNAME $ pye
, _flag = Nothing
, _foreignAccount = []
, _flipSign = False
, _offsettingAccount = []
, _commodity = ""
, _arrangement = Arrangement CommodityOnRight True
, _zonedTime = OFX.txDTPOSTED . _ofxTxn $ ofxIn
}
-- | Converts a local time to UTC time, and then converts it back to a
-- zoned time where the zone is UTC. Some financial institutions
-- report times using various local time zones; this converts them to
-- UTC.
toUTC :: Time.ZonedTime -> Time.ZonedTime
toUTC = Time.utcToZonedTime Time.utc
. Time.zonedTimeToUTC
-- | Strips off local times and changes them to midnight. Some
-- financial institutions report transactions with a local time (often
-- it is an arbitrary time). Use this if you don't care about the
-- local time. You might want to first use 'toUTC' to get an accurate
-- UTC date before stripping off the time.
toMidnight :: Time.ZonedTime -> Time.ZonedTime
toMidnight
= Lens.set (localTime . Timelens.todHour) 0
. Lens.set (localTime . Timelens.todMin) 0
. Lens.set (localTime . Timelens.todSec) 0
where
localTime = Timelens.zonedTimeToLocalTime . Timelens.localTimeOfDay
-- | Examines the OFX payee information to determine the best test to
-- use as a simple payee name. OFX allows for two different kinds of
-- payee records. This function examines the OFX and reduces the
-- payee record to a simple text or, if there is no payee information,
-- returns an empty Text.
ofxPayee :: OfxIn -> Text
ofxPayee ofxIn = case OFX.txPayeeInfo . _ofxTxn $ ofxIn of
Nothing -> ""
Just (Left str) -> X.pack str
Just (Right pye) -> X.pack . OFX.peNAME $ pye
-- * Command-line program
-- | Reads OFX and Copper files, and produces a result. Returns
-- result; not destructive.
ofxToCopper
:: (OfxIn -> Maybe OfxOut)
-- ^
-> Seq FilePath
-- ^ Copper files to read
-> Seq FilePath
-- ^ OFX files to read
-> IO Text
ofxToCopper fOfx copFilenames ofxFilenames = do
copperTxts <- traverse readFile copFilenames
let readCopperFiles = zipWith (\fp txt -> (Right fp, txt))
copFilenames copperTxts
readOfxFiles <- traverse readFile ofxFilenames
result <- either Exception.throwIO return
. ofxImportWithCopperParse fOfx readCopperFiles
$ readOfxFiles
return . printResult $ result
-- | Prints the 'WholeFile' to standard output.
printResult :: WholeFile Char () -> Text
printResult = X.pack . toList . fmap fst . t'WholeFile
-- * Errors
type Accuseq a = Accuerr (NonEmptySeq a)
data OfxToCopperError
= OTCBadOfxFile Text
| OTCBadOfxAmount (NonEmptySeq OFX.Transaction)
| OTCBadCopperFile (NonEmptySeq (ParseConvertProofError Pinchot.Loc))
| OTCCopperizationFailed (NonEmptySeq (TracompriError ()))
deriving Show
instance Exception.Exception OfxToCopperError
-- * Creating Penny transactions
-- | Given OFX data, creates a 'Tranche.TopLine'.
topLineTranche
:: OfxIn
-- ^
-> OfxOut
-- ^
-> Tranche.TopLine ()
topLineTranche inp out = Tranche.Tranche ()
$ Fields.TopLineFields zt pye origPye
where
zt = _zonedTime out
pye = _payee out
origPye = case OFX.txPayeeInfo . _ofxTxn $ inp of
Nothing -> X.empty
Just (Left s) -> X.pack s
Just (Right p) -> X.pack . OFX.peNAME $ p
-- | Given OFX data, create the foreign posting.
foreignPair
:: OfxIn
-- ^
-> OfxOut
-- ^
-> (Tranche.Postline (), Amount)
foreignPair inp out = (Tranche.Tranche () fields, amt)
where
fields = Fields.PostingFields
{ Fields._number = Nothing
, Fields._flag = toFlag . _flag $ out
, Fields._account = _foreignAccount out
, Fields._fitid = X.pack . OFX.txFITID . _ofxTxn $ inp
, Fields._tags = Seq.empty
, Fields._uid = X.empty
, Fields._trnType = Just . OFX.txTRNTYPE . _ofxTxn $ inp
, Fields._origDate = Just . OFX.txDTPOSTED . _ofxTxn $ inp
, Fields._memo = Seq.empty
}
where
toFlag Nothing = ""
toFlag (Just Cleared) = "C"
toFlag (Just Reconciled) = "R"
amt = Amount.Amount
{ Amount._commodity = _commodity out
, Amount._qty = flipper . _qty $ inp
}
where
flipper | _flipSign out = negate
| otherwise = id
-- | Given the OFX data, create the 'Tranche.Postline' for the
-- offsetting posting. The offsetting posting does not get an amount
-- because ultimately we use 'twoPostingBalanced', which does not
-- require an amount for the offsetting posting.
offsettingMeta
:: OfxOut
-- ^
-> Tranche.Postline ()
-- ^
offsettingMeta out = Tranche.Tranche () fields
where
fields = Fields.PostingFields
{ Fields._number = Nothing
, Fields._flag = X.empty
, Fields._account = _offsettingAccount out
, Fields._fitid = X.empty
, Fields._tags = Seq.empty
, Fields._uid = X.empty
, Fields._trnType = Nothing
, Fields._origDate = Nothing
, Fields._memo = Seq.empty
}
-- | Given the OFX data, create a 'Transaction'.
ofxToTxn
:: OfxIn
-- ^
-> OfxOut
-- ^
-> Transaction ()
ofxToTxn ofxIn ofxOut = Transaction tl bal
where
tl = topLineTranche ofxIn ofxOut
bal = twoPostingBalanced (rar, metaForeign) cy (_arrangement ofxOut)
metaOffset
where
(metaForeign, (Amount.Amount cy q)) = foreignPair ofxIn ofxOut
rar = repDecimal (Right Nothing) q
metaOffset = offsettingMeta ofxOut
-- * Parsing Copper data and importing OFX data
-- | Importing OFX transactions is a three-step process:
--
-- 1. Parse Copper files. These files contain existing transactions and
-- are used to detect duplicate OFX transactions. Also, optionally
-- the new OFX transactions are appended to the last Copper file, so
-- the parse step returns the last Copper file.
--
-- 2. Import OFX transactions. Uses the duplicate detector from step 1.
--
-- 3. Copperize and format new transactions. Append new transactions
-- to Copper file, if requested. Return new, formatted transactions,
-- and new Copper file (if requested).
ofxImportWithCopperParse
:: (OfxIn -> Maybe OfxOut)
-- ^ Examines each OFX transaction
-> Seq (Either Text FilePath, Text)
-- ^ Copper files with their names
-> Seq Text
-- ^ OFX input files
-> Either OfxToCopperError (WholeFile Char ())
-- ^ If successful, returns the formatted new transactions. Also,
-- if there is a last Copper file, returns its filename and its
-- parsed 'WholeFile'.
ofxImportWithCopperParse fOrig copperFiles ofxFiles = do
fNoDupes <- Lens.over Lens._Left OTCBadCopperFile
. parseCopperFiles fOrig $ copperFiles
txns <- fmap join . traverse (importOfxTxns fNoDupes) $ ofxFiles
Lens.over Lens._Left OTCCopperizationFailed
. copperizeAndFormat $ txns
-- * Importing OFX data (without Copper data)
-- | Imports all OFX transactions.
importOfxTxns
:: (OfxIn -> Maybe OfxOut)
-- ^ Examines each OFX transaction. This function must do something
-- about duplicates, as 'importOfxTxns' does nothing special to
-- handle duplicates.
-> Text
-- ^ OFX input file
-> Either OfxToCopperError (Seq (Transaction ()))
importOfxTxns fOfx inp = do
ofx <- Lens.over Lens._Left (OTCBadOfxFile . pack)
. OFX.parseTransactions . unpack $ inp
let ofxMkr t = case mkOfxIn t of
Nothing -> Accuerr.AccFailure $ NE.singleton t
Just r -> Accuerr.AccSuccess r
ofxIns <- case traverse ofxMkr ofx of
Accuerr.AccFailure fails -> Left (OTCBadOfxAmount fails)
Accuerr.AccSuccess g -> Right . Seq.fromList $ g
let maybeOfxOuts = fmap fOfx ofxIns
return . fmap (uncurry ofxToTxn) . Seq.zip ofxIns . catMaybes
$ maybeOfxOuts
-- | Given an OFX Transaction, make an OfxIn. Fails only if the
-- amount cannot be parsed.
mkOfxIn :: OFX.Transaction -> Maybe OfxIn
mkOfxIn ofxTxn = case parseProduction a'DecimalRadPer decTxt of
Left _ -> Nothing
Right copper -> Just ofxIn
where
dec = dDecimalRadPer copper
ofxIn = OfxIn ofxTxn dec
where
decTxt = X.pack . OFX.txTRNAMT $ ofxTxn
-- | Takes an OfxIn and imports it to Transaction. Rejects
-- duplicates.
importOfx
:: Map Account (Set Text)
-- ^
-> (OfxIn -> Maybe OfxOut)
-- ^
-> OfxIn
-- ^
-> Maybe OfxOut
importOfx lkp f inp = do
out <- f inp
guard (freshPosting inp out lkp)
return out
-- * Reading Copper data
-- | Parses existing copper files. Takes a function that creates new
-- transactions, and returns a new function that will also reject
-- duplicates.
parseCopperFiles
:: (OfxIn -> Maybe OfxOut)
-- ^ Original function
-> Seq (Either Text FilePath, Text)
-> Either (NonEmptySeq (ParseConvertProofError Pinchot.Loc))
(OfxIn -> Maybe OfxOut)
parseCopperFiles fOrig
= fmap f . Lens.view Accuerr.isoAccuerrEither . getAccountsMap
where
f acctMap = importOfx acctMap fOrig
-- * Formatting Copperized data
-- | Returns a 'WholeFile' that is suitable for use as a standalone
-- file. There is no extra whitespace at the beginning or end of the
-- text.
copperizeAndFormat
:: Seq (Transaction ())
-- ^
-> Either (NonEmptySeq (TracompriError ())) (WholeFile Char ())
copperizeAndFormat
= fmap (formatWholeFile 4)
. Accuerr.accuerrToEither
. tracompriWholeFile
. fmap Tracompri'Transaction
-- * Duplicate detection
-- | Returns True if this transaction is not a duplicate.
freshPosting
:: OfxIn
-- ^
-> OfxOut
-- ^
-> Map Account (Set Text)
-- ^
-> Bool
freshPosting inp out lkp = case Map.lookup acctName lkp of
Nothing -> True
Just set -> not $ Set.member fitid set
where
acctName = _foreignAccount out
fitid = X.pack . OFX.txFITID . _ofxTxn $ inp
-- | Given a sequence of filenames and the text that is within those
-- files, returns a map. The keys in this map are all the accounts,
-- and the values are a set of all the fitids. Also, if the sequence
-- of filenames is non-empty, returns the last filename, and its
-- corresponding WholeFile.
getAccountsMap
:: Seq (Either Text FilePath, Text)
-- ^
-> Accuerr (NonEmptySeq (ParseConvertProofError Pinchot.Loc))
(Map Account (Set Text))
-- ^
getAccountsMap = fmap f . parseConvertProofFiles
where
f = foldl' addTracompriToAccountMap Map.empty . join
addTracompriToAccountMap
:: Map Account (Set Text)
-- ^
-> Tracompri a
-- ^
-> Map Account (Set Text)
-- ^
addTracompriToAccountMap oldMap (Tracompri'Transaction txn)
= foldl' addPostlineToAccountMap oldMap
. fmap snd
. balancedToSeqEnt
. _postings
$ txn
addTracompriToAccountMap oldMap _ = oldMap
addPostlineToAccountMap
:: Map Account (Set Text)
-- ^
-> Postline a
-- ^
-> Map Account (Set Text)
-- ^
addPostlineToAccountMap acctMap postline
| X.null fitid = acctMap
| otherwise = Map.alter f acct acctMap
where
fitid = Lens.view Tranche.fitid postline
acct = Lens.view Tranche.account postline
f = Just . maybe (Set.singleton fitid) (Set.insert fitid)
| massysett/penny | penny/lib/Penny/OfxToCopper.hs | bsd-3-clause | 14,927 | 0 | 15 | 3,074 | 3,014 | 1,634 | 1,380 | 264 | 3 |
module Privilege
( tryDropPrivilege
)
where
import Control.Applicative ( (<$>) )
import Data.IORef ( newIORef, readIORef , writeIORef )
import System.Posix.User ( getUserEntryForName, setUserID
, userID, getRealUserID )
import Control.Monad ( join, unless )
-- Obtain an action that will attempt to drop privileges if the
-- environment and configuration allow it. Ideally, we would be able
-- to drop privileges after binding to the port and before doing
-- anything else. This is a compromise that provides a modicum of
-- safety if the request can co-opt the server, but no protection from
-- any local attacks. In particular, all of the server start-up stuff
-- happened before this, including creating the database. This could
-- potentially cause permission errors.
tryDropPrivilege :: String -> IO (IO ())
tryDropPrivilege username = do
-- Figure out what user id we need to switch to (if any)
uid <- getRealUserID
targetUID <-
do t <- userID <$> getUserEntryForName username
case uid of
-- Root:
0 ->
return $ Just t
-- We already are the target user:
_ | t == uid ->
return Nothing
-- Anyone else:
_ ->
error $ "Only root can change users \
\(trying to run as " ++ username ++ ")"
case targetUID of
Nothing ->
-- If we have no target UID, then just return a no-op
return $ return ()
Just target ->
-- Build and return an action that will ensure that we are
-- running as the target user before proceeding
do
-- The variable that holds the action that ensures that we
-- have dropped privileges
startRef <- newIORef $ return ()
-- Put the privilege dropping action in
writeIORef startRef $
do putStrLn $
"Dropping privileges: switching to user " ++ show target
setUserID target `catch` \e ->
-- Check that we didn't lose a race
-- trying to drop privileges. If we lost,
-- then everything's OK because the
-- privileges are already dropped.
do newUID <- getRealUserID
-- If it wasn't losing the race,
-- raise it again here
unless (newUID == target) $ ioError e
finalUID <- getRealUserID
if finalUID == target
-- replace the action with a no-op
then writeIORef startRef $ return ()
else error "Failed to drop privileges"
return $ join $ readIORef startRef
| j3h/doc-review | src/Privilege.hs | bsd-3-clause | 2,787 | 0 | 22 | 1,003 | 374 | 197 | 177 | 37 | 5 |
{-# LANGUAGE CPP #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE PatternGuards #-}
{-# OPTIONS_GHC -fno-warn-deprecations #-}
-- | This module implements a high-level view of the state of
-- the IRC connection. The library user calls 'advanceModel' to
-- step the 'IrcConnection' as new messages arrive.
module Irc.Model
( -- * IRC Connection model
IrcConnection(..)
, connNick
, connChannels
, connId
, connChanModeTypes
, connUserModeTypes
, connKnock
, connNickLen
, connExcepts
, connInvex
, connStatusMsg
, connTopicLen
, connPhase
, connModes
, connUsers
, connMyInfo
, connSasl
, connUmode
, connSnoMask
, connPingTime
, defaultIrcConnection
-- * Ping information
, PingStatus(..)
-- * Phases
, Phase(..)
-- * IRC Channel model
, IrcChannel(..)
, chanTopic
, chanUsers
, chanModes
, chanCreation
, chanMaskLists
, chanUrl
-- * Mode Settings
, ModeTypes(..)
, modesLists
, modesAlwaysArg
, modesSetArg
, modesNeverArg
, modesPrefixModes
, defaultChanModeTypes
, defaultUmodeTypes
-- * Channel Mask Entry
, IrcMaskEntry(..)
, maskEntryMask
, maskEntryWho
, maskEntryStamp
-- * User metadata
, IrcUser(..)
, usrAway
, usrAccount
, usrHost
, defaultIrcUser
-- * Model execution
, runLogic
, LogicOp(..)
, Logic
-- * General functionality
, advanceModel
, isChannelName
, isNickName
, isMyNick
, splitStatusMsg
, splitModes
, unsplitModes
, nickHasModeInChannel
, channelHasMode
) where
import Control.Monad (guard)
import Control.Lens
import Control.Monad (foldM)
import Control.Monad.Free
import Control.Monad.Trans.Error
import Control.Monad.Trans.Reader
import Data.ByteString (ByteString)
import Data.Char (toUpper)
import Data.Fixed (Pico)
import Data.List (foldl',find,nub,delete,intersect)
import Data.Map (Map)
import Data.Maybe (fromMaybe)
import Data.Monoid
import Data.Text (Text)
import Data.Time
import Data.Time.Clock.POSIX (posixSecondsToUTCTime)
import qualified Data.ByteString as B
import qualified Data.ByteString.Base64 as Base64
import qualified Data.ByteString.Char8 as B8
import qualified Data.Map as Map
import Text.Read (readMaybe)
#if !MIN_VERSION_base(4,8,0)
import Control.Applicative
#endif
import Irc.Format
import Irc.Message
import Irc.Cmd
import Irc.Core
import Irc.Core.Prisms
-- | 'IrcConnection' is the state of an IRC connection. It maintains
-- channel membership, user and channel modes, and other connection
-- state.
data IrcConnection = IrcConnection
{ _connNick :: !Identifier
, _connChannels :: !(Map Identifier IrcChannel)
, _connId :: Maybe ByteString
, _connChanTypes :: [Char]
, _connStatusMsg :: [Char]
, _connKnock :: !Bool
, _connNickLen :: !Int
, _connExcepts :: Maybe Char
, _connInvex :: Maybe Char
, _connUsers :: !(Map Identifier IrcUser)
, _connChanModeTypes :: !ModeTypes
, _connUserModeTypes :: !ModeTypes
, _connModes :: !Int
, _connTopicLen :: !Int
, _connMyInfo :: Maybe (ByteString,ByteString)
, _connSasl :: Maybe (ByteString,ByteString)
, _connUmode :: !ByteString
, _connSnoMask :: !ByteString
, _connPhase :: !Phase
, _connPingTime :: !PingStatus
}
deriving (Read, Show)
data PingStatus = PingTime Pico | PingSent UTCTime | NoPing
deriving (Read, Show)
-- | 'IrcConnection' value with everything unspecified
defaultIrcConnection :: IrcConnection
defaultIrcConnection = IrcConnection
{ _connNick = mkId ""
, _connChannels = mempty
, _connId = Nothing
, _connChanTypes = "#&" -- default per RFC
, _connStatusMsg = ""
, _connKnock = False
, _connNickLen = 9
, _connExcepts = Nothing
, _connInvex = Nothing
, _connUsers = mempty
, _connModes = 3
, _connTopicLen = 400 -- default is unbounded but message length is bounded
, _connChanModeTypes = defaultChanModeTypes
, _connUserModeTypes = defaultUmodeTypes
, _connMyInfo = Nothing
, _connSasl = Nothing
, _connUmode = ""
, _connSnoMask = ""
, _connPhase = RegistrationPhase
, _connPingTime = NoPing
}
data Phase
= RegistrationPhase
| ActivePhase
| SaslPhase
deriving (Read, Show, Eq)
-- | Settings that describe how to interpret channel modes
data ModeTypes = ModeTypes
{ _modesLists :: String
, _modesAlwaysArg :: String
, _modesSetArg :: String
, _modesNeverArg :: String
, _modesPrefixModes :: [(Char,Char)]
}
deriving (Read, Show)
-- | The channel modes used by Freenode
defaultChanModeTypes :: ModeTypes
defaultChanModeTypes = ModeTypes
{ _modesLists = "eIbq"
, _modesAlwaysArg = "k"
, _modesSetArg = "flj"
, _modesNeverArg = "CFLMPQScgimnprstz"
, _modesPrefixModes = [('o','@'),('v','+')]
}
-- | The default UMODE as defined by Freenode
defaultUmodeTypes :: ModeTypes
defaultUmodeTypes = ModeTypes
{ _modesLists = ""
, _modesAlwaysArg = ""
, _modesSetArg = "s"
, _modesNeverArg = ""
, _modesPrefixModes = []
}
-- | 'IrcChannel' represents the current state of a channel
-- as seen on the connection. It includes all user lists,
-- modes, and other metadata about a channel.
data IrcChannel = IrcChannel
{ _chanTopic :: Maybe (Maybe (Text, ByteString, UTCTime)) -- TODO: use UserInfo
, _chanUsers :: !(Map Identifier String) -- modes: ov
, _chanModes :: Maybe (Map Char ByteString)
, _chanCreation :: Maybe UTCTime
, _chanMaskLists :: Map Char [IrcMaskEntry]
, _chanUrl :: Maybe ByteString
}
deriving (Read, Show)
-- | Default value for 'IrcChannel' with everything unspecified.
defaultChannel :: IrcChannel
defaultChannel = IrcChannel
{ _chanTopic = Nothing
, _chanModes = Nothing
, _chanCreation = Nothing
, _chanUsers = mempty
, _chanMaskLists = mempty
, _chanUrl = Nothing
}
-- | Mask entries are used to represent an entry in a ban list for
-- a channel.
data IrcMaskEntry = IrcMaskEntry
{ _maskEntryMask :: ByteString
, _maskEntryWho :: ByteString
, _maskEntryStamp :: UTCTime
}
deriving (Read, Show)
-- | 'IrcUser' is the type of user-level metadata tracked for
-- the users visible on the current IRC connection.
data IrcUser = IrcUser
{ _usrAway :: !Bool
, _usrAccount :: !(Maybe ByteString)
, _usrHost :: !(Maybe ByteString)
}
deriving (Read,Show)
-- | This represents the metadata of an unknown user.
defaultIrcUser :: IrcUser
defaultIrcUser = IrcUser
{ _usrAway = False
, _usrAccount = Nothing
, _usrHost = Nothing
}
data Fuzzy a = Known !a | Unknown | None
deriving (Read,Show)
makeLenses ''IrcConnection
makeLenses ''IrcChannel
makeLenses ''IrcUser
makeLenses ''IrcMaskEntry
makeLenses ''ModeTypes
-- | Primary state machine step function. Call this function with a timestamp
-- and a server message to update the 'IrcConnection' state. If additional
-- messages are required they will be requested via the 'Logic' type.
advanceModel :: MsgFromServer -> IrcConnection -> Logic IrcConnection
advanceModel msg0 conn =
case msg0 of
Ping x -> sendMessage (pongCmd x) >> return conn
Pong _ txt ->
case view connPingTime conn of
PingSent sentTime ->
do now <- getStamp
let delta = realToFrac (now `diffUTCTime` sentTime)
return (set connPingTime (PingTime delta) conn)
_ -> return conn
RplWelcome txt -> doServerMessage "Welcome" txt
$ set connPhase ActivePhase conn
RplYourHost txt -> doServerMessage "YourHost" txt conn
RplCreated txt -> doServerMessage "Created" txt conn
RplMyInfo host version _ ->
return (set connMyInfo (Just (host,version)) conn)
-- Random uninteresting statistics
RplLuserOp _ -> return conn
RplLuserChannels _ -> return conn
RplLuserMe _ -> return conn
RplLuserClient _ -> return conn
RplLocalUsers _ -> return conn
RplGlobalUsers _ -> return conn
RplStatsConn _ -> return conn
RplLuserUnknown _ -> return conn
RplLuserAdminMe txt ->
doServerMessage "ADMIN" txt conn
RplLuserAdminLoc1 txt ->
doServerMessage "ADMIN" txt conn
RplLuserAdminLoc2 txt ->
doServerMessage "ADMIN" txt conn
RplLuserAdminEmail txt ->
doServerMessage "ADMIN" txt conn
-- Channel list not implemented
RplListStart -> return conn
RplList chan count topic -> doList chan count topic conn
RplListEnd -> return conn
RplUserHost host ->
doServerMessage "USERHOST" (B8.unwords host) conn
RplTime server time -> doServerMessage "TIME" (B8.unwords [server,time]) conn
RplInfo _ -> return conn
RplEndOfInfo -> return conn
Join who chan -> doJoinChannel who Unknown chan conn
ExtJoin who chan account _realname -> doJoinChannel who (maybe None Known account) chan conn
Part who chan reason -> doPart who chan reason conn
Kick who chan tgt reason -> doKick who chan tgt reason conn
Quit who reason -> doQuit who reason conn
Nick who newnick -> doNick who newnick conn
RplChannelUrl chan url ->
return (set (connChannels . ix chan . chanUrl)
(Just url)
conn)
RplNoTopicSet chan ->
return (set (connChannels . ix chan . chanTopic)
(Just Nothing)
conn)
RplTopic chan topic ->
do RplTopicWhoTime _ who time <- getMessage
return (set (connChannels . ix chan . chanTopic)
(Just (Just (asUtf8 topic,who,time)))
conn)
RplTopicWhoTime _ _ _ ->
fail "Unexpected RPL_TOPICWHOTIME"
Topic who chan topic -> doTopic who chan topic conn
PrivMsg who chan msg -> doPrivMsg who chan msg conn
Notice who chan msg -> doNotifyChannel who chan msg conn
Account who acct ->
return (set (connUsers . ix (userNick who) . usrAccount) acct conn)
Away who Just{} ->
return (updateUserRecord (userNick who) (set usrAway True) conn)
Away who Nothing ->
return (updateUserRecord (userNick who) (set usrAway False) conn)
RplYourId yourId -> return (set connId (Just yourId) conn)
RplMotdStart -> return conn
RplEndOfMotd -> return conn
RplMotd x -> doServerMessage "MOTD" x conn
RplNameReply _ chan xs -> doNameReply chan xs conn
RplEndOfNames _ -> return conn
RplChannelModeIs chan modes params -> doChannelModeIs chan modes params conn
RplCreationTime chan creation ->
return (set (connChannels . ix chan . chanCreation) (Just creation) conn)
RplWhoReply _chan _username hostname _servername nickname flags _realname ->
doWhoReply nickname hostname flags conn
RplEndOfWho _chan -> return conn
RplIsOn nicks -> return (doIsOn nicks conn)
RplBanList chan mask who when ->
doMaskList (preview _RplBanList)
(has _RplEndOfBanList)
'b' chan
[IrcMaskEntry
{ _maskEntryMask = mask
, _maskEntryWho = who
, _maskEntryStamp = when
} ] conn
RplEndOfBanList chan ->
return (set (connChannels . ix chan . chanMaskLists . at 'b') (Just []) conn)
RplInviteList chan mask who when ->
doMaskList (preview _RplInviteList)
(has _RplEndOfInviteList)
'I' chan
[IrcMaskEntry
{ _maskEntryMask = mask
, _maskEntryWho = who
, _maskEntryStamp = when
} ] conn
RplEndOfInviteList chan ->
return (set (connChannels . ix chan . chanMaskLists . at 'I') (Just []) conn)
RplExceptionList chan mask who when ->
doMaskList (preview _RplExceptionList)
(has _RplEndOfExceptionList)
'e' chan
[IrcMaskEntry
{ _maskEntryMask = mask
, _maskEntryWho = who
, _maskEntryStamp = when
} ] conn
RplEndOfExceptionList chan ->
return (set (connChannels . ix chan . chanMaskLists . at 'e') (Just []) conn)
RplQuietList chan mode mask who when ->
let fixup (a,_,c,d,e) = (a,c,d,e) in -- drop the matched mode field
doMaskList (previews _RplQuietList fixup)
(has _RplEndOfQuietList)
mode chan
[IrcMaskEntry
{ _maskEntryMask = mask
, _maskEntryWho = who
, _maskEntryStamp = when
} ] conn
RplEndOfQuietList chan mode ->
return (set (connChannels . ix chan . chanMaskLists . at mode) (Just []) conn)
Mode _ _ [] -> fail "Unexpected MODE"
Mode who target (modes:args) ->
doModeChange who target modes args conn
RplSnoMask snomask ->
return (set connSnoMask snomask conn)
RplUmodeIs mode _params -> -- TODO: params?
return (set connUmode (B.tail mode) conn)
Err target err ->
do now <- getStamp
let (statusmsg, target') = splitStatusMsg target conn
let mesg = defaultIrcMessage
{ _mesgType = ErrMsgType err
, _mesgSender = UserInfo "" Nothing Nothing
, _mesgStamp = now
, _mesgStatus = statusmsg
}
recordMessage mesg target' conn
RplKnockDelivered chan ->
doChannelError chan "Knock delivered" conn
RplKnock chan who ->
do now <- getStamp
let mesg = defaultIrcMessage
{ _mesgType = KnockMsgType
, _mesgSender = who
, _mesgStamp = now
}
recordMessage mesg chan conn
RplInviting nick chan ->
doChannelError chan ("Inviting " <> asUtf8 (idBytes nick)) conn
Invite who chan ->
do now <- getStamp
let mesg = defaultIrcMessage
{ _mesgType = InviteMsgType
, _mesgSender = who
, _mesgStamp = now
}
recordMessage mesg chan conn
-- TODO: Structure this more nicely than as simple message,
-- perhaps store it in the user map
RplWhoisUser nick user host real ->
doServerMessage "WHOIS" (B8.unwords [idBytes nick, user, host, real])
(updateUserRecord nick (set usrHost (Just host)) conn)
RplWhoisChannels _nick channels ->
doServerMessage "WHOIS" channels conn
RplWhoisServer _nick host txt ->
doServerMessage "WHOIS" (B8.unwords [host,txt]) conn
RplWhoisSecure _nick ->
doServerMessage "WHOIS" "secure connection" conn
RplWhoisHost _nick txt ->
doServerMessage "WHOIS" txt conn
RplWhoisIdle _nick idle signon ->
doServerMessage "WHOIS" ("Idle seconds: " <> B8.pack (show idle) <>
", Sign-on: " <> maybe "unknown" (B8.pack . show)
signon
) conn
RplWhoisAccount nick account ->
doServerMessage "WHOIS" ("Logged in as: " <> account)
(set (connUsers . ix nick . usrAccount) (Just account) conn)
RplWhoisModes _nick modes args ->
doServerMessage "WHOIS" ("Modes: " <> B8.unwords (modes:args)) conn
RplWhoisOperator _nick txt ->
doServerMessage "WHOIS" ("Operator: " <> txt) conn
RplWhoisCertFp _nick txt ->
doServerMessage "WHOIS" ("CertFP: " <> txt) conn
RplEndOfWhois _nick ->
doServerMessage "WHOIS" "--END--" conn
RplSyntax txt ->
doServerMessage "SYNTAX" txt conn
RplAway nick message ->
doAwayReply nick (asUtf8 message) conn
RplUnAway ->
doServerMessage "AWAY" "You are no longer marked away" conn
RplNowAway ->
doServerMessage "AWAY" "You are marked away" conn
RplWhoWasUser nick user host real ->
doServerMessage "WHOWAS" (B8.unwords [idBytes nick, user, host, real]) conn
RplEndOfWhoWas _nick ->
doServerMessage "WHOWAS" "--END--" conn
RplHostHidden host ->
doServerMessage "HOST" ("Host hidden: " <> host) conn
RplYoureOper txt ->
doServerMessage "OPER" txt conn
RplHelpStart topic txt -> doServerMessage topic txt conn
RplHelp topic txt -> doServerMessage topic txt conn
RplEndOfHelp topic -> doServerMessage topic "--END--" conn
Cap "LS" caps -> doCapLs caps conn
Cap "ACK" caps -> doCapAck caps conn
Cap "NACK" _caps -> sendMessage capEndCmd >> return conn
Cap _ _ -> fail "Unexpected CAP"
RplSaslAborted -> return conn
RplLoadTooHigh cmd ->
doServerError ("Command rate limited: " <> asUtf8 cmd) conn
RplNickLocked ->
doServerError "Nickname locked" conn
RplLoggedIn account ->
doServerMessage "LOGIN" account conn
RplLoggedOut ->
doServerMessage "LOGOUT" "" conn
RplSaslTooLong ->
doServerError "Unexpected SASL Too Long" conn
RplSaslAlready ->
doServerError "Unexpected SASL Already" conn
RplSaslMechs _ ->
doServerError "Unexpected SASL Mechanism List" conn
Error e -> doServerError (asUtf8 e) conn
RplISupport isupport -> doISupport isupport conn
RplVersion version ->
doServerMessage "VERSION" (B8.unwords version) conn
RplUmodeGMsg nick mask -> doCallerId nick mask conn
RplTargNotify nick -> doCallerIdDeliver nick conn
RplAcceptList nick -> doAcceptList [nick] conn
RplEndOfAccept -> doServerMessage "ACCEPTLIST" "Accept list empty" conn
RplLinks mask server info -> doServerMessage "LINKS" (B8.unwords [mask,server,info]) conn
RplEndOfLinks mask -> doServerMessage "LINKS" mask conn
RplStatsLinkInfo linkinfo -> doServerMessage "LINKINFO" (B8.unwords linkinfo) conn
RplStatsCommands commands -> doServerMessage "COMMANDS" (B8.unwords commands) conn
RplStatsCLine cline -> doServerMessage "CLINE" (B8.unwords cline) conn
RplStatsNLine nline -> doServerMessage "NLINE" (B8.unwords nline) conn
RplStatsILine iline -> doServerMessage "ILINE" (B8.unwords iline) conn
RplStatsKLine kline -> doServerMessage "KLINE" (B8.unwords kline) conn
RplStatsQLine qline -> doServerMessage "QLINE" (B8.unwords qline) conn
RplStatsYLine yline -> doServerMessage "YLINE" (B8.unwords yline) conn
RplEndOfStats mode -> doServerMessage "ENDSTATS" (B8.pack [mode]) conn
RplStatsPLine pline -> doServerMessage "PLINE" (B8.unwords pline) conn
RplStatsDLine dline -> doServerMessage "DLINE" (B8.unwords dline) conn
RplStatsVLine vline -> doServerMessage "VLINE" (B8.unwords vline) conn
RplStatsLLine lline -> doServerMessage "LLINE" (B8.unwords lline) conn
RplStatsUptime uptime -> doServerMessage "UPTIME" uptime conn
RplStatsOLine oline -> doServerMessage "OLINE" (B8.unwords oline) conn
RplStatsHLine hline -> doServerMessage "HLINE" (B8.unwords hline) conn
RplStatsSLine sline -> doServerMessage "SLINE" (B8.unwords sline) conn
RplStatsPing ping -> doServerMessage "STATSPING" (B8.unwords ping) conn
RplStatsXLine xline -> doServerMessage "XLINE" (B8.unwords xline) conn
RplStatsULine uline -> doServerMessage "ULINE" (B8.unwords uline) conn
RplStatsDebug debug -> doServerMessage "STATSDEBUG" (B8.unwords debug) conn
RplPrivs txt -> doServerMessage "PRIVS" txt conn
Authenticate msg
| view connPhase conn == SaslPhase
, msg == "+"
, Just (user,pass) <- view connSasl conn ->
do sendMessage (authenticateCmd (encodePlainAuthentication user pass))
return conn
| otherwise ->
doServerError "Unexpected Authenticate" conn
RplSaslSuccess
| view connPhase conn == SaslPhase ->
do sendMessage capEndCmd
doServerMessage "SASL" "Authentication successful"
$ set connPhase RegistrationPhase conn
| otherwise ->
doServerError "Unexpected SASL Success" conn
RplSaslFail
| view connPhase conn == SaslPhase ->
do sendMessage capEndCmd
doServerMessage "SASL" "Authentication failed"
$ set connPhase RegistrationPhase conn
| otherwise ->
doServerError "Unexpected SASL Fail" conn
-- ISUPPORT is defined by
-- https://tools.ietf.org/html/draft-brocklesby-irc-isupport-03#section-3.14
doISupport ::
[(ByteString,ByteString)] {- ^ [(key,value)] -} ->
IrcConnection -> Logic IrcConnection
doISupport params conn = return (foldl' (flip support) conn params)
support :: (ByteString,ByteString) -> IrcConnection -> IrcConnection
support ("CHANTYPES",types) = set connChanTypes (B8.unpack types)
support ("CHANMODES",modes) = updateChanModes (B8.unpack modes)
support ("STATUSMSG",modes) = set connStatusMsg (B8.unpack modes)
support ("PREFIX",modes) = updateChanPrefix (B8.unpack modes)
support ("KNOCK",_) = set connKnock True
support ("NICKLEN",len) =
case B8.readInt len of
Just (n,rest) | B.null rest -> set connNickLen n
_ -> id
support ("TOPICLEN",len) =
case B8.readInt len of
Just (n,rest) | B.null rest -> set connTopicLen n
_ -> id
support ("MODES",str) =
case B8.readInt str of
Just (n,rest) | B.null rest -> set connModes (max 1 n)
_ -> id
support ("INVEX",mode) =
case B8.uncons mode of
Nothing -> set connInvex (Just 'I')
Just (m,_) -> set connInvex (Just $! m)
support ("EXCEPTS",mode) =
case B8.uncons mode of
Nothing -> set connExcepts (Just 'e')
Just (m,_) -> set connExcepts (Just $! m)
support _ = id
updateChanModes ::
String {- lists,always,set,never -} ->
IrcConnection -> IrcConnection
updateChanModes modes
= over connChanModeTypes
$ set modesLists listModes
. set modesAlwaysArg alwaysModes
. set modesSetArg setModes
. set modesNeverArg neverModes
where
next = over _2 (drop 1) . break (==',')
(listModes ,modes1) = next modes
(alwaysModes,modes2) = next modes1
(setModes ,modes3) = next modes2
(neverModes ,_) = next modes3
updateChanPrefix ::
String {- e.g. (ov)@+ -} ->
IrcConnection -> IrcConnection
updateChanPrefix [] = id
updateChanPrefix (_:modes) =
set (connChanModeTypes . modesPrefixModes) (zip a b)
where
(a,b) = over _2 (drop 1) (break (==')') modes)
doAcceptList ::
[Identifier] {- ^ nicks -} ->
IrcConnection -> Logic IrcConnection
doAcceptList acc conn =
do msg <- getMessage
case msg of
RplAcceptList nick -> doAcceptList (nick:acc) conn
RplEndOfAccept -> doServerMessage "ACCEPTLIST"
(B8.unwords (map idBytes (reverse acc))) conn
_ -> fail "doAcceptList: Unexpected message!"
doCallerIdDeliver ::
Identifier {- ^ nick -} ->
IrcConnection -> Logic IrcConnection
doCallerIdDeliver nick conn =
do stamp <- getStamp
let mesg = defaultIrcMessage
{ _mesgType = CallerIdDeliveredMsgType
, _mesgSender = UserInfo nick Nothing Nothing
, _mesgStamp = stamp
}
recordMessage mesg nick conn
doCallerId ::
Identifier {- ^ nick -} ->
ByteString {- ^ user\@host -} ->
IrcConnection -> Logic IrcConnection
doCallerId nick mask conn =
do stamp <- getStamp
let (user,host) = B8.break (=='@') mask
let mesg = defaultIrcMessage
{ _mesgType = CallerIdMsgType
, _mesgSender = UserInfo nick (Just user) (Just (B8.drop 1 host))
, _mesgStamp = stamp
}
recordMessage mesg nick conn
doList ::
Identifier {- ^ channel -} ->
Integer {- ^ members -} ->
ByteString {- ^ topic -} ->
IrcConnection -> Logic IrcConnection
doList chan num topic =
doServerMessage "LIST"
(B8.unwords [idBytes chan, " - ",
B8.pack (show num), " - ",
topic])
doAwayReply ::
Identifier {- ^ nickname -} ->
Text {- ^ away message -} ->
IrcConnection -> Logic IrcConnection
doAwayReply nick message conn =
do stamp <- getStamp
let mesg = defaultIrcMessage
{ _mesgType = AwayMsgType message
, _mesgSender = UserInfo nick Nothing Nothing
, _mesgStamp = stamp
}
recordMessage mesg nick conn
doChannelError ::
Identifier {- ^ channel -} ->
Text {- ^ error -} ->
IrcConnection -> Logic IrcConnection
doChannelError chan reason conn =
do stamp <- getStamp
let mesg = defaultIrcMessage
{ _mesgType = ErrorMsgType reason
, _mesgSender = UserInfo (mkId "server") Nothing Nothing
, _mesgStamp = stamp
}
recordMessage mesg chan conn
-- | Event handler when receiving a new privmsg.
-- The message will be passed along as an event.
doPrivMsg ::
UserInfo {- ^ sender -} ->
Identifier {- ^ message target -} ->
ByteString {- ^ message -} ->
IrcConnection -> Logic IrcConnection
doPrivMsg who chan msg conn =
do stamp <- getStamp
let (statusmsg, chan') = splitStatusMsg chan conn
modes = view (connChannels . ix chan' . chanUsers . ix (userNick who)) conn
mesg = defaultIrcMessage
{ _mesgType = ty
, _mesgSender = who
, _mesgStamp = stamp
, _mesgStatus = statusmsg
, _mesgModes = modes
}
ty = case parseCtcpCommand msg of
Nothing -> PrivMsgType (asUtf8 msg)
Just ("ACTION", action) -> ActionMsgType (asUtf8 action)
Just (command , args ) -> CtcpReqMsgType command args
recordMessage mesg chan' conn
parseCtcpCommand :: ByteString -> Maybe (ByteString, ByteString)
parseCtcpCommand msg
| B8.length msg >= 3
, B8.head msg == '\^A'
, B8.last msg == '\^A' = Just (B8.map toUpper command, B8.drop 1 rest)
| otherwise = Nothing
where
sansControls = B8.tail (B8.init msg)
(command,rest) = B8.break (==' ') sansControls
-- | Record the new topic as set by the given user and
-- emit a change event.
doTopic ::
UserInfo {- ^ changed by -} ->
Identifier {- ^ channel -} ->
ByteString {- ^ topic text -} ->
IrcConnection -> Logic IrcConnection
doTopic who chan topic conn =
do stamp <- getStamp
let topicText = asUtf8 topic
modes = view (connChannels . ix chan . chanUsers . ix (userNick who)) conn
m = defaultIrcMessage
{ _mesgType = TopicMsgType topicText
, _mesgSender = who
, _mesgStamp = stamp
, _mesgModes = modes
}
topicEntry = Just (topicText,renderUserInfo who,stamp)
conn1 = set (connChannels . ix chan . chanTopic) (Just topicEntry) conn
recordMessage m chan conn1
doCapLs :: ByteString -> IrcConnection -> Logic IrcConnection
doCapLs rawCaps conn =
do sendMessage (capReqCmd activeCaps)
return conn
where
activeCaps = intersect supportedCaps offeredCaps
offeredCaps = B8.words rawCaps
supportedCaps = saslSupport
++ ["away-notify","account-notify","userhost-in-names",
"extended-join","multi-prefix",
"znc.in/server-time-iso","server-time",
"znc.in/self-message"]
saslSupport =
case view connSasl conn of
Nothing -> []
Just{} -> ["sasl"]
doCapAck ::
ByteString {- ^ raw, spaces delimited caps list -} ->
IrcConnection -> Logic IrcConnection
doCapAck rawCaps conn =
let ackCaps = B8.words rawCaps in
case view connSasl conn of
Just{} | "sasl" `elem` ackCaps ->
do sendMessage (authenticateCmd "PLAIN")
return (set connPhase SaslPhase conn)
_ -> do sendMessage capEndCmd
return conn
encodePlainAuthentication ::
ByteString {- ^ username -} ->
ByteString {- ^ password -} ->
ByteString
encodePlainAuthentication user pass
= Base64.encode
$ B8.intercalate "\0" [user,user,pass]
doChannelModeIs ::
Identifier {- ^ Channel -} ->
ByteString {- ^ modes -} ->
[ByteString] {- ^ mode parameters -} ->
IrcConnection -> Logic IrcConnection
doChannelModeIs chan modes args conn =
case splitModes (view connChanModeTypes conn) modes args of
Nothing -> fail "Bad mode string"
Just xs -> return (set (connChannels . ix chan . chanModes) (Just modeMap) conn)
where
modeMap = Map.fromList [ (mode,arg) | (True,mode,arg) <- xs ]
doServerError :: Text -> IrcConnection -> Logic IrcConnection
doServerError err conn =
do stamp <- getStamp
let mesg = defaultIrcMessage
{ _mesgType = ErrorMsgType err
, _mesgSender = UserInfo (mkId "server") Nothing Nothing
, _mesgStamp = stamp
}
recordFor "" mesg
return conn
-- | Mark all the given nicks as active (not-away).
doIsOn ::
[Identifier] {- ^ active nicks -} ->
IrcConnection -> IrcConnection
doIsOn nicks conn = foldl' setIsOn conn nicks
where
setIsOn connAcc nick = updateUserRecord nick (set usrAway False) connAcc
doModeChange ::
UserInfo {- ^ who -} ->
Identifier {- ^ target -} ->
ByteString {- ^ modes changed -} ->
[ByteString] {- ^ arguments -} ->
IrcConnection -> Logic IrcConnection
doModeChange who target modes0 args0 conn
| isChannelName target conn =
case splitModes modeSettings modes0 args0 of
Nothing -> return conn
Just ms -> doChannelModeChanges ms who target conn
-- TODO: Implement user modes
| otherwise =
case splitModes (view connUserModeTypes conn) modes0 args0 of
Nothing -> return conn
Just ms -> return (doUserModeChanges ms conn)
where
modeSettings = view connChanModeTypes conn
doUserModeChanges ::
[(Bool, Char, ByteString)] {- ^ [(+/-,mode,argument)] -} ->
IrcConnection -> IrcConnection
doUserModeChanges ms =
over connUmode addModes
where
addModes bs = B.sort (foldl' aux bs ms)
aux bs (polarity,m,_)
| polarity && B8.elem m bs = bs
| polarity = B8.cons m bs
| otherwise = B8.filter (/= m) bs
doChannelModeChanges ::
[(Bool, Char, ByteString)] {- ^ [(+/-,mode,argument)] -} ->
UserInfo {- ^ changer -} ->
Identifier {- ^ channel -} ->
IrcConnection -> Logic IrcConnection
doChannelModeChanges ms who chan conn0 =
do now <- getStamp
foldM (aux now) conn0 ms
where
settings = view connChanModeTypes conn0
aux now conn (polarity,m,a)
= fmap (over (connChannels . ix chan)
(installModeChange settings now who polarity m a))
(recordMessage modeMsg chan conn)
where
modeMsg = defaultIrcMessage
{ _mesgType = ModeMsgType polarity m a
, _mesgSender = who
, _mesgStamp = now
, _mesgModes = view ( connChannels . ix chan
. chanUsers . ix (userNick who)
) conn
}
installModeChange ::
ModeTypes {- ^ settings -} ->
UTCTime {- ^ timestamp -} ->
UserInfo {- ^ changer -} ->
Bool {- ^ +/- -} ->
Char {- ^ mode -} ->
ByteString {- ^ argument -} ->
IrcChannel -> IrcChannel
installModeChange settings now who polarity mode arg
-- Handle bans, exceptions, invex, quiets
| mode `elem` view modesLists settings =
if polarity
then over (chanMaskLists . ix mode)
(cons (IrcMaskEntry arg (renderUserInfo who) now))
else over (chanMaskLists . ix mode)
(filter (\x -> ircFoldCase (view maskEntryMask x)
/= ircFoldCase arg))
-- Handle ops and voices
| mode `elem` views modesPrefixModes (map fst) settings =
if polarity
then over (chanUsers . ix (mkId arg))
(nub . cons mode)
else over (chanUsers . ix (mkId arg))
(delete mode)
| otherwise =
if polarity
then set (chanModes . mapped . at mode)
(Just arg)
else set (chanModes . mapped . at mode)
Nothing
unsplitModes ::
[(Bool,Char,ByteString)] ->
[ByteString]
unsplitModes modes
= B8.pack (foldr combineModeChars (const "") modes True)
: [arg | (_,_,arg) <- modes, not (B.null arg)]
where
combineModeChars (q,m,_) rest p
| p == q = m : rest p
| q = '+' : m : rest True
| otherwise = '-' : m : rest False
-- | Split up a mode change command and arguments into individual changes
-- given a configuration.
splitModes ::
ModeTypes {- ^ mode interpretation -} ->
ByteString {- ^ modes -} ->
[ByteString] {- ^ arguments -} ->
Maybe [(Bool,Char,ByteString)]
splitModes icm modes0 =
foldr aux (\_ args -> [] <$ guard (null args)) (B8.unpack modes0) True
where
aux ::
Char {- current mode -} ->
(Bool -> [ByteString] -> Maybe [(Bool,Char,ByteString)])
{- continuation with updated polarity and arguments -} ->
Bool {- current polarity -} ->
[ByteString] {- current arguments -} ->
Maybe [(Bool,Char,ByteString)]
aux m rec polarity args =
case m of
'+' -> rec True args
'-' -> rec False args
_ | m `elem` view modesAlwaysArg icm
|| polarity && m `elem` view modesSetArg icm
|| m `elem` views modesPrefixModes (map fst) icm
|| m `elem` view modesLists icm ->
do x:xs <- Just args
fmap (cons (polarity,m,x)) (rec polarity xs)
| otherwise -> -- default to no arg
fmap (cons (polarity,m,"")) (rec polarity args)
doMaskList ::
(MsgFromServer -> Maybe (Identifier,ByteString,ByteString,UTCTime)) ->
(MsgFromServer -> Bool) ->
Char ->
Identifier ->
[IrcMaskEntry] ->
IrcConnection -> Logic IrcConnection
doMaskList matchEntry matchEnd mode chan acc conn =
do msg <- getMessage
case matchEntry msg of
Just (_,mask,who,stamp) ->
doMaskList
matchEntry matchEnd
mode chan
(IrcMaskEntry
{ _maskEntryMask = mask
, _maskEntryWho = who
, _maskEntryStamp = stamp
} : acc)
conn
_ | matchEnd msg ->
return (set (connChannels . ix chan . chanMaskLists . at mode)
(Just (reverse acc))
conn)
_ -> fail "Expected mode list end"
-- | Update an 'IrcConnection' when a user changes nicknames.
doNick ::
UserInfo {- ^ old user infomation -} ->
Identifier {- ^ new nickname -} ->
IrcConnection -> Logic IrcConnection
doNick who newnick conn =
do stamp <- getStamp
let m = defaultIrcMessage
{ _mesgType = NickMsgType newnick
, _mesgSender = who
, _mesgStamp = stamp
}
let conn1 | isMyNick (userNick who) conn =
set connNick newnick conn
| otherwise = conn
conn2 = set (connUsers . at newnick)
(view (connUsers . at (userNick who)) conn1)
$ set (connUsers . at (userNick who))
Nothing
$ conn1
iforOf (connChannels . itraversed) conn2 (updateChannel m)
where
oldnick = userNick who
updateChannel :: IrcMessage -> Identifier -> IrcChannel -> Logic IrcChannel
updateChannel m tgt chan
| has (chanUsers . ix oldnick) chan
= do recordFor tgt m
pure $ set (chanUsers . at oldnick) Nothing
$ set (chanUsers . at newnick) (view (chanUsers . at oldnick) chan)
$ chan
| otherwise = pure chan
-- | Update the 'IrcConnection' when a user parts from a channel.
doPart ::
UserInfo {- ^ user information -} ->
Identifier {- ^ channel -} ->
ByteString {- ^ part reason -} ->
IrcConnection -> Logic IrcConnection
doPart who chan reason conn =
do stamp <- getStamp
let mesg = defaultIrcMessage
{ _mesgType = PartMsgType (asUtf8 reason)
, _mesgSender = who
, _mesgStamp = stamp
}
removeUser = set (chanUsers . at (userNick who)) Nothing
conn1 <- fmap (over (connChannels . ix chan) removeUser)
(recordMessage mesg chan conn)
let stillKnown = has (connChannels . folded . chanUsers . ix (userNick who))
conn1
conn2 | stillKnown = conn1
| otherwise = set (connUsers . at (userNick who)) Nothing conn1
conn3 | isMyNick (userNick who) conn =
set (connChannels . at chan) Nothing conn2
| otherwise = conn2
return conn3
-- | Update an 'IrcConnection' when a user is kicked from a channel.
doKick ::
UserInfo {- ^ kicker -} ->
Identifier {- ^ channel -} ->
Identifier {- ^ kicked -} ->
ByteString {- ^ kick reason -} ->
IrcConnection -> Logic IrcConnection
doKick who chan tgt reason conn =
do stamp <- getStamp
let modes = view (connChannels . ix chan . chanUsers . ix (userNick who)) conn
mesg = defaultIrcMessage
{ _mesgType = KickMsgType tgt (asUtf8 reason)
, _mesgSender = who
, _mesgStamp = stamp
, _mesgModes = modes
}
let conn1 = set (connChannels . ix chan . chanUsers . at tgt)
Nothing
conn
stillKnown = has (connChannels . folded . chanUsers . ix (userNick who))
conn1
conn2 | stillKnown = conn1
| otherwise = set (connUsers . at (userNick who)) Nothing conn1
conn3
| isMyNick tgt conn2 =
set (connChannels . at chan) Nothing conn2
| otherwise = conn2
recordMessage mesg chan conn3
updateUserRecord :: Identifier -> (IrcUser -> IrcUser) -> IrcConnection -> IrcConnection
updateUserRecord nick f conn =
case view (connUsers . at nick) conn of
Nothing -> conn
Just old -> (set (connUsers . ix nick) $! f old) conn
doWhoReply :: Identifier -> ByteString -> ByteString -> IrcConnection -> Logic IrcConnection
doWhoReply nickname hostname flags conn =
return $! updateUserRecord
nickname
(set usrAway away . updateHost)
conn
where
away = not (B.null flags) && B.take 1 flags == "G"
updateHost = set usrHost (Just hostname)
-- | Update an 'IrcConnection' with the quitting of a user.
doQuit ::
UserInfo {- ^ user info -} ->
ByteString {- ^ quit reason -} ->
IrcConnection -> Logic IrcConnection
doQuit who reason conn =
do stamp <- getStamp
let mesg = defaultIrcMessage
{ _mesgType = QuitMsgType (asUtf8 reason)
, _mesgSender = who
, _mesgStamp = stamp
}
iforOf (connChannels . itraversed)
(set (connUsers . at (userNick who)) Nothing conn)
$ \tgt chan ->
if has (chanUsers . ix (userNick who)) chan
then do recordFor tgt mesg
pure (set (chanUsers . at (userNick who)) Nothing chan)
else pure chan
doJoinChannel ::
UserInfo {- ^ who joined -} ->
Fuzzy ByteString {- ^ account name -} ->
Identifier {- ^ channel -} ->
IrcConnection -> Logic IrcConnection
doJoinChannel who acct chan conn =
do stamp <- getStamp
-- add channel if necessary
let conn1
| isMyNick (userNick who) conn =
set (connChannels . at chan) (Just defaultChannel) conn
| otherwise = conn
-- add user to channel
conn2 = set (connChannels . ix chan . chanUsers . at (userNick who))
(Just "") -- empty modes
conn1
conn3 = recordAccount (learnUserInfo who (ensureRecord conn2))
-- update user record
ensureRecord = over (connUsers . at (userNick who)) (Just . fromMaybe defaultIrcUser)
recordAccount = case acct of
None -> over (connUsers . ix (userNick who))
(set usrAccount Nothing)
Known a -> over (connUsers . ix (userNick who))
(set usrAccount (Just a))
Unknown -> id
-- record join event
m = defaultIrcMessage
{ _mesgType = JoinMsgType
, _mesgSender = who
, _mesgStamp = stamp
}
recordMessage m chan conn3
learnUserInfo :: UserInfo -> IrcConnection -> IrcConnection
learnUserInfo ui conn =
case userHost ui of
Nothing -> conn
Just host ->
let update Nothing = Just defaultIrcUser { _usrHost = Just host }
update (Just u) = Just $! set usrHost (Just host) u
in over (connUsers . at (userNick ui)) update conn
doNotifyChannel ::
UserInfo ->
Identifier ->
ByteString ->
IrcConnection ->
Logic IrcConnection
doNotifyChannel who chan msg conn =
do stamp <- getStamp
let (statusmsg, chan') = splitStatusMsg chan conn
let ty = case parseCtcpCommand msg of
Nothing -> NoticeMsgType (asUtf8 msg)
Just (command , args ) -> CtcpRspMsgType command args
modes = view (connChannels . ix chan' . chanUsers . ix (userNick who)) conn
mesg = defaultIrcMessage
{ _mesgType = ty
, _mesgSender = who
, _mesgStamp = stamp
, _mesgStatus = statusmsg
, _mesgModes = modes
}
recordMessage mesg chan' conn
doServerMessage ::
ByteString {- ^ who -} ->
ByteString {- ^ message -} ->
IrcConnection -> Logic IrcConnection
doServerMessage who txt conn =
do stamp <- getStamp
let m = defaultIrcMessage
{ _mesgType = PrivMsgType (asUtf8 txt)
, _mesgSender = UserInfo (mkId who) Nothing Nothing
, _mesgStamp = stamp
}
recordFor "" m
return conn
doNameReply :: Identifier -> [ByteString] -> IrcConnection -> Logic IrcConnection
doNameReply chan xs conn =
do msg <- getMessage
case msg of
RplNameReply _ _ x -> doNameReply chan (x++xs) conn
RplEndOfNames _ -> return
$ learnAllHosts
$ set (connChannels . ix chan . chanUsers)
users
conn
_ -> fail "Expected end of names"
where
modeMap = view (connChanModeTypes . modesPrefixModes) conn
splitNames :: [(UserInfo, String)]
splitNames = map (splitNamesReplyName modeMap) xs
users :: Map Identifier String
users = Map.fromList (map (over _1 userNick) splitNames)
learnAllHosts x = foldl' (flip learnUserInfo) x (map fst splitNames)
-- | Compute the nickname and channel modes from an entry in
-- a NAMES reply. The leading channel prefixes are translated
-- into the appropriate modes.
splitNamesReplyName ::
[(Char,Char)] {- ^ [(mode,prefix)] -} ->
ByteString {- ^ names entry -} ->
(UserInfo, String) {- ^ (nickname, modes) -}
splitNamesReplyName modeMap = aux []
where
aux modes n =
case B8.uncons n of
Just (x,xs)
| Just (mode,_) <- find (\(_mode,symbol) -> x == symbol) modeMap
-> aux (mode:modes) xs
_ -> (parseUserInfo n,modes)
------------------------------------------------------------------------
-- Type describing computations that will require zero or more messages
-- to perform complex updates to the model.
------------------------------------------------------------------------
-- | Execute the 'Logic' value using a given operation for sending and
-- recieving IRC messages.
runLogic :: (Functor m,Monad m) =>
UTCTime ->
(forall r. LogicOp r -> m r) ->
Logic a ->
m (Either String a)
runLogic now ops (Logic f)
= retract
$ hoistFree ops
$ runErrorT
$ runReaderT f now
data LogicOp r
= Expect (MsgFromServer -> r)
| Emit ByteString r
| Record Identifier IrcMessage r
deriving (Functor)
newtype Logic a = Logic (ReaderT UTCTime (ErrorT String (Free LogicOp)) a)
deriving (Functor, Applicative, Monad)
getStamp :: Logic UTCTime
getStamp = Logic ask
recordFor :: Identifier -> IrcMessage -> Logic ()
recordFor target msg = Logic (wrap (Record target msg (return ())))
getMessage :: Logic MsgFromServer
getMessage = Logic (wrap (Expect return))
sendMessage :: ByteString -> Logic ()
sendMessage x = Logic (wrap (Emit x (return ())))
-- | Add a message to the client state for users and channels.
-- The user or channel record should be added if it does not already
-- exist.
recordMessage ::
IrcMessage ->
Identifier {- ^ target -} ->
IrcConnection ->
Logic IrcConnection
recordMessage mesg target conn =
do let mesg1 = set mesgMe isMe mesg
recordFor target mesg1
return conn
where
isMe = isMyNick (views mesgSender userNick mesg) conn
-- | Predicate to determine if a given identifier is the primary nick
-- for the given connection.
isMyNick :: Identifier -> IrcConnection -> Bool
isMyNick nick conn = nick == view connNick conn
-- | Predicate for identifiers to identify which represent channel names.
-- Channel prefixes are configurable, but the most common is @#@
isChannelName :: Identifier -> IrcConnection -> Bool
isChannelName c conn =
case B8.uncons (idBytes c) of
Just (x,xs) -> not (B.null xs)
&& x `elem` view connChanTypes conn
_ -> False -- probably shouldn't happen
-- | Predicate for identifiers to identify which represent nicknames
isNickName :: Identifier -> IrcConnection -> Bool
isNickName c conn =
case B8.uncons (idBytes c) of
Just (x,_) -> not (x `elem` view connChanTypes conn)
_ -> False -- probably shouldn't happen
splitStatusMsg :: Identifier -> IrcConnection -> (String,Identifier)
splitStatusMsg target conn = aux [] (idBytes target)
where
aux acc bs =
case B8.uncons bs of
Just (x,xs) | x `elem` view connStatusMsg conn -> aux (x:acc) xs
_ -> (reverse acc, mkId bs)
nickHasModeInChannel ::
Identifier {- ^ nick -} ->
Char {- ^ mode -} ->
Identifier {- ^ channel -} ->
IrcConnection -> Bool
nickHasModeInChannel nick mode chan =
elemOf ( connChannels . ix chan
. chanUsers . ix nick
. folded)
mode
channelHasMode ::
Identifier {- ^ channel -} ->
Char {- ^ mode -} ->
IrcConnection -> Bool
channelHasMode chan mode =
has ( connChannels . ix chan
. chanModes . folded . ix mode
)
| TomMD/irc-core | src/Irc/Model.hs | bsd-3-clause | 47,820 | 0 | 21 | 14,410 | 12,755 | 6,499 | 6,256 | 1,148 | 138 |
module Main where
import CsvToJson.Core (parseCsvToJson)
main :: IO ()
main = parseCsvToJson
| ulisses-alves/csv-to-json | app/Main.hs | bsd-3-clause | 95 | 0 | 6 | 15 | 29 | 17 | 12 | 4 | 1 |
-- | Utility functions.
module OANDA.Internal
( module X
) where
import OANDA.Internal.Import as X
import OANDA.Internal.Request as X
import OANDA.Internal.Types as X
| jdreaver/oanda-rest-api | src/OANDA/Internal.hs | bsd-3-clause | 173 | 0 | 4 | 29 | 37 | 27 | 10 | 5 | 0 |
module Sharc.Instruments.AltoFlute (altoFlute) where
import Sharc.Types
altoFlute :: Instr
altoFlute = Instr
"altoflute_vibrato"
"Alto Flute"
(Legend "McGill" "2" "5")
(Range
(InstrRange
(HarmonicFreq 1 (Pitch 195.99 43 "g3"))
(Pitch 195.99 43 "g3")
(Amplitude 7848.76 (HarmonicFreq 15 (Pitch 523.251 60 "c5")) 0.63))
(InstrRange
(HarmonicFreq 27 (Pitch 9989.83 54 "f#4"))
(Pitch 1046.5 72 "c6")
(Amplitude 739.98 (HarmonicFreq 2 (Pitch 369.994 54 "f#4")) 9130.0)))
[note0
,note1
,note2
,note3
,note4
,note5
,note6
,note7
,note8
,note9
,note10
,note11
,note12
,note13
,note14
,note15
,note16
,note17
,note18
,note19
,note20
,note21
,note22
,note23
,note24
,note25
,note26
,note27
,note28
,note29]
note0 :: Note
note0 = Note
(Pitch 195.998 43 "g3")
1
(Range
(NoteRange
(NoteRangeAmplitude 5291.94 27 2.91)
(NoteRangeHarmonicFreq 1 195.99))
(NoteRange
(NoteRangeAmplitude 391.99 2 6148.0)
(NoteRangeHarmonicFreq 50 9799.9)))
[Harmonic 1 (-2.581) 1380.34
,Harmonic 2 1.565 6148.0
,Harmonic 3 (-0.358) 4033.99
,Harmonic 4 (-2.04) 4032.32
,Harmonic 5 2.03 2979.07
,Harmonic 6 (-0.372) 1184.64
,Harmonic 7 1.908 271.56
,Harmonic 8 (-2.575) 84.42
,Harmonic 9 1.506 270.63
,Harmonic 10 (-1.377) 218.2
,Harmonic 11 2.662 123.02
,Harmonic 12 1.135 53.76
,Harmonic 13 9.2e-2 60.51
,Harmonic 14 (-1.576) 122.4
,Harmonic 15 2.189 113.49
,Harmonic 16 0.173 110.72
,Harmonic 17 (-2.021) 43.54
,Harmonic 18 0.564 31.69
,Harmonic 19 2.766 78.74
,Harmonic 20 0.548 57.6
,Harmonic 21 (-1.43) 73.16
,Harmonic 22 2.634 35.81
,Harmonic 23 (-0.576) 13.11
,Harmonic 24 2.422 12.67
,Harmonic 25 0.319 14.71
,Harmonic 26 (-2.602) 23.74
,Harmonic 27 (-2.56) 2.91
,Harmonic 28 (-0.11) 5.98
,Harmonic 29 (-1.91) 6.48
,Harmonic 30 (-2.111) 13.47
,Harmonic 31 1.984 3.53
,Harmonic 32 (-3.005) 5.48
,Harmonic 33 0.895 15.38
,Harmonic 34 (-2.804) 10.16
,Harmonic 35 2.968 11.89
,Harmonic 36 (-1.637) 9.68
,Harmonic 37 2.054 5.9
,Harmonic 38 (-1.022) 16.44
,Harmonic 39 0.539 3.62
,Harmonic 40 (-1.312) 5.62
,Harmonic 41 (-2.495) 9.12
,Harmonic 42 (-0.954) 4.57
,Harmonic 43 (-0.984) 13.36
,Harmonic 44 1.423 19.73
,Harmonic 45 (-1.624) 16.57
,Harmonic 46 1.768 16.16
,Harmonic 47 (-1.058) 9.11
,Harmonic 48 2.319 5.3
,Harmonic 49 (-2.538) 3.99
,Harmonic 50 (-2.88) 4.03]
note1 :: Note
note1 = Note
(Pitch 207.652 44 "g#3")
2
(Range
(NoteRange
(NoteRangeAmplitude 8513.73 41 2.08)
(NoteRangeHarmonicFreq 1 207.65))
(NoteRange
(NoteRangeAmplitude 415.3 2 6858.0)
(NoteRangeHarmonicFreq 47 9759.64)))
[Harmonic 1 1.533 1238.84
,Harmonic 2 2.299 6858.0
,Harmonic 3 (-1.853) 3032.13
,Harmonic 4 (-0.144) 4128.11
,Harmonic 5 0.875 3274.67
,Harmonic 6 1.429 1457.79
,Harmonic 7 1.043 324.73
,Harmonic 8 1.205 349.71
,Harmonic 9 0.99 326.07
,Harmonic 10 2.338 344.4
,Harmonic 11 (-2.919) 268.21
,Harmonic 12 (-1.52) 89.43
,Harmonic 13 (-0.435) 39.68
,Harmonic 14 (-2.203) 23.97
,Harmonic 15 (-0.367) 82.23
,Harmonic 16 0.539 71.09
,Harmonic 17 2.01 59.97
,Harmonic 18 2.705 43.99
,Harmonic 19 (-1.008) 12.93
,Harmonic 20 (-2.644) 27.53
,Harmonic 21 (-2.583) 19.27
,Harmonic 22 (-0.899) 22.19
,Harmonic 23 (-0.145) 11.67
,Harmonic 24 (-5.9e-2) 4.6
,Harmonic 25 2.404 9.64
,Harmonic 26 1.79 2.59
,Harmonic 27 1.961 3.13
,Harmonic 28 (-2.709) 7.85
,Harmonic 29 (-1.336) 3.53
,Harmonic 30 0.479 5.67
,Harmonic 31 (-2.948) 2.47
,Harmonic 32 2.148 6.56
,Harmonic 33 0.983 6.14
,Harmonic 34 (-2.474) 9.16
,Harmonic 35 (-3.011) 8.43
,Harmonic 36 0.704 5.55
,Harmonic 37 (-2.949) 4.43
,Harmonic 38 0.881 3.91
,Harmonic 39 (-0.903) 8.43
,Harmonic 40 0.325 15.79
,Harmonic 41 0.292 2.08
,Harmonic 42 1.717 6.68
,Harmonic 43 (-0.688) 4.47
,Harmonic 44 1.163 11.1
,Harmonic 45 1.336 7.4
,Harmonic 46 2.581 7.51
,Harmonic 47 (-1.727) 2.93]
note2 :: Note
note2 = Note
(Pitch 220.0 45 "a3")
3
(Range
(NoteRange
(NoteRangeAmplitude 5500.0 25 0.67)
(NoteRangeHarmonicFreq 1 220.0))
(NoteRange
(NoteRangeAmplitude 440.0 2 4824.0)
(NoteRangeHarmonicFreq 45 9900.0)))
[Harmonic 1 2.604 1607.41
,Harmonic 2 (-1.235) 4824.0
,Harmonic 3 2.653 2332.73
,Harmonic 4 (-1.061) 2310.39
,Harmonic 5 0.906 1024.84
,Harmonic 6 1.819 302.72
,Harmonic 7 1.53 184.77
,Harmonic 8 (-1.769) 159.01
,Harmonic 9 0.761 185.23
,Harmonic 10 (-2.99) 106.58
,Harmonic 11 (-1.929) 9.37
,Harmonic 12 (-0.316) 15.34
,Harmonic 13 1.912 47.82
,Harmonic 14 (-1.232) 57.3
,Harmonic 15 (-0.281) 33.68
,Harmonic 16 (-1.814) 12.31
,Harmonic 17 (-1.894) 20.35
,Harmonic 18 (-1.568) 12.45
,Harmonic 19 (-2.152) 3.75
,Harmonic 20 (-9.7e-2) 7.54
,Harmonic 21 (-0.787) 3.18
,Harmonic 22 2.607 5.69
,Harmonic 23 (-1.033) 13.42
,Harmonic 24 0.946 5.45
,Harmonic 25 (-1.8) 0.67
,Harmonic 26 (-2.753) 6.15
,Harmonic 27 (-0.637) 12.6
,Harmonic 28 2.539 8.21
,Harmonic 29 (-2.529) 2.63
,Harmonic 30 (-1.688) 1.27
,Harmonic 31 2.78 7.0
,Harmonic 32 (-2.667) 8.44
,Harmonic 33 0.57 7.89
,Harmonic 34 (-0.237) 5.31
,Harmonic 35 (-3.095) 12.63
,Harmonic 36 0.659 3.56
,Harmonic 37 (-2.167) 4.88
,Harmonic 38 (-1.232) 7.77
,Harmonic 39 3.5e-2 1.84
,Harmonic 40 (-2.761) 7.48
,Harmonic 41 (-1.434) 7.63
,Harmonic 42 1.103 11.33
,Harmonic 43 (-2.969) 3.83
,Harmonic 44 (-1.43) 1.34
,Harmonic 45 0.764 6.15]
note3 :: Note
note3 = Note
(Pitch 233.082 46 "a#3")
4
(Range
(NoteRange
(NoteRangeAmplitude 4894.72 21 2.63)
(NoteRangeHarmonicFreq 1 233.08))
(NoteRange
(NoteRangeAmplitude 466.16 2 5347.0)
(NoteRangeHarmonicFreq 42 9789.44)))
[Harmonic 1 (-0.596) 2511.36
,Harmonic 2 (-1.913) 5347.0
,Harmonic 3 (-1.094) 3533.52
,Harmonic 4 (-1.993) 3098.77
,Harmonic 5 2.943 2071.96
,Harmonic 6 0.565 566.93
,Harmonic 7 (-1.442) 222.02
,Harmonic 8 (-2.463) 231.7
,Harmonic 9 2.588 275.29
,Harmonic 10 1.3 223.11
,Harmonic 11 0.36 122.56
,Harmonic 12 (-0.509) 70.96
,Harmonic 13 (-2.394) 39.42
,Harmonic 14 1.916 52.88
,Harmonic 15 1.516 56.21
,Harmonic 16 0.558 44.26
,Harmonic 17 1.103 26.12
,Harmonic 18 (-1.37) 24.86
,Harmonic 19 (-1.054) 4.5
,Harmonic 20 2.893 15.81
,Harmonic 21 2.432 2.63
,Harmonic 22 (-2.736) 4.52
,Harmonic 23 2.221 6.24
,Harmonic 24 1.016 15.08
,Harmonic 25 (-9.0e-3) 6.45
,Harmonic 26 (-1.071) 9.86
,Harmonic 27 (-2.195) 9.03
,Harmonic 28 2.668 6.46
,Harmonic 29 2.283 10.24
,Harmonic 30 0.448 11.52
,Harmonic 31 0.359 21.05
,Harmonic 32 (-0.302) 3.27
,Harmonic 33 (-2.389) 6.24
,Harmonic 34 (-2.134) 5.11
,Harmonic 35 (-3.055) 9.69
,Harmonic 36 2.439 17.39
,Harmonic 37 1.069 15.4
,Harmonic 38 (-0.555) 8.61
,Harmonic 39 (-1.441) 27.56
,Harmonic 40 2.965 9.16
,Harmonic 41 0.801 11.92
,Harmonic 42 0.336 2.75]
note4 :: Note
note4 = Note
(Pitch 246.942 47 "b3")
5
(Range
(NoteRange
(NoteRangeAmplitude 6420.49 26 0.83)
(NoteRangeHarmonicFreq 1 246.94))
(NoteRange
(NoteRangeAmplitude 740.82 3 6334.0)
(NoteRangeHarmonicFreq 40 9877.68)))
[Harmonic 1 (-2.748) 1680.15
,Harmonic 2 (-0.612) 5285.26
,Harmonic 3 (-2.043) 6334.0
,Harmonic 4 0.409 2587.1
,Harmonic 5 (-3.038) 2452.83
,Harmonic 6 2.176 345.2
,Harmonic 7 0.413 491.19
,Harmonic 8 1.318 239.97
,Harmonic 9 (-1.369) 410.71
,Harmonic 10 1.531 57.88
,Harmonic 11 (-2.188) 163.1
,Harmonic 12 0.743 69.0
,Harmonic 13 2.189 127.7
,Harmonic 14 (-0.994) 149.59
,Harmonic 15 1.492 59.78
,Harmonic 16 (-1.855) 88.8
,Harmonic 17 0.761 14.18
,Harmonic 18 (-2.725) 17.63
,Harmonic 19 (-1.026) 25.33
,Harmonic 20 2.779 24.65
,Harmonic 21 (-0.9) 18.31
,Harmonic 22 2.822 9.6
,Harmonic 23 (-1.911) 10.2
,Harmonic 24 (-1.446) 11.11
,Harmonic 25 (-2.508) 10.62
,Harmonic 26 (-1.686) 0.83
,Harmonic 27 2.996 9.05
,Harmonic 28 (-2.719) 2.8
,Harmonic 29 2.784 3.74
,Harmonic 30 (-2.342) 6.39
,Harmonic 31 1.094 6.51
,Harmonic 32 2.157 10.79
,Harmonic 33 0.893 9.38
,Harmonic 34 (-0.954) 4.74
,Harmonic 35 (-1.645) 28.34
,Harmonic 36 2.58 6.01
,Harmonic 37 2.461 16.47
,Harmonic 38 (-1.431) 4.29
,Harmonic 39 1.117 4.2
,Harmonic 40 (-2.654) 5.25]
note5 :: Note
note5 = Note
(Pitch 261.626 48 "c4")
6
(Range
(NoteRange
(NoteRangeAmplitude 7848.77 30 1.66)
(NoteRangeHarmonicFreq 1 261.62))
(NoteRange
(NoteRangeAmplitude 784.87 3 7572.0)
(NoteRangeHarmonicFreq 38 9941.78)))
[Harmonic 1 1.745 5351.6
,Harmonic 2 3.138 7269.23
,Harmonic 3 (-0.39) 7572.0
,Harmonic 4 1.262 6820.63
,Harmonic 5 1.484 1036.8
,Harmonic 6 0.969 177.58
,Harmonic 7 2.116 512.99
,Harmonic 8 (-2.51) 466.52
,Harmonic 9 (-0.898) 181.51
,Harmonic 10 (-2.619) 49.46
,Harmonic 11 (-0.733) 143.12
,Harmonic 12 1.438 151.37
,Harmonic 13 2.786 82.06
,Harmonic 14 2.897 28.09
,Harmonic 15 (-2.573) 80.33
,Harmonic 16 (-0.883) 62.86
,Harmonic 17 0.416 57.73
,Harmonic 18 1.779 45.01
,Harmonic 19 2.301 56.43
,Harmonic 20 (-2.455) 30.17
,Harmonic 21 (-0.626) 35.81
,Harmonic 22 0.113 21.45
,Harmonic 23 1.538 16.88
,Harmonic 24 (-2.803) 28.08
,Harmonic 25 (-2.136) 7.88
,Harmonic 26 (-0.19) 21.16
,Harmonic 27 0.771 15.8
,Harmonic 28 1.288 17.48
,Harmonic 29 (-2.473) 12.37
,Harmonic 30 0.374 1.66
,Harmonic 31 (-0.264) 10.43
,Harmonic 32 1.023 36.42
,Harmonic 33 2.729 31.18
,Harmonic 34 (-2.932) 25.72
,Harmonic 35 (-3.087) 4.6
,Harmonic 36 2.97 6.58
,Harmonic 37 (-2.877) 2.81
,Harmonic 38 2.601 3.66]
note6 :: Note
note6 = Note
(Pitch 277.183 49 "c#4")
7
(Range
(NoteRange
(NoteRangeAmplitude 6098.02 22 0.86)
(NoteRangeHarmonicFreq 1 277.18))
(NoteRange
(NoteRangeAmplitude 554.36 2 7095.0)
(NoteRangeHarmonicFreq 36 9978.58)))
[Harmonic 1 (-2.244) 5923.35
,Harmonic 2 1.592 7095.0
,Harmonic 3 (-0.102) 6448.97
,Harmonic 4 3.128 2630.15
,Harmonic 5 (-0.482) 102.9
,Harmonic 6 1.212 326.64
,Harmonic 7 (-0.768) 443.77
,Harmonic 8 2.606 172.24
,Harmonic 9 (-2.43) 68.54
,Harmonic 10 1.798 126.08
,Harmonic 11 (-0.583) 94.47
,Harmonic 12 2.926 40.64
,Harmonic 13 (-1.068) 28.04
,Harmonic 14 2.413 17.89
,Harmonic 15 (-0.451) 23.41
,Harmonic 16 2.451 13.13
,Harmonic 17 0.594 15.85
,Harmonic 18 2.54 12.56
,Harmonic 19 (-0.293) 7.12
,Harmonic 20 2.94 13.41
,Harmonic 21 1.59 8.5
,Harmonic 22 2.461 0.86
,Harmonic 23 (-1.576) 1.77
,Harmonic 24 (-2.067) 12.4
,Harmonic 25 1.946 14.27
,Harmonic 26 (-1.35) 4.37
,Harmonic 27 0.717 10.73
,Harmonic 28 (-1.132) 3.46
,Harmonic 29 (-2.239) 7.3
,Harmonic 30 1.51 7.72
,Harmonic 31 (-2.718) 5.63
,Harmonic 32 0.596 29.85
,Harmonic 33 (-2.125) 8.35
,Harmonic 34 (-1.72) 4.36
,Harmonic 35 3.134 3.92
,Harmonic 36 1.809 5.51]
note7 :: Note
note7 = Note
(Pitch 293.665 50 "d4")
8
(Range
(NoteRange
(NoteRangeAmplitude 6460.63 22 3.75)
(NoteRangeHarmonicFreq 1 293.66))
(NoteRange
(NoteRangeAmplitude 587.33 2 6931.0)
(NoteRangeHarmonicFreq 34 9984.61)))
[Harmonic 1 (-2.963) 5940.04
,Harmonic 2 0.175 6931.0
,Harmonic 3 (-2.039) 5255.81
,Harmonic 4 (-0.123) 1070.02
,Harmonic 5 1.347 1399.52
,Harmonic 6 (-2.147) 696.92
,Harmonic 7 0.845 347.12
,Harmonic 8 2.691 106.23
,Harmonic 9 (-1.148) 186.29
,Harmonic 10 1.707 160.02
,Harmonic 11 (-1.154) 149.47
,Harmonic 12 0.281 46.2
,Harmonic 13 3.065 82.51
,Harmonic 14 (-4.1e-2) 65.32
,Harmonic 15 2.106 33.89
,Harmonic 16 (-2.192) 35.3
,Harmonic 17 0.758 42.51
,Harmonic 18 (-1.687) 6.34
,Harmonic 19 (-0.247) 18.28
,Harmonic 20 2.842 22.81
,Harmonic 21 (-0.265) 12.39
,Harmonic 22 (-2.103) 3.75
,Harmonic 23 (-1.788) 24.51
,Harmonic 24 2.229 7.99
,Harmonic 25 2.245 5.55
,Harmonic 26 1.999 7.45
,Harmonic 27 (-1.483) 3.8
,Harmonic 28 (-1.057) 5.03
,Harmonic 29 2.739 7.63
,Harmonic 30 (-1.862) 38.49
,Harmonic 31 2.375 19.16
,Harmonic 32 1.363 7.03
,Harmonic 33 (-0.85) 10.21
,Harmonic 34 (-3.137) 5.37]
note8 :: Note
note8 = Note
(Pitch 311.127 51 "d#4")
9
(Range
(NoteRange
(NoteRangeAmplitude 7467.04 24 2.4)
(NoteRangeHarmonicFreq 1 311.12))
(NoteRange
(NoteRangeAmplitude 933.38 3 8800.0)
(NoteRangeHarmonicFreq 32 9956.06)))
[Harmonic 1 1.923 5523.98
,Harmonic 2 (-2.459) 5686.01
,Harmonic 3 0.327 8800.0
,Harmonic 4 1.874 3471.69
,Harmonic 5 1.405 548.02
,Harmonic 6 2.916 547.41
,Harmonic 7 (-1.753) 601.27
,Harmonic 8 (-0.326) 174.32
,Harmonic 9 0.639 123.7
,Harmonic 10 1.825 211.87
,Harmonic 11 (-2.713) 224.93
,Harmonic 12 (-0.954) 90.97
,Harmonic 13 (-0.178) 48.09
,Harmonic 14 1.07 64.37
,Harmonic 15 3.021 44.79
,Harmonic 16 (-1.807) 43.51
,Harmonic 17 (-0.297) 9.22
,Harmonic 18 0.165 13.75
,Harmonic 19 2.524 13.86
,Harmonic 20 (-2.217) 12.27
,Harmonic 21 0.215 5.27
,Harmonic 22 (-1.255) 10.23
,Harmonic 23 2.03 15.55
,Harmonic 24 (-1.996) 2.4
,Harmonic 25 1.08 6.4
,Harmonic 26 (-1.208) 10.94
,Harmonic 27 1.034 16.27
,Harmonic 28 2.793 27.96
,Harmonic 29 0.386 24.01
,Harmonic 30 2.672 18.97
,Harmonic 31 (-1.773) 7.92
,Harmonic 32 0.3 2.86]
note9 :: Note
note9 = Note
(Pitch 329.628 52 "e4")
10
(Range
(NoteRange
(NoteRangeAmplitude 9888.84 30 4.82)
(NoteRangeHarmonicFreq 1 329.62))
(NoteRange
(NoteRangeAmplitude 988.88 3 8281.0)
(NoteRangeHarmonicFreq 30 9888.84)))
[Harmonic 1 (-1.311) 6192.44
,Harmonic 2 (-1.386) 6811.9
,Harmonic 3 (-2.097) 8281.0
,Harmonic 4 2.836 1452.05
,Harmonic 5 0.166 391.51
,Harmonic 6 (-1.272) 845.12
,Harmonic 7 (-2.937) 393.25
,Harmonic 8 2.692 115.5
,Harmonic 9 4.6e-2 151.81
,Harmonic 10 (-0.746) 194.79
,Harmonic 11 (-2.033) 94.93
,Harmonic 12 2.283 53.7
,Harmonic 13 0.978 54.28
,Harmonic 14 8.0e-2 44.09
,Harmonic 15 (-1.772) 38.18
,Harmonic 16 (-2.11) 22.26
,Harmonic 17 (-3.076) 19.4
,Harmonic 18 0.894 27.63
,Harmonic 19 0.213 23.34
,Harmonic 20 (-0.78) 23.1
,Harmonic 21 0.733 4.91
,Harmonic 22 2.115 17.89
,Harmonic 23 2.732 13.05
,Harmonic 24 1.5 11.9
,Harmonic 25 0.251 32.71
,Harmonic 26 (-0.601) 31.17
,Harmonic 27 (-1.548) 50.12
,Harmonic 28 2.996 23.25
,Harmonic 29 (-0.384) 12.74
,Harmonic 30 0.347 4.82]
note10 :: Note
note10 = Note
(Pitch 349.228 53 "f4")
11
(Range
(NoteRange
(NoteRangeAmplitude 7333.78 21 2.96)
(NoteRangeHarmonicFreq 1 349.22))
(NoteRange
(NoteRangeAmplitude 698.45 2 6380.0)
(NoteRangeHarmonicFreq 28 9778.38)))
[Harmonic 1 1.333 5145.88
,Harmonic 2 (-2.307) 6380.0
,Harmonic 3 (-1.329) 4939.57
,Harmonic 4 (-0.493) 866.99
,Harmonic 5 (-1.213) 359.79
,Harmonic 6 (-0.641) 391.35
,Harmonic 7 8.3e-2 280.12
,Harmonic 8 2.068 166.91
,Harmonic 9 2.326 115.56
,Harmonic 10 3.022 147.03
,Harmonic 11 (-2.306) 87.16
,Harmonic 12 (-1.382) 66.79
,Harmonic 13 (-0.638) 68.91
,Harmonic 14 0.347 74.64
,Harmonic 15 1.578 30.53
,Harmonic 16 2.769 29.17
,Harmonic 17 (-2.255) 24.52
,Harmonic 18 (-1.4) 20.15
,Harmonic 19 (-0.177) 25.81
,Harmonic 20 0.824 13.89
,Harmonic 21 (-0.34) 2.96
,Harmonic 22 3.136 9.96
,Harmonic 23 (-0.556) 7.23
,Harmonic 24 (-1.742) 9.97
,Harmonic 25 (-0.388) 13.1
,Harmonic 26 (-0.84) 22.84
,Harmonic 27 (-0.674) 17.84
,Harmonic 28 0.708 9.08]
note11 :: Note
note11 = Note
(Pitch 369.994 54 "f#4")
12
(Range
(NoteRange
(NoteRangeAmplitude 7029.88 19 1.41)
(NoteRangeHarmonicFreq 1 369.99))
(NoteRange
(NoteRangeAmplitude 739.98 2 9130.0)
(NoteRangeHarmonicFreq 27 9989.83)))
[Harmonic 1 (-1.31) 5379.36
,Harmonic 2 (-1.214) 9130.0
,Harmonic 3 (-2.598) 5355.33
,Harmonic 4 1.744 266.01
,Harmonic 5 (-1.155) 566.26
,Harmonic 6 (-2.842) 314.02
,Harmonic 7 1.672 75.01
,Harmonic 8 (-3.5e-2) 179.1
,Harmonic 9 (-1.543) 189.05
,Harmonic 10 3.052 96.46
,Harmonic 11 1.684 56.24
,Harmonic 12 (-0.309) 47.71
,Harmonic 13 (-1.901) 60.82
,Harmonic 14 (-3.106) 18.29
,Harmonic 15 1.455 22.2
,Harmonic 16 (-0.828) 18.23
,Harmonic 17 (-1.855) 15.84
,Harmonic 18 (-1.795) 9.53
,Harmonic 19 (-0.335) 1.41
,Harmonic 20 2.866 4.87
,Harmonic 21 (-0.56) 8.28
,Harmonic 22 (-1.35) 6.43
,Harmonic 23 (-1.929) 3.37
,Harmonic 24 0.444 16.09
,Harmonic 25 (-1.346) 12.49
,Harmonic 26 (-1.887) 3.66
,Harmonic 27 1.69 1.47]
note12 :: Note
note12 = Note
(Pitch 391.995 55 "g4")
13
(Range
(NoteRange
(NoteRangeAmplitude 7447.9 19 3.5)
(NoteRangeHarmonicFreq 1 391.99))
(NoteRange
(NoteRangeAmplitude 783.99 2 6401.0)
(NoteRangeHarmonicFreq 25 9799.87)))
[Harmonic 1 9.4e-2 5703.3
,Harmonic 2 2.047 6401.0
,Harmonic 3 2.217 3687.14
,Harmonic 4 1.241 399.29
,Harmonic 5 (-0.416) 207.72
,Harmonic 6 (-2.3e-2) 266.16
,Harmonic 7 (-0.152) 123.11
,Harmonic 8 (-0.315) 167.92
,Harmonic 9 (-0.109) 132.27
,Harmonic 10 1.5e-2 47.65
,Harmonic 11 (-0.801) 73.49
,Harmonic 12 (-0.297) 48.76
,Harmonic 13 (-0.364) 14.93
,Harmonic 14 (-0.622) 14.07
,Harmonic 15 (-0.211) 15.05
,Harmonic 16 0.445 7.89
,Harmonic 17 (-0.784) 4.86
,Harmonic 18 (-1.767) 9.5
,Harmonic 19 (-0.325) 3.5
,Harmonic 20 (-2.777) 5.44
,Harmonic 21 (-1.486) 5.32
,Harmonic 22 0.643 23.05
,Harmonic 23 (-2.37) 22.34
,Harmonic 24 (-2.035) 5.71
,Harmonic 25 (-1.803) 6.06]
note13 :: Note
note13 = Note
(Pitch 415.305 56 "g#4")
14
(Range
(NoteRange
(NoteRangeAmplitude 7890.79 19 2.02)
(NoteRangeHarmonicFreq 1 415.3))
(NoteRange
(NoteRangeAmplitude 830.61 2 7262.0)
(NoteRangeHarmonicFreq 24 9967.32)))
[Harmonic 1 (-1.516) 6162.51
,Harmonic 2 (-1.556) 7262.0
,Harmonic 3 2.418 1826.06
,Harmonic 4 (-1.233) 320.22
,Harmonic 5 2.826 339.05
,Harmonic 6 1.154 113.28
,Harmonic 7 (-1.566) 123.99
,Harmonic 8 (-3.124) 129.7
,Harmonic 9 0.777 57.78
,Harmonic 10 (-1.781) 39.13
,Harmonic 11 2.694 33.59
,Harmonic 12 0.665 34.14
,Harmonic 13 (-0.832) 10.78
,Harmonic 14 (-2.883) 15.57
,Harmonic 15 1.818 9.43
,Harmonic 16 9.7e-2 6.05
,Harmonic 17 (-2.816) 9.92
,Harmonic 18 2.818 2.74
,Harmonic 19 0.805 2.02
,Harmonic 20 (-0.503) 10.19
,Harmonic 21 (-2.164) 7.08
,Harmonic 22 2.294 3.51
,Harmonic 23 (-1.5e-2) 2.92
,Harmonic 24 (-0.974) 3.16]
note14 :: Note
note14 = Note
(Pitch 440.0 57 "a4")
15
(Range
(NoteRange
(NoteRangeAmplitude 7920.0 18 4.92)
(NoteRangeHarmonicFreq 1 440.0))
(NoteRange
(NoteRangeAmplitude 880.0 2 8412.0)
(NoteRangeHarmonicFreq 22 9680.0)))
[Harmonic 1 (-1.518) 5555.41
,Harmonic 2 (-1.384) 8412.0
,Harmonic 3 2.94 2513.38
,Harmonic 4 (-0.555) 205.46
,Harmonic 5 (-2.791) 368.4
,Harmonic 6 2.333 233.24
,Harmonic 7 0.51 111.88
,Harmonic 8 (-1.79) 119.07
,Harmonic 9 2.651 131.29
,Harmonic 10 1.314 63.94
,Harmonic 11 (-0.413) 31.29
,Harmonic 12 (-3.03) 17.51
,Harmonic 13 2.231 20.89
,Harmonic 14 1.178 6.77
,Harmonic 15 (-2.107) 8.04
,Harmonic 16 2.228 9.56
,Harmonic 17 0.541 5.03
,Harmonic 18 (-1.007) 4.92
,Harmonic 19 (-2.147) 44.39
,Harmonic 20 2.716 11.7
,Harmonic 21 (-1.128) 18.3
,Harmonic 22 (-2.941) 6.75]
note15 :: Note
note15 = Note
(Pitch 466.164 58 "a#4")
16
(Range
(NoteRange
(NoteRangeAmplitude 9323.27 20 0.68)
(NoteRangeHarmonicFreq 1 466.16))
(NoteRange
(NoteRangeAmplitude 932.32 2 3523.0)
(NoteRangeHarmonicFreq 21 9789.44)))
[Harmonic 1 1.14 2300.39
,Harmonic 2 (-1.85) 3523.0
,Harmonic 3 (-1.69) 736.01
,Harmonic 4 (-0.583) 101.95
,Harmonic 5 (-1.425) 244.58
,Harmonic 6 0.667 159.19
,Harmonic 7 2.091 70.9
,Harmonic 8 2.265 32.53
,Harmonic 9 3.108 35.97
,Harmonic 10 (-1.638) 26.92
,Harmonic 11 (-0.214) 9.34
,Harmonic 12 0.765 4.58
,Harmonic 13 1.902 5.99
,Harmonic 14 (-2.041) 2.56
,Harmonic 15 0.153 4.69
,Harmonic 16 2.066 2.21
,Harmonic 17 3.114 1.41
,Harmonic 18 (-0.741) 3.22
,Harmonic 19 (-1.125) 4.49
,Harmonic 20 0.629 0.68
,Harmonic 21 (-1.132) 1.27]
note16 :: Note
note16 = Note
(Pitch 493.883 59 "b4")
17
(Range
(NoteRange
(NoteRangeAmplitude 6914.36 14 3.26)
(NoteRangeHarmonicFreq 1 493.88))
(NoteRange
(NoteRangeAmplitude 987.76 2 4822.0)
(NoteRangeHarmonicFreq 20 9877.66)))
[Harmonic 1 1.528 2150.46
,Harmonic 2 (-1.842) 4822.0
,Harmonic 3 (-1.086) 832.91
,Harmonic 4 (-0.23) 264.83
,Harmonic 5 (-0.987) 142.99
,Harmonic 6 1.323 260.84
,Harmonic 7 (-3.089) 174.26
,Harmonic 8 (-2.128) 25.75
,Harmonic 9 (-1.798) 39.58
,Harmonic 10 (-5.5e-2) 49.24
,Harmonic 11 2.088 13.88
,Harmonic 12 (-2.86) 11.98
,Harmonic 13 (-2.54) 4.67
,Harmonic 14 0.757 3.26
,Harmonic 15 2.889 4.71
,Harmonic 16 1.581 7.77
,Harmonic 17 2.027 36.7
,Harmonic 18 3.054 39.33
,Harmonic 19 (-2.75) 28.67
,Harmonic 20 (-0.531) 12.42]
note17 :: Note
note17 = Note
(Pitch 523.251 60 "c5")
18
(Range
(NoteRange
(NoteRangeAmplitude 7848.76 15 0.63)
(NoteRangeHarmonicFreq 1 523.25))
(NoteRange
(NoteRangeAmplitude 523.25 1 3971.0)
(NoteRangeHarmonicFreq 19 9941.76)))
[Harmonic 1 2.412 3971.0
,Harmonic 2 0.151 3130.05
,Harmonic 3 (-0.67) 340.92
,Harmonic 4 1.343 284.56
,Harmonic 5 2.983 139.98
,Harmonic 6 (-1.593) 119.81
,Harmonic 7 (-5.2e-2) 95.41
,Harmonic 8 1.922 57.39
,Harmonic 9 (-2.382) 39.18
,Harmonic 10 (-1.081) 21.54
,Harmonic 11 1.223 21.36
,Harmonic 12 (-2.123) 19.23
,Harmonic 13 (-2.146) 2.89
,Harmonic 14 0.149 13.99
,Harmonic 15 1.543 0.63
,Harmonic 16 (-0.585) 7.98
,Harmonic 17 1.05 42.48
,Harmonic 18 2.575 24.89
,Harmonic 19 (-2.076) 6.85]
note18 :: Note
note18 = Note
(Pitch 554.365 61 "c#5")
19
(Range
(NoteRange
(NoteRangeAmplitude 6652.38 12 3.14)
(NoteRangeHarmonicFreq 1 554.36))
(NoteRange
(NoteRangeAmplitude 554.36 1 4104.0)
(NoteRangeHarmonicFreq 17 9424.2)))
[Harmonic 1 (-1.417) 4104.0
,Harmonic 2 (-2.257) 2098.35
,Harmonic 3 0.822 289.31
,Harmonic 4 (-1.53) 460.23
,Harmonic 5 (-3.053) 150.35
,Harmonic 6 0.762 113.61
,Harmonic 7 (-1.436) 68.01
,Harmonic 8 (-3.028) 39.83
,Harmonic 9 1.648 11.65
,Harmonic 10 8.6e-2 8.67
,Harmonic 11 2.441 8.09
,Harmonic 12 4.9e-2 3.14
,Harmonic 13 (-2.571) 9.23
,Harmonic 14 0.53 3.51
,Harmonic 15 1.287 20.76
,Harmonic 16 (-1.36) 12.74
,Harmonic 17 (-0.244) 22.02]
note19 :: Note
note19 = Note
(Pitch 587.33 62 "d5")
20
(Range
(NoteRange
(NoteRangeAmplitude 8809.95 15 3.49)
(NoteRangeHarmonicFreq 1 587.33))
(NoteRange
(NoteRangeAmplitude 587.33 1 4404.0)
(NoteRangeHarmonicFreq 16 9397.28)))
[Harmonic 1 0.892 4404.0
,Harmonic 2 2.654 2759.39
,Harmonic 3 1.413 529.21
,Harmonic 4 2.048 189.06
,Harmonic 5 1.361 138.3
,Harmonic 6 2.385 132.51
,Harmonic 7 2.356 26.46
,Harmonic 8 (-3.078) 20.74
,Harmonic 9 1.943 5.13
,Harmonic 10 (-2.975) 4.82
,Harmonic 11 2.663 19.35
,Harmonic 12 (-1.911) 9.42
,Harmonic 13 (-2.457) 13.4
,Harmonic 14 0.747 25.7
,Harmonic 15 (-3.016) 3.49
,Harmonic 16 (-1.517) 38.85]
note20 :: Note
note20 = Note
(Pitch 622.254 63 "d#5")
21
(Range
(NoteRange
(NoteRangeAmplitude 6222.54 10 6.28)
(NoteRangeHarmonicFreq 1 622.25))
(NoteRange
(NoteRangeAmplitude 622.25 1 3750.0)
(NoteRangeHarmonicFreq 16 9956.06)))
[Harmonic 1 (-1.447) 3750.0
,Harmonic 2 (-1.977) 3574.83
,Harmonic 3 0.394 417.16
,Harmonic 4 (-1.611) 207.2
,Harmonic 5 2.442 132.45
,Harmonic 6 0.682 128.82
,Harmonic 7 (-0.93) 46.79
,Harmonic 8 2.416 18.3
,Harmonic 9 1.269 27.72
,Harmonic 10 2.31 6.28
,Harmonic 11 2.715 15.56
,Harmonic 12 (-0.711) 7.38
,Harmonic 13 0.2 10.77
,Harmonic 14 (-3.132) 14.33
,Harmonic 15 1.194 31.54
,Harmonic 16 0.409 10.99]
note21 :: Note
note21 = Note
(Pitch 659.255 64 "e5")
22
(Range
(NoteRange
(NoteRangeAmplitude 7251.8 11 2.73)
(NoteRangeHarmonicFreq 1 659.25))
(NoteRange
(NoteRangeAmplitude 659.25 1 5490.0)
(NoteRangeHarmonicFreq 15 9888.82)))
[Harmonic 1 (-1.218) 5490.0
,Harmonic 2 2.941 2313.07
,Harmonic 3 (-1.205) 459.95
,Harmonic 4 3.024 278.64
,Harmonic 5 0.267 116.05
,Harmonic 6 (-2.792) 146.67
,Harmonic 7 1.811 51.74
,Harmonic 8 (-1.108) 24.86
,Harmonic 9 (-3.113) 27.43
,Harmonic 10 1.516 9.64
,Harmonic 11 (-3.071) 2.73
,Harmonic 12 (-0.474) 8.21
,Harmonic 13 (-1.098) 24.86
,Harmonic 14 1.681 10.58
,Harmonic 15 (-1.175) 3.94]
note22 :: Note
note22 = Note
(Pitch 698.456 65 "f5")
23
(Range
(NoteRange
(NoteRangeAmplitude 7683.01 11 7.93)
(NoteRangeHarmonicFreq 1 698.45))
(NoteRange
(NoteRangeAmplitude 698.45 1 5541.0)
(NoteRangeHarmonicFreq 14 9778.38)))
[Harmonic 1 (-1.328) 5541.0
,Harmonic 2 3.139 1966.29
,Harmonic 3 (-1.109) 594.83
,Harmonic 4 (-2.701) 423.2
,Harmonic 5 0.494 152.21
,Harmonic 6 (-1.893) 92.85
,Harmonic 7 2.215 57.02
,Harmonic 8 0.46 19.56
,Harmonic 9 2.496 23.36
,Harmonic 10 1.704 9.13
,Harmonic 11 0.737 7.93
,Harmonic 12 2.825 13.4
,Harmonic 13 2.678 32.05
,Harmonic 14 2.043 9.41]
note23 :: Note
note23 = Note
(Pitch 739.989 66 "f#5")
24
(Range
(NoteRange
(NoteRangeAmplitude 8139.87 11 9.46)
(NoteRangeHarmonicFreq 1 739.98))
(NoteRange
(NoteRangeAmplitude 739.98 1 5567.0)
(NoteRangeHarmonicFreq 13 9619.85)))
[Harmonic 1 (-1.617) 5567.0
,Harmonic 2 2.067 735.89
,Harmonic 3 (-1.97) 358.56
,Harmonic 4 1.434 354.4
,Harmonic 5 (-1.64) 145.72
,Harmonic 6 1.739 106.4
,Harmonic 7 (-0.86) 46.2
,Harmonic 8 2.693 34.53
,Harmonic 9 (-0.128) 29.36
,Harmonic 10 2.808 15.84
,Harmonic 11 1.948 9.46
,Harmonic 12 (-2.328) 51.27
,Harmonic 13 0.937 16.63]
note24 :: Note
note24 = Note
(Pitch 783.991 67 "g5")
25
(Range
(NoteRange
(NoteRangeAmplitude 7839.91 10 4.44)
(NoteRangeHarmonicFreq 1 783.99))
(NoteRange
(NoteRangeAmplitude 783.99 1 5865.0)
(NoteRangeHarmonicFreq 12 9407.89)))
[Harmonic 1 1.447 5865.0
,Harmonic 2 2.091 1018.69
,Harmonic 3 0.272 377.94
,Harmonic 4 1.538 359.73
,Harmonic 5 1.272 78.77
,Harmonic 6 1.992 66.43
,Harmonic 7 2.822 42.99
,Harmonic 8 2.884 31.53
,Harmonic 9 2.929 14.64
,Harmonic 10 (-0.277) 4.44
,Harmonic 11 (-0.7) 31.69
,Harmonic 12 (-0.949) 26.61]
note25 :: Note
note25 = Note
(Pitch 830.609 68 "g#5")
26
(Range
(NoteRange
(NoteRangeAmplitude 9967.3 12 3.22)
(NoteRangeHarmonicFreq 1 830.6))
(NoteRange
(NoteRangeAmplitude 830.6 1 5287.0)
(NoteRangeHarmonicFreq 12 9967.3)))
[Harmonic 1 1.538 5287.0
,Harmonic 2 1.476 405.69
,Harmonic 3 0.143 312.44
,Harmonic 4 1.27 158.07
,Harmonic 5 0.497 41.86
,Harmonic 6 1.108 48.3
,Harmonic 7 1.381 18.43
,Harmonic 8 1.53 10.49
,Harmonic 9 1.78 3.37
,Harmonic 10 3.012 36.33
,Harmonic 11 2.086 24.25
,Harmonic 12 2.706 3.22]
note26 :: Note
note26 = Note
(Pitch 880.0 69 "a5")
27
(Range
(NoteRange
(NoteRangeAmplitude 7920.0 9 5.54)
(NoteRangeHarmonicFreq 1 880.0))
(NoteRange
(NoteRangeAmplitude 880.0 1 5199.0)
(NoteRangeHarmonicFreq 11 9680.0)))
[Harmonic 1 (-1.666) 5199.0
,Harmonic 2 1.189 634.05
,Harmonic 3 2.529 128.64
,Harmonic 4 (-0.293) 196.11
,Harmonic 5 2.155 36.75
,Harmonic 6 (-1.109) 27.31
,Harmonic 7 2.524 15.05
,Harmonic 8 (-1.491) 14.03
,Harmonic 9 (-2.06) 5.54
,Harmonic 10 (-1.605) 42.97
,Harmonic 11 0.818 10.95]
note27 :: Note
note27 = Note
(Pitch 932.328 70 "a#5")
28
(Range
(NoteRange
(NoteRangeAmplitude 9323.27 10 11.16)
(NoteRangeHarmonicFreq 1 932.32))
(NoteRange
(NoteRangeAmplitude 932.32 1 4237.0)
(NoteRangeHarmonicFreq 10 9323.27)))
[Harmonic 1 1.384 4237.0
,Harmonic 2 2.1 711.82
,Harmonic 3 0.499 223.26
,Harmonic 4 1.007 200.97
,Harmonic 5 0.898 20.23
,Harmonic 6 1.781 32.6
,Harmonic 7 1.558 18.14
,Harmonic 8 (-2.691) 12.52
,Harmonic 9 2.706 52.44
,Harmonic 10 2.923 11.16]
note28 :: Note
note28 = Note
(Pitch 987.767 71 "b5")
29
(Range
(NoteRange
(NoteRangeAmplitude 7902.13 8 3.53)
(NoteRangeHarmonicFreq 1 987.76))
(NoteRange
(NoteRangeAmplitude 987.76 1 5062.0)
(NoteRangeHarmonicFreq 9 8889.9)))
[Harmonic 1 (-1.893) 5062.0
,Harmonic 2 (-0.1) 732.11
,Harmonic 3 0.536 217.91
,Harmonic 4 (-2.319) 194.23
,Harmonic 5 (-2.023) 7.26
,Harmonic 6 2.947 48.06
,Harmonic 7 (-1.001) 9.28
,Harmonic 8 1.649 3.53
,Harmonic 9 (-1.784) 25.55]
note29 :: Note
note29 = Note
(Pitch 1046.5 72 "c6")
30
(Range
(NoteRange
(NoteRangeAmplitude 9418.5 9 3.07)
(NoteRangeHarmonicFreq 1 1046.5))
(NoteRange
(NoteRangeAmplitude 1046.5 1 4284.0)
(NoteRangeHarmonicFreq 9 9418.5)))
[Harmonic 1 1.453 4284.0
,Harmonic 2 0.984 238.12
,Harmonic 3 (-1.354) 110.34
,Harmonic 4 (-0.882) 78.14
,Harmonic 5 (-1.103) 6.21
,Harmonic 6 (-1.383) 23.27
,Harmonic 7 (-3.078) 3.21
,Harmonic 8 (-0.771) 29.15
,Harmonic 9 (-1.454) 3.07] | anton-k/sharc-timbre | src/Sharc/Instruments/AltoFlute.hs | bsd-3-clause | 32,174 | 0 | 15 | 9,337 | 12,143 | 6,290 | 5,853 | 1,110 | 1 |
{- | Cabal support for creating Mac OSX application bundles.
GUI applications on Mac OSX should be run as application /bundles/;
these wrap an executable in a particular directory structure which can
also carry resources such as icons, program metadata, images, other
binaries, and copies of shared libraries.
This module provides a Cabal post-build hook for creating such
application bundles, and controlling their contents.
For more information about OSX application bundles, look for the
/Bundle Programming Guide/ on the /Apple Developer Connection/
website, <http://developer.apple.com/>.
-}
module Distribution.MacOSX (
appBundleBuildHook,
MacApp(..),
ChaseDeps(..),
Exclusions,
defaultExclusions
) where
import Control.Monad (forM_)
import Data.String.Utils (replace)
import Distribution.PackageDescription (PackageDescription(..),
Executable(..))
import Distribution.Simple
import Distribution.Simple.LocalBuildInfo (LocalBuildInfo(..))
import Distribution.Simple.Setup (BuildFlags)
import System.Cmd (system)
import System.FilePath
import System.Info (os)
import System.Directory (copyFile, createDirectoryIfMissing)
import System.Exit
import Distribution.MacOSX.Common
import Distribution.MacOSX.Dependencies
-- | Post-build hook for OS X application bundles. Does nothing if
-- called on another O/S.
appBundleBuildHook ::
[MacApp] -- ^ List of applications to build; if empty, an
-- application is built for each executable in the package,
-- with no icon or plist, and no dependency-chasing.
-> Args -- ^ All other parameters as per
-- 'Distribution.Simple.postBuild'.
-> BuildFlags -> PackageDescription -> LocalBuildInfo -> IO ()
appBundleBuildHook apps _ _ pkg localb =
case os of
"darwin" -> forM_ apps' $ makeAppBundle localb
where apps' = case apps of
[] -> map mkDefault $ executables pkg
xs -> xs
mkDefault x = MacApp (exeName x) Nothing Nothing [] [] DoNotChase
_ -> putStrLn "Not OS X, so not building an application bundle."
-- | Given a 'MacApp' in context, make an application bundle in the
-- build area.
makeAppBundle ::
LocalBuildInfo -> MacApp -> IO ()
makeAppBundle localb app =
do appPath <- createAppDir localb app
maybeCopyPlist appPath app
maybeCopyIcon appPath app
`catch` \err -> putStrLn ("Warning: could not set up icon for " ++
appName app ++ ": " ++ show err)
includeResources appPath app
includeDependencies appPath app
osxIncantations appPath app
-- | Create application bundle directory structure in build directory
-- and copy executable into it. Returns path to newly created
-- directory.
createAppDir :: LocalBuildInfo -> MacApp -> IO FilePath
createAppDir localb app =
do putStrLn $ "Creating application bundle directory " ++ appPath
createDirectoryIfMissing False appPath
createDirectoryIfMissing True $ takeDirectory exeDest
createDirectoryIfMissing True $ appPath </> "Contents/Resources"
putStrLn $ "Copying executable " ++ appName app ++ " into place"
copyFile exeSrc exeDest
return appPath
where appPath = buildDir localb </> appName app <.> "app"
exeDest = appPath </> pathInApp app (appName app)
exeSrc = buildDir localb </> appName app </> appName app
-- | Include any external resources specified.
includeResources ::
FilePath -- ^ Path to application bundle root.
-> MacApp -> IO ()
includeResources appPath app = mapM_ includeResource $ resources app
where includeResource :: FilePath -> IO ()
includeResource p =
do let pDest = appPath </> pathInApp app p
putStrLn $ "Copying resource " ++ p ++ " to " ++ pDest
createDirectoryIfMissing True $ takeDirectory pDest
copyFile p $ pDest
return ()
-- | If a plist has been specified, copy it into place. If not, but
-- an icon has been specified, construct a default shell plist so the
-- icon is honoured.
maybeCopyPlist ::
FilePath -- ^ Path to application bundle root.
-> MacApp -> IO ()
maybeCopyPlist appPath app =
case appPlist app of
Just plPath -> do -- Explicit plist path, so copy it in and assume OK.
putStrLn $ "Copying " ++ plPath ++ " to " ++ plDest
copyFile plPath plDest
Nothing -> case appIcon app of
Just icPath ->
do -- Need a plist to support icon; use default.
let pl = replace "$program" (appName app) plistTemplate
pl' = replace "$iconPath" (takeFileName icPath) pl
writeFile plDest pl'
return ()
Nothing -> return () -- No icon, no plist, nothing to do.
where plDest = appPath </> "Contents/Info.plist"
-- | If an icon file has been specified, copy it into place.
maybeCopyIcon ::
FilePath -- ^ Path to application bundle root.
-> MacApp -> IO ()
maybeCopyIcon appPath app =
case appIcon app of
Just icPath ->
do putStrLn $ "Copying " ++ icPath ++ " to app's icon"
copyFile icPath $
appPath </> "Contents/Resources" </> takeFileName icPath
Nothing -> return ()
-- | Perform various magical OS X incantations for turning the app
-- directory into a bundle proper.
osxIncantations ::
FilePath -- ^ Path to application bundle root.
-> MacApp -> IO ()
osxIncantations appPath app =
do putStrLn "Running Rez, etc."
ExitSuccess <- system $ rez ++ " Carbon.r -o " ++
appPath </> pathInApp app (appName app)
writeFile (appPath </> "PkgInfo") "APPL????"
-- Tell Finder about the icon.
ExitSuccess <- system $ setFile ++ " -a C " ++ appPath </> "Contents"
return ()
-- | Path to @Rez@ tool.
rez :: FilePath
rez = "/Developer/Tools/Rez"
-- | Path to @SetFile@ tool.
setFile :: FilePath
setFile = "/Developer/Tools/SetFile"
-- | Default plist template, based on that in macosx-app from wx (but
-- with version stuff removed).
plistTemplate :: String
plistTemplate = "\
\<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\
\<!DOCTYPE plist SYSTEM \"file://localhost/System/Library/DTDs/PropertyList.dtd\">\n\
\<plist version=\"0.9\">\n\
\<dict>\n\
\<key>CFBundleInfoDictionaryVersion</key>\n\
\<string>6.0</string>\n\
\<key>CFBundleIdentifier</key>\n\
\<string>org.haskell.$program</string>\n\
\<key>CFBundleDevelopmentRegion</key>\n\
\<string>English</string>\n\
\<key>CFBundleExecutable</key>\n\
\<string>$program</string>\n\
\<key>CFBundleIconFile</key>\n\
\<string>$iconPath</string>\n\
\<key>CFBundleName</key>\n\
\<string>$program</string>\n\
\<key>CFBundlePackageType</key>\n\
\<string>APPL</string>\n\
\<key>CFBundleSignature</key>\n\
\<string>????</string>\n\
\<key>CFBundleVersion</key>\n\
\<string>1.0</string>\n\
\<key>CFBundleShortVersionString</key>\n\
\<string>1.0</string>\n\
\<key>CFBundleGetInfoString</key>\n\
\<string>$program, bundled by cabal-macosx</string>\n\
\<key>LSRequiresCarbon</key>\n\
\<true/>\n\
\<key>CSResourcesFileMapped</key>\n\
\<true/>\n\
\</dict>\n\
\</plist>"
| mchinen/cabal-macosx | Distribution/MacOSX.hs | bsd-3-clause | 7,527 | 0 | 18 | 1,900 | 1,153 | 582 | 571 | 109 | 3 |
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeOperators #-}
module Ivory.BSP.STM32.Driver.CAN
( canTower
) where
import Control.Monad (forM, forM_)
import Ivory.Language
import Ivory.Stdlib
import Ivory.Tower
import Ivory.Tower.HAL.Bus.CAN
import Ivory.Tower.HAL.Bus.Interface
import Ivory.HW
import Ivory.BSP.STM32.Interrupt
import Ivory.BSP.STM32.ClockConfig
import Ivory.BSP.STM32.Peripheral.CAN
import Ivory.BSP.STM32.Peripheral.GPIOF4
canTower :: (e -> ClockConfig)
-> CANPeriph
-> Integer
-> GPIOPin
-> GPIOPin
-> Tower e ( ChanOutput ('Struct "can_message")
, AbortableTransmit ('Struct "can_message") ('Stored IBool)
, AbortableTransmit ('Struct "can_message") ('Stored IBool)
, AbortableTransmit ('Struct "can_message") ('Stored IBool)
)
canTower tocc periph bitrate rxpin txpin = do
towerDepends canDriverTypes
towerModule canDriverTypes
reschan <- channel
let minMessageLength = 44 -- bits in a frame with no data and no stuffing
let minTimePerFrame = Microseconds $ 1000000 * minMessageLength `div` bitrate
tx_irq <- signalUnsafe
(Interrupt $ canIntTX periph)
minTimePerFrame
(interrupt_disable $ canIntTX periph)
([api0, api1, api2], transmitters) <- fmap unzip $ forM (canRegTX periph) $ \ txmailbox -> do
(abortableTransmit, reqChan) <- channel
(resChan, abortableComplete) <- channel
(abortableAbort, abortChan) <- channel
return $ (,) (AbortableTransmit { .. }) $ do
handler reqChan "request" $ do
callback $ \ req -> do
tsr <- getReg (canRegTSR periph)
comment "mailbox must be empty"
assert $ bitToBool $ tsr #. canTXEmpty txmailbox
comment "any completed request must have already been reported"
assert $ iNot $ bitToBool $ tsr #. canTXRQCP txmailbox
arb <- deref $ req ~> can_message_id
len <- deref $ req ~> can_message_len
let get_bytes :: (BitData reg, SafeCast Uint8 (BitDataRep reg)) => [(Ix 8, BitDataField reg (Bits 8))] -> Ivory eff [BitDataM reg ()]
get_bytes = mapM $ \ (idx, field) -> do
v <- deref $ (req ~> can_message_buf) ! idx
return $ setField field $ fromRep v
low_bytes <- get_bytes [(0, can_tdlr_data0), (1, can_tdlr_data1), (2, can_tdlr_data2), (3, can_tdlr_data3)]
hi_bytes <- get_bytes [(4, can_tdhr_data4), (5, can_tdhr_data5), (6, can_tdhr_data6), (7, can_tdhr_data7)]
modifyReg (canRegTDTR txmailbox) $ do
clearBit can_tdtr_tgt
setField can_tdtr_dlc $ fromRep $ castDefault $ fromIx len
setReg (canRegTDLR txmailbox) $ sequence_ low_bytes
setReg (canRegTDHR txmailbox) $ sequence_ hi_bytes
setReg (canRegTIR txmailbox) $ do
setField can_tir_id $ arb #. can_arbitration_id
setField can_tir_ide $ arb #. can_arbitration_ide
setField can_tir_rtr $ arb #. can_arbitration_rtr
setBit can_tir_txrq
handler abortChan "abort" $ do
callback $ const $ do
setReg (canRegTSR periph) $ setBit $ canTXAbort txmailbox
return (resChan, txmailbox)
receivers <- forM (zip [0 :: Int ..] $ canRegRX periph) $ \ (idx, fifo) -> do
rx_irq <- signalUnsafe
(Interrupt $ canIntRX fifo)
minTimePerFrame
(interrupt_disable $ canIntRX fifo)
return $ handler rx_irq ("rx" ++ show idx ++ "_irq") $ do
resultEmitter <- emitter (fst reschan) 3
callback $ const $ do
arrayMap $ \ (_ :: Ix 3) -> do
rfr <- getReg $ canRegRFR fifo
-- If the FIFO is empty, we have nothing to do.
when (rfr #. can_rfr_fmp ==? fromRep 0) breakOut
-- If the FIFO is still reloading the mailbox, we can't pull the
-- next message out. All we can do is loop and try again.
unless (bitToBool $ rfr #. can_rfr_rfom) $ do
rir <- getReg $ canRegRIR fifo
rdtr <- getReg $ canRegRDTR fifo
rdlr <- getReg $ canRegRDLR fifo
rdhr <- getReg $ canRegRDHR fifo
-- Release this FIFO entry ASAP to overlap the mailbox reload
-- with emitting the result.
setReg (canRegRFR fifo) $ do
setBit can_rfr_rfom
setBit can_rfr_fovr
setBit can_rfr_full
let arb = fromRep $ withBits 0 $ do
setField can_arbitration_id $ rir #. can_rir_id
setField can_arbitration_ide $ rir #. can_rir_ide
setField can_arbitration_rtr $ rir #. can_rir_rtr
msg <- local $ istruct
[ can_message_id .= ival arb
, can_message_buf .= iarray (map ival $ map toRep $
map (rdlr #.) [can_rdlr_data0, can_rdlr_data1, can_rdlr_data2, can_rdlr_data3] ++
map (rdhr #.) [can_rdhr_data4, can_rdhr_data5, can_rdhr_data6, can_rdhr_data7])
, can_message_len .= ival (toIx $ toRep $ rdtr #. can_rdtr_dlc)
]
emit resultEmitter $ constRef msg
interrupt_enable $ canIntRX fifo
monitor (canName periph ++ "PeripheralDriver") $ do
clockconfig <- fmap tocc getEnv
handler systemInit "init" $ do
callback $ const $ do
canInit periph bitrate rxpin txpin clockconfig
modifyReg (canRegIER periph) $ do
setBit can_ier_tmeie
setBit can_ier_fmpie0
setBit can_ier_fmpie1
interrupt_enable $ canIntTX periph
forM_ (canRegRX periph) $ \ fifo -> do
interrupt_enable $ canIntRX fifo
tx_emitters <- sequence transmitters
handler tx_irq "tx_irq" $ do
tx_callbacks <- forM tx_emitters $ \ (resChan, txmailbox) -> do
res <- emitter resChan 1
return (res, txmailbox)
callback $ const $ do
tsr <- getReg $ canRegTSR periph
forM_ tx_callbacks $ \ (res, txmailbox) -> do
when (bitToBool $ tsr #. canTXRQCP txmailbox) $ do
setReg (canRegTSR periph) $ setBit $ canTXRQCP txmailbox
emitV res $ bitToBool $ tsr #. canTXOK txmailbox
interrupt_enable $ canIntTX periph
sequence_ receivers
monitorModuleDef $ do
hw_moduledef
return (snd reschan, api0, api1, api2)
| GaloisInc/ivory-tower-stm32 | ivory-bsp-stm32/src/Ivory/BSP/STM32/Driver/CAN.hs | bsd-3-clause | 6,553 | 0 | 35 | 1,974 | 1,879 | 916 | 963 | 131 | 1 |
-----------------------------------------------------------------------------
--
-- Module : Code.Generating.Utils.Syntax.Names
-- Copyright : (c) 2011 Lars Corbijn
-- License : BSD-style (see the file /LICENSE)
--
-- Maintainer :
-- Stability :
-- Portability :
--
-- |
--
-----------------------------------------------------------------------------
module Code.Generating.Utils.Syntax.Names (
qual',
unQual', unQualSym', qual,
unname,
unQName,
unCName,
) where
-----------------------------------------------------------------------------
import Control.Arrow(first)
import Language.Haskell.Exts.Syntax
-----------------------------------------------------------------------------
unQual' :: String -> QName
unQual' = UnQual . Ident
unQualSym' :: String -> QName
unQualSym' = UnQual . Symbol
qual :: ModuleName -> String -> QName
qual name = Qual name . Ident
unname :: Name -> String
unname (Ident n) = n
unname (Symbol s) = s
unQName :: QName -> Name
unQName (UnQual n) = n
unQName (Qual _ n) = n
unQName (Special _) = error $ "unQName: can't unQualify a special con"
unCName :: CName -> Name
unCName (VarName n) = n
unCName (ConName n) = n
-- | Makes a `QName` from a string, this string can contain a fully
-- qualified name and symbols which all will be parsed correctly.
-- SpecialCon is not handled correctly
qual' :: String -> QName
qual' ('(':nr) = case reverse nr of
[] -> error "qual' only a '('"
(')':n) -> case symModSplit (reverse n) of
([], s) -> UnQual . Symbol $ s
( m, s) -> Qual (ModuleName m) (Symbol s)
_ -> error "qual' unmatched '('"
qual' n =
let (rname, rmodu) = break (== '.') $ reverse n
name = Ident $ reverse rname
in case rmodu of
[] -> UnQual name
rmod -> Qual (ModuleName . reverse $ tail rmod) name
symModSplit :: String -> (String, String)
symModSplit n =
let modrest = span (`elem` nonSyms) n
in case modrest of
([], _) -> modrest
(m, '.':r) -> first (\m' -> m ++ (if null m' then id else ('.':) ) m')
$ symModSplit r
_ -> error $ "Module part not followed by symbol in (" ++ show n ++ ")"
where
nonSyms = ['A'..'z'] ++ ['0'..'9'] ++ "_"
-----------------------------------------------------------------------------
| Laar/CodeGenerating | src/Code/Generating/Utils/Syntax/Names.hs | bsd-3-clause | 2,335 | 0 | 18 | 514 | 652 | 355 | 297 | 46 | 5 |
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE PatternGuards, ViewPatterns, TupleSections #-}
module Development.Shake.Internal.FilePattern(
-- * Primitive API, as exposed
FilePattern, (?==), (<//>),
-- * General API, used by other people.
filePattern,
-- * Optimisation opportunities
simple, (?==*),
-- * Multipattern file rules
compatible, extract, substitute,
-- * Accelerated searching
Walk(..), walk,
-- * Testing only
internalTest, isRelativePath, isRelativePattern
) where
import Development.Shake.Internal.Errors
import System.FilePath(isPathSeparator)
import Data.List.Extra
import Control.Monad
import Data.Char
import Data.Maybe
import System.Info.Extra
-- | A type synonym for file patterns, containing @\/\/@ and @*@. For the syntax
-- and semantics of 'FilePattern' see '?=='.
--
-- Most 'normaliseEx'd 'FilePath' values are suitable as 'FilePattern' values which match
-- only that specific file. On Windows @\\@ is treated as equivalent to @\/@.
--
-- You can write 'FilePattern' values as a literal string, or build them
-- up using the operators 'Development.Shake.FilePath.<.>', 'Development.Shake.FilePath.</>'
-- and 'Development.Shake.<//>'. However, beware that:
--
-- * On Windows, use 'Development.Shake.FilePath.<.>' from "Development.Shake.FilePath" instead of from
-- "System.FilePath" - otherwise @\"\/\/*\" \<.\> exe@ results in @\"\/\/*\\\\.exe\"@.
--
-- * If the second argument of 'Development.Shake.FilePath.</>' has a leading path separator (namely @\/@)
-- then the second argument will be returned.
type FilePattern = String
infixr 5 <//>
-- | Join two 'FilePattern' values by inserting two @\/@ characters between them.
-- Will first remove any trailing path separators on the first argument, and any leading
-- separators on the second.
--
-- > "dir" <//> "*" == "dir//*"
(<//>) :: FilePattern -> FilePattern -> FilePattern
a <//> b = dropWhileEnd isPathSeparator a ++ "//" ++ dropWhile isPathSeparator b
---------------------------------------------------------------------
-- PATTERNS
data Pat = Lit String -- ^ foo
| Star -- ^ /*/
| Skip -- ^ //
| Skip1 -- ^ //, but must be at least 1 element
| Stars String [String] String -- ^ *foo*, prefix (fixed), infix floaters, suffix
-- e.g. *foo*bar = Stars "" ["foo"] "bar"
deriving (Show,Eq,Ord)
fromLit :: Pat -> Maybe String
fromLit (Lit x) = Just x
fromLit _ = Nothing
data Lexeme = Str String | Slash | SlashSlash
lexer :: FilePattern -> [Lexeme]
lexer "" = []
lexer (x1:x2:xs) | isPathSeparator x1, isPathSeparator x2 = SlashSlash : lexer xs
lexer (x1:xs) | isPathSeparator x1 = Slash : lexer xs
lexer xs = Str a : lexer b
where (a,b) = break isPathSeparator xs
-- | Parse a FilePattern. All optimisations I can think of are invalid because they change the extracted expressions.
parse :: FilePattern -> [Pat]
parse = f False True . lexer
where
-- str = I have ever seen a Str go past (equivalent to "can I be satisfied by no paths")
-- slash = I am either at the start, or my previous character was Slash
f str slash = \case
[] -> [Lit "" | slash]
Str "**":xs -> Skip : f True False xs
Str x:xs -> parseLit x : f True False xs
SlashSlash:Slash:xs | not str -> Skip1 : f str True xs
SlashSlash:xs -> Skip : f str False xs
Slash:xs -> [Lit "" | not str] ++ f str True xs
parseLit :: String -> Pat
parseLit "*" = Star
parseLit x = case split (== '*') x of
[x] -> Lit x
pre:xs | Just (mid,post) <- unsnoc xs -> Stars pre mid post
_ -> Lit ""
internalTest :: IO ()
internalTest = do
let x # y = when (parse x /= y) $ fail $ show ("FilePattern.internalTest",x,parse x,y)
"" # [Lit ""]
"x" # [Lit "x"]
"/" # [Lit "",Lit ""]
"x/" # [Lit "x",Lit ""]
"/x" # [Lit "",Lit "x"]
"x/y" # [Lit "x",Lit "y"]
"//" # [Skip]
"**" # [Skip]
"//x" # [Skip, Lit "x"]
"**/x" # [Skip, Lit "x"]
"x//" # [Lit "x", Skip]
"x/**" # [Lit "x", Skip]
"x//y" # [Lit "x",Skip, Lit "y"]
"x/**/y" # [Lit "x",Skip, Lit "y"]
"///" # [Skip1, Lit ""]
"**/**" # [Skip,Skip]
"**/**/" # [Skip, Skip, Lit ""]
"///x" # [Skip1, Lit "x"]
"**/x" # [Skip, Lit "x"]
"x///" # [Lit "x", Skip, Lit ""]
"x/**/" # [Lit "x", Skip, Lit ""]
"x///y" # [Lit "x",Skip, Lit "y"]
"x/**/y" # [Lit "x",Skip, Lit "y"]
"////" # [Skip, Skip]
"**/**/**" # [Skip, Skip, Skip]
"////x" # [Skip, Skip, Lit "x"]
"x////" # [Lit "x", Skip, Skip]
"x////y" # [Lit "x",Skip, Skip, Lit "y"]
"**//x" # [Skip, Skip, Lit "x"]
-- | Optimisations that may change the matched expressions
optimise :: [Pat] -> [Pat]
optimise (Skip:Skip:xs) = optimise $ Skip:xs
optimise (Skip:Star:xs) = optimise $ Skip1:xs
optimise (Star:Skip:xs) = optimise $ Skip1:xs
optimise (x:xs) = x : optimise xs
optimise [] =[]
-- | A 'FilePattern' that will only match 'isRelativePath' values.
isRelativePattern :: FilePattern -> Bool
isRelativePattern ('*':'*':xs)
| [] <- xs = True
| x:_ <- xs, isPathSeparator x = True
isRelativePattern _ = False
-- | A non-absolute 'FilePath'.
isRelativePath :: FilePath -> Bool
isRelativePath (x:_) | isPathSeparator x = False
isRelativePath (x:':':_) | isWindows, isAlpha x = False
isRelativePath _ = True
-- | Given a pattern, and a list of path components, return a list of all matches
-- (for each wildcard in order, what the wildcard matched).
match :: [Pat] -> [String] -> [[String]]
match (Skip:xs) (y:ys) = map ("":) (match xs (y:ys)) ++ match (Skip1:xs) (y:ys)
match (Skip1:xs) (y:ys) = [(y++"/"++r):rs | r:rs <- match (Skip:xs) ys]
match (Skip:xs) [] = map ("":) $ match xs []
match (Star:xs) (y:ys) = map (y:) $ match xs ys
match (Lit x:xs) (y:ys) = concat $ [match xs ys | x == y] ++ [match xs (y:ys) | x == "."]
match (x@Stars{}:xs) (y:ys) | Just rs <- matchStars x y = map (rs ++) $ match xs ys
match [] [] = [[]]
match _ _ = []
matchOne :: Pat -> String -> Bool
matchOne (Lit x) y = x == y
matchOne x@Stars{} y = isJust $ matchStars x y
matchOne Star _ = True
matchOne p _ = throwImpure $ errorInternal $ "unreachablePattern, matchOne " ++ show p
-- Only return the first (all patterns left-most) valid star matching
matchStars :: Pat -> String -> Maybe [String]
matchStars (Stars pre mid post) x = do
x <- stripPrefix pre x
x <- if null post then Just x else stripSuffix post x
stripInfixes mid x
where
stripInfixes [] x = Just [x]
stripInfixes (m:ms) x = do
(a,x) <- stripInfix m x
(a:) <$> stripInfixes ms x
matchStars p _ = throwImpure $ errorInternal $ "unreachablePattern, matchStars " ++ show p
-- | Match a 'FilePattern' against a 'FilePath', There are three special forms:
--
-- * @*@ matches an entire path component, excluding any separators.
--
-- * @\/\/@ matches an arbitrary number of path components, including absolute path
-- prefixes.
--
-- * @**@ as a path component matches an arbitrary number of path components, but not
-- absolute path prefixes.
-- Currently considered experimental.
--
-- Some examples:
--
-- * @test.c@ matches @test.c@ and nothing else.
--
-- * @*.c@ matches all @.c@ files in the current directory, so @file.c@ matches,
-- but @file.h@ and @dir\/file.c@ don't.
--
-- * @\/\/*.c@ matches all @.c@ files anywhere on the filesystem,
-- so @file.c@, @dir\/file.c@, @dir1\/dir2\/file.c@ and @\/path\/to\/file.c@ all match,
-- but @file.h@ and @dir\/file.h@ don't.
--
-- * @dir\/*\/*@ matches all files one level below @dir@, so @dir\/one\/file.c@ and
-- @dir\/two\/file.h@ match, but @file.c@, @one\/dir\/file.c@, @dir\/file.h@
-- and @dir\/one\/two\/file.c@ don't.
--
-- Patterns with constructs such as @foo\/..\/bar@ will never match
-- normalised 'FilePath' values, so are unlikely to be correct.
(?==) :: FilePattern -> FilePath -> Bool
(?==) p = case optimise $ parse p of
[x] | x == Skip || x == Skip1 -> if rp then isRelativePath else const True
p -> let f = not . null . match p . split isPathSeparator
in if rp then (\x -> isRelativePath x && f x) else f
where rp = isRelativePattern p
(?==*) :: [FilePattern] -> FilePath -> Bool
(?==*) ps = \x -> any ($ x) vs
where vs = map (?==) ps
-- | Like '?==', but returns 'Nothing' on if there is no match, otherwise 'Just' with the list
-- of fragments matching each wildcard. For example:
--
-- @
-- 'filePattern' \"**\/*.c\" \"test.txt\" == Nothing
-- 'filePattern' \"**\/*.c\" \"foo.c\" == Just [\"",\"foo\"]
-- 'filePattern' \"**\/*.c\" \"bar\/baz\/foo.c\" == Just [\"bar\/baz/\",\"foo\"]
-- @
--
-- Note that the @**@ will often contain a trailing @\/@, and even on Windows any
-- @\\@ separators will be replaced by @\/@.
filePattern :: FilePattern -> FilePath -> Maybe [String]
filePattern p = \x -> if eq x then Just $ ex x else Nothing
where eq = (?==) p
ex = extract p
---------------------------------------------------------------------
-- MULTIPATTERN COMPATIBLE SUBSTITUTIONS
specials :: FilePattern -> [Pat]
specials = concatMap f . parse
where
f Lit{} = []
f Star = [Star]
f Skip = [Skip]
f Skip1 = [Skip]
f (Stars _ xs _) = replicate (length xs + 1) Star
-- | Is the pattern free from any * and //.
simple :: FilePattern -> Bool
simple = null . specials
-- | Do they have the same * and // counts in the same order
compatible :: [FilePattern] -> Bool
compatible [] = True
compatible (x:xs) = all ((==) (specials x) . specials) xs
-- | Extract the items that match the wildcards. The pair must match with '?=='.
extract :: FilePattern -> FilePath -> [String]
extract p = let pat = parse p in \x ->
case match pat (split isPathSeparator x) of
[] | p ?== x -> throwImpure $ errorInternal $ "extract with " ++ show p ++ " and " ++ show x
| otherwise -> error $ "Pattern " ++ show p ++ " does not match " ++ x ++ ", when trying to extract the FilePattern matches"
ms:_ -> ms
-- | Given the result of 'extract', substitute it back in to a 'compatible' pattern.
--
-- > p '?==' x ==> substitute (extract p x) p == x
substitute :: [String] -> FilePattern -> FilePath
substitute oms oxs = intercalate "/" $ concat $ snd $ mapAccumL f oms (parse oxs)
where
f ms (Lit x) = (ms, [x])
f (m:ms) Star = (ms, [m])
f (m:ms) Skip = (ms, split m)
f (m:ms) Skip1 = (ms, split m)
f ms (Stars pre mid post) = (ms2, [concat $ pre : zipWith (++) ms1 (mid++[post])])
where (ms1,ms2) = splitAt (length mid + 1) ms
f _ _ = error $ "Substitution failed into pattern " ++ show oxs ++ " with " ++ show (length oms) ++ " matches, namely " ++ show oms
split = linesBy (== '/')
---------------------------------------------------------------------
-- EFFICIENT PATH WALKING
-- | Given a list of files, return a list of things I can match in this directory
-- plus a list of subdirectories and walks that apply to them.
-- Use WalkTo when the list can be predicted in advance
data Walk = Walk ([String] -> ([String],[(String,Walk)]))
| WalkTo ([String],[(String,Walk)])
walk :: [FilePattern] -> (Bool, Walk)
walk ps = (any (\p -> isEmpty p || not (null $ match p [""])) ps2, f ps2)
where
ps2 = map (filter (/= Lit ".") . optimise . parse) ps
f (nubOrd -> ps)
| Just fin <- mapM fromLit fin
, Just nxt <- mapM (\(a,b) -> (,f b) <$> fromLit a) nxt
= WalkTo (fin, nxt)
| otherwise = Walk $ \xs ->
(if finStar then xs else filter (\x -> any (`matchOne` x) fin) xs
,[(x, f ys) | x <- xs, let ys = concat [b | (a,b) <- nxt, matchOne a x], not $ null ys])
where
finStar = Star `elem` fin
fin = nubOrd $ mapMaybe final ps
nxt = groupSort $ concatMap next ps
next :: [Pat] -> [(Pat, [Pat])]
next (Skip1:xs) = [(Star,Skip:xs)]
next (Skip:xs) = (Star,Skip:xs) : next xs
next (x:xs) = [(x,xs) | not $ null xs]
next [] = []
final :: [Pat] -> Maybe Pat
final (Skip:xs) = if isEmpty xs then Just Star else final xs
final (Skip1:xs) = if isEmpty xs then Just Star else Nothing
final (x:xs) = if isEmpty xs then Just x else Nothing
final [] = Nothing
isEmpty = all (== Skip)
| ndmitchell/shake | src/Development/Shake/Internal/FilePattern.hs | bsd-3-clause | 12,475 | 0 | 20 | 2,965 | 3,903 | 2,071 | 1,832 | 189 | 6 |
-- The @FamInst@ type: family instance heads
{-# LANGUAGE CPP, GADTs #-}
module FamInst (
FamInstEnvs, tcGetFamInstEnvs,
checkFamInstConsistency, tcExtendLocalFamInstEnv,
tcLookupDataFamInst, tcLookupDataFamInst_maybe,
tcInstNewTyCon_maybe, tcTopNormaliseNewTypeTF_maybe,
newFamInst,
-- * Injectivity
makeInjectivityErrors
) where
import HscTypes
import FamInstEnv
import InstEnv( roughMatchTcs )
import Coercion
import TcEvidence
import LoadIface
import TcRnMonad
import SrcLoc
import TyCon
import TcType
import CoAxiom
import DynFlags
import Module
import Outputable
import UniqFM
import Util
import RdrName
import DataCon ( dataConName )
import Maybes
import Type
import TyCoRep
import TcMType
import Name
import Pair
import Panic
import VarSet
import Control.Monad
import Data.Map (Map)
import qualified Data.Map as Map
#include "HsVersions.h"
{-
************************************************************************
* *
Making a FamInst
* *
************************************************************************
-}
-- All type variables in a FamInst must be fresh. This function
-- creates the fresh variables and applies the necessary substitution
-- It is defined here to avoid a dependency from FamInstEnv on the monad
-- code.
newFamInst :: FamFlavor -> CoAxiom Unbranched -> TcRnIf gbl lcl FamInst
-- Freshen the type variables of the FamInst branches
-- Called from the vectoriser monad too, hence the rather general type
newFamInst flavor axiom@(CoAxiom { co_ax_tc = fam_tc })
= ASSERT2( tyCoVarsOfTypes lhs `subVarSet` tcv_set, text "lhs" <+> pp_ax )
ASSERT2( tyCoVarsOfType rhs `subVarSet` tcv_set, text "rhs" <+> pp_ax )
ASSERT2( lhs_kind `eqType` rhs_kind, text "kind" <+> pp_ax $$ ppr lhs_kind $$ ppr rhs_kind )
do { (subst, tvs') <- freshenTyVarBndrs tvs
; (subst, cvs') <- freshenCoVarBndrsX subst cvs
; return (FamInst { fi_fam = tyConName fam_tc
, fi_flavor = flavor
, fi_tcs = roughMatchTcs lhs
, fi_tvs = tvs'
, fi_cvs = cvs'
, fi_tys = substTys subst lhs
, fi_rhs = substTy subst rhs
, fi_axiom = axiom }) }
where
lhs_kind = typeKind (mkTyConApp fam_tc lhs)
rhs_kind = typeKind rhs
tcv_set = mkVarSet (tvs ++ cvs)
pp_ax = pprCoAxiom axiom
CoAxBranch { cab_tvs = tvs
, cab_cvs = cvs
, cab_lhs = lhs
, cab_rhs = rhs } = coAxiomSingleBranch axiom
{-
************************************************************************
* *
Optimised overlap checking for family instances
* *
************************************************************************
For any two family instance modules that we import directly or indirectly, we
check whether the instances in the two modules are consistent, *unless* we can
be certain that the instances of the two modules have already been checked for
consistency during the compilation of modules that we import.
Why do we need to check? Consider
module X1 where module X2 where
data T1 data T2
type instance F T1 b = Int type instance F a T2 = Char
f1 :: F T1 a -> Int f2 :: Char -> F a T2
f1 x = x f2 x = x
Now if we import both X1 and X2 we could make (f2 . f1) :: Int -> Char.
Notice that neither instance is an orphan.
How do we know which pairs of modules have already been checked? Any pair of
modules where both modules occur in the `HscTypes.dep_finsts' set (of the
`HscTypes.Dependencies') of one of our directly imported modules must have
already been checked. Everything else, we check now. (So that we can be
certain that the modules in our `HscTypes.dep_finsts' are consistent.)
-}
-- The optimisation of overlap tests is based on determining pairs of modules
-- whose family instances need to be checked for consistency.
--
data ModulePair = ModulePair Module Module
-- canonical order of the components of a module pair
--
canon :: ModulePair -> (Module, Module)
canon (ModulePair m1 m2) | m1 < m2 = (m1, m2)
| otherwise = (m2, m1)
instance Eq ModulePair where
mp1 == mp2 = canon mp1 == canon mp2
instance Ord ModulePair where
mp1 `compare` mp2 = canon mp1 `compare` canon mp2
instance Outputable ModulePair where
ppr (ModulePair m1 m2) = angleBrackets (ppr m1 <> comma <+> ppr m2)
-- Sets of module pairs
--
type ModulePairSet = Map ModulePair ()
listToSet :: [ModulePair] -> ModulePairSet
listToSet l = Map.fromList (zip l (repeat ()))
checkFamInstConsistency :: [Module] -> [Module] -> TcM ()
checkFamInstConsistency famInstMods directlyImpMods
= do { dflags <- getDynFlags
; (eps, hpt) <- getEpsAndHpt
; let { -- Fetch the iface of a given module. Must succeed as
-- all directly imported modules must already have been loaded.
modIface mod =
case lookupIfaceByModule dflags hpt (eps_PIT eps) mod of
Nothing -> panicDoc "FamInst.checkFamInstConsistency"
(ppr mod $$ pprHPT hpt)
Just iface -> iface
; hmiModule = mi_module . hm_iface
; hmiFamInstEnv = extendFamInstEnvList emptyFamInstEnv
. md_fam_insts . hm_details
; hpt_fam_insts = mkModuleEnv [ (hmiModule hmi, hmiFamInstEnv hmi)
| hmi <- eltsUFM hpt]
; groups = map (dep_finsts . mi_deps . modIface)
directlyImpMods
; okPairs = listToSet $ concatMap allPairs groups
-- instances of okPairs are consistent
; criticalPairs = listToSet $ allPairs famInstMods
-- all pairs that we need to consider
; toCheckPairs = Map.keys $ criticalPairs `Map.difference` okPairs
-- the difference gives us the pairs we need to check now
}
; mapM_ (check hpt_fam_insts) toCheckPairs
}
where
allPairs [] = []
allPairs (m:ms) = map (ModulePair m) ms ++ allPairs ms
check hpt_fam_insts (ModulePair m1 m2)
= do { env1 <- getFamInsts hpt_fam_insts m1
; env2 <- getFamInsts hpt_fam_insts m2
; mapM_ (checkForConflicts (emptyFamInstEnv, env2))
(famInstEnvElts env1)
; mapM_ (checkForInjectivityConflicts (emptyFamInstEnv,env2))
(famInstEnvElts env1)
}
getFamInsts :: ModuleEnv FamInstEnv -> Module -> TcM FamInstEnv
getFamInsts hpt_fam_insts mod
| Just env <- lookupModuleEnv hpt_fam_insts mod = return env
| otherwise = do { _ <- initIfaceTcRn (loadSysInterface doc mod)
; eps <- getEps
; return (expectJust "checkFamInstConsistency" $
lookupModuleEnv (eps_mod_fam_inst_env eps) mod) }
where
doc = ppr mod <+> text "is a family-instance module"
{-
************************************************************************
* *
Lookup
* *
************************************************************************
-}
-- | If @co :: T ts ~ rep_ty@ then:
--
-- > instNewTyCon_maybe T ts = Just (rep_ty, co)
--
-- Checks for a newtype, and for being saturated
-- Just like Coercion.instNewTyCon_maybe, but returns a TcCoercion
tcInstNewTyCon_maybe :: TyCon -> [TcType] -> Maybe (TcType, TcCoercion)
tcInstNewTyCon_maybe = instNewTyCon_maybe
-- | Like 'tcLookupDataFamInst_maybe', but returns the arguments back if
-- there is no data family to unwrap.
-- Returns a Representational coercion
tcLookupDataFamInst :: FamInstEnvs -> TyCon -> [TcType]
-> (TyCon, [TcType], Coercion)
tcLookupDataFamInst fam_inst_envs tc tc_args
| Just (rep_tc, rep_args, co)
<- tcLookupDataFamInst_maybe fam_inst_envs tc tc_args
= (rep_tc, rep_args, co)
| otherwise
= (tc, tc_args, mkRepReflCo (mkTyConApp tc tc_args))
tcLookupDataFamInst_maybe :: FamInstEnvs -> TyCon -> [TcType]
-> Maybe (TyCon, [TcType], Coercion)
-- ^ Converts a data family type (eg F [a]) to its representation type (eg FList a)
-- and returns a coercion between the two: co :: F [a] ~R FList a.
tcLookupDataFamInst_maybe fam_inst_envs tc tc_args
| isDataFamilyTyCon tc
, match : _ <- lookupFamInstEnv fam_inst_envs tc tc_args
, FamInstMatch { fim_instance = rep_fam@(FamInst { fi_axiom = ax
, fi_cvs = cvs })
, fim_tys = rep_args
, fim_cos = rep_cos } <- match
, let rep_tc = dataFamInstRepTyCon rep_fam
co = mkUnbranchedAxInstCo Representational ax rep_args
(mkCoVarCos cvs)
= ASSERT( null rep_cos ) -- See Note [Constrained family instances] in FamInstEnv
Just (rep_tc, rep_args, co)
| otherwise
= Nothing
-- | 'tcTopNormaliseNewTypeTF_maybe' gets rid of top-level newtypes,
-- potentially looking through newtype instances.
--
-- It is only used by the type inference engine (specifically, when
-- solving representational equality), and hence it is careful to unwrap
-- only if the relevant data constructor is in scope. That's why
-- it get a GlobalRdrEnv argument.
--
-- It is careful not to unwrap data/newtype instances if it can't
-- continue unwrapping. Such care is necessary for proper error
-- messages.
--
-- It does not look through type families.
-- It does not normalise arguments to a tycon.
--
-- Always produces a representational coercion.
tcTopNormaliseNewTypeTF_maybe :: FamInstEnvs
-> GlobalRdrEnv
-> Type
-> Maybe (TcCoercion, Type)
tcTopNormaliseNewTypeTF_maybe faminsts rdr_env ty
-- cf. FamInstEnv.topNormaliseType_maybe and Coercion.topNormaliseNewType_maybe
= topNormaliseTypeX_maybe stepper ty
where
stepper = unwrap_newtype `composeSteppers` unwrap_newtype_instance
-- For newtype instances we take a double step or nothing, so that
-- we don't return the reprsentation type of the newtype instance,
-- which would lead to terrible error messages
unwrap_newtype_instance rec_nts tc tys
| Just (tc', tys', co) <- tcLookupDataFamInst_maybe faminsts tc tys
= modifyStepResultCo (co `mkTransCo`) $
unwrap_newtype rec_nts tc' tys'
| otherwise = NS_Done
unwrap_newtype rec_nts tc tys
| data_cons_in_scope tc
= unwrapNewTypeStepper rec_nts tc tys
| otherwise
= NS_Done
data_cons_in_scope :: TyCon -> Bool
data_cons_in_scope tc
= isWiredInName (tyConName tc) ||
(not (isAbstractTyCon tc) && all in_scope data_con_names)
where
data_con_names = map dataConName (tyConDataCons tc)
in_scope dc = not $ null $ lookupGRE_Name rdr_env dc
{-
************************************************************************
* *
Extending the family instance environment
* *
************************************************************************
-}
-- Add new locally-defined family instances
tcExtendLocalFamInstEnv :: [FamInst] -> TcM a -> TcM a
tcExtendLocalFamInstEnv fam_insts thing_inside
= do { env <- getGblEnv
; (inst_env', fam_insts') <- foldlM addLocalFamInst
(tcg_fam_inst_env env, tcg_fam_insts env)
fam_insts
; let env' = env { tcg_fam_insts = fam_insts'
, tcg_fam_inst_env = inst_env' }
; setGblEnv env' thing_inside
}
-- Check that the proposed new instance is OK,
-- and then add it to the home inst env
-- This must be lazy in the fam_inst arguments, see Note [Lazy axiom match]
-- in FamInstEnv.hs
addLocalFamInst :: (FamInstEnv,[FamInst])
-> FamInst
-> TcM (FamInstEnv, [FamInst])
addLocalFamInst (home_fie, my_fis) fam_inst
-- home_fie includes home package and this module
-- my_fies is just the ones from this module
= do { traceTc "addLocalFamInst" (ppr fam_inst)
; isGHCi <- getIsGHCi
; mod <- getModule
; traceTc "alfi" (ppr mod $$ ppr isGHCi)
-- In GHCi, we *override* any identical instances
-- that are also defined in the interactive context
-- See Note [Override identical instances in GHCi] in HscTypes
; let home_fie'
| isGHCi = deleteFromFamInstEnv home_fie fam_inst
| otherwise = home_fie
-- Load imported instances, so that we report
-- overlaps correctly
; eps <- getEps
; let inst_envs = (eps_fam_inst_env eps, home_fie')
home_fie'' = extendFamInstEnv home_fie fam_inst
-- Check for conflicting instance decls and injectivity violations
; no_conflict <- checkForConflicts inst_envs fam_inst
; injectivity_ok <- checkForInjectivityConflicts inst_envs fam_inst
; if no_conflict && injectivity_ok then
return (home_fie'', fam_inst : my_fis)
else
return (home_fie, my_fis) }
{-
************************************************************************
* *
Checking an instance against conflicts with an instance env
* *
************************************************************************
Check whether a single family instance conflicts with those in two instance
environments (one for the EPS and one for the HPT).
-}
checkForConflicts :: FamInstEnvs -> FamInst -> TcM Bool
checkForConflicts inst_envs fam_inst
= do { let conflicts = lookupFamInstEnvConflicts inst_envs fam_inst
no_conflicts = null conflicts
; traceTc "checkForConflicts" $
vcat [ ppr (map fim_instance conflicts)
, ppr fam_inst
-- , ppr inst_envs
]
; unless no_conflicts $ conflictInstErr fam_inst conflicts
; return no_conflicts }
-- | Check whether a new open type family equation can be added without
-- violating injectivity annotation supplied by the user. Returns True when
-- this is possible and False if adding this equation would violate injectivity
-- annotation.
checkForInjectivityConflicts :: FamInstEnvs -> FamInst -> TcM Bool
checkForInjectivityConflicts instEnvs famInst
| isTypeFamilyTyCon tycon
-- type family is injective in at least one argument
, Injective inj <- familyTyConInjectivityInfo tycon = do
{ let axiom = coAxiomSingleBranch fi_ax
conflicts = lookupFamInstEnvInjectivityConflicts inj instEnvs famInst
-- see Note [Verifying injectivity annotation] in FamInstEnv
errs = makeInjectivityErrors fi_ax axiom inj conflicts
; mapM_ (\(err, span) -> setSrcSpan span $ addErr err) errs
; return (null errs)
}
-- if there was no injectivity annotation or tycon does not represent a
-- type family we report no conflicts
| otherwise = return True
where tycon = famInstTyCon famInst
fi_ax = fi_axiom famInst
-- | Build a list of injectivity errors together with their source locations.
makeInjectivityErrors
:: CoAxiom br -- ^ Type family for which we generate errors
-> CoAxBranch -- ^ Currently checked equation (represented by axiom)
-> [Bool] -- ^ Injectivity annotation
-> [CoAxBranch] -- ^ List of injectivity conflicts
-> [(SDoc, SrcSpan)]
makeInjectivityErrors fi_ax axiom inj conflicts
= ASSERT2( any id inj, text "No injective type variables" )
let lhs = coAxBranchLHS axiom
rhs = coAxBranchRHS axiom
are_conflicts = not $ null conflicts
unused_inj_tvs = unusedInjTvsInRHS (coAxiomTyCon fi_ax) inj lhs rhs
inj_tvs_unused = not $ and (isEmptyVarSet <$> unused_inj_tvs)
tf_headed = isTFHeaded rhs
bare_variables = bareTvInRHSViolated lhs rhs
wrong_bare_rhs = not $ null bare_variables
err_builder herald eqns
= ( hang herald
2 (vcat (map (pprCoAxBranch fi_ax) eqns))
, coAxBranchSpan (head eqns) )
errorIf p f = if p then [f err_builder axiom] else []
in errorIf are_conflicts (conflictInjInstErr conflicts )
++ errorIf inj_tvs_unused (unusedInjectiveVarsErr unused_inj_tvs)
++ errorIf tf_headed tfHeadedErr
++ errorIf wrong_bare_rhs (bareVariableInRHSErr bare_variables)
-- | Return a list of type variables that the function is injective in and that
-- do not appear on injective positions in the RHS of a family instance
-- declaration. The returned Pair includes invisible vars followed by visible ones
unusedInjTvsInRHS :: TyCon -> [Bool] -> [Type] -> Type -> Pair TyVarSet
-- INVARIANT: [Bool] list contains at least one True value
-- See Note [Verifying injectivity annotation]. This function implements fourth
-- check described there.
-- In theory, instead of implementing this whole check in this way, we could
-- attempt to unify equation with itself. We would reject exactly the same
-- equations but this method gives us more precise error messages by returning
-- precise names of variables that are not mentioned in the RHS.
unusedInjTvsInRHS tycon injList lhs rhs =
(`minusVarSet` injRhsVars) <$> injLHSVars
where
-- set of type and kind variables in which type family is injective
(invis_pairs, vis_pairs)
= partitionInvisibles tycon snd (zipEqual "unusedInjTvsInRHS" injList lhs)
invis_lhs = uncurry filterByList $ unzip invis_pairs
vis_lhs = uncurry filterByList $ unzip vis_pairs
invis_vars = tyCoVarsOfTypes invis_lhs
Pair invis_vars' vis_vars = splitVisVarsOfTypes vis_lhs
injLHSVars
= Pair (invis_vars `minusVarSet` vis_vars `unionVarSet` invis_vars')
vis_vars
-- set of type variables appearing in the RHS on an injective position.
-- For all returned variables we assume their associated kind variables
-- also appear in the RHS.
injRhsVars = collectInjVars rhs
-- Collect all type variables that are either arguments to a type
-- constructor or to injective type families.
collectInjVars :: Type -> VarSet
collectInjVars (TyVarTy v)
= unitVarSet v `unionVarSet` collectInjVars (tyVarKind v)
collectInjVars (TyConApp tc tys)
| isTypeFamilyTyCon tc = collectInjTFVars tys
(familyTyConInjectivityInfo tc)
| otherwise = mapUnionVarSet collectInjVars tys
collectInjVars (LitTy {})
= emptyVarSet
collectInjVars (ForAllTy (Anon arg) res)
= collectInjVars arg `unionVarSet` collectInjVars res
collectInjVars (AppTy fun arg)
= collectInjVars fun `unionVarSet` collectInjVars arg
-- no forall types in the RHS of a type family
collectInjVars (ForAllTy _ _) =
panic "unusedInjTvsInRHS.collectInjVars"
collectInjVars (CastTy ty _) = collectInjVars ty
collectInjVars (CoercionTy {}) = emptyVarSet
collectInjTFVars :: [Type] -> Injectivity -> VarSet
collectInjTFVars _ NotInjective
= emptyVarSet
collectInjTFVars tys (Injective injList)
= mapUnionVarSet collectInjVars (filterByList injList tys)
-- | Is type headed by a type family application?
isTFHeaded :: Type -> Bool
-- See Note [Verifying injectivity annotation]. This function implements third
-- check described there.
isTFHeaded ty | Just ty' <- coreView ty
= isTFHeaded ty'
isTFHeaded ty | (TyConApp tc args) <- ty
, isTypeFamilyTyCon tc
= tyConArity tc == length args
isTFHeaded _ = False
-- | If a RHS is a bare type variable return a set of LHS patterns that are not
-- bare type variables.
bareTvInRHSViolated :: [Type] -> Type -> [Type]
-- See Note [Verifying injectivity annotation]. This function implements second
-- check described there.
bareTvInRHSViolated pats rhs | isTyVarTy rhs
= filter (not . isTyVarTy) pats
bareTvInRHSViolated _ _ = []
conflictInstErr :: FamInst -> [FamInstMatch] -> TcRn ()
conflictInstErr fam_inst conflictingMatch
| (FamInstMatch { fim_instance = confInst }) : _ <- conflictingMatch
= let (err, span) = makeFamInstsErr
(text "Conflicting family instance declarations:")
[fam_inst, confInst]
in setSrcSpan span $ addErr err
| otherwise
= panic "conflictInstErr"
-- | Type of functions that use error message and a list of axioms to build full
-- error message (with a source location) for injective type families.
type InjErrorBuilder = SDoc -> [CoAxBranch] -> (SDoc, SrcSpan)
-- | Build injecivity error herald common to all injectivity errors.
injectivityErrorHerald :: Bool -> SDoc
injectivityErrorHerald isSingular =
text "Type family equation" <> s isSingular <+> text "violate" <>
s (not isSingular) <+> text "injectivity annotation" <>
if isSingular then dot else colon
-- Above is an ugly hack. We want this: "sentence. herald:" (note the dot and
-- colon). But if herald is empty we want "sentence:" (note the colon). We
-- can't test herald for emptiness so we rely on the fact that herald is empty
-- only when isSingular is False. If herald is non empty it must end with a
-- colon.
where
s False = text "s"
s True = empty
-- | Build error message for a pair of equations violating an injectivity
-- annotation.
conflictInjInstErr :: [CoAxBranch] -> InjErrorBuilder -> CoAxBranch
-> (SDoc, SrcSpan)
conflictInjInstErr conflictingEqns errorBuilder tyfamEqn
| confEqn : _ <- conflictingEqns
= errorBuilder (injectivityErrorHerald False) [confEqn, tyfamEqn]
| otherwise
= panic "conflictInjInstErr"
-- | Build error message for equation with injective type variables unused in
-- the RHS.
unusedInjectiveVarsErr :: Pair TyVarSet -> InjErrorBuilder -> CoAxBranch
-> (SDoc, SrcSpan)
unusedInjectiveVarsErr (Pair invis_vars vis_vars) errorBuilder tyfamEqn
= errorBuilder (injectivityErrorHerald True $$ msg)
[tyfamEqn]
where
tvs = varSetElemsWellScoped (invis_vars `unionVarSet` vis_vars)
has_types = not $ isEmptyVarSet vis_vars
has_kinds = not $ isEmptyVarSet invis_vars
doc = sep [ what <+> text "variable" <>
plural tvs <+> pprQuotedList tvs
, text "cannot be inferred from the right-hand side." ]
what = case (has_types, has_kinds) of
(True, True) -> text "Type and kind"
(True, False) -> text "Type"
(False, True) -> text "Kind"
(False, False) -> pprPanic "mkUnusedInjectiveVarsErr" $ ppr tvs
print_kinds_info = ppWhen has_kinds ppSuggestExplicitKinds
msg = doc $$ print_kinds_info $$
text "In the type family equation:"
-- | Build error message for equation that has a type family call at the top
-- level of RHS
tfHeadedErr :: InjErrorBuilder -> CoAxBranch
-> (SDoc, SrcSpan)
tfHeadedErr errorBuilder famInst
= errorBuilder (injectivityErrorHerald True $$
text "RHS of injective type family equation cannot" <+>
text "be a type family:") [famInst]
-- | Build error message for equation that has a bare type variable in the RHS
-- but LHS pattern is not a bare type variable.
bareVariableInRHSErr :: [Type] -> InjErrorBuilder -> CoAxBranch
-> (SDoc, SrcSpan)
bareVariableInRHSErr tys errorBuilder famInst
= errorBuilder (injectivityErrorHerald True $$
text "RHS of injective type family equation is a bare" <+>
text "type variable" $$
text "but these LHS type and kind patterns are not bare" <+>
text "variables:" <+> pprQuotedList tys) [famInst]
makeFamInstsErr :: SDoc -> [FamInst] -> (SDoc, SrcSpan)
makeFamInstsErr herald insts
= ASSERT( not (null insts) )
( hang herald
2 (vcat [ pprCoAxBranchHdr (famInstAxiom fi) 0
| fi <- sorted ])
, srcSpan )
where
getSpan = getSrcLoc . famInstAxiom
sorted = sortWith getSpan insts
fi1 = head sorted
srcSpan = coAxBranchSpan (coAxiomSingleBranch (famInstAxiom fi1))
-- The sortWith just arranges that instances are dislayed in order
-- of source location, which reduced wobbling in error messages,
-- and is better for users
tcGetFamInstEnvs :: TcM FamInstEnvs
-- Gets both the external-package inst-env
-- and the home-pkg inst env (includes module being compiled)
tcGetFamInstEnvs
= do { eps <- getEps; env <- getGblEnv
; return (eps_fam_inst_env eps, tcg_fam_inst_env env) }
| tjakway/ghcjvm | compiler/typecheck/FamInst.hs | bsd-3-clause | 25,802 | 0 | 17 | 7,345 | 4,383 | 2,313 | 2,070 | -1 | -1 |
main = do
x <- getLine
if x == "42"
then return ()
else do
putStrLn x
main
| paramsingh/codechef-solutions | src/practice/test.hs | mit | 131 | 0 | 10 | 74 | 42 | 19 | 23 | 7 | 2 |
{-# LANGUAGE LambdaCase, ScopedTypeVariables #-}
module GLHelpers ( getGLStrings
, getGLExtensionList
, traceOnGLError
, throwOnGLError
, getCurTex2DSize
, disableVAOAndShaders
, Transparency(..)
, setTransparency
, setTextureFiltering
, setTextureClampST
, TextureFiltering(..)
, setupViewport
, maxRenderSize
, genObjectNameResource
) where
import qualified Graphics.Rendering.OpenGL as GL
import qualified Graphics.GL as GLR
import qualified Graphics.UI.GLFW as GLFW
import Control.Monad
import Control.Exception
import Control.Monad.Trans.Resource
import Text.Printf
import Data.Maybe
import Foreign.Marshal.Alloc
import Foreign.Marshal.Array
import Foreign.Storable
import Foreign.Ptr
import Foreign.C.String
import Trace
-- Various utility functions related to OpenGL
getErrors :: Maybe String -> IO (Maybe String)
getErrors context =
GL.get GL.errors >>= \case
[] -> return Nothing
err -> return . Just $
"OpenGL Error" ++ maybe ": " (\c -> " (" ++ c ++ "): ") context ++ show err
traceOnGLError :: Maybe String -> IO ()
traceOnGLError context = getErrors context >>= maybe (return ()) (traceS TLError)
throwOnGLError :: Maybe String -> IO ()
throwOnGLError context = getErrors context >>= maybe (return ()) (throwIO . ErrorCall)
-- No wrapper around the OpenGL 3 extension APIs yet, have to use the raw ones
getNumExtensions :: IO Int
getNumExtensions =
alloca $ \(ptr :: Ptr GLR.GLint) ->
GLR.glGetIntegerv GLR.GL_NUM_EXTENSIONS ptr >> fromIntegral <$> peek ptr
getExtensionStr :: Int -> IO String
getExtensionStr i =
peekCString =<< castPtr <$> GLR.glGetStringi GLR.GL_EXTENSIONS (fromIntegral i)
getGLExtensionList :: IO [String]
getGLExtensionList =
getNumExtensions >>= \numExt -> forM [0..numExt - 1] $ \i -> getExtensionStr i
-- Take the minimum of the maximum viewport and texture size to figure out
-- how large of a frame buffer we can allocate and render into
maxRenderSize :: IO (Int, Int)
maxRenderSize =
withArray [0, 0] $ \ptr -> do
GLR.glGetIntegerv GLR.GL_MAX_VIEWPORT_DIMS ptr
[vpWdh, vpHgt] <- peekArray 2 ptr
GLR.glGetIntegerv GLR.GL_MAX_TEXTURE_SIZE ptr
texDim <- peek ptr
return (fromIntegral $ min vpWdh texDim, fromIntegral $ max vpHgt texDim)
getGLStrings :: IO String
getGLStrings = do
numExt <- getNumExtensions
(w, h) <- maxRenderSize
printf
( "OpenGL - Vendor: %s · Renderer: %s · Version: %s · GLSL: %s · Num Extensions: %i" ++
" · Max FB Res: %ix%i\nGLFW - Version: %s"
)
<$> GL.get GL.vendor
<*> GL.get GL.renderer
<*> GL.get GL.glVersion
<*> GL.get GL.shadingLanguageVersion
<*> pure numExt
<*> pure w
<*> pure h
<*> (fromJust <$> GLFW.getVersionString)
getCurTex2DSize :: IO (Int, Int)
getCurTex2DSize = (\(GL.TextureSize2D w h) -> (fromIntegral w, fromIntegral h))
<$> (GL.get $ GL.textureSize2D GL.Texture2D 0)
data TextureFiltering = TFNone | TFMinMag | TFMinOnly | TFMagOnly
setTextureFiltering :: GL.ParameterizedTextureTarget t => t -> TextureFiltering -> IO ()
setTextureFiltering target TFNone =
GL.textureFilter target GL.$= ((GL.Nearest, Nothing ), GL.Nearest)
setTextureFiltering target TFMinMag =
GL.textureFilter target GL.$= ((GL.Linear', Just GL.Linear'), GL.Linear')
setTextureFiltering target TFMinOnly =
GL.textureFilter target GL.$= ((GL.Linear', Just GL.Linear'), GL.Nearest)
setTextureFiltering target TFMagOnly =
GL.textureFilter target GL.$= ((GL.Nearest, Nothing ), GL.Linear')
setTextureClampST :: GL.ParameterizedTextureTarget t => t -> IO ()
setTextureClampST target =
forM_ [GL.S, GL.T] $
\x -> GL.textureWrapMode target x GL.$= (GL.Repeated, GL.ClampToEdge)
data Transparency = TRNone
| TRBlend !Float
| TRSrcAlpha
deriving (Eq, Ord, Show)
setTransparency :: Transparency -> IO ()
setTransparency trans =
case trans of TRNone -> GL.blend GL.$= GL.Disabled
TRBlend weight -> do
GL.blend GL.$= GL.Enabled
GL.blendFunc GL.$= (GL.ConstantAlpha, GL.OneMinusConstantAlpha)
GL.blendColor GL.$= GL.Color4 0 0 0 (realToFrac weight :: GL.GLfloat)
TRSrcAlpha -> do
GL.blend GL.$= GL.Enabled
GL.blendFunc GL.$= (GL.SrcAlpha, GL.OneMinusSrcAlpha)
-- Disable vertex attribute arrays and shaders
disableVAOAndShaders :: IO ()
disableVAOAndShaders = do
GL.bindVertexArrayObject GL.$= Nothing
GL.currentProgram GL.$= Nothing
setupViewport :: Int -> Int -> IO ()
setupViewport w h = GL.viewport GL.$= (GL.Position 0 0, GL.Size (fromIntegral w) (fromIntegral h))
-- Allocate OpenGL object name in ResourceT
genObjectNameResource :: (GL.GeneratableObjectName a, MonadResource m) => m a
genObjectNameResource = snd <$> allocate GL.genObjectName GL.deleteObjectName
| blitzcode/rust-exp | hs-src/GLHelpers.hs | mit | 5,254 | 0 | 17 | 1,342 | 1,425 | 744 | 681 | 113 | 3 |
{-# LANGUAGE OverloadedStrings #-}
{-
Copyright (C) 2011-2015 John MacFarlane <[email protected]>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-}
{- |
Module : Text.Pandoc.SelfContained
Copyright : Copyright (C) 2011-2015 John MacFarlane
License : GNU GPL, version 2 or above
Maintainer : John MacFarlane <[email protected]>
Stability : alpha
Portability : portable
Functions for converting an HTML file into one that can be viewed
offline, by incorporating linked images, CSS, and scripts into
the HTML using data URIs.
-}
module Text.Pandoc.SelfContained ( makeSelfContained ) where
import Text.HTML.TagSoup
import Network.URI (isURI, escapeURIString, URI(..), parseURI)
import Data.ByteString.Base64
import qualified Data.ByteString.Char8 as B
import Data.ByteString (ByteString)
import System.FilePath (takeExtension, takeDirectory, (</>))
import Data.Char (toLower, isAscii, isAlphaNum)
import Codec.Compression.GZip as Gzip
import qualified Data.ByteString.Lazy as L
import Text.Pandoc.Shared (renderTags', err, fetchItem', warn, trim)
import Text.Pandoc.MediaBag (MediaBag)
import Text.Pandoc.MIME (MimeType)
import Text.Pandoc.UTF8 (toString)
import Text.Pandoc.Options (WriterOptions(..))
import Data.List (isPrefixOf)
import Control.Applicative
import Text.Parsec (runParserT, ParsecT)
import qualified Text.Parsec as P
import Control.Monad.Trans (lift)
isOk :: Char -> Bool
isOk c = isAscii c && isAlphaNum c
makeDataURI :: String -> ByteString -> String
makeDataURI mime raw =
if textual
then "data:" ++ mime' ++ "," ++ escapeURIString isOk (toString raw)
else "data:" ++ mime' ++ ";base64," ++ toString (encode raw)
where textual = "text/" `Data.List.isPrefixOf` mime
mime' = if textual && ';' `notElem` mime
then mime ++ ";charset=utf-8"
else mime -- mime type already has charset
convertTag :: MediaBag -> Maybe String -> Tag String -> IO (Tag String)
convertTag media sourceURL t@(TagOpen tagname as)
| tagname `elem`
["img", "embed", "video", "input", "audio", "source", "track"] = do
as' <- mapM processAttribute as
return $ TagOpen tagname as'
where processAttribute (x,y) =
if x == "src" || x == "href" || x == "poster"
then do
enc <- getDataURI media sourceURL (fromAttrib "type" t) y
return (x, enc)
else return (x,y)
convertTag media sourceURL t@(TagOpen "script" as) =
case fromAttrib "src" t of
[] -> return t
src -> do
enc <- getDataURI media sourceURL (fromAttrib "type" t) src
return $ TagOpen "script" (("src",enc) : [(x,y) | (x,y) <- as, x /= "src"])
convertTag media sourceURL t@(TagOpen "link" as) =
case fromAttrib "href" t of
[] -> return t
src -> do
enc <- getDataURI media sourceURL (fromAttrib "type" t) src
return $ TagOpen "link" (("href",enc) : [(x,y) | (x,y) <- as, x /= "href"])
convertTag _ _ t = return t
cssURLs :: MediaBag -> Maybe String -> FilePath -> ByteString
-> IO ByteString
cssURLs media sourceURL d orig = do
res <- runParserT (parseCSSUrls media sourceURL d) () "css" orig
case res of
Left e -> warn ("Could not parse CSS: " ++ show e) >> return orig
Right bs -> return bs
parseCSSUrls :: MediaBag -> Maybe String -> FilePath
-> ParsecT ByteString () IO ByteString
parseCSSUrls media sourceURL d = B.concat <$> P.many
(pCSSWhite <|> pCSSComment <|> pCSSUrl media sourceURL d <|> pCSSOther)
pCSSWhite :: ParsecT ByteString () IO ByteString
pCSSWhite = P.space >> P.spaces >> return B.empty
pCSSComment :: ParsecT ByteString () IO ByteString
pCSSComment = P.try $ do
P.string "/*"
P.manyTill P.anyChar (P.try (P.string "*/"))
return B.empty
pCSSOther :: ParsecT ByteString () IO ByteString
pCSSOther = do
(B.pack <$> P.many1 (P.noneOf "u/ \n\r\t")) <|>
(B.singleton <$> P.char 'u') <|>
(B.singleton <$> P.char '/')
pCSSUrl :: MediaBag -> Maybe String -> FilePath
-> ParsecT ByteString () IO ByteString
pCSSUrl media sourceURL d = P.try $ do
P.string "url("
P.spaces
quote <- P.option Nothing (Just <$> P.oneOf "\"'")
url <- P.manyTill P.anyChar (maybe (P.lookAhead (P.char ')')) P.char quote)
P.spaces
P.char ')'
let fallback = B.pack ("url(" ++ maybe "" (:[]) quote ++ trim url ++
maybe "" (:[]) quote ++ ")")
case trim url of
'#':_ -> return fallback
'd':'a':'t':'a':':':_ -> return fallback
u -> do let url' = if isURI u then u else d </> u
enc <- lift $ getDataURI media sourceURL "" url'
return (B.pack enc)
getDataURI :: MediaBag -> Maybe String -> MimeType -> String
-> IO String
getDataURI _ _ _ src@('d':'a':'t':'a':':':_) = return src -- already data: uri
getDataURI media sourceURL mimetype src = do
let ext = map toLower $ takeExtension src
fetchResult <- fetchItem' media sourceURL src
(raw, respMime) <- case fetchResult of
Left msg -> err 67 $ "Could not fetch " ++ src ++
"\n" ++ show msg
Right x -> return x
let raw' = if ext == ".gz"
then B.concat $ L.toChunks $ Gzip.decompress $ L.fromChunks
$ [raw]
else raw
let mime = case (mimetype, respMime) of
("",Nothing) -> error
$ "Could not determine mime type for `" ++ src ++ "'"
(x, Nothing) -> x
(_, Just x ) -> x
let cssSourceURL = case parseURI src of
Just u
| uriScheme u `elem` ["http:","https:"] ->
Just $ show u{ uriPath = "",
uriQuery = "",
uriFragment = "" }
_ -> Nothing
result <- if mime == "text/css"
then cssURLs media cssSourceURL (takeDirectory src) raw'
else return raw'
return $ makeDataURI mime result
-- | Convert HTML into self-contained HTML, incorporating images,
-- scripts, and CSS using data: URIs.
makeSelfContained :: WriterOptions -> String -> IO String
makeSelfContained opts inp = do
let tags = parseTags inp
out' <- mapM (convertTag (writerMediaBag opts) (writerSourceURL opts)) tags
return $ renderTags' out'
| mindriot101/pandoc | src/Text/Pandoc/SelfContained.hs | gpl-2.0 | 7,140 | 0 | 19 | 1,932 | 2,071 | 1,065 | 1,006 | 132 | 7 |
{-# OPTIONS_GHC -fno-warn-unused-imports #-} -- disable warning for unused imports, need to import Arbitrary instances
module Agent.Ageing
( prop_agent_ageing
, prop_agent_dieOfAge
) where
import Data.Maybe
import Test.Tasty.QuickCheck as QC
import Agent.Agent
import SugarScape.Agent.Ageing
import SugarScape.Agent.Interface
import SugarScape.Core.Common
import SugarScape.Core.Model
import Utils.Runner
prop_agent_ageing :: SugAgentState -> DTime -> Bool
prop_agent_ageing as0 dt = as' == asExp && aoEmpty
where
(_, as', ao) = runAgentMonadDefaultConst (agentAgeing dt) as0 Nothing Nothing Nothing
-- maybe not very useful to repeat the implementation in the test but
-- for completeness we test it
asExp = as0 { sugAgAge = sugAgAge as0 + dt }
-- agentout must not have changed
aoEmpty = ao == mkAgentOut
-- NOTE: this property-test needs an adjusted agent state => runs in Gen
-- NOTE: dieOfAge is not AgentLocalMonad but just MonadState => can be ran conveniently with runState
prop_agent_dieOfAge :: SugAgentState -> Gen Bool
prop_agent_dieOfAge as0 = do
age <- choose (60, 100)
let as = as0 { sugAgAge = age }
return $ prop_agent_dieOfAge_prop as age
where
prop_agent_dieOfAge_prop :: SugAgentState
-> Int
-> Bool
prop_agent_dieOfAge_prop as age
= died == (age >= asMaxAge) && asUnchanged && aoEmpty
where
asMaxAge = fromJust $ sugAgMaxAge as
(died, as', ao) = runAgentMonadDefaultConst dieOfAge as Nothing Nothing Nothing
asUnchanged = as == as'
-- agentout must not have changed
aoEmpty = ao == mkAgentOut | thalerjonathan/phd | thesis/code/sugarscape/src/test/Agent/Ageing.hs | gpl-3.0 | 1,689 | 0 | 11 | 397 | 330 | 184 | 146 | 31 | 1 |
{-# LANGUAGE TupleSections, PatternGuards, BangPatterns,
TypeSynonymInstances, FlexibleInstances, FlexibleContexts #-}
module Language.Java.Paragon.TypeCheck.Monad
(
{- check, checkM, ignore, orElse, maybeM,
withFold, withFoldMap,
getReturn,
extendVarEnvList, extendVarEnv,
lookupPrefixName,
lookupVar, lookupActorName,
--lookupField,
lookupFieldT,
lookupMethod, lookupMethodT,
lookupConstr,
lookupLock,
lookupExn, registerExn, registerExns,
extendLockEnv,
getBranchPC, getBranchPC_, extendBranchPC,
addBranchPC, addBranchPCList,
getActorId, setActorId,
newActorId, newActorIdWith, newUnknownId,
freshActorId, unknownActorId,
scrambleActors,
getPolicy,
getExnPC, throwExn,
activateExns, deactivateExn,
getExnState, mergeActiveExnStates, useExnState,
getCurrentPC,
getCurrentLockState, applyLockMods,
openLock, closeLock,
newMetaPolVar,
constraint, constraintPC, constraintLS,
exnConsistent,
extendTypeMapP, extendTypeMapT, -- lookupPkgTypeMap,
-- getTypeMap, withTypeMap,
evalSrcType, evalSrcRefType, evalSrcClsType,
evalSrcTypeArg, evalSrcNWTypeArg,
evalReturnType,
getReadPolicy, getWritePolicy, getLockPolicy,
getParamPolicy, getReturnPolicy,
--fromSrcType,
(<:),
evalPolicy, evalPolicyExp,
evalLock, evalActor,
-}
module Language.Java.Paragon.TypeCheck.Monad.TcCodeM,
module Language.Java.Paragon.TypeCheck.Monad,
{- debug, debugTc,
solve
-}
) where
import Language.Java.Paragon.Error
import Language.Java.Paragon.Syntax
import Language.Java.Paragon.Pretty
import Language.Java.Paragon.Interaction
import Language.Java.Paragon.SourcePos
-- import Language.Java.Paragon.Monad.Base (failE)
--import Language.Java.Paragon.TypeCheck.Monad.TcBase
--import Language.Java.Paragon.TypeCheck.Monad.TcCont
--import Language.Java.Paragon.TypeCheck.Monad.TcMonad
import Language.Java.Paragon.TypeCheck.Monad.TcDeclM
import Language.Java.Paragon.TypeCheck.Monad.TcCodeM
-- import Language.Java.Paragon.TypeCheck.Monad.CodeEnv
-- import Language.Java.Paragon.TypeCheck.Monad.CodeState
import Language.Java.Paragon.TypeCheck.Types
import Language.Java.Paragon.TypeCheck.TypeMap
--import Language.Java.Paragon.TypeCheck.Actors
--import Language.Java.Paragon.TypeCheck.Policy
--import Language.Java.Paragon.TypeCheck.Locks
--import Language.Java.Paragon.TypeCheck.Containment
--import Language.Java.Paragon.TypeCheck.Constraints
import Language.Java.Paragon.PolicyLang
import Language.Java.Paragon.TypeCheck.NullAnalysis
import Control.Monad hiding (join) -- (filterM, zipWithM, when,)
--import qualified Control.Monad (join) as Monad
import Control.Applicative ( (<$>), (<*>) )
--import Control.Arrow ( first, second )
import qualified Data.Map as Map
--import Data.IORef
import Data.List (intersperse, partition)
import Data.Maybe (isJust)
import Data.Generics.Uniplate.Data
import qualified Data.ByteString.Char8 as B
--debug :: String -> TcDeclM ()
--debug str = liftIO $ finePrint $ "DEBUG: " ++ str
--debugTc :: String -> TcCodeM ()
--debugTc = liftTcDeclM . debug
-- TODO BART fail -> failE
monadModule :: String
monadModule = typeCheckerBase ++ ".Monad"
--------------------------------------------
-- Working with the env --
--------------------------------------------
-- this
--getThisType :: TcCodeM TcType
--getThisType = liftCont getThisT
-- returns
getReturn :: TcCodeM (TcType, ActorPolicy)
getReturn = do
mRet <- returnI <$> getEnv
case mRet of
Nothing -> fail "Attempting to use 'return' in a simple expression context"
Just ret -> return ret
{-
registerReturn :: TcType -> TcPolicy -> TcCodeM r a -> TcCodeM r a
registerReturn ty p = withEnv $ \env -> env { returnI = (ty,p) }
-}
-- lookup entities
--fieldEnvToVars :: TcCodeM r a -> TcCodeM r a
--fieldEnvToVars = withEnv $ \env -> env { vars = fields (typemap env) }
extendVarEnvList :: [(B.ByteString, VarFieldSig)] -> TcCodeM a -> TcCodeM a
extendVarEnvList vs = withEnv $ \env ->
let (oldVmap:oldVmaps) = vars env
newVmap = foldl (\m (i,vti) -> Map.insert i vti m) oldVmap vs
in return $ env { vars = newVmap : oldVmaps }
extendVarEnv :: B.ByteString -> VarFieldSig -> TcCodeM a -> TcCodeM a
--extendVarEnv i = extendVarEnvN i
--extendVarEnvN :: Ident -> VarFieldSig -> TcCodeM a -> TcCodeM a
extendVarEnv i vti = withEnv $ \env -> do
let (oldVmap:oldVmaps) = vars env
if Map.notMember i oldVmap
then return $ env { vars = (Map.insert i vti oldVmap) : oldVmaps }
else failE $ mkErrorFromInfo $ VariableAlreadyDefined (B.unpack i)
lookupActorName :: ActorName SourcePos -> TcCodeM (TcStateType, ActorPolicy)
lookupActorName (ActorName _ nam@(Name _ nt mPre i))
| nt == EName =
do (ty, pol, _, _) <- lookupVar mPre i
return (ty, pol)
| otherwise = panic (monadModule ++ ".lookupActorName")
$ "Not an EName: " ++ show nam
lookupActorName (ActorTypeVar _ _rt i) = do
(ty, pol, _, _) <- lookupVar Nothing i
return (ty, pol)
lookupActorName n = panic (monadModule ++ ".lookupActorName")
$ "Unexpected AntiQName: " ++ show n
type Sig = ([TypeParam SourcePos], [B.ByteString], [TcType], Bool)
type APPairs = [(ActorPolicy, ActorPolicy)]
instance Pretty Sig where
pretty (tps, _, tys, isva) = pretty (tps, tys, isva)
findBestMethod
:: [TypeArgument SourcePos]
-> [TcType]
-> [ActorPolicy]
-> [Sig] -- Works for both methods and constrs
-> TcCodeM [(Sig, APPairs)]
findBestMethod tArgs argTys argPs candidates = do
--debugPrint $ "findBestMethod: "
--debugPrint $ " Candidates: "
--mapM_ (debugPrint . (" " ++) . prettyPrint) candidates
--debugPrint $ " Argument types: "
--debugPrint $ " " ++ prettyPrint argTys
mps <- mapM isApplicable candidates
res <- findBestFit [ (c, ps) | (c, Just ps) <- zip candidates mps ]
--debugPrint $ "Best method done"
return res
-- findBestFit =<< filterM isApplicable candidates
where isApplicable :: Sig -> TcCodeM (Maybe APPairs)
isApplicable (tps, pIs, pTys, isVA) = do
b1 <- checkArgs tps tArgs
if b1 then do
tyArgs <- mapM (uncurry $ evalSrcTypeArg genBot) $ zip tps tArgs
let subst = zip pIs argPs
pTys' <- mapM (substTypeParPols subst) $
instantiate (zip tps tyArgs) pTys
--debugPrint $ "isApplicable: "
-- ++ show (isVA, map prettyPrint pTys', map prettyPrint argTys)
ps <- checkTys isVA pTys' argTys
--debugPrint $ " .... "
-- ++ maybe "Nope" (prettyPrint . (map (\(a,b) -> [a,b]))) ps
return ps
else return Nothing
checkArgs :: [TypeParam SourcePos] -> [TypeArgument SourcePos] -> TcCodeM Bool
checkArgs [] [] = return True
checkArgs (tp:tps) (ta:tas) = (&&) <$> checkArg tp ta <*> checkArgs tps tas
checkArgs _ _ = return False
-- this needs to be done in TcCodeM, to account for local variables.
checkArg :: TypeParam SourcePos -> TypeArgument SourcePos -> TcCodeM Bool
checkArg tp ta = isRight <$> tryM (evalSrcTypeArg genBot tp ta)
checkTys :: Bool -> [TcType] -> [TcType] -> TcCodeM (Maybe APPairs)
checkTys _ [] [] = return $ Just []
checkTys b ps as
| not b && length ps /= length as = return Nothing
| b && length ps > length as + 1 = return Nothing
checkTys True [p] [a] = do
mps <- a `isAssignableTo` p
case mps of
Just _ -> return $ mps
Nothing -> bottomM >>= \bt -> a `isAssignableTo` arrayType p bt
checkTys True [p] as = do
mpps <- zipWithM isAssignableTo as (repeat p) -- [M [(P,P)]]
return $ concat <$> sequence mpps
checkTys b (p:ps) (a:as) = do
mps <- a `isAssignableTo` p
case mps of
Just aps -> do mAps' <- checkTys b ps as
return $ fmap (aps++) mAps'
Nothing -> return Nothing
checkTys _ _ _ = return Nothing
findBestFit :: [(Sig, APPairs)] -> TcCodeM [(Sig, APPairs)]
findBestFit [] = return []
findBestFit (x:xs) = go [x] xs
go :: [(Sig, APPairs)] -> [(Sig, APPairs)] -> TcCodeM [(Sig, APPairs)]
go xs [] = return xs
go xs (y:ys) = do
bs0 <- mapM (\x -> fst y `moreSpecificThan` fst x) xs
if and bs0 then go [y] ys
else do bs1 <- mapM (\x -> fst x `moreSpecificThan` fst y) xs
if and bs1 then go xs ys else go (y:xs) ys
moreSpecificThan :: Sig -> Sig -> TcCodeM Bool
moreSpecificThan (_,_,ps1,False) (_,_,ps2,False) = do
mpss <- zipWithM isAssignableTo ps1 ps2 -- [M [(P,P)]]
return $ isJust $ sequence mpss
moreSpecificThan _ _ = fail $ "Varargs not yet supported"
{- moreSpecificThan (_,ps1,True ) (_,ps2,True ) = do
let n = length ps1
k = length ps2
undefined n k
moreSpecificThan _ _ = undefined -}
isRight :: Either a b -> Bool
isRight (Right _) = True
isRight _ = False
-- | Lookup the signature of a method, and the policy of its access path.
lookupMethod :: Maybe (Name SourcePos) -- Access path
-> Ident SourcePos -- Method name
-> [TypeArgument SourcePos] -- Type arguments
-> [TcType] -- Argument types
-> [ActorPolicy] -- Argument policies
-> TcCodeM (ActorPolicy, [TypeParam SourcePos], MethodSig)
lookupMethod mPre i tArgs argTys argPs = do
--debugPrint $ "lookupMethod: " ++ show (mPre, i, argTys)
baseTm <- getTypeMap
(mPreTy, preTm, prePol, _) <-
case mPre of
Nothing -> bottomM >>= \bt ->
return (Nothing, baseTm, bt, Nothing)
Just pre -> lookupPrefixName pre
case Map.lookup (unIdent i) $ methods preTm of
Nothing -> fail $ case mPreTy of
Just preTy ->
"Type " ++ prettyPrint preTy ++
" does not have a method named " ++ prettyPrint i
Nothing -> "No method named " ++ prettyPrint i ++
" is in scope"
Just methodMap -> do
--debugPrint $ prettyPrint methodMap
bests <- findBestMethod tArgs argTys argPs (getSigs methodMap)
case bests of
[] -> fail $ case mPreTy of
Just preTy ->
"Type " ++ prettyPrint preTy ++
" does not have a method named " ++ prettyPrint i ++
" matching argument types (" ++
(unwords $ intersperse ", " $ map prettyPrint argTys) ++
")"
Nothing -> "No method named " ++ prettyPrint i ++
" matching argument types (" ++
(unwords $ intersperse ", " $ map prettyPrint argTys) ++
") is in scope"
(_:_:_) -> fail $ case mPreTy of
Just preTy ->
"Type " ++ prettyPrint preTy ++
" has more than one most specific method " ++ prettyPrint i ++
" matching argument types (" ++
(unwords $ intersperse ", " $ map prettyPrint argTys) ++
")"
Nothing -> "More than one most specific method named " ++ prettyPrint i ++
" matching argument types (" ++
(unwords $ intersperse ", " $ map prettyPrint argTys) ++
") is in scope"
[((tps,_,ts,isVA), aps)] ->
let sig = (tps,ts,isVA) in
case Map.lookup sig methodMap of
Nothing -> panic (monadModule ++ ".lookupMethod")
$ "Sig must be one of the keys of methodMap: " ++ show sig
Just msig -> do
mapM_ (\(p,q) -> do
constraint emptyLockSet p q $ toUndef $
"Cannot unify policy type parameters at call to method " ++ prettyPrint i ++ ":\n" ++
" p: " ++ prettyPrint p ++ "\n" ++
" q: " ++ prettyPrint q
constraint emptyLockSet q p $ toUndef $
"Cannot unify policy type parameters at call to method " ++ prettyPrint i ++ ":\n" ++
" p: " ++ prettyPrint q ++ "\n" ++
" q: " ++ prettyPrint p) aps
return (prePol, tps, msig)
-- | Lookup the signature of a lock -- note that all locks are static,
-- so the policy of the access path is irrelevant.
lookupLock :: Maybe (Name SourcePos) -- Access path
-> Ident SourcePos -- Name of lock
-> TcCodeM LockSig
lookupLock mPre i@(Ident sp _) = do
baseTm <- getTypeMap
preTm <- case mPre of
Nothing -> return baseTm
Just pre -> do
(_, preTm, _, _) <- lookupPrefixName pre
return preTm
case Map.lookup (unIdent i) $ locks preTm of
Just lsig -> return lsig
Nothing -> do
fail $ "Lock " ++ prettyPrint (Name sp LName mPre i) ++ " not in scope"
lookupFieldT :: TcStateType -> Ident SourcePos -> TcCodeM VarFieldSig
lookupFieldT typ i = do
check (isRefType typ) $ toUndef $ "Not a reference type: " ++ (prettyPrint typ)
aSig <- lookupTypeOfStateType typ
case Map.lookup (unIdent i) (fields $ tMembers aSig) of
Just vti -> return vti
Nothing -> failE $ toUndef $ "Class " ++ prettyPrint typ
++ " does not have a field named " ++ prettyPrint i
lookupMethodT :: TcStateType
-> Ident SourcePos
-> [TypeArgument SourcePos]
-> [TcType]
-> [ActorPolicy]
-> TcCodeM ([TypeParam SourcePos], MethodSig)
lookupMethodT typ i tArgs argTys argPs = do
check (isRefType typ) $ toUndef $ "Not a reference type: " ++ prettyPrint typ
aSig <- lookupTypeOfStateType typ
case Map.lookup (unIdent i) (methods $ tMembers aSig) of
Nothing -> fail $ "Class " ++ prettyPrint typ
++ " does not have a method named " ++ prettyPrint i
Just mMap -> do
bests <- findBestMethod tArgs argTys argPs (getSigs mMap)
case bests of
[] -> fail $
"Type " ++ prettyPrint typ ++
" does not have a method named " ++ prettyPrint i ++
" matching argument types (" ++
(unwords $ intersperse ", " $ map prettyPrint argTys) ++
")"
(_:_:_) -> fail $
"Type " ++ prettyPrint typ ++
" has more than one most specific method " ++ prettyPrint i ++
" matching argument types (" ++
(unwords $ intersperse ", " $ map prettyPrint argTys) ++
")"
[((tps,_,ts,isVA), aps)] ->
let sig = (tps,ts,isVA) in
case Map.lookup sig mMap of
Nothing -> panic (monadModule ++ ".lookupMethodT")
$ "Sig must be one of the keys of methodMap: " ++ show sig
Just msig -> do
mapM_ (\(p,q) -> do
constraint emptyLockSet p q $ toUndef $
"Cannot unify policy type parameters at method call:\n" ++
" p: " ++ prettyPrint p ++ "\n" ++
" q: " ++ prettyPrint q
constraint emptyLockSet q p $ toUndef $
"Cannot unify policy type parameters at method call:\n" ++
" p: " ++ prettyPrint q ++ "\n" ++
" q: " ++ prettyPrint p) aps
return (tps, msig)
lookupConstr :: TcClassType
-> [TypeArgument SourcePos]
-> ActorPolicy -- policyof(this), i.e. the result
-> [TcType]
-> [ActorPolicy]
-> TcCodeM ([TypeParam SourcePos], [(RefType SourcePos, B.ByteString)], ConstrSig)
lookupConstr ctyp tArgs pThis argTys argPs = do
--debugPrint $ "\n\n######## Looking up constructor! ######## \n"
let typ = clsTypeToType ctyp
--debugPrint $ "typ: " ++ prettyPrint typ
-- tm <- getTypeMap
-- debugPrint $ prettyPrint tm
(iaps, aSig) <- lookupTypeOfType typ
-- debugPrint $ "aSig: " ++ show aSig
let cMap = constrs $ tMembers aSig
--debugPrint $ "cMap: "
--debugPrint $ prettyPrint cMap
cMap' <- instThis pThis cMap
bests <- findBestMethod tArgs argTys argPs (getSigsC cMap')
case bests of
[] -> fail $ "Type " ++ prettyPrint ctyp ++
" does not have a constructor \
\matching argument types (" ++
(unwords $ intersperse ", " $ map prettyPrint argTys) ++
")"
(_:_:_) ->
fail $ "Type " ++ prettyPrint ctyp ++
" has more than one most specific \
\constructor matching argument types (" ++
(unwords $ intersperse ", " $ map prettyPrint argTys) ++
")"
[((tps,_,ts,isVA), aps)] ->
let sig = (tps, ts, isVA) in
case Map.lookup sig cMap' of
Nothing -> panic (monadModule ++ ".lookupConstr")
$ "Sig must be one of the keys of constrMap: " ++ show sig
Just csig -> do
mapM_ (\(p,q) -> do
constraint emptyLockSet p q $ toUndef $
"Cannot unify policy type parameters at constructor call:\n" ++
" p: " ++ prettyPrint p ++ "\n" ++
" q: " ++ prettyPrint q
constraint emptyLockSet q p $ toUndef $
"Cannot unify policy type parameters at constructor call:\n" ++
" p: " ++ prettyPrint q ++ "\n" ++
" q: " ++ prettyPrint p) aps
return (tps, iaps, csig)
getSigs :: MethodMap -> [Sig]
getSigs = map getSig . Map.assocs
where getSig ((tps, pTs, vAr), msig) = (tps, mPars msig, pTs, vAr)
getSigsC :: ConstrMap -> [Sig]
getSigsC = map getSig . Map.assocs
where getSig ((tps, pTs, vAr), csig) = (tps, cPars csig, pTs, vAr)
substParPols :: Lattice m ActorPolicy =>
[(B.ByteString, ActorPolicy)] -> ActorPolicy -> m ActorPolicy
substParPols subst (VarPolicy pol) = substParPrgPols subst pol
substParPols subst (MetaJoin p q) = do
pp <- substParPols subst p
qq <- substParPols subst q
pp `lub` qq
substParPols subst (MetaMeet p q) = do
pp <- substParPols subst p
qq <- substParPols subst q
pp `glb` qq
substParPols _ p = return p
substParPrgPols :: Lattice m ActorPolicy =>
[(B.ByteString, ActorPolicy)] -> PrgPolicy -> m ActorPolicy
substParPrgPols subst p@(PolicyVar (PolicyOfVar i)) =
case lookup i subst of
Just newP -> return newP
Nothing -> return $ VarPolicy p
substParPrgPols subst (Join p q) = do
pp <- substParPrgPols subst p
qq <- substParPrgPols subst q
pp `lub` qq
substParPrgPols subst (Meet p q) = do
pp <- substParPrgPols subst p
qq <- substParPrgPols subst q
pp `glb` qq
substParPrgPols _ p = return $ VarPolicy p
substTypeParPols :: (HasSubTyping m, Lattice m ActorPolicy) =>
[(B.ByteString, ActorPolicy)] -> TcType -> m TcType
substTypeParPols subst (TcRefT rty) = TcRefT <$> substRefTypePPs rty
where substRefTypePPs rt =
case rt of
TcArrayT ty p ->
TcArrayT <$> substTypeParPols subst ty <*> substParPols subst p
TcClsRefT ct ->
TcClsRefT <$> substClsTypePPs ct
_ -> return rt
substClsTypePPs (TcClassT n targs) = TcClassT n <$> mapM substTAPPs targs
substTAPPs (TcActualType rt) = TcActualType <$> substRefTypePPs rt
substTAPPs (TcActualPolicy p) = TcActualPolicy <$> substParPols subst p
substTAPPs a = return a
substTypeParPols _ ty = return ty
{-
registerStateType i tyV mSty | tyV == actorT = do
case mSty of
Nothing -> actorIdT <$> newActorId i -- fresh generation
Just sty -> case mActorId sty of
Nothing -> panic (monadModule ++ ".registerStateType")
$ "Actor state but non-actor target type: "
++ show (tyV, sty)
Just aid -> do
newActorIdWith i aid
return $ actorIdT aid
registerStateType i tyV mSty | tyV == policyT = do
let pbs = case mSty of
Nothing -> PolicyBounds bottom top
Just sty -> case mPolicyPol sty of
Nothing -> panic (monadModule ++ ".registerStateType")
$ "Policy state but non-policy target type: "
++ show (tyV, sty)
Just bs -> bs
updateState $ \s ->
s { policySt = Map.insert (mkSimpleName EName i) pbs $ policySt s }
return $ policyPolT pbs
registerStateType i tyV mSty | Just ct <- mClassType tyV = do
debugPrint $ "registerStateType: " ++ show (i, tyV, mSty)
case mSty of
-- no initialiser
Nothing -> return $ instanceT ct [] -- ??
Just sty -> case mInstanceType sty of
Just (_, aids) -> do
updateState $ \s ->
s { instanceSt = Map.insert (mkSimpleName EName i) aids
$ instanceSt s }
return $ instanceT ct aids
Nothing | isNullType sty -> return $ instanceT ct []
| otherwise -> panic (monadModule ++ ".registerStateType")
$ "Instance state but non-instance target type: "
++ show (tyV, sty)
registerStateType _i tyV _mSty = return $ stateType tyV
-}
{-
updateStateType mN _mTyO tyV sty | tyV == actorT = do
case mActorId sty of
Just aid -> do
-- maybeM mTyO $ \tyO -> scrambleActors (Just tyO)
maybeM mN $ \n -> setActorId n aid
return sty
_ -> panic (monadModule ++ ".updateStateType")
$ "Actor state but non-actor target type: "
++ show (tyV, sty)
-- TODO
{-
updateStateType mN mTyO tyV mSty | tyV == policyT = do
case mSty of
Just sty | Just pbs <- mPolicyPol sty -> do
-}
updateStateType _mN _mTyO ty _sty | isPrimType (stateType ty) = return $ stateType ty
updateStateType mN _mTyO ty sty
| Just ct <- mClassType ty =
case sty of
TcInstance _ aids -> return $ TcInstance ct aids
_ | isNullType sty -> TcInstance ct <$> getInstanceActors mN ct
_ | isArrayType sty -> return $ TcInstance ct []
_ -> panic (monadModule ++ ".updateStateType")
$ "Class type target but no instance type"
++ show (ty, sty)
updateStateType _mN _mTyO _ty sty = return sty -- BOGUS!!!
-- Instance Analysis
getInstanceActors :: Maybe (Name SourcePos) -> TcClassType -> TcCodeM [ActorId]
getInstanceActors mn ct@(TcClassT tyN _) = do
instanceMap <- instanceSt <$> getState
case maybe Nothing (\n -> Map.lookup n instanceMap) mn of
Nothing -> do
(iaps, _) <- lookupTypeOfType (clsTypeToType ct)
mapM (instanceActorId . Name defaultPos EName (Just tyN)) iaps
Just aids -> return aids
-- Policy Analysis
getPolicyBounds :: Maybe (Name SourcePos) -> Maybe TcStateType -> TcCodeM ActorPolicyBounds
getPolicyBounds mn mtyO = do
policyMap <- policySt <$> getState
case maybe Nothing (\n -> Map.lookup n policyMap) mn of
Nothing -> case (mtyO, mn) of
(Just styO, Just (Name _ _ _ i)) -> do
tsig <- lookupTypeOfStateType styO
case Map.lookup i $ policies $ tMembers tsig of
Just pol -> return $ KnownPolicy $ RealPolicy pol
Nothing -> return $ PolicyBounds bottom top
_ -> return $ PolicyBounds bottom top
Just pif -> return pif
-- Actor Analysis
getActorId :: Maybe (Name SourcePos) -> Maybe TcStateType -> TcCodeM ActorId
getActorId mn mtyO = do
actorMap <- actorSt <$> getState
case maybe Nothing (\n -> Map.lookup n actorMap) mn of
Nothing -> case (mtyO, mn) of
(Just styO, Just (Name _ _ _ i)) -> do
tsig <- lookupTypeOfStateType styO
case Map.lookup i $ actors $ tMembers tsig of
Just aid -> return aid
Nothing -> liftTcDeclM $ unknownActorId
_ -> liftTcDeclM $ unknownActorId
Just ai -> return $ aID ai
setActorId :: Name SourcePos -> ActorId -> TcCodeM ()
setActorId n aid = updateState setAct
where setAct :: CodeState -> CodeState
setAct s@(CodeState { actorSt = actMap }) = s { actorSt = Map.adjust replId n actMap }
replId (AI _ st) = AI aid st
newActorIdWith :: Ident SourcePos -> ActorId -> TcCodeM ()
newActorIdWith i aid = do
updateState insertAct
where insertAct :: CodeState -> CodeState
insertAct s@(CodeState { actorSt = actMap }) =
s { actorSt = Map.insert (mkSimpleName EName i) (AI aid Stable) actMap }
newActorId :: Ident SourcePos -> TcCodeM ActorId
newActorId i = do
aid <- liftTcDeclM $ freshActorId (prettyPrint i)
newActorIdWith i aid
return aid
newUnknownId :: Ident SourcePos -> TcCodeM ActorId
newUnknownId i = do
aid <- liftTcDeclM unknownActorId
newActorIdWith i aid
return aid
-}
{-
scrambleActors :: Maybe TcType -> TcCodeM ()
scrambleActors mtc = do
let stb = maybe FullV (FieldV . Just . typeName_) mtc
state <- getState
u <- getUniqRef
newState <- liftIO $ scramble u stb state
setState newState
-}
-- Exception tracking
-- Lockstate tracking
-- Policy inference
--newRigidPolVar :: TcCodeM TcPolicy
--newRigidPolVar = do
-- uniq <- lift . getUniq =<< getUniqRef
-- return $ TcRigidVar uniq
-- Subtyping/conversion/promotion
-- Note that we do NOT allow unchecked conversion or capture conversion.
-- We don't give crap about backwards compatibility here, and even if we
-- did, we would have to rule it out because it would be unsound.
isAssignableTo :: TcType -> TcType -> TcCodeM (Maybe [(ActorPolicy, ActorPolicy)])
isAssignableTo t1 t2 = do
case t1 `equivTo` t2 of -- identity conversion
Just ps -> return $ Just ps
Nothing -> do
b <- liftTcDeclM $ t1 `widensTo` t2 -- widening conversion
return $ if b then Just [] else Nothing
(=<:) :: TcType -> TcStateType -> TcCodeM (Maybe [(ActorPolicy, ActorPolicy)])
lhs =<: rhs = isAssignableTo (unStateType rhs) lhs
equivTo :: TcType -> TcType -> Maybe [(ActorPolicy, ActorPolicy)]
equivTo (TcRefT rt1) (TcRefT rt2) = equivRefT rt1 rt2
where equivRefT :: TcRefType -> TcRefType -> Maybe [(ActorPolicy, ActorPolicy)]
equivRefT (TcArrayT t1 p1) (TcArrayT t2 p2) = do
ps <- t1 `equivTo` t2
return $ (p1,p2):ps
equivRefT (TcClsRefT ct1) (TcClsRefT ct2) = equivClsT ct1 ct2
equivRefT _ _ = if rt1 == rt2 then return [] else Nothing
equivClsT :: TcClassType -> TcClassType -> Maybe [(ActorPolicy, ActorPolicy)]
equivClsT (TcClassT n1 tas1) (TcClassT n2 tas2) =
if n1 /= n2 then Nothing
else equivTypeArgs tas1 tas2
equivTypeArgs :: [TcTypeArg] -> [TcTypeArg] -> Maybe [(ActorPolicy, ActorPolicy)]
equivTypeArgs tas1 tas2 = concat <$> sequence (map (uncurry equivTypeArg) (zip tas1 tas2))
equivTypeArg :: TcTypeArg -> TcTypeArg -> Maybe [(ActorPolicy, ActorPolicy)]
equivTypeArg (TcActualPolicy p1) (TcActualPolicy p2) = Just [(p1, p2)]
equivTypeArg (TcActualType r1) (TcActualType r2) = equivRefT r1 r2
equivTypeArg a1 a2 = if a1 == a2 then return [] else Nothing
equivTo t1 t2 = if t1 == t2 then return [] else Nothing
isCastableTo :: TcType
-> TcType
-> TcCodeM (Maybe [(ActorPolicy, ActorPolicy)], Bool) -- (Can be cast, needs reference narrowing)
isCastableTo t1 t2 = do
-- 'isAssignableTo' handles the cases of identity, primitive widening,
-- boxing + reference widening and unboxing + primitive widening.
-- It also handles reference widening, but not with subsequent unboxing.
mps <- isAssignableTo t1 t2
case mps of
Just ps -> return (Just ps, False)
Nothing -> liftTcDeclM $ do
-- What we have left is primitive narrowing, primitive widening+narrowing,
-- reference widening + unboxing, and reference narrowing + optional unboxing.
-- Only the last one, that includes reference narrowing, can throw a ClassCastException.
case (t1, t2) of
(TcPrimT pt1, TcPrimT pt2) -> -- primitive (widening +) narrowing
return $ (if pt2 `elem` narrowConvert pt1 ++ widenNarrowConvert pt1 then Just [] else Nothing, False)
(TcRefT rt1, TcPrimT pt2)
| Just ct2 <- box pt2 -> do -- reference widening + unboxing AND
-- reference narrowing + unboxing
-- We cheat and compare to the boxing of the target instead
-- since box/unbox are inverses.
let rt2 = TcClsRefT ct2
bWide <- rt1 `subTypeOf` rt2
if bWide then return (Just [], False)
else return (Just [], True)
(TcRefT _rt1, TcRefT _rt2) -> do -- reference narrowing, no unboxing
-- TODO: There are restrictions here, but not relevant at this point
return (Just [], True)
_ -> return (Nothing, False)
(<<:) :: TcType -> TcStateType -> TcCodeM (Maybe [(ActorPolicy, ActorPolicy)], Bool)
lhs <<: rhs = isCastableTo (unStateType rhs) lhs
-- widening conversion can come in four basic shapes:
-- 1) pt/pt -> widening primitive conversion
-- 2) rt/rt -> widening reference conversion
-- 3) pt/rt -> boxing conversion + widening reference conversion
-- 4) rt/pt -> unboxing conversion + widening primitive conversion
widensTo :: TcType -> TcType -> TcDeclM Bool
widensTo (TcPrimT pt1) (TcPrimT pt2) = return $ pt2 `elem` widenConvert pt1
widensTo (TcRefT rt1) (TcRefT rt2) = rt1 `subTypeOf` rt2
widensTo (TcPrimT pt1) t2@(TcRefT _) =
maybe (return False)
(\ct -> clsTypeToType ct `widensTo` t2) (box pt1)
widensTo (TcRefT rt1) t2@(TcPrimT _) =
case rt1 of
TcClsRefT ct -> maybe (return False)
(\pt -> TcPrimT pt `widensTo` t2) (unbox ct)
_ -> return False
{-- 5) Paragon-specific types
widensTo t1 t2 | isPolicyType t1 && t2 == policyT = return True
| isLockType t1 && t2 == booleanT = return True
| isActorType t1 && t2 == actorT = return True
-}
widensTo _ _ = return False
{-
instance HasSubTyping TcDeclM where
--subTypeOf :: TcRefType -> TcRefType -> TcDeclM Bool
subTypeOf TcNullT _ = return True
subTypeOf rt1 rt2 = (rt2 `elem`) <$> ([TcClsRefT objectT] ++) <$> superTypes rt1
where superTypes :: TcRefType -> TcDeclM [TcRefType]
superTypes rt = do
tm <- getTypeMap
tsig <- case lookupTypeOfRefT rt tm of
Left Nothing -> do
case rt of
TcClsRefT (TcClassT n tas) -> do
(tps, _iaps, tsig) <- fetchType n
return $ instantiate (zip tps tas) tsig
_ -> panic (monadModule ++ ".subTypeOf")
$ show rt
Left err -> panic (monadModule ++ ".subTypeOf")
$ "Looking up type:" ++ show rt ++ "\nError: " ++ show err
Right (_,tsig) -> return tsig
let sups = tSupers tsig
impls = tImpls tsig
allS = map TcClsRefT $ sups ++ impls
supsups <- mapM superTypes allS
return $ concat $ allS:supsups
-}
------------------------------------------
-- Constraints resolution --
------------------------------------------
-- Resolution thanks to the transitive closure.
solveConstraints :: [ConstraintWMsg] -> TcDeclM ()
solveConstraints cs = do
finePrint $ "Solving constraints..."
debugPrint $ show (length cs)
let wcs = [c | (c, _) <- cs] -- TODO: Take error texts into account
b <- solve wcs
check b (toUndef "The system failed to infer the set of unspecified policies ")
finePrint $ "Constraints successfully solved!"
{-
checkCstr :: String -> Constraint -> TcDeclM ()
checkCstr str (LRT bs g ls p q) = do
case lrt bs g ls p q of
Left b -> do
-- add xml node to tree
check b $ toUndef $ str
Right _ -> panic (monadModule ++ ".checkCstr")
$ "This set of constraint should be solved !"
-}
{-
solve :: [ConstraintWMsg] -> TcDeclM ()
solve cs =
liftIO $ do
wcs <- return [(p, q) | (LRT _ p q, _) <- cs]
cvars <- filterM isCstrVar wcs
cvarsm <- return (foldl linker Map.empty cvars)
csubsts <- return (Map.foldlWithKey (\cs' x pxs -> foldl (\cs'' px-> (substitution x px cs'')) cs' pxs) wcs cvarsm)
tobechecked <- filterM (\c -> do b <- (isCstrVar c); return $ not b) csubsts
mapM_ print tobechecked
mapM_ (checkCstr "The unspecified variable's policies inference leads, without taking into account the global policy, to an unsolvable system. Please explicite them.") tobechecked
-}
--------------------------------------------------
-- State scrambling
-- 'scramble' should be called at method calls,
-- and will remove everything that is not known
-- not to be affected by that call.
scrambleState :: TcCodeM ()
scrambleState = do
-- s1 <- getState
-- debugPrint $ "\nScrambling: " ++ show s1
updateState scramble
-- s2 <- getState
-- debugPrint $ "Scrambling done: " ++ show s2 ++ "\n"
scramble :: CodeState -> CodeState
scramble = transformBi scr
where scr :: VarMap -> VarMap
scr (VarMap {-aMap-} pMap iMap tMap) =
VarMap
-- (deleteIf (const $ not . aStable) aMap)
(deleteIf (const $ not . pStable) pMap)
(deleteIf (const $ not . iStable) iMap)
tMap -- fixed recursively by transformBi
-- 'scrambleT' should be called when a field is
-- updated, and will remove everything that could
-- be an update-through-alias of that field.
scrambleT :: TcRefType -> Ident SourcePos -> Bool -> TcCodeM ()
scrambleT rtyO iF fresh = setState =<< transformBiM scr =<< getState -- "updateStateM"
where scr :: InstanceInfo -> TcCodeM InstanceInfo
scr isig = do
appl <- liftTcDeclM $ (iType isig) `subTypeOf` rtyO
return $ if appl && not (fresh && iFresh isig)
then isig { iMembers = scrVM $ iMembers isig }
else isig
scrVM :: VarMap -> VarMap
scrVM (VarMap {-aMap-} pMap iMap tMap) =
let matches k _v = k == unIdent iF
in VarMap
-- (deleteIf matches aMap)
(deleteIf matches pMap)
(deleteIf matches iMap)
tMap -- will be empty
deleteIf :: Ord k => (k -> v -> Bool) -> Map k v -> Map k v
deleteIf test = snd . Map.partitionWithKey test
varUpdatedNN :: Name SourcePos -> Maybe (Name SourcePos) -> Ident SourcePos -> TcCodeM ()
varUpdatedNN n mPre i = do
(ty, _, _, _) <- lookupVar mPre i
_ <- updateStateType (Just (n, True)) (unStateType ty) (Just $ setNullInStateType ty (NotNull, Committed))
return ()
isNullChecked :: Exp SourcePos -> TcCodeM ()
isNullChecked ( BinOp _ (ExpName _ n@(Name _ EName mPre i)) (Equal _) (Lit _ (Null _)) ) =
varUpdatedNN n mPre i
isNullChecked ( BinOp _ (Lit _ (Null _)) (Equal _) (ExpName _ n@(Name _ EName mPre i)) ) =
varUpdatedNN n mPre i
isNullChecked _ = return ()
isNotNullChecked :: Exp SourcePos -> TcCodeM ()
isNotNullChecked ( BinOp _ (ExpName _ n@(Name _ EName mPre i)) (NotEq _) (Lit _ (Null _)) ) =
varUpdatedNN n mPre i
isNotNullChecked ( BinOp _ (Lit _ (Null _)) (NotEq _) (ExpName _ n@(Name _ EName mPre i)) ) =
varUpdatedNN n mPre i
isNotNullChecked _ = return ()
| bvdelft/parac2 | src/Language/Java/Paragon/TypeCheck/Monad.hs | bsd-3-clause | 37,627 | 0 | 36 | 12,271 | 7,217 | 3,710 | 3,507 | 453 | 17 |
module Language.JsonGrammar.Util where
import Control.Monad ((>=>), MonadPlus(..))
manyM :: (Monad m, MonadPlus m) => (a -> m a) -> a -> m a
manyM m x = (m >=> manyM m) x `mplus` return x
| MedeaMelana/JsonGrammar2 | src/Language/JsonGrammar/Util.hs | bsd-3-clause | 190 | 0 | 9 | 37 | 99 | 55 | 44 | 4 | 1 |
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE DeriveGeneric #-}
import Data.Monoid ((<>))
import Data.Aeson (FromJSON, ToJSON)
import GHC.Generics
import Web.Scotty
data User = User { userId :: Int, userName :: String } deriving (Show, Generic)
instance ToJSON User
instance FromJSON User
bob :: User
bob = User { userId = 1, userName = "bob" }
jenny :: User
jenny = User { userId = 2, userName = "jenny" }
allUsers :: [User]
allUsers = [bob, jenny]
matchesId :: Int -> User -> Bool
matchesId id user = userId user == id
main = do
putStrLn "Starting Server..."
scotty 3000 $ do
get "/hello/:name" $ do
name <- param "name"
text ("hello " <> name <> "!")
get "/users" $ do
json allUsers
get "/users/:id" $ do
id <- param "id"
json (filter (matchesId id) allUsers)
-- assignment: post user and print it out
post "/users" $ do
user <- jsonData :: ActionM User
json user
| ryoia/practical-haskell | 04-rest-api/src/Assignments.hs | bsd-3-clause | 946 | 0 | 17 | 231 | 325 | 167 | 158 | 31 | 1 |
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TypeFamilies #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-- Module : Network.AWS.CloudFront.GetStreamingDistributionConfig
-- Copyright : (c) 2013-2014 Brendan Hay <[email protected]>
-- License : This Source Code Form is subject to the terms of
-- the Mozilla Public License, v. 2.0.
-- A copy of the MPL can be found in the LICENSE file or
-- you can obtain it at http://mozilla.org/MPL/2.0/.
-- Maintainer : Brendan Hay <[email protected]>
-- Stability : experimental
-- Portability : non-portable (GHC extensions)
--
-- Derived from AWS service descriptions, licensed under Apache 2.0.
-- | Get the configuration information about a streaming distribution.
--
-- <http://docs.aws.amazon.com/AmazonCloudFront/latest/APIReference/GetStreamingDistributionConfig.html>
module Network.AWS.CloudFront.GetStreamingDistributionConfig
(
-- * Request
GetStreamingDistributionConfig
-- ** Request constructor
, getStreamingDistributionConfig
-- ** Request lenses
, gsdcId
-- * Response
, GetStreamingDistributionConfigResponse
-- ** Response constructor
, getStreamingDistributionConfigResponse
-- ** Response lenses
, gsdcrETag
, gsdcrStreamingDistributionConfig
) where
import Network.AWS.Prelude
import Network.AWS.Request.RestXML
import Network.AWS.CloudFront.Types
import qualified GHC.Exts
newtype GetStreamingDistributionConfig = GetStreamingDistributionConfig
{ _gsdcId :: Text
} deriving (Eq, Ord, Read, Show, Monoid, IsString)
-- | 'GetStreamingDistributionConfig' constructor.
--
-- The fields accessible through corresponding lenses are:
--
-- * 'gsdcId' @::@ 'Text'
--
getStreamingDistributionConfig :: Text -- ^ 'gsdcId'
-> GetStreamingDistributionConfig
getStreamingDistributionConfig p1 = GetStreamingDistributionConfig
{ _gsdcId = p1
}
-- | The streaming distribution's id.
gsdcId :: Lens' GetStreamingDistributionConfig Text
gsdcId = lens _gsdcId (\s a -> s { _gsdcId = a })
data GetStreamingDistributionConfigResponse = GetStreamingDistributionConfigResponse
{ _gsdcrETag :: Maybe Text
, _gsdcrStreamingDistributionConfig :: Maybe StreamingDistributionConfig
} deriving (Eq, Read, Show)
-- | 'GetStreamingDistributionConfigResponse' constructor.
--
-- The fields accessible through corresponding lenses are:
--
-- * 'gsdcrETag' @::@ 'Maybe' 'Text'
--
-- * 'gsdcrStreamingDistributionConfig' @::@ 'Maybe' 'StreamingDistributionConfig'
--
getStreamingDistributionConfigResponse :: GetStreamingDistributionConfigResponse
getStreamingDistributionConfigResponse = GetStreamingDistributionConfigResponse
{ _gsdcrStreamingDistributionConfig = Nothing
, _gsdcrETag = Nothing
}
-- | The current version of the configuration. For example: E2QWRUHAPOMQZL.
gsdcrETag :: Lens' GetStreamingDistributionConfigResponse (Maybe Text)
gsdcrETag = lens _gsdcrETag (\s a -> s { _gsdcrETag = a })
-- | The streaming distribution's configuration information.
gsdcrStreamingDistributionConfig :: Lens' GetStreamingDistributionConfigResponse (Maybe StreamingDistributionConfig)
gsdcrStreamingDistributionConfig =
lens _gsdcrStreamingDistributionConfig
(\s a -> s { _gsdcrStreamingDistributionConfig = a })
instance ToPath GetStreamingDistributionConfig where
toPath GetStreamingDistributionConfig{..} = mconcat
[ "/2014-11-06/streaming-distribution/"
, toText _gsdcId
, "/config"
]
instance ToQuery GetStreamingDistributionConfig where
toQuery = const mempty
instance ToHeaders GetStreamingDistributionConfig
instance ToXMLRoot GetStreamingDistributionConfig where
toXMLRoot = const (namespaced ns "GetStreamingDistributionConfig" [])
instance ToXML GetStreamingDistributionConfig
instance AWSRequest GetStreamingDistributionConfig where
type Sv GetStreamingDistributionConfig = CloudFront
type Rs GetStreamingDistributionConfig = GetStreamingDistributionConfigResponse
request = get
response = xmlHeaderResponse $ \h x -> GetStreamingDistributionConfigResponse
<$> h ~:? "ETag"
<*> x .@? "StreamingDistributionConfig"
| kim/amazonka | amazonka-cloudfront/gen/Network/AWS/CloudFront/GetStreamingDistributionConfig.hs | mpl-2.0 | 4,654 | 0 | 11 | 901 | 520 | 312 | 208 | 64 | 1 |
{-# LANGUAGE CPP #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
#ifndef MIN_VERSION_profunctors
#define MIN_VERSION_profunctors(x,y,z) 1
#endif
#if __GLASGOW_HASKELL__ < 708 || !(MIN_VERSION_profunctors(4,4,0))
{-# LANGUAGE Trustworthy #-}
#endif
{-# OPTIONS_GHC -fno-warn-orphans #-}
----------------------------------------------------------------------------
-- |
-- Module : Control.Lens.Fold
-- Copyright : (C) 2012-15 Edward Kmett
-- License : BSD-style (see the file LICENSE)
-- Maintainer : Edward Kmett <[email protected]>
-- Stability : provisional
-- Portability : Rank2Types
--
-- A @'Fold' s a@ is a generalization of something 'Foldable'. It allows
-- you to extract multiple results from a container. A 'Foldable' container
-- can be characterized by the behavior of
-- @'Data.Foldable.foldMap' :: ('Foldable' t, 'Monoid' m) => (a -> m) -> t a -> m@.
-- Since we want to be able to work with monomorphic containers, we could
-- generalize this signature to @forall m. 'Monoid' m => (a -> m) -> s -> m@,
-- and then decorate it with 'Const' to obtain
--
-- @type 'Fold' s a = forall m. 'Monoid' m => 'Getting' m s a@
--
-- Every 'Getter' is a valid 'Fold' that simply doesn't use the 'Monoid'
-- it is passed.
--
-- In practice the type we use is slightly more complicated to allow for
-- better error messages and for it to be transformed by certain
-- 'Applicative' transformers.
--
-- Everything you can do with a 'Foldable' container, you can with with a 'Fold' and there are
-- combinators that generalize the usual 'Foldable' operations here.
----------------------------------------------------------------------------
module Control.Lens.Fold
(
-- * Folds
Fold
, IndexedFold
-- * Getting Started
, (^..)
, (^?)
, (^?!)
, pre, ipre
, preview, previews, ipreview, ipreviews
, preuse, preuses, ipreuse, ipreuses
, has, hasn't
-- ** Building Folds
, folding, ifolding
, foldring, ifoldring
, folded
, folded64
, unfolded
, iterated
, filtered
, backwards
, repeated
, replicated
, cycled
, takingWhile
, droppingWhile
, worded, lined
-- ** Folding
, foldMapOf, foldOf
, foldrOf, foldlOf
, toListOf
, anyOf, allOf, noneOf
, andOf, orOf
, productOf, sumOf
, traverseOf_, forOf_, sequenceAOf_
, mapMOf_, forMOf_, sequenceOf_
, asumOf, msumOf
, concatMapOf, concatOf
, elemOf, notElemOf
, lengthOf
, nullOf, notNullOf
, firstOf, lastOf
, maximumOf, minimumOf
, maximumByOf, minimumByOf
, findOf
, findMOf
, foldrOf', foldlOf'
, foldr1Of, foldl1Of
, foldr1Of', foldl1Of'
, foldrMOf, foldlMOf
-- * Indexed Folds
, (^@..)
, (^@?)
, (^@?!)
-- ** Indexed Folding
, ifoldMapOf
, ifoldrOf
, ifoldlOf
, ianyOf
, iallOf
, inoneOf
, itraverseOf_
, iforOf_
, imapMOf_
, iforMOf_
, iconcatMapOf
, ifindOf
, ifindMOf
, ifoldrOf'
, ifoldlOf'
, ifoldrMOf
, ifoldlMOf
, itoListOf
, elemIndexOf
, elemIndicesOf
, findIndexOf
, findIndicesOf
-- ** Building Indexed Folds
, ifiltered
, itakingWhile
, idroppingWhile
-- * Internal types
, Leftmost
, Rightmost
, Traversed
, Sequenced
-- * Fold with Reified Monoid
, foldBy
, foldByOf
, foldMapBy
, foldMapByOf
) where
import Control.Applicative as Applicative
import Control.Applicative.Backwards
import Control.Comonad
import Control.Lens.Getter
import Control.Lens.Internal.Fold
import Control.Lens.Internal.Getter
import Control.Lens.Internal.Indexed
import Control.Lens.Internal.Magma
import Control.Lens.Type
import Control.Monad as Monad
import Control.Monad.Reader
import Control.Monad.State
import Data.Foldable
import Data.Functor.Apply
import Data.Functor.Compose
import Data.Int (Int64)
import Data.List (intercalate)
import Data.Maybe
import Data.Monoid
import Data.Profunctor
import Data.Profunctor.Rep
import Data.Profunctor.Sieve
import Data.Profunctor.Unsafe
import Data.Traversable
import Prelude hiding (foldr)
-- $setup
-- >>> :set -XNoOverloadedStrings
-- >>> import Control.Lens
-- >>> import Control.Lens.Extras (is)
-- >>> import Data.Function
-- >>> import Data.List.Lens
-- >>> import Debug.SimpleReflect.Expr
-- >>> import Debug.SimpleReflect.Vars as Vars hiding (f,g)
-- >>> import Control.DeepSeq (NFData (..), force)
-- >>> import Control.Exception (evaluate)
-- >>> import Data.Maybe (fromMaybe)
-- >>> import System.Timeout (timeout)
-- >>> let f :: Expr -> Expr; f = Debug.SimpleReflect.Vars.f
-- >>> let g :: Expr -> Expr; g = Debug.SimpleReflect.Vars.g
-- >>> let timingOut :: NFData a => a -> IO a; timingOut = fmap (fromMaybe (error "timeout")) . timeout (5*10^6) . evaluate . force
#ifdef HLINT
{-# ANN module "HLint: ignore Eta reduce" #-}
{-# ANN module "HLint: ignore Use camelCase" #-}
{-# ANN module "HLint: ignore Use curry" #-}
#endif
infixl 8 ^.., ^?, ^?!, ^@.., ^@?, ^@?!
--------------------------
-- Folds
--------------------------
-- | Obtain a 'Fold' by lifting an operation that returns a 'Foldable' result.
--
-- This can be useful to lift operations from @Data.List@ and elsewhere into a 'Fold'.
--
-- >>> [1,2,3,4]^..folding tail
-- [2,3,4]
folding :: Foldable f => (s -> f a) -> Fold s a
folding sfa agb = coerce . traverse_ agb . sfa
{-# INLINE folding #-}
ifolding :: (Foldable f, Indexable i p, Contravariant g, Applicative g) => (s -> f (i, a)) -> Over p g s t a b
ifolding sfa f = coerce . traverse_ (coerce . uncurry (indexed f)) . sfa
{-# INLINE ifolding #-}
-- | Obtain a 'Fold' by lifting 'foldr' like function.
--
-- >>> [1,2,3,4]^..foldring foldr
-- [1,2,3,4]
foldring :: (Contravariant f, Applicative f) => ((a -> f a -> f a) -> f a -> s -> f a) -> LensLike f s t a b
foldring fr f = coerce . fr (\a fa -> f a *> fa) noEffect
{-# INLINE foldring #-}
-- | Obtain 'FoldWithIndex' by lifting 'ifoldr' like function.
ifoldring :: (Indexable i p, Contravariant f, Applicative f) => ((i -> a -> f a -> f a) -> f a -> s -> f a) -> Over p f s t a b
ifoldring ifr f = coerce . ifr (\i a fa -> indexed f i a *> fa) noEffect
{-# INLINE ifoldring #-}
-- | Obtain a 'Fold' from any 'Foldable' indexed by ordinal position.
--
-- >>> Just 3^..folded
-- [3]
--
-- >>> Nothing^..folded
-- []
--
-- >>> [(1,2),(3,4)]^..folded.both
-- [1,2,3,4]
folded :: Foldable f => IndexedFold Int (f a) a
folded = conjoined (foldring foldr) (ifoldring ifoldr)
{-# INLINE folded #-}
ifoldr :: Foldable f => (Int -> a -> b -> b) -> b -> f a -> b
ifoldr f z xs = foldr (\ x g i -> i `seq` f i x (g (i+1))) (const z) xs 0
{-# INLINE ifoldr #-}
-- | Obtain a 'Fold' from any 'Foldable' indexed by ordinal position.
folded64 :: Foldable f => IndexedFold Int64 (f a) a
folded64 = conjoined (foldring foldr) (ifoldring ifoldr64)
{-# INLINE folded64 #-}
ifoldr64 :: Foldable f => (Int64 -> a -> b -> b) -> b -> f a -> b
ifoldr64 f z xs = foldr (\ x g i -> i `seq` f i x (g (i+1))) (const z) xs 0
{-# INLINE ifoldr64 #-}
-- | Form a 'Fold1' by repeating the input forever.
--
-- @
-- 'repeat' ≡ 'toListOf' 'repeated'
-- @
--
-- >>> timingOut $ 5^..taking 20 repeated
-- [5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5]
--
-- @
-- 'repeated' :: 'Fold1' a a
-- @
repeated :: Apply f => LensLike' f a a
repeated f a = as where as = f a .> as
{-# INLINE repeated #-}
-- | A 'Fold' that replicates its input @n@ times.
--
-- @
-- 'replicate' n ≡ 'toListOf' ('replicated' n)
-- @
--
-- >>> 5^..replicated 20
-- [5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5]
replicated :: Int -> Fold a a
replicated n0 f a = go n0 where
m = f a
go 0 = noEffect
go n = m *> go (n - 1)
{-# INLINE replicated #-}
-- | Transform a non-empty 'Fold' into a 'Fold1' that loops over its elements over and over.
--
-- >>> timingOut $ [1,2,3]^..taking 7 (cycled traverse)
-- [1,2,3,1,2,3,1]
--
-- @
-- 'cycled' :: 'Fold1' s a -> 'Fold1' s a
-- @
cycled :: Apply f => LensLike f s t a b -> LensLike f s t a b
cycled l f a = as where as = l f a .> as
{-# INLINE cycled #-}
-- | Build a 'Fold' that unfolds its values from a seed.
--
-- @
-- 'Prelude.unfoldr' ≡ 'toListOf' '.' 'unfolded'
-- @
--
-- >>> 10^..unfolded (\b -> if b == 0 then Nothing else Just (b, b-1))
-- [10,9,8,7,6,5,4,3,2,1]
unfolded :: (b -> Maybe (a, b)) -> Fold b a
unfolded f g b0 = go b0 where
go b = case f b of
Just (a, b') -> g a *> go b'
Nothing -> noEffect
{-# INLINE unfolded #-}
-- | @x '^.' 'iterated' f@ returns an infinite 'Fold1' of repeated applications of @f@ to @x@.
--
-- @
-- 'toListOf' ('iterated' f) a ≡ 'iterate' f a
-- @
--
-- @
-- 'iterated' :: (a -> a) -> 'Fold1' a a
-- @
iterated :: Apply f => (a -> a) -> LensLike' f a a
iterated f g a0 = go a0 where
go a = g a .> go (f a)
{-# INLINE iterated #-}
-- | Obtain an 'Fold' that can be composed with to filter another 'Lens', 'Iso', 'Getter', 'Fold' (or 'Traversal').
--
-- Note: This is /not/ a legal 'Traversal', unless you are very careful not to invalidate the predicate on the target.
--
-- Note: This is also /not/ a legal 'Prism', unless you are very careful not to inject a value that matches the predicate.
--
-- As a counter example, consider that given @evens = 'filtered' 'even'@ the second 'Traversal' law is violated:
--
-- @
-- 'Control.Lens.Setter.over' evens 'succ' '.' 'Control.Lens.Setter.over' evens 'succ' '/=' 'Control.Lens.Setter.over' evens ('succ' '.' 'succ')
-- @
--
-- So, in order for this to qualify as a legal 'Traversal' you can only use it for actions that preserve the result of the predicate!
--
-- >>> [1..10]^..folded.filtered even
-- [2,4,6,8,10]
--
-- This will preserve an index if it is present.
filtered :: (Choice p, Applicative f) => (a -> Bool) -> Optic' p f a a
filtered p = dimap (\x -> if p x then Right x else Left x) (either pure id) . right'
{-# INLINE filtered #-}
-- | Obtain a 'Fold' by taking elements from another 'Fold', 'Lens', 'Iso', 'Getter' or 'Traversal' while a predicate holds.
--
-- @
-- 'takeWhile' p ≡ 'toListOf' ('takingWhile' p 'folded')
-- @
--
-- >>> timingOut $ toListOf (takingWhile (<=3) folded) [1..]
-- [1,2,3]
--
-- @
-- 'takingWhile' :: (a -> 'Bool') -> 'Fold' s a -> 'Fold' s a
-- 'takingWhile' :: (a -> 'Bool') -> 'Getter' s a -> 'Fold' s a
-- 'takingWhile' :: (a -> 'Bool') -> 'Traversal'' s a -> 'Fold' s a -- * See note below
-- 'takingWhile' :: (a -> 'Bool') -> 'Lens'' s a -> 'Fold' s a -- * See note below
-- 'takingWhile' :: (a -> 'Bool') -> 'Prism'' s a -> 'Fold' s a -- * See note below
-- 'takingWhile' :: (a -> 'Bool') -> 'Iso'' s a -> 'Fold' s a -- * See note below
-- 'takingWhile' :: (a -> 'Bool') -> 'IndexedTraversal'' i s a -> 'IndexedFold' i s a -- * See note below
-- 'takingWhile' :: (a -> 'Bool') -> 'IndexedLens'' i s a -> 'IndexedFold' i s a -- * See note below
-- 'takingWhile' :: (a -> 'Bool') -> 'IndexedFold' i s a -> 'IndexedFold' i s a
-- 'takingWhile' :: (a -> 'Bool') -> 'IndexedGetter' i s a -> 'IndexedFold' i s a
-- @
--
-- /Note:/ When applied to a 'Traversal', 'takingWhile' yields something that can be used as if it were a 'Traversal', but
-- which is not a 'Traversal' per the laws, unless you are careful to ensure that you do not invalidate the predicate when
-- writing back through it.
takingWhile :: (Conjoined p, Applicative f) => (a -> Bool) -> Over p (TakingWhile p f a a) s t a a -> Over p f s t a a
takingWhile p l pafb = fmap runMagma . traverse (cosieve pafb) . runTakingWhile . l flag where
flag = cotabulate $ \wa -> let a = extract wa; r = p a in TakingWhile r a $ \pr ->
if pr && r then Magma () wa else MagmaPure a
{-# INLINE takingWhile #-}
-- | Obtain a 'Fold' by dropping elements from another 'Fold', 'Lens', 'Iso', 'Getter' or 'Traversal' while a predicate holds.
--
-- @
-- 'dropWhile' p ≡ 'toListOf' ('droppingWhile' p 'folded')
-- @
--
-- >>> toListOf (droppingWhile (<=3) folded) [1..6]
-- [4,5,6]
--
-- >>> toListOf (droppingWhile (<=3) folded) [1,6,1]
-- [6,1]
--
-- @
-- 'droppingWhile' :: (a -> 'Bool') -> 'Fold' s a -> 'Fold' s a
-- 'droppingWhile' :: (a -> 'Bool') -> 'Getter' s a -> 'Fold' s a
-- 'droppingWhile' :: (a -> 'Bool') -> 'Traversal'' s a -> 'Fold' s a -- see notes
-- 'droppingWhile' :: (a -> 'Bool') -> 'Lens'' s a -> 'Fold' s a -- see notes
-- 'droppingWhile' :: (a -> 'Bool') -> 'Prism'' s a -> 'Fold' s a -- see notes
-- 'droppingWhile' :: (a -> 'Bool') -> 'Iso'' s a -> 'Fold' s a -- see notes
-- @
--
-- @
-- 'droppingWhile' :: (a -> 'Bool') -> 'IndexPreservingTraversal'' s a -> 'IndexPreservingFold' s a -- see notes
-- 'droppingWhile' :: (a -> 'Bool') -> 'IndexPreservingLens'' s a -> 'IndexPreservingFold' s a -- see notes
-- 'droppingWhile' :: (a -> 'Bool') -> 'IndexPreservingGetter' s a -> 'IndexPreservingFold' s a
-- 'droppingWhile' :: (a -> 'Bool') -> 'IndexPreservingFold' s a -> 'IndexPreservingFold' s a
-- @
--
-- @
-- 'droppingWhile' :: (a -> 'Bool') -> 'IndexedTraversal'' i s a -> 'IndexedFold' i s a -- see notes
-- 'droppingWhile' :: (a -> 'Bool') -> 'IndexedLens'' i s a -> 'IndexedFold' i s a -- see notes
-- 'droppingWhile' :: (a -> 'Bool') -> 'IndexedGetter' i s a -> 'IndexedFold' i s a
-- 'droppingWhile' :: (a -> 'Bool') -> 'IndexedFold' i s a -> 'IndexedFold' i s a
-- @
--
-- Note: Many uses of this combinator will yield something that meets the types, but not the laws of a valid
-- 'Traversal' or 'IndexedTraversal'. The 'Traversal' and 'IndexedTraversal' laws are only satisfied if the
-- new values you assign also pass the predicate! Otherwise subsequent traversals will visit fewer elements
-- and 'Traversal' fusion is not sound.
droppingWhile :: (Conjoined p, Profunctor q, Applicative f)
=> (a -> Bool)
-> Optical p q (Compose (State Bool) f) s t a a
-> Optical p q f s t a a
droppingWhile p l f = (flip evalState True .# getCompose) `rmap` l g where
g = cotabulate $ \wa -> Compose $ state $ \b -> let
a = extract wa
b' = b && p a
in (if b' then pure a else cosieve f wa, b')
{-# INLINE droppingWhile #-}
-- | A 'Fold' over the individual 'words' of a 'String'.
--
-- @
-- 'worded' :: 'Fold' 'String' 'String'
-- 'worded' :: 'Traversal'' 'String' 'String'
-- @
--
-- @
-- 'worded' :: 'IndexedFold' 'Int' 'String' 'String'
-- 'worded' :: 'IndexedTraversal'' 'Int' 'String' 'String'
-- @
--
-- Note: This function type-checks as a 'Traversal' but it doesn't satisfy the laws. It's only valid to use it
-- when you don't insert any whitespace characters while traversing, and if your original 'String' contains only
-- isolated space characters (and no other characters that count as space, such as non-breaking spaces).
worded :: Applicative f => IndexedLensLike' Int f String String
worded f = fmap unwords . conjoined traverse (indexing traverse) f . words
{-# INLINE worded #-}
-- | A 'Fold' over the individual 'lines' of a 'String'.
--
-- @
-- 'lined' :: 'Fold' 'String' 'String'
-- 'lined' :: 'Traversal'' 'String' 'String'
-- @
--
-- @
-- 'lined' :: 'IndexedFold' 'Int' 'String' 'String'
-- 'lined' :: 'IndexedTraversal'' 'Int' 'String' 'String'
-- @
--
-- Note: This function type-checks as a 'Traversal' but it doesn't satisfy the laws. It's only valid to use it
-- when you don't insert any newline characters while traversing, and if your original 'String' contains only
-- isolated newline characters.
lined :: Applicative f => IndexedLensLike' Int f String String
lined f = fmap (intercalate "\n") . conjoined traverse (indexing traverse) f . lines
{-# INLINE lined #-}
--------------------------
-- Fold/Getter combinators
--------------------------
-- | Map each part of a structure viewed through a 'Lens', 'Getter',
-- 'Fold' or 'Traversal' to a monoid and combine the results.
--
-- >>> foldMapOf (folded . both . _Just) Sum [(Just 21, Just 21)]
-- Sum {getSum = 42}
--
-- @
-- 'Data.Foldable.foldMap' = 'foldMapOf' 'folded'
-- @
--
-- @
-- 'foldMapOf' ≡ 'views'
-- 'ifoldMapOf' l = 'foldMapOf' l '.' 'Indexed'
-- @
--
-- @
-- 'foldMapOf' :: 'Getter' s a -> (a -> r) -> s -> r
-- 'foldMapOf' :: 'Monoid' r => 'Fold' s a -> (a -> r) -> s -> r
-- 'foldMapOf' :: 'Lens'' s a -> (a -> r) -> s -> r
-- 'foldMapOf' :: 'Iso'' s a -> (a -> r) -> s -> r
-- 'foldMapOf' :: 'Monoid' r => 'Traversal'' s a -> (a -> r) -> s -> r
-- 'foldMapOf' :: 'Monoid' r => 'Prism'' s a -> (a -> r) -> s -> r
-- @
--
-- @
-- 'foldMapOf' :: 'Getting' r s a -> (a -> r) -> s -> r
-- @
foldMapOf :: Profunctor p => Accessing p r s a -> p a r -> s -> r
foldMapOf l f = getConst #. l (Const #. f)
{-# INLINE foldMapOf #-}
-- | Combine the elements of a structure viewed through a 'Lens', 'Getter',
-- 'Fold' or 'Traversal' using a monoid.
--
-- >>> foldOf (folded.folded) [[Sum 1,Sum 4],[Sum 8, Sum 8],[Sum 21]]
-- Sum {getSum = 42}
--
-- @
-- 'Data.Foldable.fold' = 'foldOf' 'folded'
-- @
--
-- @
-- 'foldOf' ≡ 'view'
-- @
--
-- @
-- 'foldOf' :: 'Getter' s m -> s -> m
-- 'foldOf' :: 'Monoid' m => 'Fold' s m -> s -> m
-- 'foldOf' :: 'Lens'' s m -> s -> m
-- 'foldOf' :: 'Iso'' s m -> s -> m
-- 'foldOf' :: 'Monoid' m => 'Traversal'' s m -> s -> m
-- 'foldOf' :: 'Monoid' m => 'Prism'' s m -> s -> m
-- @
foldOf :: Getting a s a -> s -> a
foldOf l = getConst #. l Const
{-# INLINE foldOf #-}
-- | Right-associative fold of parts of a structure that are viewed through a 'Lens', 'Getter', 'Fold' or 'Traversal'.
--
-- @
-- 'Data.Foldable.foldr' ≡ 'foldrOf' 'folded'
-- @
--
-- @
-- 'foldrOf' :: 'Getter' s a -> (a -> r -> r) -> r -> s -> r
-- 'foldrOf' :: 'Fold' s a -> (a -> r -> r) -> r -> s -> r
-- 'foldrOf' :: 'Lens'' s a -> (a -> r -> r) -> r -> s -> r
-- 'foldrOf' :: 'Iso'' s a -> (a -> r -> r) -> r -> s -> r
-- 'foldrOf' :: 'Traversal'' s a -> (a -> r -> r) -> r -> s -> r
-- 'foldrOf' :: 'Prism'' s a -> (a -> r -> r) -> r -> s -> r
-- @
--
-- @
-- 'ifoldrOf' l ≡ 'foldrOf' l '.' 'Indexed'
-- @
--
-- @
-- 'foldrOf' :: 'Getting' ('Endo' r) s a -> (a -> r -> r) -> r -> s -> r
-- @
foldrOf :: Profunctor p => Accessing p (Endo r) s a -> p a (r -> r) -> r -> s -> r
foldrOf l f z = flip appEndo z `rmap` foldMapOf l (Endo #. f)
{-# INLINE foldrOf #-}
-- | Left-associative fold of the parts of a structure that are viewed through a 'Lens', 'Getter', 'Fold' or 'Traversal'.
--
-- @
-- 'Data.Foldable.foldl' ≡ 'foldlOf' 'folded'
-- @
--
-- @
-- 'foldlOf' :: 'Getter' s a -> (r -> a -> r) -> r -> s -> r
-- 'foldlOf' :: 'Fold' s a -> (r -> a -> r) -> r -> s -> r
-- 'foldlOf' :: 'Lens'' s a -> (r -> a -> r) -> r -> s -> r
-- 'foldlOf' :: 'Iso'' s a -> (r -> a -> r) -> r -> s -> r
-- 'foldlOf' :: 'Traversal'' s a -> (r -> a -> r) -> r -> s -> r
-- 'foldlOf' :: 'Prism'' s a -> (r -> a -> r) -> r -> s -> r
-- @
foldlOf :: Getting (Dual (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
foldlOf l f z = (flip appEndo z .# getDual) `rmap` foldMapOf l (Dual #. Endo #. flip f)
{-# INLINE foldlOf #-}
-- | Extract a list of the targets of a 'Fold'. See also ('^..').
--
-- @
-- 'Data.Foldable.toList' ≡ 'toListOf' 'folded'
-- ('^..') ≡ 'flip' 'toListOf'
-- @
-- >>> toListOf both ("hello","world")
-- ["hello","world"]
--
-- @
-- 'toListOf' :: 'Getter' s a -> s -> [a]
-- 'toListOf' :: 'Fold' s a -> s -> [a]
-- 'toListOf' :: 'Lens'' s a -> s -> [a]
-- 'toListOf' :: 'Iso'' s a -> s -> [a]
-- 'toListOf' :: 'Traversal'' s a -> s -> [a]
-- 'toListOf' :: 'Prism'' s a -> s -> [a]
-- @
toListOf :: Getting (Endo [a]) s a -> s -> [a]
toListOf l = foldrOf l (:) []
{-# INLINE toListOf #-}
-- | A convenient infix (flipped) version of 'toListOf'.
--
-- >>> [[1,2],[3]]^..traverse.traverse
-- [1,2,3]
--
-- >>> (1,2)^..both
-- [1,2]
--
-- @
-- 'Data.Foldable.toList' xs ≡ xs '^..' 'folded'
-- ('^..') ≡ 'flip' 'toListOf'
-- @
--
-- @
-- ('^..') :: s -> 'Getter' s a -> [a]
-- ('^..') :: s -> 'Fold' s a -> [a]
-- ('^..') :: s -> 'Lens'' s a -> [a]
-- ('^..') :: s -> 'Iso'' s a -> [a]
-- ('^..') :: s -> 'Traversal'' s a -> [a]
-- ('^..') :: s -> 'Prism'' s a -> [a]
-- @
(^..) :: s -> Getting (Endo [a]) s a -> [a]
s ^.. l = toListOf l s
{-# INLINE (^..) #-}
-- | Returns 'True' if every target of a 'Fold' is 'True'.
--
-- >>> andOf both (True,False)
-- False
-- >>> andOf both (True,True)
-- True
--
-- @
-- 'Data.Foldable.and' ≡ 'andOf' 'folded'
-- @
--
-- @
-- 'andOf' :: 'Getter' s 'Bool' -> s -> 'Bool'
-- 'andOf' :: 'Fold' s 'Bool' -> s -> 'Bool'
-- 'andOf' :: 'Lens'' s 'Bool' -> s -> 'Bool'
-- 'andOf' :: 'Iso'' s 'Bool' -> s -> 'Bool'
-- 'andOf' :: 'Traversal'' s 'Bool' -> s -> 'Bool'
-- 'andOf' :: 'Prism'' s 'Bool' -> s -> 'Bool'
-- @
andOf :: Getting All s Bool -> s -> Bool
andOf l = getAll #. foldMapOf l All
{-# INLINE andOf #-}
-- | Returns 'True' if any target of a 'Fold' is 'True'.
--
-- >>> orOf both (True,False)
-- True
-- >>> orOf both (False,False)
-- False
--
-- @
-- 'Data.Foldable.or' ≡ 'orOf' 'folded'
-- @
--
-- @
-- 'orOf' :: 'Getter' s 'Bool' -> s -> 'Bool'
-- 'orOf' :: 'Fold' s 'Bool' -> s -> 'Bool'
-- 'orOf' :: 'Lens'' s 'Bool' -> s -> 'Bool'
-- 'orOf' :: 'Iso'' s 'Bool' -> s -> 'Bool'
-- 'orOf' :: 'Traversal'' s 'Bool' -> s -> 'Bool'
-- 'orOf' :: 'Prism'' s 'Bool' -> s -> 'Bool'
-- @
orOf :: Getting Any s Bool -> s -> Bool
orOf l = getAny #. foldMapOf l Any
{-# INLINE orOf #-}
-- | Returns 'True' if any target of a 'Fold' satisfies a predicate.
--
-- >>> anyOf both (=='x') ('x','y')
-- True
-- >>> import Data.Data.Lens
-- >>> anyOf biplate (== "world") (((),2::Int),"hello",("world",11::Int))
-- True
--
-- @
-- 'Data.Foldable.any' ≡ 'anyOf' 'folded'
-- @
--
-- @
-- 'ianyOf' l ≡ 'allOf' l '.' 'Indexed'
-- @
--
-- @
-- 'anyOf' :: 'Getter' s a -> (a -> 'Bool') -> s -> 'Bool'
-- 'anyOf' :: 'Fold' s a -> (a -> 'Bool') -> s -> 'Bool'
-- 'anyOf' :: 'Lens'' s a -> (a -> 'Bool') -> s -> 'Bool'
-- 'anyOf' :: 'Iso'' s a -> (a -> 'Bool') -> s -> 'Bool'
-- 'anyOf' :: 'Traversal'' s a -> (a -> 'Bool') -> s -> 'Bool'
-- 'anyOf' :: 'Prism'' s a -> (a -> 'Bool') -> s -> 'Bool'
-- @
anyOf :: Profunctor p => Accessing p Any s a -> p a Bool -> s -> Bool
anyOf l f = getAny #. foldMapOf l (Any #. f)
{-# INLINE anyOf #-}
-- | Returns 'True' if every target of a 'Fold' satisfies a predicate.
--
-- >>> allOf both (>=3) (4,5)
-- True
-- >>> allOf folded (>=2) [1..10]
-- False
--
-- @
-- 'Data.Foldable.all' ≡ 'allOf' 'folded'
-- @
--
-- @
-- 'iallOf' l = 'allOf' l '.' 'Indexed'
-- @
--
-- @
-- 'allOf' :: 'Getter' s a -> (a -> 'Bool') -> s -> 'Bool'
-- 'allOf' :: 'Fold' s a -> (a -> 'Bool') -> s -> 'Bool'
-- 'allOf' :: 'Lens'' s a -> (a -> 'Bool') -> s -> 'Bool'
-- 'allOf' :: 'Iso'' s a -> (a -> 'Bool') -> s -> 'Bool'
-- 'allOf' :: 'Traversal'' s a -> (a -> 'Bool') -> s -> 'Bool'
-- 'allOf' :: 'Prism'' s a -> (a -> 'Bool') -> s -> 'Bool'
-- @
allOf :: Profunctor p => Accessing p All s a -> p a Bool -> s -> Bool
allOf l f = getAll #. foldMapOf l (All #. f)
{-# INLINE allOf #-}
-- | Returns 'True' only if no targets of a 'Fold' satisfy a predicate.
--
-- >>> noneOf each (is _Nothing) (Just 3, Just 4, Just 5)
-- True
-- >>> noneOf (folded.folded) (<10) [[13,99,20],[3,71,42]]
-- False
--
-- @
-- 'inoneOf' l = 'noneOf' l '.' 'Indexed'
-- @
--
-- @
-- 'noneOf' :: 'Getter' s a -> (a -> 'Bool') -> s -> 'Bool'
-- 'noneOf' :: 'Fold' s a -> (a -> 'Bool') -> s -> 'Bool'
-- 'noneOf' :: 'Lens'' s a -> (a -> 'Bool') -> s -> 'Bool'
-- 'noneOf' :: 'Iso'' s a -> (a -> 'Bool') -> s -> 'Bool'
-- 'noneOf' :: 'Traversal'' s a -> (a -> 'Bool') -> s -> 'Bool'
-- 'noneOf' :: 'Prism'' s a -> (a -> 'Bool') -> s -> 'Bool'
-- @
noneOf :: Profunctor p => Accessing p Any s a -> p a Bool -> s -> Bool
noneOf l f = not . anyOf l f
{-# INLINE noneOf #-}
-- | Calculate the 'Product' of every number targeted by a 'Fold'.
--
-- >>> productOf both (4,5)
-- 20
-- >>> productOf folded [1,2,3,4,5]
-- 120
--
-- @
-- 'Data.Foldable.product' ≡ 'productOf' 'folded'
-- @
--
-- This operation may be more strict than you would expect. If you
-- want a lazier version use @'ala' 'Product' '.' 'foldMapOf'@
--
-- @
-- 'productOf' :: 'Num' a => 'Getter' s a -> s -> a
-- 'productOf' :: 'Num' a => 'Fold' s a -> s -> a
-- 'productOf' :: 'Num' a => 'Lens'' s a -> s -> a
-- 'productOf' :: 'Num' a => 'Iso'' s a -> s -> a
-- 'productOf' :: 'Num' a => 'Traversal'' s a -> s -> a
-- 'productOf' :: 'Num' a => 'Prism'' s a -> s -> a
-- @
productOf :: Num a => Getting (Endo (Endo a)) s a -> s -> a
productOf l = foldlOf' l (*) 1
{-# INLINE productOf #-}
-- | Calculate the 'Sum' of every number targeted by a 'Fold'.
--
-- >>> sumOf both (5,6)
-- 11
-- >>> sumOf folded [1,2,3,4]
-- 10
-- >>> sumOf (folded.both) [(1,2),(3,4)]
-- 10
-- >>> import Data.Data.Lens
-- >>> sumOf biplate [(1::Int,[]),(2,[(3::Int,4::Int)])] :: Int
-- 10
--
-- @
-- 'Data.Foldable.sum' ≡ 'sumOf' 'folded'
-- @
--
-- This operation may be more strict than you would expect. If you
-- want a lazier version use @'ala' 'Sum' '.' 'foldMapOf'@
--
-- @
-- 'sumOf' '_1' :: 'Num' a => (a, b) -> a
-- 'sumOf' ('folded' '.' 'Control.Lens.Tuple._1') :: ('Foldable' f, 'Num' a) => f (a, b) -> a
-- @
--
-- @
-- 'sumOf' :: 'Num' a => 'Getter' s a -> s -> a
-- 'sumOf' :: 'Num' a => 'Fold' s a -> s -> a
-- 'sumOf' :: 'Num' a => 'Lens'' s a -> s -> a
-- 'sumOf' :: 'Num' a => 'Iso'' s a -> s -> a
-- 'sumOf' :: 'Num' a => 'Traversal'' s a -> s -> a
-- 'sumOf' :: 'Num' a => 'Prism'' s a -> s -> a
-- @
sumOf :: Num a => Getting (Endo (Endo a)) s a -> s -> a
sumOf l = foldlOf' l (+) 0
{-# INLINE sumOf #-}
-- | Traverse over all of the targets of a 'Fold' (or 'Getter'), computing an 'Applicative' (or 'Functor')-based answer,
-- but unlike 'Control.Lens.Traversal.traverseOf' do not construct a new structure. 'traverseOf_' generalizes
-- 'Data.Foldable.traverse_' to work over any 'Fold'.
--
-- When passed a 'Getter', 'traverseOf_' can work over any 'Functor', but when passed a 'Fold', 'traverseOf_' requires
-- an 'Applicative'.
--
-- >>> traverseOf_ both putStrLn ("hello","world")
-- hello
-- world
--
-- @
-- 'Data.Foldable.traverse_' ≡ 'traverseOf_' 'folded'
-- @
--
-- @
-- 'traverseOf_' '_2' :: 'Functor' f => (c -> f r) -> (d, c) -> f ()
-- 'traverseOf_' 'Control.Lens.Prism._Left' :: 'Applicative' f => (a -> f b) -> 'Either' a c -> f ()
-- @
--
-- @
-- 'itraverseOf_' l ≡ 'traverseOf_' l '.' 'Indexed'
-- @
--
-- The rather specific signature of 'traverseOf_' allows it to be used as if the signature was any of:
--
-- @
-- 'traverseOf_' :: 'Functor' f => 'Getter' s a -> (a -> f r) -> s -> f ()
-- 'traverseOf_' :: 'Applicative' f => 'Fold' s a -> (a -> f r) -> s -> f ()
-- 'traverseOf_' :: 'Functor' f => 'Lens'' s a -> (a -> f r) -> s -> f ()
-- 'traverseOf_' :: 'Functor' f => 'Iso'' s a -> (a -> f r) -> s -> f ()
-- 'traverseOf_' :: 'Applicative' f => 'Traversal'' s a -> (a -> f r) -> s -> f ()
-- 'traverseOf_' :: 'Applicative' f => 'Prism'' s a -> (a -> f r) -> s -> f ()
-- @
traverseOf_ :: (Profunctor p, Functor f) => Accessing p (Traversed r f) s a -> p a (f r) -> s -> f ()
traverseOf_ l f = void . getTraversed #. foldMapOf l (Traversed #. f)
{-# INLINE traverseOf_ #-}
-- | Traverse over all of the targets of a 'Fold' (or 'Getter'), computing an 'Applicative' (or 'Functor')-based answer,
-- but unlike 'Control.Lens.Traversal.forOf' do not construct a new structure. 'forOf_' generalizes
-- 'Data.Foldable.for_' to work over any 'Fold'.
--
-- When passed a 'Getter', 'forOf_' can work over any 'Functor', but when passed a 'Fold', 'forOf_' requires
-- an 'Applicative'.
--
-- @
-- 'for_' ≡ 'forOf_' 'folded'
-- @
--
-- >>> forOf_ both ("hello","world") putStrLn
-- hello
-- world
--
-- The rather specific signature of 'forOf_' allows it to be used as if the signature was any of:
--
-- @
-- 'iforOf_' l s ≡ 'forOf_' l s '.' 'Indexed'
-- @
--
-- @
-- 'forOf_' :: 'Functor' f => 'Getter' s a -> s -> (a -> f r) -> f ()
-- 'forOf_' :: 'Applicative' f => 'Fold' s a -> s -> (a -> f r) -> f ()
-- 'forOf_' :: 'Functor' f => 'Lens'' s a -> s -> (a -> f r) -> f ()
-- 'forOf_' :: 'Functor' f => 'Iso'' s a -> s -> (a -> f r) -> f ()
-- 'forOf_' :: 'Applicative' f => 'Traversal'' s a -> s -> (a -> f r) -> f ()
-- 'forOf_' :: 'Applicative' f => 'Prism'' s a -> s -> (a -> f r) -> f ()
-- @
forOf_ :: (Profunctor p, Functor f) => Accessing p (Traversed r f) s a -> s -> p a (f r) -> f ()
forOf_ = flip . traverseOf_
{-# INLINE forOf_ #-}
-- | Evaluate each action in observed by a 'Fold' on a structure from left to right, ignoring the results.
--
-- @
-- 'sequenceA_' ≡ 'sequenceAOf_' 'folded'
-- @
--
-- >>> sequenceAOf_ both (putStrLn "hello",putStrLn "world")
-- hello
-- world
--
-- @
-- 'sequenceAOf_' :: 'Functor' f => 'Getter' s (f a) -> s -> f ()
-- 'sequenceAOf_' :: 'Applicative' f => 'Fold' s (f a) -> s -> f ()
-- 'sequenceAOf_' :: 'Functor' f => 'Lens'' s (f a) -> s -> f ()
-- 'sequenceAOf_' :: 'Functor' f => 'Iso'' s (f a) -> s -> f ()
-- 'sequenceAOf_' :: 'Applicative' f => 'Traversal'' s (f a) -> s -> f ()
-- 'sequenceAOf_' :: 'Applicative' f => 'Prism'' s (f a) -> s -> f ()
-- @
sequenceAOf_ :: Functor f => Getting (Traversed a f) s (f a) -> s -> f ()
sequenceAOf_ l = void . getTraversed #. foldMapOf l Traversed
{-# INLINE sequenceAOf_ #-}
-- | Map each target of a 'Fold' on a structure to a monadic action, evaluate these actions from left to right, and ignore the results.
--
-- >>> mapMOf_ both putStrLn ("hello","world")
-- hello
-- world
--
-- @
-- 'Data.Foldable.mapM_' ≡ 'mapMOf_' 'folded'
-- @
--
-- @
-- 'mapMOf_' :: 'Monad' m => 'Getter' s a -> (a -> m r) -> s -> m ()
-- 'mapMOf_' :: 'Monad' m => 'Fold' s a -> (a -> m r) -> s -> m ()
-- 'mapMOf_' :: 'Monad' m => 'Lens'' s a -> (a -> m r) -> s -> m ()
-- 'mapMOf_' :: 'Monad' m => 'Iso'' s a -> (a -> m r) -> s -> m ()
-- 'mapMOf_' :: 'Monad' m => 'Traversal'' s a -> (a -> m r) -> s -> m ()
-- 'mapMOf_' :: 'Monad' m => 'Prism'' s a -> (a -> m r) -> s -> m ()
-- @
mapMOf_ :: (Profunctor p, Monad m) => Accessing p (Sequenced r m) s a -> p a (m r) -> s -> m ()
mapMOf_ l f = liftM skip . getSequenced #. foldMapOf l (Sequenced #. f)
{-# INLINE mapMOf_ #-}
-- | 'forMOf_' is 'mapMOf_' with two of its arguments flipped.
--
-- >>> forMOf_ both ("hello","world") putStrLn
-- hello
-- world
--
-- @
-- 'Data.Foldable.forM_' ≡ 'forMOf_' 'folded'
-- @
--
-- @
-- 'forMOf_' :: 'Monad' m => 'Getter' s a -> s -> (a -> m r) -> m ()
-- 'forMOf_' :: 'Monad' m => 'Fold' s a -> s -> (a -> m r) -> m ()
-- 'forMOf_' :: 'Monad' m => 'Lens'' s a -> s -> (a -> m r) -> m ()
-- 'forMOf_' :: 'Monad' m => 'Iso'' s a -> s -> (a -> m r) -> m ()
-- 'forMOf_' :: 'Monad' m => 'Traversal'' s a -> s -> (a -> m r) -> m ()
-- 'forMOf_' :: 'Monad' m => 'Prism'' s a -> s -> (a -> m r) -> m ()
-- @
forMOf_ :: (Profunctor p, Monad m) => Accessing p (Sequenced r m) s a -> s -> p a (m r) -> m ()
forMOf_ = flip . mapMOf_
{-# INLINE forMOf_ #-}
-- | Evaluate each monadic action referenced by a 'Fold' on the structure from left to right, and ignore the results.
--
-- >>> sequenceOf_ both (putStrLn "hello",putStrLn "world")
-- hello
-- world
--
-- @
-- 'Data.Foldable.sequence_' ≡ 'sequenceOf_' 'folded'
-- @
--
-- @
-- 'sequenceOf_' :: 'Monad' m => 'Getter' s (m a) -> s -> m ()
-- 'sequenceOf_' :: 'Monad' m => 'Fold' s (m a) -> s -> m ()
-- 'sequenceOf_' :: 'Monad' m => 'Lens'' s (m a) -> s -> m ()
-- 'sequenceOf_' :: 'Monad' m => 'Iso'' s (m a) -> s -> m ()
-- 'sequenceOf_' :: 'Monad' m => 'Traversal'' s (m a) -> s -> m ()
-- 'sequenceOf_' :: 'Monad' m => 'Prism'' s (m a) -> s -> m ()
-- @
sequenceOf_ :: Monad m => Getting (Sequenced a m) s (m a) -> s -> m ()
sequenceOf_ l = liftM skip . getSequenced #. foldMapOf l Sequenced
{-# INLINE sequenceOf_ #-}
-- | The sum of a collection of actions, generalizing 'concatOf'.
--
-- >>> asumOf both ("hello","world")
-- "helloworld"
--
-- >>> asumOf each (Nothing, Just "hello", Nothing)
-- Just "hello"
--
-- @
-- 'asum' ≡ 'asumOf' 'folded'
-- @
--
-- @
-- 'asumOf' :: 'Alternative' f => 'Getter' s (f a) -> s -> f a
-- 'asumOf' :: 'Alternative' f => 'Fold' s (f a) -> s -> f a
-- 'asumOf' :: 'Alternative' f => 'Lens'' s (f a) -> s -> f a
-- 'asumOf' :: 'Alternative' f => 'Iso'' s (f a) -> s -> f a
-- 'asumOf' :: 'Alternative' f => 'Traversal'' s (f a) -> s -> f a
-- 'asumOf' :: 'Alternative' f => 'Prism'' s (f a) -> s -> f a
-- @
asumOf :: Alternative f => Getting (Endo (f a)) s (f a) -> s -> f a
asumOf l = foldrOf l (<|>) Applicative.empty
{-# INLINE asumOf #-}
-- | The sum of a collection of actions, generalizing 'concatOf'.
--
-- >>> msumOf both ("hello","world")
-- "helloworld"
--
-- >>> msumOf each (Nothing, Just "hello", Nothing)
-- Just "hello"
--
-- @
-- 'msum' ≡ 'msumOf' 'folded'
-- @
--
-- @
-- 'msumOf' :: 'MonadPlus' m => 'Getter' s (m a) -> s -> m a
-- 'msumOf' :: 'MonadPlus' m => 'Fold' s (m a) -> s -> m a
-- 'msumOf' :: 'MonadPlus' m => 'Lens'' s (m a) -> s -> m a
-- 'msumOf' :: 'MonadPlus' m => 'Iso'' s (m a) -> s -> m a
-- 'msumOf' :: 'MonadPlus' m => 'Traversal'' s (m a) -> s -> m a
-- 'msumOf' :: 'MonadPlus' m => 'Prism'' s (m a) -> s -> m a
-- @
msumOf :: MonadPlus m => Getting (Endo (m a)) s (m a) -> s -> m a
msumOf l = foldrOf l mplus mzero
{-# INLINE msumOf #-}
-- | Does the element occur anywhere within a given 'Fold' of the structure?
--
-- >>> elemOf both "hello" ("hello","world")
-- True
--
-- @
-- 'elem' ≡ 'elemOf' 'folded'
-- @
--
-- @
-- 'elemOf' :: 'Eq' a => 'Getter' s a -> a -> s -> 'Bool'
-- 'elemOf' :: 'Eq' a => 'Fold' s a -> a -> s -> 'Bool'
-- 'elemOf' :: 'Eq' a => 'Lens'' s a -> a -> s -> 'Bool'
-- 'elemOf' :: 'Eq' a => 'Iso'' s a -> a -> s -> 'Bool'
-- 'elemOf' :: 'Eq' a => 'Traversal'' s a -> a -> s -> 'Bool'
-- 'elemOf' :: 'Eq' a => 'Prism'' s a -> a -> s -> 'Bool'
-- @
elemOf :: Eq a => Getting Any s a -> a -> s -> Bool
elemOf l = anyOf l . (==)
{-# INLINE elemOf #-}
-- | Does the element not occur anywhere within a given 'Fold' of the structure?
--
-- >>> notElemOf each 'd' ('a','b','c')
-- True
--
-- >>> notElemOf each 'a' ('a','b','c')
-- False
--
-- @
-- 'notElem' ≡ 'notElemOf' 'folded'
-- @
--
-- @
-- 'notElemOf' :: 'Eq' a => 'Getter' s a -> a -> s -> 'Bool'
-- 'notElemOf' :: 'Eq' a => 'Fold' s a -> a -> s -> 'Bool'
-- 'notElemOf' :: 'Eq' a => 'Iso'' s a -> a -> s -> 'Bool'
-- 'notElemOf' :: 'Eq' a => 'Lens'' s a -> a -> s -> 'Bool'
-- 'notElemOf' :: 'Eq' a => 'Traversal'' s a -> a -> s -> 'Bool'
-- 'notElemOf' :: 'Eq' a => 'Prism'' s a -> a -> s -> 'Bool'
-- @
notElemOf :: Eq a => Getting All s a -> a -> s -> Bool
notElemOf l = allOf l . (/=)
{-# INLINE notElemOf #-}
-- | Map a function over all the targets of a 'Fold' of a container and concatenate the resulting lists.
--
-- >>> concatMapOf both (\x -> [x, x + 1]) (1,3)
-- [1,2,3,4]
--
-- @
-- 'concatMap' ≡ 'concatMapOf' 'folded'
-- @
--
-- @
-- 'concatMapOf' :: 'Getter' s a -> (a -> [r]) -> s -> [r]
-- 'concatMapOf' :: 'Fold' s a -> (a -> [r]) -> s -> [r]
-- 'concatMapOf' :: 'Lens'' s a -> (a -> [r]) -> s -> [r]
-- 'concatMapOf' :: 'Iso'' s a -> (a -> [r]) -> s -> [r]
-- 'concatMapOf' :: 'Traversal'' s a -> (a -> [r]) -> s -> [r]
-- @
concatMapOf :: Profunctor p => Accessing p [r] s a -> p a [r] -> s -> [r]
concatMapOf l ces = getConst #. l (Const #. ces)
{-# INLINE concatMapOf #-}
-- | Concatenate all of the lists targeted by a 'Fold' into a longer list.
--
-- >>> concatOf both ("pan","ama")
-- "panama"
--
-- @
-- 'concat' ≡ 'concatOf' 'folded'
-- 'concatOf' ≡ 'view'
-- @
--
-- @
-- 'concatOf' :: 'Getter' s [r] -> s -> [r]
-- 'concatOf' :: 'Fold' s [r] -> s -> [r]
-- 'concatOf' :: 'Iso'' s [r] -> s -> [r]
-- 'concatOf' :: 'Lens'' s [r] -> s -> [r]
-- 'concatOf' :: 'Traversal'' s [r] -> s -> [r]
-- @
concatOf :: Getting [r] s [r] -> s -> [r]
concatOf l = getConst #. l Const
{-# INLINE concatOf #-}
-- | Calculate the number of targets there are for a 'Fold' in a given container.
--
-- /Note:/ This can be rather inefficient for large containers and just like 'length',
-- this will not terminate for infinite folds.
--
-- @
-- 'length' ≡ 'lengthOf' 'folded'
-- @
--
-- >>> lengthOf _1 ("hello",())
-- 1
--
-- >>> lengthOf traverse [1..10]
-- 10
--
-- >>> lengthOf (traverse.traverse) [[1,2],[3,4],[5,6]]
-- 6
--
-- @
-- 'lengthOf' ('folded' '.' 'folded') :: ('Foldable' f, 'Foldable' g) => f (g a) -> 'Int'
-- @
--
-- @
-- 'lengthOf' :: 'Getter' s a -> s -> 'Int'
-- 'lengthOf' :: 'Fold' s a -> s -> 'Int'
-- 'lengthOf' :: 'Lens'' s a -> s -> 'Int'
-- 'lengthOf' :: 'Iso'' s a -> s -> 'Int'
-- 'lengthOf' :: 'Traversal'' s a -> s -> 'Int'
-- @
lengthOf :: Getting (Endo (Endo Int)) s a -> s -> Int
lengthOf l = foldlOf' l (\a _ -> a + 1) 0
{-# INLINE lengthOf #-}
-- | Perform a safe 'head' of a 'Fold' or 'Traversal' or retrieve 'Just' the result
-- from a 'Getter' or 'Lens'.
--
-- When using a 'Traversal' as a partial 'Lens', or a 'Fold' as a partial 'Getter' this can be a convenient
-- way to extract the optional value.
--
-- Note: if you get stack overflows due to this, you may want to use 'firstOf' instead, which can deal
-- more gracefully with heavily left-biased trees.
--
-- >>> Left 4 ^?_Left
-- Just 4
--
-- >>> Right 4 ^?_Left
-- Nothing
--
-- >>> "world" ^? ix 3
-- Just 'l'
--
-- >>> "world" ^? ix 20
-- Nothing
--
-- @
-- ('^?') ≡ 'flip' 'preview'
-- @
--
-- @
-- ('^?') :: s -> 'Getter' s a -> 'Maybe' a
-- ('^?') :: s -> 'Fold' s a -> 'Maybe' a
-- ('^?') :: s -> 'Lens'' s a -> 'Maybe' a
-- ('^?') :: s -> 'Iso'' s a -> 'Maybe' a
-- ('^?') :: s -> 'Traversal'' s a -> 'Maybe' a
-- @
(^?) :: s -> Getting (First a) s a -> Maybe a
s ^? l = getFirst (foldMapOf l (First #. Just) s)
{-# INLINE (^?) #-}
-- | Perform an *UNSAFE* 'head' of a 'Fold' or 'Traversal' assuming that it is there.
--
-- >>> Left 4 ^?! _Left
-- 4
--
-- >>> "world" ^?! ix 3
-- 'l'
--
-- @
-- ('^?!') :: s -> 'Getter' s a -> a
-- ('^?!') :: s -> 'Fold' s a -> a
-- ('^?!') :: s -> 'Lens'' s a -> a
-- ('^?!') :: s -> 'Iso'' s a -> a
-- ('^?!') :: s -> 'Traversal'' s a -> a
-- @
(^?!) :: s -> Getting (Endo a) s a -> a
s ^?! l = foldrOf l const (error "(^?!): empty Fold") s
{-# INLINE (^?!) #-}
-- | Retrieve the 'First' entry of a 'Fold' or 'Traversal' or retrieve 'Just' the result
-- from a 'Getter' or 'Lens'.
--
-- The answer is computed in a manner that leaks space less than @'ala' 'First' '.' 'foldMapOf'@
-- and gives you back access to the outermost 'Just' constructor more quickly, but may have worse
-- constant factors.
--
-- >>> firstOf traverse [1..10]
-- Just 1
--
-- >>> firstOf both (1,2)
-- Just 1
--
-- >>> firstOf ignored ()
-- Nothing
--
-- @
-- 'firstOf' :: 'Getter' s a -> s -> 'Maybe' a
-- 'firstOf' :: 'Fold' s a -> s -> 'Maybe' a
-- 'firstOf' :: 'Lens'' s a -> s -> 'Maybe' a
-- 'firstOf' :: 'Iso'' s a -> s -> 'Maybe' a
-- 'firstOf' :: 'Traversal'' s a -> s -> 'Maybe' a
-- @
firstOf :: Getting (Leftmost a) s a -> s -> Maybe a
firstOf l = getLeftmost . foldMapOf l LLeaf
{-# INLINE firstOf #-}
-- | Retrieve the 'Last' entry of a 'Fold' or 'Traversal' or retrieve 'Just' the result
-- from a 'Getter' or 'Lens'.
--
-- The answer is computed in a manner that leaks space less than @'ala' 'Last' '.' 'foldMapOf'@
-- and gives you back access to the outermost 'Just' constructor more quickly, but may have worse
-- constant factors.
--
-- >>> lastOf traverse [1..10]
-- Just 10
--
-- >>> lastOf both (1,2)
-- Just 2
--
-- >>> lastOf ignored ()
-- Nothing
--
-- @
-- 'lastOf' :: 'Getter' s a -> s -> 'Maybe' a
-- 'lastOf' :: 'Fold' s a -> s -> 'Maybe' a
-- 'lastOf' :: 'Lens'' s a -> s -> 'Maybe' a
-- 'lastOf' :: 'Iso'' s a -> s -> 'Maybe' a
-- 'lastOf' :: 'Traversal'' s a -> s -> 'Maybe' a
-- @
lastOf :: Getting (Rightmost a) s a -> s -> Maybe a
lastOf l = getRightmost . foldMapOf l RLeaf
{-# INLINE lastOf #-}
-- | Returns 'True' if this 'Fold' or 'Traversal' has no targets in the given container.
--
-- Note: 'nullOf' on a valid 'Iso', 'Lens' or 'Getter' should always return 'False'.
--
-- @
-- 'null' ≡ 'nullOf' 'folded'
-- @
--
-- This may be rather inefficient compared to the 'null' check of many containers.
--
-- >>> nullOf _1 (1,2)
-- False
--
-- >>> nullOf ignored ()
-- True
--
-- >>> nullOf traverse []
-- True
--
-- >>> nullOf (element 20) [1..10]
-- True
--
-- @
-- 'nullOf' ('folded' '.' '_1' '.' 'folded') :: ('Foldable' f, 'Foldable' g) => f (g a, b) -> 'Bool'
-- @
--
-- @
-- 'nullOf' :: 'Getter' s a -> s -> 'Bool'
-- 'nullOf' :: 'Fold' s a -> s -> 'Bool'
-- 'nullOf' :: 'Iso'' s a -> s -> 'Bool'
-- 'nullOf' :: 'Lens'' s a -> s -> 'Bool'
-- 'nullOf' :: 'Traversal'' s a -> s -> 'Bool'
-- @
nullOf :: Getting All s a -> s -> Bool
nullOf = hasn't
{-# INLINE nullOf #-}
-- | Returns 'True' if this 'Fold' or 'Traversal' has any targets in the given container.
--
-- A more \"conversational\" alias for this combinator is 'has'.
--
-- Note: 'notNullOf' on a valid 'Iso', 'Lens' or 'Getter' should always return 'True'.
--
-- @
-- 'null' ≡ 'notNullOf' 'folded'
-- @
--
-- This may be rather inefficient compared to the @'not' '.' 'null'@ check of many containers.
--
-- >>> notNullOf _1 (1,2)
-- True
--
-- >>> notNullOf traverse [1..10]
-- True
--
-- >>> notNullOf folded []
-- False
--
-- >>> notNullOf (element 20) [1..10]
-- False
--
-- @
-- 'notNullOf' ('folded' '.' '_1' '.' 'folded') :: ('Foldable' f, 'Foldable' g) => f (g a, b) -> 'Bool'
-- @
--
-- @
-- 'notNullOf' :: 'Getter' s a -> s -> 'Bool'
-- 'notNullOf' :: 'Fold' s a -> s -> 'Bool'
-- 'notNullOf' :: 'Iso'' s a -> s -> 'Bool'
-- 'notNullOf' :: 'Lens'' s a -> s -> 'Bool'
-- 'notNullOf' :: 'Traversal'' s a -> s -> 'Bool'
-- @
notNullOf :: Getting Any s a -> s -> Bool
notNullOf = has
{-# INLINE notNullOf #-}
-- | Obtain the maximum element (if any) targeted by a 'Fold' or 'Traversal' safely.
--
-- Note: 'maximumOf' on a valid 'Iso', 'Lens' or 'Getter' will always return 'Just' a value.
--
-- >>> maximumOf traverse [1..10]
-- Just 10
--
-- >>> maximumOf traverse []
-- Nothing
--
-- >>> maximumOf (folded.filtered even) [1,4,3,6,7,9,2]
-- Just 6
--
-- @
-- 'maximum' ≡ 'fromMaybe' ('error' \"empty\") '.' 'maximumOf' 'folded'
-- @
--
-- In the interest of efficiency, This operation has semantics more strict than strictly necessary.
-- @'rmap' 'getMax' ('foldMapOf' l 'Max')@ has lazier semantics but could leak memory.
--
-- @
-- 'maximumOf' :: 'Ord' a => 'Getter' s a -> s -> 'Maybe' a
-- 'maximumOf' :: 'Ord' a => 'Fold' s a -> s -> 'Maybe' a
-- 'maximumOf' :: 'Ord' a => 'Iso'' s a -> s -> 'Maybe' a
-- 'maximumOf' :: 'Ord' a => 'Lens'' s a -> s -> 'Maybe' a
-- 'maximumOf' :: 'Ord' a => 'Traversal'' s a -> s -> 'Maybe' a
-- @
maximumOf :: Ord a => Getting (Endo (Endo (Maybe a))) s a -> s -> Maybe a
maximumOf l = foldlOf' l mf Nothing where
mf Nothing y = Just $! y
mf (Just x) y = Just $! max x y
{-# INLINE maximumOf #-}
-- | Obtain the minimum element (if any) targeted by a 'Fold' or 'Traversal' safely.
--
-- Note: 'minimumOf' on a valid 'Iso', 'Lens' or 'Getter' will always return 'Just' a value.
--
-- >>> minimumOf traverse [1..10]
-- Just 1
--
-- >>> minimumOf traverse []
-- Nothing
--
-- >>> minimumOf (folded.filtered even) [1,4,3,6,7,9,2]
-- Just 2
--
-- @
-- 'minimum' ≡ 'Data.Maybe.fromMaybe' ('error' \"empty\") '.' 'minimumOf' 'folded'
-- @
--
-- In the interest of efficiency, This operation has semantics more strict than strictly necessary.
-- @'rmap' 'getMin' ('foldMapOf' l 'Min')@ has lazier semantics but could leak memory.
--
--
-- @
-- 'minimumOf' :: 'Ord' a => 'Getter' s a -> s -> 'Maybe' a
-- 'minimumOf' :: 'Ord' a => 'Fold' s a -> s -> 'Maybe' a
-- 'minimumOf' :: 'Ord' a => 'Iso'' s a -> s -> 'Maybe' a
-- 'minimumOf' :: 'Ord' a => 'Lens'' s a -> s -> 'Maybe' a
-- 'minimumOf' :: 'Ord' a => 'Traversal'' s a -> s -> 'Maybe' a
-- @
minimumOf :: Ord a => Getting (Endo (Endo (Maybe a))) s a -> s -> Maybe a
minimumOf l = foldlOf' l mf Nothing where
mf Nothing y = Just $! y
mf (Just x) y = Just $! min x y
{-# INLINE minimumOf #-}
-- | Obtain the maximum element (if any) targeted by a 'Fold', 'Traversal', 'Lens', 'Iso',
-- or 'Getter' according to a user supplied 'Ordering'.
--
-- >>> maximumByOf traverse (compare `on` length) ["mustard","relish","ham"]
-- Just "mustard"
--
-- In the interest of efficiency, This operation has semantics more strict than strictly necessary.
--
-- @
-- 'Data.Foldable.maximumBy' cmp ≡ 'Data.Maybe.fromMaybe' ('error' \"empty\") '.' 'maximumByOf' 'folded' cmp
-- @
--
-- @
-- 'maximumByOf' :: 'Getter' s a -> (a -> a -> 'Ordering') -> s -> 'Maybe' a
-- 'maximumByOf' :: 'Fold' s a -> (a -> a -> 'Ordering') -> s -> 'Maybe' a
-- 'maximumByOf' :: 'Iso'' s a -> (a -> a -> 'Ordering') -> s -> 'Maybe' a
-- 'maximumByOf' :: 'Lens'' s a -> (a -> a -> 'Ordering') -> s -> 'Maybe' a
-- 'maximumByOf' :: 'Traversal'' s a -> (a -> a -> 'Ordering') -> s -> 'Maybe' a
-- @
maximumByOf :: Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> Ordering) -> s -> Maybe a
maximumByOf l cmp = foldlOf' l mf Nothing where
mf Nothing y = Just $! y
mf (Just x) y = Just $! if cmp x y == GT then x else y
{-# INLINE maximumByOf #-}
-- | Obtain the minimum element (if any) targeted by a 'Fold', 'Traversal', 'Lens', 'Iso'
-- or 'Getter' according to a user supplied 'Ordering'.
--
-- In the interest of efficiency, This operation has semantics more strict than strictly necessary.
--
-- >>> minimumByOf traverse (compare `on` length) ["mustard","relish","ham"]
-- Just "ham"
--
-- @
-- 'minimumBy' cmp ≡ 'Data.Maybe.fromMaybe' ('error' \"empty\") '.' 'minimumByOf' 'folded' cmp
-- @
--
-- @
-- 'minimumByOf' :: 'Getter' s a -> (a -> a -> 'Ordering') -> s -> 'Maybe' a
-- 'minimumByOf' :: 'Fold' s a -> (a -> a -> 'Ordering') -> s -> 'Maybe' a
-- 'minimumByOf' :: 'Iso'' s a -> (a -> a -> 'Ordering') -> s -> 'Maybe' a
-- 'minimumByOf' :: 'Lens'' s a -> (a -> a -> 'Ordering') -> s -> 'Maybe' a
-- 'minimumByOf' :: 'Traversal'' s a -> (a -> a -> 'Ordering') -> s -> 'Maybe' a
-- @
minimumByOf :: Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> Ordering) -> s -> Maybe a
minimumByOf l cmp = foldlOf' l mf Nothing where
mf Nothing y = Just $! y
mf (Just x) y = Just $! if cmp x y == GT then y else x
{-# INLINE minimumByOf #-}
-- | The 'findOf' function takes a 'Lens' (or 'Getter', 'Iso', 'Fold', or 'Traversal'),
-- a predicate and a structure and returns the leftmost element of the structure
-- matching the predicate, or 'Nothing' if there is no such element.
--
-- >>> findOf each even (1,3,4,6)
-- Just 4
--
-- >>> findOf folded even [1,3,5,7]
-- Nothing
--
-- @
-- 'findOf' :: 'Getter' s a -> (a -> 'Bool') -> s -> 'Maybe' a
-- 'findOf' :: 'Fold' s a -> (a -> 'Bool') -> s -> 'Maybe' a
-- 'findOf' :: 'Iso'' s a -> (a -> 'Bool') -> s -> 'Maybe' a
-- 'findOf' :: 'Lens'' s a -> (a -> 'Bool') -> s -> 'Maybe' a
-- 'findOf' :: 'Traversal'' s a -> (a -> 'Bool') -> s -> 'Maybe' a
-- @
--
-- @
-- 'Data.Foldable.find' ≡ 'findOf' 'folded'
-- 'ifindOf' l ≡ 'findOf' l '.' 'Indexed'
-- @
--
-- A simpler version that didn't permit indexing, would be:
--
-- @
-- 'findOf' :: 'Getting' ('Endo' ('Maybe' a)) s a -> (a -> 'Bool') -> s -> 'Maybe' a
-- 'findOf' l p = 'foldrOf' l (\a y -> if p a then 'Just' a else y) 'Nothing'
-- @
findOf :: Conjoined p => Accessing p (Endo (Maybe a)) s a -> p a Bool -> s -> Maybe a
findOf l p = foldrOf l (cotabulate $ \wa y -> if cosieve p wa then Just (extract wa) else y) Nothing
{-# INLINE findOf #-}
-- | The 'findMOf' function takes a 'Lens' (or 'Getter', 'Iso', 'Fold', or 'Traversal'),
-- a monadic predicate and a structure and returns in the monad the leftmost element of the structure
-- matching the predicate, or 'Nothing' if there is no such element.
--
-- >>> findMOf each ( \x -> print ("Checking " ++ show x) >> return (even x)) (1,3,4,6)
-- "Checking 1"
-- "Checking 3"
-- "Checking 4"
-- Just 4
--
-- >>> findMOf each ( \x -> print ("Checking " ++ show x) >> return (even x)) (1,3,5,7)
-- "Checking 1"
-- "Checking 3"
-- "Checking 5"
-- "Checking 7"
-- Nothing
--
-- @
-- 'findMOf' :: ('Monad' m, 'Getter' s a) -> (a -> m 'Bool') -> s -> m ('Maybe' a)
-- 'findMOf' :: ('Monad' m, 'Fold' s a) -> (a -> m 'Bool') -> s -> m ('Maybe' a)
-- 'findMOf' :: ('Monad' m, 'Iso'' s a) -> (a -> m 'Bool') -> s -> m ('Maybe' a)
-- 'findMOf' :: ('Monad' m, 'Lens'' s a) -> (a -> m 'Bool') -> s -> m ('Maybe' a)
-- 'findMOf' :: ('Monad' m, 'Traversal'' s a) -> (a -> m 'Bool') -> s -> m ('Maybe' a)
-- @
--
-- @
-- 'findMOf' 'folded' :: (Monad m, Foldable f) => (a -> m Bool) -> f a -> m (Maybe a)
-- 'ifindMOf' l ≡ 'findMOf' l '.' 'Indexed'
-- @
--
-- A simpler version that didn't permit indexing, would be:
--
-- @
-- 'findMOf' :: Monad m => 'Getting' ('Endo' (m ('Maybe' a))) s a -> (a -> m 'Bool') -> s -> m ('Maybe' a)
-- 'findMOf' l p = 'foldrOf' l (\a y -> p a >>= \x -> if x then return ('Just' a) else y) $ return 'Nothing'
-- @
findMOf :: (Monad m, Conjoined p) => Accessing p (Endo (m (Maybe a))) s a -> p a (m Bool) -> s -> m (Maybe a)
findMOf l p = foldrOf l (cotabulate $ \wa y -> cosieve p wa >>= \r -> if r then return (Just (extract wa)) else y) $ return Nothing
{-# INLINE findMOf #-}
-- | A variant of 'foldrOf' that has no base case and thus may only be applied
-- to lenses and structures such that the 'Lens' views at least one element of
-- the structure.
--
-- >>> foldr1Of each (+) (1,2,3,4)
-- 10
--
-- @
-- 'foldr1Of' l f ≡ 'Prelude.foldr1' f '.' 'toListOf' l
-- 'Data.Foldable.foldr1' ≡ 'foldr1Of' 'folded'
-- @
--
-- @
-- 'foldr1Of' :: 'Getter' s a -> (a -> a -> a) -> s -> a
-- 'foldr1Of' :: 'Fold' s a -> (a -> a -> a) -> s -> a
-- 'foldr1Of' :: 'Iso'' s a -> (a -> a -> a) -> s -> a
-- 'foldr1Of' :: 'Lens'' s a -> (a -> a -> a) -> s -> a
-- 'foldr1Of' :: 'Traversal'' s a -> (a -> a -> a) -> s -> a
-- @
foldr1Of :: Getting (Endo (Maybe a)) s a -> (a -> a -> a) -> s -> a
foldr1Of l f xs = fromMaybe (error "foldr1Of: empty structure")
(foldrOf l mf Nothing xs) where
mf x my = Just $ case my of
Nothing -> x
Just y -> f x y
{-# INLINE foldr1Of #-}
-- | A variant of 'foldlOf' that has no base case and thus may only be applied to lenses and structures such
-- that the 'Lens' views at least one element of the structure.
--
-- >>> foldl1Of each (+) (1,2,3,4)
-- 10
--
-- @
-- 'foldl1Of' l f ≡ 'Prelude.foldl1' f '.' 'toListOf' l
-- 'Data.Foldable.foldl1' ≡ 'foldl1Of' 'folded'
-- @
--
-- @
-- 'foldl1Of' :: 'Getter' s a -> (a -> a -> a) -> s -> a
-- 'foldl1Of' :: 'Fold' s a -> (a -> a -> a) -> s -> a
-- 'foldl1Of' :: 'Iso'' s a -> (a -> a -> a) -> s -> a
-- 'foldl1Of' :: 'Lens'' s a -> (a -> a -> a) -> s -> a
-- 'foldl1Of' :: 'Traversal'' s a -> (a -> a -> a) -> s -> a
-- @
foldl1Of :: Getting (Dual (Endo (Maybe a))) s a -> (a -> a -> a) -> s -> a
foldl1Of l f xs = fromMaybe (error "foldl1Of: empty structure") (foldlOf l mf Nothing xs) where
mf mx y = Just $ case mx of
Nothing -> y
Just x -> f x y
{-# INLINE foldl1Of #-}
-- | Strictly fold right over the elements of a structure.
--
-- @
-- 'Data.Foldable.foldr'' ≡ 'foldrOf'' 'folded'
-- @
--
-- @
-- 'foldrOf'' :: 'Getter' s a -> (a -> r -> r) -> r -> s -> r
-- 'foldrOf'' :: 'Fold' s a -> (a -> r -> r) -> r -> s -> r
-- 'foldrOf'' :: 'Iso'' s a -> (a -> r -> r) -> r -> s -> r
-- 'foldrOf'' :: 'Lens'' s a -> (a -> r -> r) -> r -> s -> r
-- 'foldrOf'' :: 'Traversal'' s a -> (a -> r -> r) -> r -> s -> r
-- @
foldrOf' :: Getting (Dual (Endo (Endo r))) s a -> (a -> r -> r) -> r -> s -> r
foldrOf' l f z0 xs = foldlOf l f' (Endo id) xs `appEndo` z0
where f' (Endo k) x = Endo $ \ z -> k $! f x z
{-# INLINE foldrOf' #-}
-- | Fold over the elements of a structure, associating to the left, but strictly.
--
-- @
-- 'Data.Foldable.foldl'' ≡ 'foldlOf'' 'folded'
-- @
--
-- @
-- 'foldlOf'' :: 'Getter' s a -> (r -> a -> r) -> r -> s -> r
-- 'foldlOf'' :: 'Fold' s a -> (r -> a -> r) -> r -> s -> r
-- 'foldlOf'' :: 'Iso'' s a -> (r -> a -> r) -> r -> s -> r
-- 'foldlOf'' :: 'Lens'' s a -> (r -> a -> r) -> r -> s -> r
-- 'foldlOf'' :: 'Traversal'' s a -> (r -> a -> r) -> r -> s -> r
-- @
foldlOf' :: Getting (Endo (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
foldlOf' l f z0 xs = foldrOf l f' (Endo id) xs `appEndo` z0
where f' x (Endo k) = Endo $ \z -> k $! f z x
{-# INLINE foldlOf' #-}
-- | A variant of 'foldrOf'' that has no base case and thus may only be applied
-- to folds and structures such that the fold views at least one element of the
-- structure.
--
-- @
-- 'foldr1Of' l f ≡ 'Prelude.foldr1' f '.' 'toListOf' l
-- @
--
-- @
-- 'foldr1Of'' :: 'Getter' s a -> (a -> a -> a) -> s -> a
-- 'foldr1Of'' :: 'Fold' s a -> (a -> a -> a) -> s -> a
-- 'foldr1Of'' :: 'Iso'' s a -> (a -> a -> a) -> s -> a
-- 'foldr1Of'' :: 'Lens'' s a -> (a -> a -> a) -> s -> a
-- 'foldr1Of'' :: 'Traversal'' s a -> (a -> a -> a) -> s -> a
-- @
foldr1Of' :: Getting (Dual (Endo (Endo (Maybe a)))) s a -> (a -> a -> a) -> s -> a
foldr1Of' l f xs = fromMaybe (error "foldr1Of': empty structure") (foldrOf' l mf Nothing xs) where
mf x Nothing = Just $! x
mf x (Just y) = Just $! f x y
{-# INLINE foldr1Of' #-}
-- | A variant of 'foldlOf'' that has no base case and thus may only be applied
-- to folds and structures such that the fold views at least one element of
-- the structure.
--
-- @
-- 'foldl1Of'' l f ≡ 'Data.List.foldl1'' f '.' 'toListOf' l
-- @
--
-- @
-- 'foldl1Of'' :: 'Getter' s a -> (a -> a -> a) -> s -> a
-- 'foldl1Of'' :: 'Fold' s a -> (a -> a -> a) -> s -> a
-- 'foldl1Of'' :: 'Iso'' s a -> (a -> a -> a) -> s -> a
-- 'foldl1Of'' :: 'Lens'' s a -> (a -> a -> a) -> s -> a
-- 'foldl1Of'' :: 'Traversal'' s a -> (a -> a -> a) -> s -> a
-- @
foldl1Of' :: Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> a) -> s -> a
foldl1Of' l f xs = fromMaybe (error "foldl1Of': empty structure") (foldlOf' l mf Nothing xs) where
mf Nothing y = Just $! y
mf (Just x) y = Just $! f x y
{-# INLINE foldl1Of' #-}
-- | Monadic fold over the elements of a structure, associating to the right,
-- i.e. from right to left.
--
-- @
-- 'Data.Foldable.foldrM' ≡ 'foldrMOf' 'folded'
-- @
--
-- @
-- 'foldrMOf' :: 'Monad' m => 'Getter' s a -> (a -> r -> m r) -> r -> s -> m r
-- 'foldrMOf' :: 'Monad' m => 'Fold' s a -> (a -> r -> m r) -> r -> s -> m r
-- 'foldrMOf' :: 'Monad' m => 'Iso'' s a -> (a -> r -> m r) -> r -> s -> m r
-- 'foldrMOf' :: 'Monad' m => 'Lens'' s a -> (a -> r -> m r) -> r -> s -> m r
-- 'foldrMOf' :: 'Monad' m => 'Traversal'' s a -> (a -> r -> m r) -> r -> s -> m r
-- @
foldrMOf :: Monad m
=> Getting (Dual (Endo (r -> m r))) s a
-> (a -> r -> m r) -> r -> s -> m r
foldrMOf l f z0 xs = foldlOf l f' return xs z0
where f' k x z = f x z >>= k
{-# INLINE foldrMOf #-}
-- | Monadic fold over the elements of a structure, associating to the left,
-- i.e. from left to right.
--
-- @
-- 'Data.Foldable.foldlM' ≡ 'foldlMOf' 'folded'
-- @
--
-- @
-- 'foldlMOf' :: 'Monad' m => 'Getter' s a -> (r -> a -> m r) -> r -> s -> m r
-- 'foldlMOf' :: 'Monad' m => 'Fold' s a -> (r -> a -> m r) -> r -> s -> m r
-- 'foldlMOf' :: 'Monad' m => 'Iso'' s a -> (r -> a -> m r) -> r -> s -> m r
-- 'foldlMOf' :: 'Monad' m => 'Lens'' s a -> (r -> a -> m r) -> r -> s -> m r
-- 'foldlMOf' :: 'Monad' m => 'Traversal'' s a -> (r -> a -> m r) -> r -> s -> m r
-- @
foldlMOf :: Monad m
=> Getting (Endo (r -> m r)) s a
-> (r -> a -> m r) -> r -> s -> m r
foldlMOf l f z0 xs = foldrOf l f' return xs z0
where f' x k z = f z x >>= k
{-# INLINE foldlMOf #-}
-- | Check to see if this 'Fold' or 'Traversal' matches 1 or more entries.
--
-- >>> has (element 0) []
-- False
--
-- >>> has _Left (Left 12)
-- True
--
-- >>> has _Right (Left 12)
-- False
--
-- This will always return 'True' for a 'Lens' or 'Getter'.
--
-- >>> has _1 ("hello","world")
-- True
--
-- @
-- 'has' :: 'Getter' s a -> s -> 'Bool'
-- 'has' :: 'Fold' s a -> s -> 'Bool'
-- 'has' :: 'Iso'' s a -> s -> 'Bool'
-- 'has' :: 'Lens'' s a -> s -> 'Bool'
-- 'has' :: 'Traversal'' s a -> s -> 'Bool'
-- @
has :: Getting Any s a -> s -> Bool
has l = getAny #. foldMapOf l (\_ -> Any True)
{-# INLINE has #-}
-- | Check to see if this 'Fold' or 'Traversal' has no matches.
--
-- >>> hasn't _Left (Right 12)
-- True
--
-- >>> hasn't _Left (Left 12)
-- False
hasn't :: Getting All s a -> s -> Bool
hasn't l = getAll #. foldMapOf l (\_ -> All False)
{-# INLINE hasn't #-}
------------------------------------------------------------------------------
-- Pre
------------------------------------------------------------------------------
-- | This converts a 'Fold' to a 'IndexPreservingGetter' that returns the first element, if it
-- exists, as a 'Maybe'.
--
-- @
-- 'pre' :: 'Getter' s a -> 'IndexPreservingGetter' s ('Maybe' a)
-- 'pre' :: 'Fold' s a -> 'IndexPreservingGetter' s ('Maybe' a)
-- 'pre' :: 'Traversal'' s a -> 'IndexPreservingGetter' s ('Maybe' a)
-- 'pre' :: 'Lens'' s a -> 'IndexPreservingGetter' s ('Maybe' a)
-- 'pre' :: 'Iso'' s a -> 'IndexPreservingGetter' s ('Maybe' a)
-- 'pre' :: 'Prism'' s a -> 'IndexPreservingGetter' s ('Maybe' a)
-- @
pre :: Getting (First a) s a -> IndexPreservingGetter s (Maybe a)
pre l = dimap (getFirst . getConst #. l (Const #. First #. Just)) coerce
{-# INLINE pre #-}
-- | This converts an 'IndexedFold' to an 'IndexPreservingGetter' that returns the first index
-- and element, if they exist, as a 'Maybe'.
--
-- @
-- 'ipre' :: 'IndexedGetter' i s a -> 'IndexPreservingGetter' s ('Maybe' (i, a))
-- 'ipre' :: 'IndexedFold' i s a -> 'IndexPreservingGetter' s ('Maybe' (i, a))
-- 'ipre' :: 'IndexedTraversal'' i s a -> 'IndexPreservingGetter' s ('Maybe' (i, a))
-- 'ipre' :: 'IndexedLens'' i s a -> 'IndexPreservingGetter' s ('Maybe' (i, a))
-- @
ipre :: IndexedGetting i (First (i, a)) s a -> IndexPreservingGetter s (Maybe (i, a))
ipre l = dimap (getFirst . getConst #. l (Indexed $ \i a -> Const (First (Just (i, a))))) coerce
{-# INLINE ipre #-}
------------------------------------------------------------------------------
-- Preview
------------------------------------------------------------------------------
-- | Retrieve the first value targeted by a 'Fold' or 'Traversal' (or 'Just' the result
-- from a 'Getter' or 'Lens'). See also ('^?').
--
-- @
-- 'Data.Maybe.listToMaybe' '.' 'toList' ≡ 'preview' 'folded'
-- @
--
-- This is usually applied in the 'Control.Monad.Reader.Reader'
-- 'Control.Monad.Monad' @(->) s@.
--
-- @
-- 'preview' = 'view' '.' 'pre'
-- @
--
-- @
-- 'preview' :: 'Getter' s a -> s -> 'Maybe' a
-- 'preview' :: 'Fold' s a -> s -> 'Maybe' a
-- 'preview' :: 'Lens'' s a -> s -> 'Maybe' a
-- 'preview' :: 'Iso'' s a -> s -> 'Maybe' a
-- 'preview' :: 'Traversal'' s a -> s -> 'Maybe' a
-- @
--
-- However, it may be useful to think of its full generality when working with
-- a 'Control.Monad.Monad' transformer stack:
--
-- @
-- 'preview' :: 'MonadReader' s m => 'Getter' s a -> m ('Maybe' a)
-- 'preview' :: 'MonadReader' s m => 'Fold' s a -> m ('Maybe' a)
-- 'preview' :: 'MonadReader' s m => 'Lens'' s a -> m ('Maybe' a)
-- 'preview' :: 'MonadReader' s m => 'Iso'' s a -> m ('Maybe' a)
-- 'preview' :: 'MonadReader' s m => 'Traversal'' s a -> m ('Maybe' a)
-- @
preview :: MonadReader s m => Getting (First a) s a -> m (Maybe a)
preview l = asks (getFirst #. foldMapOf l (First #. Just))
{-# INLINE preview #-}
-- | Retrieve the first index and value targeted by a 'Fold' or 'Traversal' (or 'Just' the result
-- from a 'Getter' or 'Lens'). See also ('^@?').
--
-- @
-- 'ipreview' = 'view' '.' 'ipre'
-- @
--
-- This is usually applied in the 'Control.Monad.Reader.Reader'
-- 'Control.Monad.Monad' @(->) s@.
--
-- @
-- 'ipreview' :: 'IndexedGetter' i s a -> s -> 'Maybe' (i, a)
-- 'ipreview' :: 'IndexedFold' i s a -> s -> 'Maybe' (i, a)
-- 'ipreview' :: 'IndexedLens'' i s a -> s -> 'Maybe' (i, a)
-- 'ipreview' :: 'IndexedTraversal'' i s a -> s -> 'Maybe' (i, a)
-- @
--
-- However, it may be useful to think of its full generality when working with
-- a 'Control.Monad.Monad' transformer stack:
--
-- @
-- 'ipreview' :: 'MonadReader' s m => 'IndexedGetter' s a -> m ('Maybe' (i, a))
-- 'ipreview' :: 'MonadReader' s m => 'IndexedFold' s a -> m ('Maybe' (i, a))
-- 'ipreview' :: 'MonadReader' s m => 'IndexedLens'' s a -> m ('Maybe' (i, a))
-- 'ipreview' :: 'MonadReader' s m => 'IndexedTraversal'' s a -> m ('Maybe' (i, a))
-- @
ipreview :: MonadReader s m => IndexedGetting i (First (i, a)) s a -> m (Maybe (i, a))
ipreview l = asks (getFirst #. ifoldMapOf l (\i a -> First (Just (i, a))))
{-# INLINE ipreview #-}
-- | Retrieve a function of the first value targeted by a 'Fold' or
-- 'Traversal' (or 'Just' the result from a 'Getter' or 'Lens').
--
-- This is usually applied in the 'Control.Monad.Reader.Reader'
-- 'Control.Monad.Monad' @(->) s@.
-- @
-- 'previews' = 'views' '.' 'pre'
-- @
--
-- @
-- 'previews' :: 'Getter' s a -> (a -> r) -> s -> 'Maybe' r
-- 'previews' :: 'Fold' s a -> (a -> r) -> s -> 'Maybe' r
-- 'previews' :: 'Lens'' s a -> (a -> r) -> s -> 'Maybe' r
-- 'previews' :: 'Iso'' s a -> (a -> r) -> s -> 'Maybe' r
-- 'previews' :: 'Traversal'' s a -> (a -> r) -> s -> 'Maybe' r
-- @
--
-- However, it may be useful to think of its full generality when working with
-- a 'Monad' transformer stack:
--
-- @
-- 'previews' :: 'MonadReader' s m => 'Getter' s a -> (a -> r) -> m ('Maybe' r)
-- 'previews' :: 'MonadReader' s m => 'Fold' s a -> (a -> r) -> m ('Maybe' r)
-- 'previews' :: 'MonadReader' s m => 'Lens'' s a -> (a -> r) -> m ('Maybe' r)
-- 'previews' :: 'MonadReader' s m => 'Iso'' s a -> (a -> r) -> m ('Maybe' r)
-- 'previews' :: 'MonadReader' s m => 'Traversal'' s a -> (a -> r) -> m ('Maybe' r)
-- @
previews :: MonadReader s m => Getting (First r) s a -> (a -> r) -> m (Maybe r)
previews l f = asks (getFirst . foldMapOf l (First #. Just . f))
{-# INLINE previews #-}
-- | Retrieve a function of the first index and value targeted by an 'IndexedFold' or
-- 'IndexedTraversal' (or 'Just' the result from an 'IndexedGetter' or 'IndexedLens').
-- See also ('^@?').
--
-- @
-- 'ipreviews' = 'views' '.' 'ipre'
-- @
--
-- This is usually applied in the 'Control.Monad.Reader.Reader'
-- 'Control.Monad.Monad' @(->) s@.
--
-- @
-- 'ipreviews' :: 'IndexedGetter' i s a -> (i -> a -> r) -> s -> 'Maybe' r
-- 'ipreviews' :: 'IndexedFold' i s a -> (i -> a -> r) -> s -> 'Maybe' r
-- 'ipreviews' :: 'IndexedLens'' i s a -> (i -> a -> r) -> s -> 'Maybe' r
-- 'ipreviews' :: 'IndexedTraversal'' i s a -> (i -> a -> r) -> s -> 'Maybe' r
-- @
--
-- However, it may be useful to think of its full generality when working with
-- a 'Control.Monad.Monad' transformer stack:
--
-- @
-- 'ipreviews' :: 'MonadReader' s m => 'IndexedGetter' i s a -> (i -> a -> r) -> m ('Maybe' r)
-- 'ipreviews' :: 'MonadReader' s m => 'IndexedFold' i s a -> (i -> a -> r) -> m ('Maybe' r)
-- 'ipreviews' :: 'MonadReader' s m => 'IndexedLens'' i s a -> (i -> a -> r) -> m ('Maybe' r)
-- 'ipreviews' :: 'MonadReader' s m => 'IndexedTraversal'' i s a -> (i -> a -> r) -> m ('Maybe' r)
-- @
ipreviews :: MonadReader s m => IndexedGetting i (First r) s a -> (i -> a -> r) -> m (Maybe r)
ipreviews l f = asks (getFirst . ifoldMapOf l (\i -> First #. Just . f i))
{-# INLINE ipreviews #-}
------------------------------------------------------------------------------
-- Preuse
------------------------------------------------------------------------------
-- | Retrieve the first value targeted by a 'Fold' or 'Traversal' (or 'Just' the result
-- from a 'Getter' or 'Lens') into the current state.
--
-- @
-- 'preuse' = 'use' '.' 'pre'
-- @
--
-- @
-- 'preuse' :: 'MonadState' s m => 'Getter' s a -> m ('Maybe' a)
-- 'preuse' :: 'MonadState' s m => 'Fold' s a -> m ('Maybe' a)
-- 'preuse' :: 'MonadState' s m => 'Lens'' s a -> m ('Maybe' a)
-- 'preuse' :: 'MonadState' s m => 'Iso'' s a -> m ('Maybe' a)
-- 'preuse' :: 'MonadState' s m => 'Traversal'' s a -> m ('Maybe' a)
-- @
preuse :: MonadState s m => Getting (First a) s a -> m (Maybe a)
preuse l = gets (preview l)
{-# INLINE preuse #-}
-- | Retrieve the first index and value targeted by an 'IndexedFold' or 'IndexedTraversal' (or 'Just' the index
-- and result from an 'IndexedGetter' or 'IndexedLens') into the current state.
--
-- @
-- 'ipreuse' = 'use' '.' 'ipre'
-- @
--
-- @
-- 'ipreuse' :: 'MonadState' s m => 'IndexedGetter' i s a -> m ('Maybe' (i, a))
-- 'ipreuse' :: 'MonadState' s m => 'IndexedFold' i s a -> m ('Maybe' (i, a))
-- 'ipreuse' :: 'MonadState' s m => 'IndexedLens'' i s a -> m ('Maybe' (i, a))
-- 'ipreuse' :: 'MonadState' s m => 'IndexedTraversal'' i s a -> m ('Maybe' (i, a))
-- @
ipreuse :: MonadState s m => IndexedGetting i (First (i, a)) s a -> m (Maybe (i, a))
ipreuse l = gets (ipreview l)
{-# INLINE ipreuse #-}
-- | Retrieve a function of the first value targeted by a 'Fold' or
-- 'Traversal' (or 'Just' the result from a 'Getter' or 'Lens') into the current state.
--
-- @
-- 'preuses' = 'uses' '.' 'pre'
-- @
--
-- @
-- 'preuses' :: 'MonadState' s m => 'Getter' s a -> (a -> r) -> m ('Maybe' r)
-- 'preuses' :: 'MonadState' s m => 'Fold' s a -> (a -> r) -> m ('Maybe' r)
-- 'preuses' :: 'MonadState' s m => 'Lens'' s a -> (a -> r) -> m ('Maybe' r)
-- 'preuses' :: 'MonadState' s m => 'Iso'' s a -> (a -> r) -> m ('Maybe' r)
-- 'preuses' :: 'MonadState' s m => 'Traversal'' s a -> (a -> r) -> m ('Maybe' r)
-- @
preuses :: MonadState s m => Getting (First r) s a -> (a -> r) -> m (Maybe r)
preuses l f = gets (previews l f)
{-# INLINE preuses #-}
-- | Retrieve a function of the first index and value targeted by an 'IndexedFold' or
-- 'IndexedTraversal' (or a function of 'Just' the index and result from an 'IndexedGetter'
-- or 'IndexedLens') into the current state.
--
-- @
-- 'ipreuses' = 'uses' '.' 'ipre'
-- @
--
-- @
-- 'ipreuses' :: 'MonadState' s m => 'IndexedGetter' i s a -> (i -> a -> r) -> m ('Maybe' r)
-- 'ipreuses' :: 'MonadState' s m => 'IndexedFold' i s a -> (i -> a -> r) -> m ('Maybe' r)
-- 'ipreuses' :: 'MonadState' s m => 'IndexedLens'' i s a -> (i -> a -> r) -> m ('Maybe' r)
-- 'ipreuses' :: 'MonadState' s m => 'IndexedTraversal'' i s a -> (i -> a -> r) -> m ('Maybe' r)
-- @
ipreuses :: MonadState s m => IndexedGetting i (First r) s a -> (i -> a -> r) -> m (Maybe r)
ipreuses l f = gets (ipreviews l f)
{-# INLINE ipreuses #-}
------------------------------------------------------------------------------
-- Profunctors
------------------------------------------------------------------------------
-- | This allows you to 'Control.Traversable.traverse' the elements of a pretty much any 'LensLike' construction in the opposite order.
--
-- This will preserve indexes on 'Indexed' types and will give you the elements of a (finite) 'Fold' or 'Traversal' in the opposite order.
--
-- This has no practical impact on a 'Getter', 'Setter', 'Lens' or 'Iso'.
--
-- /NB:/ To write back through an 'Iso', you want to use 'Control.Lens.Isomorphic.from'.
-- Similarly, to write back through an 'Prism', you want to use 'Control.Lens.Review.re'.
backwards :: (Profunctor p, Profunctor q) => Optical p q (Backwards f) s t a b -> Optical p q f s t a b
backwards l f = forwards #. l (Backwards #. f)
{-# INLINE backwards #-}
------------------------------------------------------------------------------
-- Indexed Folds
------------------------------------------------------------------------------
-- | Fold an 'IndexedFold' or 'IndexedTraversal' by mapping indices and values to an arbitrary 'Monoid' with access
-- to the @i@.
--
-- When you don't need access to the index then 'foldMapOf' is more flexible in what it accepts.
--
-- @
-- 'foldMapOf' l ≡ 'ifoldMapOf' l '.' 'const'
-- @
--
-- @
-- 'ifoldMapOf' :: 'IndexedGetter' i s a -> (i -> a -> m) -> s -> m
-- 'ifoldMapOf' :: 'Monoid' m => 'IndexedFold' i s a -> (i -> a -> m) -> s -> m
-- 'ifoldMapOf' :: 'IndexedLens'' i s a -> (i -> a -> m) -> s -> m
-- 'ifoldMapOf' :: 'Monoid' m => 'IndexedTraversal'' i s a -> (i -> a -> m) -> s -> m
-- @
--
ifoldMapOf :: IndexedGetting i m s a -> (i -> a -> m) -> s -> m
ifoldMapOf l = foldMapOf l .# Indexed
{-# INLINE ifoldMapOf #-}
-- | Right-associative fold of parts of a structure that are viewed through an 'IndexedFold' or 'IndexedTraversal' with
-- access to the @i@.
--
-- When you don't need access to the index then 'foldrOf' is more flexible in what it accepts.
--
-- @
-- 'foldrOf' l ≡ 'ifoldrOf' l '.' 'const'
-- @
--
-- @
-- 'ifoldrOf' :: 'IndexedGetter' i s a -> (i -> a -> r -> r) -> r -> s -> r
-- 'ifoldrOf' :: 'IndexedFold' i s a -> (i -> a -> r -> r) -> r -> s -> r
-- 'ifoldrOf' :: 'IndexedLens'' i s a -> (i -> a -> r -> r) -> r -> s -> r
-- 'ifoldrOf' :: 'IndexedTraversal'' i s a -> (i -> a -> r -> r) -> r -> s -> r
-- @
ifoldrOf :: IndexedGetting i (Endo r) s a -> (i -> a -> r -> r) -> r -> s -> r
ifoldrOf l = foldrOf l .# Indexed
{-# INLINE ifoldrOf #-}
-- | Left-associative fold of the parts of a structure that are viewed through an 'IndexedFold' or 'IndexedTraversal' with
-- access to the @i@.
--
-- When you don't need access to the index then 'foldlOf' is more flexible in what it accepts.
--
-- @
-- 'foldlOf' l ≡ 'ifoldlOf' l '.' 'const'
-- @
--
-- @
-- 'ifoldlOf' :: 'IndexedGetter' i s a -> (i -> r -> a -> r) -> r -> s -> r
-- 'ifoldlOf' :: 'IndexedFold' i s a -> (i -> r -> a -> r) -> r -> s -> r
-- 'ifoldlOf' :: 'IndexedLens'' i s a -> (i -> r -> a -> r) -> r -> s -> r
-- 'ifoldlOf' :: 'IndexedTraversal'' i s a -> (i -> r -> a -> r) -> r -> s -> r
-- @
ifoldlOf :: IndexedGetting i (Dual (Endo r)) s a -> (i -> r -> a -> r) -> r -> s -> r
ifoldlOf l f z = (flip appEndo z .# getDual) `rmap` ifoldMapOf l (\i -> Dual #. Endo #. flip (f i))
{-# INLINE ifoldlOf #-}
-- | Return whether or not any element viewed through an 'IndexedFold' or 'IndexedTraversal'
-- satisfy a predicate, with access to the @i@.
--
-- When you don't need access to the index then 'anyOf' is more flexible in what it accepts.
--
-- @
-- 'anyOf' l ≡ 'ianyOf' l '.' 'const'
-- @
--
-- @
-- 'ianyOf' :: 'IndexedGetter' i s a -> (i -> a -> 'Bool') -> s -> 'Bool'
-- 'ianyOf' :: 'IndexedFold' i s a -> (i -> a -> 'Bool') -> s -> 'Bool'
-- 'ianyOf' :: 'IndexedLens'' i s a -> (i -> a -> 'Bool') -> s -> 'Bool'
-- 'ianyOf' :: 'IndexedTraversal'' i s a -> (i -> a -> 'Bool') -> s -> 'Bool'
-- @
ianyOf :: IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
ianyOf l = anyOf l .# Indexed
{-# INLINE ianyOf #-}
-- | Return whether or not all elements viewed through an 'IndexedFold' or 'IndexedTraversal'
-- satisfy a predicate, with access to the @i@.
--
-- When you don't need access to the index then 'allOf' is more flexible in what it accepts.
--
-- @
-- 'allOf' l ≡ 'iallOf' l '.' 'const'
-- @
--
-- @
-- 'iallOf' :: 'IndexedGetter' i s a -> (i -> a -> 'Bool') -> s -> 'Bool'
-- 'iallOf' :: 'IndexedFold' i s a -> (i -> a -> 'Bool') -> s -> 'Bool'
-- 'iallOf' :: 'IndexedLens'' i s a -> (i -> a -> 'Bool') -> s -> 'Bool'
-- 'iallOf' :: 'IndexedTraversal'' i s a -> (i -> a -> 'Bool') -> s -> 'Bool'
-- @
iallOf :: IndexedGetting i All s a -> (i -> a -> Bool) -> s -> Bool
iallOf l = allOf l .# Indexed
{-# INLINE iallOf #-}
-- | Return whether or not none of the elements viewed through an 'IndexedFold' or 'IndexedTraversal'
-- satisfy a predicate, with access to the @i@.
--
-- When you don't need access to the index then 'noneOf' is more flexible in what it accepts.
--
-- @
-- 'noneOf' l ≡ 'inoneOf' l '.' 'const'
-- @
--
-- @
-- 'inoneOf' :: 'IndexedGetter' i s a -> (i -> a -> 'Bool') -> s -> 'Bool'
-- 'inoneOf' :: 'IndexedFold' i s a -> (i -> a -> 'Bool') -> s -> 'Bool'
-- 'inoneOf' :: 'IndexedLens'' i s a -> (i -> a -> 'Bool') -> s -> 'Bool'
-- 'inoneOf' :: 'IndexedTraversal'' i s a -> (i -> a -> 'Bool') -> s -> 'Bool'
-- @
inoneOf :: IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
inoneOf l = noneOf l .# Indexed
{-# INLINE inoneOf #-}
-- | Traverse the targets of an 'IndexedFold' or 'IndexedTraversal' with access to the @i@, discarding the results.
--
-- When you don't need access to the index then 'traverseOf_' is more flexible in what it accepts.
--
-- @
-- 'traverseOf_' l ≡ 'Control.Lens.Traversal.itraverseOf' l '.' 'const'
-- @
--
-- @
-- 'itraverseOf_' :: 'Functor' f => 'IndexedGetter' i s a -> (i -> a -> f r) -> s -> f ()
-- 'itraverseOf_' :: 'Applicative' f => 'IndexedFold' i s a -> (i -> a -> f r) -> s -> f ()
-- 'itraverseOf_' :: 'Functor' f => 'IndexedLens'' i s a -> (i -> a -> f r) -> s -> f ()
-- 'itraverseOf_' :: 'Applicative' f => 'IndexedTraversal'' i s a -> (i -> a -> f r) -> s -> f ()
-- @
itraverseOf_ :: Functor f => IndexedGetting i (Traversed r f) s a -> (i -> a -> f r) -> s -> f ()
itraverseOf_ l = traverseOf_ l .# Indexed
{-# INLINE itraverseOf_ #-}
-- | Traverse the targets of an 'IndexedFold' or 'IndexedTraversal' with access to the index, discarding the results
-- (with the arguments flipped).
--
-- @
-- 'iforOf_' ≡ 'flip' '.' 'itraverseOf_'
-- @
--
-- When you don't need access to the index then 'forOf_' is more flexible in what it accepts.
--
-- @
-- 'forOf_' l a ≡ 'iforOf_' l a '.' 'const'
-- @
--
-- @
-- 'iforOf_' :: 'Functor' f => 'IndexedGetter' i s a -> s -> (i -> a -> f r) -> f ()
-- 'iforOf_' :: 'Applicative' f => 'IndexedFold' i s a -> s -> (i -> a -> f r) -> f ()
-- 'iforOf_' :: 'Functor' f => 'IndexedLens'' i s a -> s -> (i -> a -> f r) -> f ()
-- 'iforOf_' :: 'Applicative' f => 'IndexedTraversal'' i s a -> s -> (i -> a -> f r) -> f ()
-- @
iforOf_ :: Functor f => IndexedGetting i (Traversed r f) s a -> s -> (i -> a -> f r) -> f ()
iforOf_ = flip . itraverseOf_
{-# INLINE iforOf_ #-}
-- | Run monadic actions for each target of an 'IndexedFold' or 'IndexedTraversal' with access to the index,
-- discarding the results.
--
-- When you don't need access to the index then 'mapMOf_' is more flexible in what it accepts.
--
-- @
-- 'mapMOf_' l ≡ 'Control.Lens.Setter.imapMOf' l '.' 'const'
-- @
--
-- @
-- 'imapMOf_' :: 'Monad' m => 'IndexedGetter' i s a -> (i -> a -> m r) -> s -> m ()
-- 'imapMOf_' :: 'Monad' m => 'IndexedFold' i s a -> (i -> a -> m r) -> s -> m ()
-- 'imapMOf_' :: 'Monad' m => 'IndexedLens'' i s a -> (i -> a -> m r) -> s -> m ()
-- 'imapMOf_' :: 'Monad' m => 'IndexedTraversal'' i s a -> (i -> a -> m r) -> s -> m ()
-- @
imapMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s a -> (i -> a -> m r) -> s -> m ()
imapMOf_ l = mapMOf_ l .# Indexed
{-# INLINE imapMOf_ #-}
-- | Run monadic actions for each target of an 'IndexedFold' or 'IndexedTraversal' with access to the index,
-- discarding the results (with the arguments flipped).
--
-- @
-- 'iforMOf_' ≡ 'flip' '.' 'imapMOf_'
-- @
--
-- When you don't need access to the index then 'forMOf_' is more flexible in what it accepts.
--
-- @
-- 'forMOf_' l a ≡ 'Control.Lens.Traversal.iforMOf' l a '.' 'const'
-- @
--
-- @
-- 'iforMOf_' :: 'Monad' m => 'IndexedGetter' i s a -> s -> (i -> a -> m r) -> m ()
-- 'iforMOf_' :: 'Monad' m => 'IndexedFold' i s a -> s -> (i -> a -> m r) -> m ()
-- 'iforMOf_' :: 'Monad' m => 'IndexedLens'' i s a -> s -> (i -> a -> m r) -> m ()
-- 'iforMOf_' :: 'Monad' m => 'IndexedTraversal'' i s a -> s -> (i -> a -> m r) -> m ()
-- @
iforMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s a -> s -> (i -> a -> m r) -> m ()
iforMOf_ = flip . imapMOf_
{-# INLINE iforMOf_ #-}
-- | Concatenate the results of a function of the elements of an 'IndexedFold' or 'IndexedTraversal'
-- with access to the index.
--
-- When you don't need access to the index then 'concatMapOf' is more flexible in what it accepts.
--
-- @
-- 'concatMapOf' l ≡ 'iconcatMapOf' l '.' 'const'
-- 'iconcatMapOf' ≡ 'ifoldMapOf'
-- @
--
-- @
-- 'iconcatMapOf' :: 'IndexedGetter' i s a -> (i -> a -> [r]) -> s -> [r]
-- 'iconcatMapOf' :: 'IndexedFold' i s a -> (i -> a -> [r]) -> s -> [r]
-- 'iconcatMapOf' :: 'IndexedLens'' i s a -> (i -> a -> [r]) -> s -> [r]
-- 'iconcatMapOf' :: 'IndexedTraversal'' i s a -> (i -> a -> [r]) -> s -> [r]
-- @
iconcatMapOf :: IndexedGetting i [r] s a -> (i -> a -> [r]) -> s -> [r]
iconcatMapOf = ifoldMapOf
{-# INLINE iconcatMapOf #-}
-- | The 'ifindOf' function takes an 'IndexedFold' or 'IndexedTraversal', a predicate that is also
-- supplied the index, a structure and returns the left-most element of the structure
-- matching the predicate, or 'Nothing' if there is no such element.
--
-- When you don't need access to the index then 'findOf' is more flexible in what it accepts.
--
-- @
-- 'findOf' l ≡ 'ifindOf' l '.' 'const'
-- @
--
-- @
-- 'ifindOf' :: 'IndexedGetter' i s a -> (i -> a -> 'Bool') -> s -> 'Maybe' a
-- 'ifindOf' :: 'IndexedFold' i s a -> (i -> a -> 'Bool') -> s -> 'Maybe' a
-- 'ifindOf' :: 'IndexedLens'' i s a -> (i -> a -> 'Bool') -> s -> 'Maybe' a
-- 'ifindOf' :: 'IndexedTraversal'' i s a -> (i -> a -> 'Bool') -> s -> 'Maybe' a
-- @
ifindOf :: IndexedGetting i (Endo (Maybe a)) s a -> (i -> a -> Bool) -> s -> Maybe a
ifindOf l = findOf l .# Indexed
{-# INLINE ifindOf #-}
-- | The 'ifindMOf' function takes an 'IndexedFold' or 'IndexedTraversal', a monadic predicate that is also
-- supplied the index, a structure and returns in the monad the left-most element of the structure
-- matching the predicate, or 'Nothing' if there is no such element.
--
-- When you don't need access to the index then 'findMOf' is more flexible in what it accepts.
--
-- @
-- 'findMOf' l ≡ 'ifindMOf' l '.' 'const'
-- @
--
-- @
-- 'ifindMOf' :: 'Monad' m => 'IndexedGetter' i s a -> (i -> a -> m 'Bool') -> s -> m ('Maybe' a)
-- 'ifindMOf' :: 'Monad' m => 'IndexedFold' i s a -> (i -> a -> m 'Bool') -> s -> m ('Maybe' a)
-- 'ifindMOf' :: 'Monad' m => 'IndexedLens'' i s a -> (i -> a -> m 'Bool') -> s -> m ('Maybe' a)
-- 'ifindMOf' :: 'Monad' m => 'IndexedTraversal'' i s a -> (i -> a -> m 'Bool') -> s -> m ('Maybe' a)
-- @
ifindMOf :: Monad m => IndexedGetting i (Endo (m (Maybe a))) s a -> (i -> a -> m Bool) -> s -> m (Maybe a)
ifindMOf l = findMOf l .# Indexed
{-# INLINE ifindMOf #-}
-- | /Strictly/ fold right over the elements of a structure with an index.
--
-- When you don't need access to the index then 'foldrOf'' is more flexible in what it accepts.
--
-- @
-- 'foldrOf'' l ≡ 'ifoldrOf'' l '.' 'const'
-- @
--
-- @
-- 'ifoldrOf'' :: 'IndexedGetter' i s a -> (i -> a -> r -> r) -> r -> s -> r
-- 'ifoldrOf'' :: 'IndexedFold' i s a -> (i -> a -> r -> r) -> r -> s -> r
-- 'ifoldrOf'' :: 'IndexedLens'' i s a -> (i -> a -> r -> r) -> r -> s -> r
-- 'ifoldrOf'' :: 'IndexedTraversal'' i s a -> (i -> a -> r -> r) -> r -> s -> r
-- @
ifoldrOf' :: IndexedGetting i (Dual (Endo (r -> r))) s a -> (i -> a -> r -> r) -> r -> s -> r
ifoldrOf' l f z0 xs = ifoldlOf l f' id xs z0
where f' i k x z = k $! f i x z
{-# INLINE ifoldrOf' #-}
-- | Fold over the elements of a structure with an index, associating to the left, but /strictly/.
--
-- When you don't need access to the index then 'foldlOf'' is more flexible in what it accepts.
--
-- @
-- 'foldlOf'' l ≡ 'ifoldlOf'' l '.' 'const'
-- @
--
-- @
-- 'ifoldlOf'' :: 'IndexedGetter' i s a -> (i -> r -> a -> r) -> r -> s -> r
-- 'ifoldlOf'' :: 'IndexedFold' i s a -> (i -> r -> a -> r) -> r -> s -> r
-- 'ifoldlOf'' :: 'IndexedLens'' i s a -> (i -> r -> a -> r) -> r -> s -> r
-- 'ifoldlOf'' :: 'IndexedTraversal'' i s a -> (i -> r -> a -> r) -> r -> s -> r
-- @
ifoldlOf' :: IndexedGetting i (Endo (r -> r)) s a -> (i -> r -> a -> r) -> r -> s -> r
ifoldlOf' l f z0 xs = ifoldrOf l f' id xs z0
where f' i x k z = k $! f i z x
{-# INLINE ifoldlOf' #-}
-- | Monadic fold right over the elements of a structure with an index.
--
-- When you don't need access to the index then 'foldrMOf' is more flexible in what it accepts.
--
-- @
-- 'foldrMOf' l ≡ 'ifoldrMOf' l '.' 'const'
-- @
--
-- @
-- 'ifoldrMOf' :: 'Monad' m => 'IndexedGetter' i s a -> (i -> a -> r -> m r) -> r -> s -> m r
-- 'ifoldrMOf' :: 'Monad' m => 'IndexedFold' i s a -> (i -> a -> r -> m r) -> r -> s -> m r
-- 'ifoldrMOf' :: 'Monad' m => 'IndexedLens'' i s a -> (i -> a -> r -> m r) -> r -> s -> m r
-- 'ifoldrMOf' :: 'Monad' m => 'IndexedTraversal'' i s a -> (i -> a -> r -> m r) -> r -> s -> m r
-- @
ifoldrMOf :: Monad m => IndexedGetting i (Dual (Endo (r -> m r))) s a -> (i -> a -> r -> m r) -> r -> s -> m r
ifoldrMOf l f z0 xs = ifoldlOf l f' return xs z0
where f' i k x z = f i x z >>= k
{-# INLINE ifoldrMOf #-}
-- | Monadic fold over the elements of a structure with an index, associating to the left.
--
-- When you don't need access to the index then 'foldlMOf' is more flexible in what it accepts.
--
-- @
-- 'foldlMOf' l ≡ 'ifoldlMOf' l '.' 'const'
-- @
--
-- @
-- 'ifoldlMOf' :: 'Monad' m => 'IndexedGetter' i s a -> (i -> r -> a -> m r) -> r -> s -> m r
-- 'ifoldlMOf' :: 'Monad' m => 'IndexedFold' i s a -> (i -> r -> a -> m r) -> r -> s -> m r
-- 'ifoldlMOf' :: 'Monad' m => 'IndexedLens'' i s a -> (i -> r -> a -> m r) -> r -> s -> m r
-- 'ifoldlMOf' :: 'Monad' m => 'IndexedTraversal'' i s a -> (i -> r -> a -> m r) -> r -> s -> m r
-- @
ifoldlMOf :: Monad m => IndexedGetting i (Endo (r -> m r)) s a -> (i -> r -> a -> m r) -> r -> s -> m r
ifoldlMOf l f z0 xs = ifoldrOf l f' return xs z0
where f' i x k z = f i z x >>= k
{-# INLINE ifoldlMOf #-}
-- | Extract the key-value pairs from a structure.
--
-- When you don't need access to the indices in the result, then 'toListOf' is more flexible in what it accepts.
--
-- @
-- 'toListOf' l ≡ 'map' 'snd' '.' 'itoListOf' l
-- @
--
-- @
-- 'itoListOf' :: 'IndexedGetter' i s a -> s -> [(i,a)]
-- 'itoListOf' :: 'IndexedFold' i s a -> s -> [(i,a)]
-- 'itoListOf' :: 'IndexedLens'' i s a -> s -> [(i,a)]
-- 'itoListOf' :: 'IndexedTraversal'' i s a -> s -> [(i,a)]
-- @
itoListOf :: IndexedGetting i (Endo [(i,a)]) s a -> s -> [(i,a)]
itoListOf l = ifoldrOf l (\i a -> ((i,a):)) []
{-# INLINE itoListOf #-}
-- | An infix version of 'itoListOf'.
-- @
-- ('^@..') :: s -> 'IndexedGetter' i s a -> [(i,a)]
-- ('^@..') :: s -> 'IndexedFold' i s a -> [(i,a)]
-- ('^@..') :: s -> 'IndexedLens'' i s a -> [(i,a)]
-- ('^@..') :: s -> 'IndexedTraversal'' i s a -> [(i,a)]
-- @
(^@..) :: s -> IndexedGetting i (Endo [(i,a)]) s a -> [(i,a)]
s ^@.. l = ifoldrOf l (\i a -> ((i,a):)) [] s
{-# INLINE (^@..) #-}
-- | Perform a safe 'head' (with index) of an 'IndexedFold' or 'IndexedTraversal' or retrieve 'Just' the index and result
-- from an 'IndexedGetter' or 'IndexedLens'.
--
-- When using a 'IndexedTraversal' as a partial 'IndexedLens', or an 'IndexedFold' as a partial 'IndexedGetter' this can be a convenient
-- way to extract the optional value.
--
-- @
-- ('^@?') :: s -> 'IndexedGetter' i s a -> 'Maybe' (i, a)
-- ('^@?') :: s -> 'IndexedFold' i s a -> 'Maybe' (i, a)
-- ('^@?') :: s -> 'IndexedLens'' i s a -> 'Maybe' (i, a)
-- ('^@?') :: s -> 'IndexedTraversal'' i s a -> 'Maybe' (i, a)
-- @
(^@?) :: s -> IndexedGetting i (Endo (Maybe (i, a))) s a -> Maybe (i, a)
s ^@? l = ifoldrOf l (\i x _ -> Just (i,x)) Nothing s
{-# INLINE (^@?) #-}
-- | Perform an *UNSAFE* 'head' (with index) of an 'IndexedFold' or 'IndexedTraversal' assuming that it is there.
--
-- @
-- ('^@?!') :: s -> 'IndexedGetter' i s a -> (i, a)
-- ('^@?!') :: s -> 'IndexedFold' i s a -> (i, a)
-- ('^@?!') :: s -> 'IndexedLens'' i s a -> (i, a)
-- ('^@?!') :: s -> 'IndexedTraversal'' i s a -> (i, a)
-- @
(^@?!) :: s -> IndexedGetting i (Endo (i, a)) s a -> (i, a)
s ^@?! l = ifoldrOf l (\i x _ -> (i,x)) (error "(^@?!): empty Fold") s
{-# INLINE (^@?!) #-}
-- | Retrieve the index of the first value targeted by a 'IndexedFold' or 'IndexedTraversal' which is equal to a given value.
--
-- @
-- 'Data.List.elemIndex' ≡ 'elemIndexOf' 'folded'
-- @
--
-- @
-- 'elemIndexOf' :: 'Eq' a => 'IndexedFold' i s a -> a -> s -> 'Maybe' i
-- 'elemIndexOf' :: 'Eq' a => 'IndexedTraversal'' i s a -> a -> s -> 'Maybe' i
-- @
elemIndexOf :: Eq a => IndexedGetting i (First i) s a -> a -> s -> Maybe i
elemIndexOf l a = findIndexOf l (a ==)
{-# INLINE elemIndexOf #-}
-- | Retrieve the indices of the values targeted by a 'IndexedFold' or 'IndexedTraversal' which are equal to a given value.
--
-- @
-- 'Data.List.elemIndices' ≡ 'elemIndicesOf' 'folded'
-- @
--
-- @
-- 'elemIndicesOf' :: 'Eq' a => 'IndexedFold' i s a -> a -> s -> [i]
-- 'elemIndicesOf' :: 'Eq' a => 'IndexedTraversal'' i s a -> a -> s -> [i]
-- @
elemIndicesOf :: Eq a => IndexedGetting i (Endo [i]) s a -> a -> s -> [i]
elemIndicesOf l a = findIndicesOf l (a ==)
{-# INLINE elemIndicesOf #-}
-- | Retrieve the index of the first value targeted by a 'IndexedFold' or 'IndexedTraversal' which satisfies a predicate.
--
-- @
-- 'Data.List.findIndex' ≡ 'findIndexOf' 'folded'
-- @
--
-- @
-- 'findIndexOf' :: 'IndexedFold' i s a -> (a -> 'Bool') -> s -> 'Maybe' i
-- 'findIndexOf' :: 'IndexedTraversal'' i s a -> (a -> 'Bool') -> s -> 'Maybe' i
-- @
findIndexOf :: IndexedGetting i (First i) s a -> (a -> Bool) -> s -> Maybe i
findIndexOf l p = preview (l . filtered p . asIndex)
{-# INLINE findIndexOf #-}
-- | Retrieve the indices of the values targeted by a 'IndexedFold' or 'IndexedTraversal' which satisfy a predicate.
--
-- @
-- 'Data.List.findIndices' ≡ 'findIndicesOf' 'folded'
-- @
--
-- @
-- 'findIndicesOf' :: 'IndexedFold' i s a -> (a -> 'Bool') -> s -> [i]
-- 'findIndicesOf' :: 'IndexedTraversal'' i s a -> (a -> 'Bool') -> s -> [i]
-- @
findIndicesOf :: IndexedGetting i (Endo [i]) s a -> (a -> Bool) -> s -> [i]
findIndicesOf l p = toListOf (l . filtered p . asIndex)
{-# INLINE findIndicesOf #-}
-------------------------------------------------------------------------------
-- Converting to Folds
-------------------------------------------------------------------------------
-- | Filter an 'IndexedFold' or 'IndexedGetter', obtaining an 'IndexedFold'.
--
-- >>> [0,0,0,5,5,5]^..traversed.ifiltered (\i a -> i <= a)
-- [0,5,5,5]
--
-- Compose with 'filtered' to filter another 'IndexedLens', 'IndexedIso', 'IndexedGetter', 'IndexedFold' (or 'IndexedTraversal') with
-- access to both the value and the index.
--
-- Note: As with 'filtered', this is /not/ a legal 'IndexedTraversal', unless you are very careful not to invalidate the predicate on the target!
ifiltered :: (Indexable i p, Applicative f) => (i -> a -> Bool) -> Optical' p (Indexed i) f a a
ifiltered p f = Indexed $ \i a -> if p i a then indexed f i a else pure a
{-# INLINE ifiltered #-}
-- | Obtain an 'IndexedFold' by taking elements from another
-- 'IndexedFold', 'IndexedLens', 'IndexedGetter' or 'IndexedTraversal' while a predicate holds.
--
-- @
-- 'itakingWhile' :: (i -> a -> 'Bool') -> 'IndexedFold' i s a -> 'IndexedFold' i s a
-- 'itakingWhile' :: (i -> a -> 'Bool') -> 'IndexedTraversal'' i s a -> 'IndexedFold' i s a
-- 'itakingWhile' :: (i -> a -> 'Bool') -> 'IndexedLens'' i s a -> 'IndexedFold' i s a
-- 'itakingWhile' :: (i -> a -> 'Bool') -> 'IndexedGetter' i s a -> 'IndexedFold' i s a
-- @
itakingWhile :: (Indexable i p, Profunctor q, Contravariant f, Applicative f)
=> (i -> a -> Bool)
-> Optical (Indexed i) q (Const (Endo (f s))) s s a a
-> Optical p q f s s a a
itakingWhile p l f = (flip appEndo noEffect .# getConst) `rmap` l g where
g = Indexed $ \i a -> Const . Endo $ if p i a then (indexed f i a *>) else const noEffect
{-# INLINE itakingWhile #-}
-- | Obtain an 'IndexedFold' by dropping elements from another 'IndexedFold', 'IndexedLens', 'IndexedGetter' or 'IndexedTraversal' while a predicate holds.
--
-- @
-- 'idroppingWhile' :: (i -> a -> 'Bool') -> 'IndexedFold' i s a -> 'IndexedFold' i s a
-- 'idroppingWhile' :: (i -> a -> 'Bool') -> 'IndexedTraversal'' i s a -> 'IndexedFold' i s a -- see notes
-- 'idroppingWhile' :: (i -> a -> 'Bool') -> 'IndexedLens'' i s a -> 'IndexedFold' i s a -- see notes
-- 'idroppingWhile' :: (i -> a -> 'Bool') -> 'IndexedGetter' i s a -> 'IndexedFold' i s a
-- @
--
-- Applying 'idroppingWhile' to an 'IndexedLens' or 'IndexedTraversal' will still allow you to use it as a
-- pseudo-'IndexedTraversal', but if you change the value of the targets to ones where the predicate returns
-- 'True', then you will break the 'Traversal' laws and 'Traversal' fusion will no longer be sound.
idroppingWhile :: (Indexable i p, Profunctor q, Applicative f)
=> (i -> a -> Bool)
-> Optical (Indexed i) q (Compose (State Bool) f) s t a a
-> Optical p q f s t a a
idroppingWhile p l f = (flip evalState True .# getCompose) `rmap` l g where
g = Indexed $ \ i a -> Compose $ state $ \b -> let
b' = b && p i a
in (if b' then pure a else indexed f i a, b')
{-# INLINE idroppingWhile #-}
------------------------------------------------------------------------------
-- Misc.
------------------------------------------------------------------------------
skip :: a -> ()
skip _ = ()
{-# INLINE skip #-}
------------------------------------------------------------------------------
-- Folds with Reified Monoid
------------------------------------------------------------------------------
foldBy :: Foldable t => (a -> a -> a) -> a -> t a -> a
foldBy f z = reifyFold f z (foldMap M)
foldByOf :: (forall i. Getting (M a i) s a) -> (a -> a -> a) -> a -> s -> a
foldByOf l f z = reifyFold f z (foldMapOf l M)
foldMapBy :: Foldable t => (r -> r -> r) -> r -> (a -> r) -> t a -> r
foldMapBy f z g = reifyFold f z (foldMap (M #. g))
foldMapByOf :: (forall s. Getting (M r s) t a) -> (r -> r -> r) -> r -> (a -> r) -> t -> r
foldMapByOf l f z g = reifyFold f z (foldMapOf l (M #. g))
| danidiaz/lens | src/Control/Lens/Fold.hs | bsd-3-clause | 91,384 | 0 | 17 | 21,309 | 11,592 | 6,878 | 4,714 | -1 | -1 |
<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE helpset PUBLIC "-//Sun Microsystems Inc.//DTD JavaHelp HelpSet Version 2.0//EN" "http://java.sun.com/products/javahelp/helpset_2_0.dtd">
<helpset version="2.0" xml:lang="sl-SI">
<title>OpenAPI Support Add-on</title>
<maps>
<homeID>openapi</homeID>
<mapref location="map.jhm"/>
</maps>
<view>
<name>TOC</name>
<label>Contents</label>
<type>org.zaproxy.zap.extension.help.ZapTocView</type>
<data>toc.xml</data>
</view>
<view>
<name>Index</name>
<label>Index</label>
<type>javax.help.IndexView</type>
<data>index.xml</data>
</view>
<view>
<name>Search</name>
<label>Search</label>
<type>javax.help.SearchView</type>
<data engine="com.sun.java.help.search.DefaultSearchEngine">
JavaHelpSearch
</data>
</view>
<view>
<name>Favorites</name>
<label>Favorites</label>
<type>javax.help.FavoritesView</type>
</view>
</helpset> | thc202/zap-extensions | addOns/openapi/src/main/javahelp/org/zaproxy/zap/extension/openapi/resources/help_sl_SI/helpset_sl_SI.hs | apache-2.0 | 971 | 82 | 53 | 157 | 396 | 209 | 187 | -1 | -1 |
{-# LANGUAGE CPP #-}
import GetURL
import Control.Concurrent
#if __GLASGOW_HASKELL__ < 706
import ConcurrentUtils (forkFinally)
#endif
import Control.Exception
import qualified Data.ByteString as B
import Control.Concurrent.STM
-----------------------------------------------------------------------------
-- Our Async API:
-- <<Async
data Async a = Async ThreadId (TMVar (Either SomeException a))
-- >>
-- <<async
async :: IO a -> IO (Async a)
async action = do
var <- newEmptyTMVarIO
t <- forkFinally action (atomically . putTMVar var)
return (Async t var)
-- >>
--- <<watchCatch
waitCatch :: Async a -> IO (Either SomeException a)
waitCatch = atomically . waitCatchSTM
-- >>
-- <<waitCatchSTM
waitCatchSTM :: Async a -> STM (Either SomeException a)
waitCatchSTM (Async _ var) = readTMVar var
-- >>
-- <<waitSTM
waitSTM :: Async a -> STM a
waitSTM a = do
r <- waitCatchSTM a
case r of
Left e -> throwSTM e
Right a -> return a
-- >>
-- <<wait
wait :: Async a -> IO a
wait = atomically . waitSTM
-- >>
-- <<cancel
cancel :: Async a -> IO ()
cancel (Async t _) = throwTo t ThreadKilled
-- >>
-- <<waitEither
waitEither :: Async a -> Async b -> IO (Either a b)
waitEither a b = atomically $
fmap Left (waitSTM a)
`orElse`
fmap Right (waitSTM b)
-- >>
-- <<waitAny
waitAny :: [Async a] -> IO a
waitAny asyncs =
atomically $ foldr orElse retry $ map waitSTM asyncs
-- >>
-- <<withAsync
withAsync :: IO a -> (Async a -> IO b) -> IO b
withAsync io operation = bracket (async io) cancel operation
-- >>
-----------------------------------------------------------------------------
-- <<main
main =
withAsync (getURL "http://www.wikipedia.org/wiki/Shovel") $ \a1 ->
withAsync (getURL "http://www.wikipedia.org/wiki/Spade") $ \a2 -> do
r1 <- wait a1
r2 <- wait a2
print (B.length r1, B.length r2)
-- >>
| prt2121/haskell-practice | parconc/geturls7.hs | apache-2.0 | 1,849 | 1 | 14 | 348 | 630 | 316 | 314 | 43 | 2 |
import System.Process (readProcessWithExitCode)
import System.Exit (ExitCode(ExitSuccess))
import System.IO.Unsafe (unsafeInterleaveIO)
import Data.List (intercalate)
import Utils (stringsFromStatus, Hash(MkHash))
import Data.Maybe (fromMaybe)
import Control.Applicative ((<$>))
{- Git commands -}
successOrNothing :: (ExitCode, a, b) -> Maybe a
successOrNothing (exitCode, output, _) =
if exitCode == ExitSuccess then Just output else Nothing
safeRun :: String -> [String] -> IO (Maybe String)
safeRun command arguments = successOrNothing <$> readProcessWithExitCode command arguments ""
gitstatus :: IO (Maybe String)
gitstatus = safeRun "git" ["status", "--porcelain", "--branch"]
gitrevparse :: IO (Maybe Hash)
gitrevparse = do
result <- safeRun "git" ["rev-parse", "--short", "HEAD"]
return $ MkHash . init <$> result
{- main -}
main :: IO ()
main = do
mstatus <- gitstatus
mhash <- unsafeInterleaveIO gitrevparse -- defer the execution until we know we need the hash
let result = do
status <- mstatus
strings <- stringsFromStatus mhash status
return $ intercalate " " strings
putStr $ fromMaybe "" result
| TiddoLangerak/zsh-git-prompt | src/Main.hs | mit | 1,136 | 3 | 13 | 177 | 362 | 192 | 170 | 27 | 2 |
{-# LANGUAGE RankNTypes, ImplicitParams, UnboxedTuples #-}
-- Test two slightly exotic things about type signatures
module ShouldCompile where
-- The for-all hoisting should hoist the
-- implicit parameter to give
-- r :: (?param::a) => a
r :: Int -> ((?param :: a) => a)
r = error "urk"
-- The unboxed tuple is OK because it is
-- used on the right hand end of an arrow
type T = (# Int, Int #)
f :: Int -> T
f = error "urk"
| lukexi/ghc | testsuite/tests/typecheck/should_compile/tc145.hs | bsd-3-clause | 457 | 0 | 8 | 116 | 68 | 43 | 25 | 7 | 1 |
module LayoutIn1 where
--Layout rule applies after 'where','let','do' and 'of'
--In this Example: rename 'sq' to 'square'.
sumSquares x y= sq x + sq y where sq x= x^pow
--There is a comment.
pow=2
| mpickering/ghc-exactprint | tests/examples/transform/LayoutIn1.hs | bsd-3-clause | 236 | 0 | 7 | 73 | 46 | 25 | 21 | 3 | 1 |
{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE NoImplicitPrelude #-}
-- ----------------------------------------------------------------------------
--
-- (c) The University of Glasgow 2006
--
-- Fingerprints for recompilation checking and ABI versioning, and
-- implementing fast comparison of Typeable.
--
-- ----------------------------------------------------------------------------
module GHC.Fingerprint.Type (Fingerprint(..)) where
import GHC.Base
import GHC.Word
-- Using 128-bit MD5 fingerprints for now.
data Fingerprint = Fingerprint {-# UNPACK #-} !Word64 {-# UNPACK #-} !Word64
deriving (Eq, Ord)
| jtojnar/haste-compiler | libraries/ghc-7.8/base/GHC/Fingerprint/Type.hs | bsd-3-clause | 615 | 0 | 7 | 76 | 63 | 42 | 21 | 7 | 0 |
{-# LANGUAGE OverloadedStrings #-}
module Lib
( dnsimpleMain
) where
import Data.Bool
import qualified Data.ByteString.Char8 as C
import qualified Data.Map.Strict as Map
import Data.Maybe (fromJust)
import GHC.Generics
import Options.Applicative (customExecParser)
import System.Environment (getArgs, getEnv)
import qualified Args
import Config (Settings, loadCfg, getCfgFile)
import Identity (Identity, getIdentity, outputIdentity)
import qualified Domain
import qualified HTTP
import State
createState :: Args.Options -> Maybe Settings -> Maybe Identity -> IO (Maybe State)
createState o Nothing _ = do
c <- getCfgFile (Args.optCfgFile o)
st <- loadCfg c
case st of
Nothing -> return Nothing
Just s -> createState o (Just s) Nothing
createState o (Just s) Nothing = do
ident <- getIdentity s
case ident of
Nothing -> return Nothing
Just i -> createState o (Just s) (Just i)
createState o (Just s) (Just i) = return $ Just State.State { State.settings = s
, State.identity = i
, State.options = o
}
dnsimpleMain :: IO ()
dnsimpleMain = Args.argsParser run
run :: Args.Options -> IO ()
run opts = do
state <- createState opts Nothing Nothing
case state of
Nothing -> putStrLn "Could not create state!"
Just s -> dispatch s opts
whoami :: State -> IO ()
whoami state = outputIdentity $ identity state
getDomain :: State -> String -> IO ()
getDomain state dom = Domain.outputDomain =<< Domain.get state dom
listDomains :: State -> IO ()
listDomains state = Domain.outputDomainList =<< Domain.list state
createDomain :: State -> String -> IO ()
createDomain st dom = Domain.outputDomain =<< Domain.create st dom
dispatch :: State -> Args.Options -> IO ()
dispatch state Args.Options {Args.subCommand = Args.WhoAmI} = whoami state
dispatch state Args.Options {Args.subCommand = Args.ListDomains} = listDomains state
dispatch state Args.Options {Args.subCommand = Args.GetDomain dom} = getDomain state dom
dispatch state Args.Options {Args.subCommand = Args.CreateDomain dom} = createDomain state dom
| dxtr/dnsimple | src/Lib.hs | isc | 2,267 | 0 | 12 | 568 | 731 | 373 | 358 | 52 | 3 |
-- Kind Polymorphism
-- The regular value level function which takes a function and applies it to an argument is universally generalized over in the usual Hindley-Milner way.
app :: forall a b. (a -> b) -> a -> b
app f a = f a
-- But when we do the same thing at the type-level we see we lose information about the polymorphism of the constructor applied.
-- TApp :: (* -> *) -> * -> *
data TApp f a = MkTApp (f a)
-- Turning on -XPolyKinds allows polymorphic variables at the kind level as well.
-- Default: (* -> *) -> * -> *
-- PolyKinds: (k -> *) -> k -> *
data TApp f a = MkTApp (f a)
-- Default: ((* -> *) -> (* -> *)) -> (* -> *)
-- PolyKinds: ((k -> *) -> (k -> *)) -> (k -> *)
data Mu f a = Roll (f (Mu f) a)
-- Default: * -> *
-- PolyKinds: k -> *
data Proxy a = Proxy
-- Using the polykinded Proxy type allows us to write down type class functions over constructors of arbitrary kind arity.
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE KindSignatures #-}
data Proxy a = Proxy
data Rep = Rep
class PolyClass a where
foo :: Proxy a -> Rep
foo = const Rep
-- () :: *
-- [] :: * -> *
-- Either :: * -> * -> *
instance PolyClass ()
instance PolyClass [] -- poly kinds enables to put into * -> * to PolyClass a
instance PolyClass Either
-- Note that the datatype Proxy has kind forall k. k -> * (inferred by GHC), and the new PolyClass class has kind forall k. k -> Constraint.
-- For example we can write down the polymorphic S K combinators at the type level now.
{-# LANGUAGE PolyKinds #-}
newtype I (a :: *) = I a
newtype K (a :: *) (b :: k) = K a
newtype Flip (f :: k1 -> k2 -> *) (x :: k2) (y :: k1) = Flip (f y x)
unI :: I a -> a
unI (I x) = x
unK :: K a b -> a
unK (K x) = x
unFlip :: Flip f x y -> f y x
unFlip (Flip x) = x
-- Data Kinds
-- DataKinds are relatively simple. You turn on the extension and all of a sudden some of your data types have unique kinds! (Otherwise they are just constructors functions with type instead of kinds)
{-
λ :set -XDataKinds
λ data Animal = Pegasus | Octopus
λ :kind Pegasus
Pegasus :: Animal
-}
-- The -XDataKinds extension allows us to use refer to constructors at the value level and the type level. Consider a simple sum type:
data S a b = L a | R b
-- S :: * -> * -> *
-- L :: a -> S a b
-- R :: b -> S a b
-- With the extension enabled we see that our type constructors are now automatically promoted so that L or R can be viewed as both a data constructor of the type S or as the type L with kind S.
{-# LANGUAGE DataKinds #-}
data S a b = L a | R b
-- S :: * -> * -> *
-- L :: * -> S * *
-- R :: * -> S * *
-- Promoted data constructors can referred to in type signatures by prefixing them with a single quote. Also of importance is that these promoted constructors are not exported with a module by default, but type synonym instances can be created for the ticked promoted types and exported directly.
data Foo = Bar | Baz
type Bar = 'Bar
type Baz = 'Baz
-- Combining this with type families we see we can write meaningful, meaningful type-level functions by lifting types to the kind level.
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE DataKinds #-}
import Prelude hiding (Bool(..))
data Bool = False | True
type family Not (a :: Bool) :: Bool
type instance Not True = False
type instance Not False = True
false :: Not True ~ False => a
false = undefined
true :: Not False ~ True => a
true = undefined
-- Fails at compile time.
-- Couldn't match type 'False with 'True
invalid :: Not True ~ True => a
invalid = undefined | Airtnp/Freshman_Simple_Haskell_Lib | Intro/WIW/Promoted/KindPolymorphism.hs | mit | 3,570 | 0 | 10 | 825 | 594 | 342 | 252 | -1 | -1 |
module Util where
import Control.Monad
import Control.Monad.State
import Control.Monad.List
-- a generic counter
freshInt :: Monad m => StateT Int m Int
freshInt = do
x <- get
() <- put (x+1)
return x
freshInts :: Monad m => Int -> StateT Int m [Int]
freshInts 0 = return []
freshInts k = do
x <- freshInt
xs <- freshInts (k-1)
return (x:xs)
| noamz/linlam-gos | src/Util.hs | mit | 357 | 0 | 10 | 78 | 162 | 81 | 81 | 15 | 1 |
{-# LANGUAGE ExistentialQuantification #-}
module Scheme48.Interpreter (
eval
, primitiveBindings
) where
import System.IO
import Control.Monad.Except
import Text.ParserCombinators.Parsec (Parser, parse)
import Scheme48.Core
import Scheme48.Parser (readExpr, readExprList)
import Scheme48.Environment
data Unpacker = forall a. Eq a => AnyUnpacker (LispVal -> ThrowsError a)
eval :: Env -> LispVal -> IOThrowsError LispVal
eval env val@(String _) = return val
eval env val@(Number _) = return val
eval env val@(Bool _) = return val
eval env val@(Atom id) = getVar env id
eval env (List [Atom "quote", val]) = return val
eval env (List [Atom "if", pred, conseq, alt]) = do
result <- eval env pred
case result of
Bool False -> eval env alt
Bool True -> eval env conseq
otherwise -> throwError $ TypeMismatch "bool" otherwise
--otherwise -> eval conseq
--eval env (List ((Atom "cond") : expressions)) = cond expressions
eval env (List [Atom "set!", Atom var, form]) =
eval env form >>= setVar env var
eval env (List [Atom "define", Atom var, form]) =
eval env form >>= defineVar env var
eval env (List (Atom "define" : List (Atom var : params) : body)) =
makeNormalFunc env params body >>= defineVar env var
eval env (List (Atom "define" : DottedList (Atom var : params) varargs : body)) =
makeVarArgs varargs env params body >>= defineVar env var
eval env (List (Atom "lambda" : List params : body)) =
makeNormalFunc env params body
eval env (List (Atom "lambda" : DottedList params varargs : body)) =
makeVarArgs varargs env params body
eval env (List (Atom "lambda" : varargs@(Atom _) : body)) =
makeVarArgs varargs env [] body
eval env (List [Atom "load", String filename]) =
load filename >>= liftM last . mapM (eval env)
eval env (List (function : args)) = do
func <- eval env function
argVals <- mapM (eval env) args
apply func argVals
eval env badForm = throwError $ BadSpecialForm "Unrecognized special form" badForm
applyProc :: [LispVal] -> IOThrowsError LispVal
applyProc [func, List args] = apply func args
applyProc (func : args) = apply func args
apply :: LispVal -> [LispVal] -> IOThrowsError LispVal
apply (PrimitiveFunc func) args = liftThrows $ func args
apply (IOFunc func) args = func args
apply (Func params varargs body closure) args =
if num params /= num args && varargs == Nothing
then throwError $ NumArgs (num params) args
else (liftIO $ bindVars closure $ zip params args) >>= bindVarArgs varargs >>= evalBody
where remainingArgs = drop (length params) args
num = toInteger . length
evalBody env = liftM last $ mapM (eval env) body
bindVarArgs arg env = case arg of
Just argName -> liftIO $ bindVars env [(argName, List remainingArgs)]
Nothing -> return env
primitiveBindings :: IO Env
primitiveBindings = nullEnv >>= (flip bindVars $ map (makeFunc IOFunc) ioPrimitives
++ map (makeFunc PrimitiveFunc) primitives)
where makeFunc constructor (var, func) = (var, constructor func)
makeFunc varargs env params body = return $ Func (map showVal params) varargs body env
makeNormalFunc = makeFunc Nothing
makeVarArgs = makeFunc . Just . showVal
--apply func args =
-- maybe (throwError $ NotFunction "Unrecognised primitive function" func) ($ args) $ lookup func primitives
ioPrimitives :: [(String, [LispVal] -> IOThrowsError LispVal)]
ioPrimitives = [
("apply", applyProc)
, ("open-input-file", makePort ReadMode)
, ("open-output-file", makePort WriteMode)
, ("close-input-port", closePort)
, ("close-output-port", closePort)
, ("read", readProc)
, ("write", writeProc)
, ("read-contents", readContents)
, ("read-all", readAll)
]
makePort :: IOMode -> [LispVal] -> IOThrowsError LispVal
makePort mode [String filename] = liftM Port $ liftIO $ openFile filename mode
closePort :: [LispVal] -> IOThrowsError LispVal
closePort [Port port] = liftIO $ hClose port >> (return $ Bool True)
closePort _ = return $ Bool False
readProc :: [LispVal] -> IOThrowsError LispVal
readProc [] = readProc [Port stdin]
readProc [Port port] = (liftIO $ hGetLine port) >>= liftThrows . readExpr
writeProc :: [LispVal] -> IOThrowsError LispVal
writeProc [obj] = writeProc [obj, Port stdout]
writeProc [obj, Port port] = liftIO $ hPrint port obj >> (return $ Bool True)
readContents :: [LispVal] -> IOThrowsError LispVal
readContents [String filename] = liftM String $ liftIO $ readFile filename
load :: String -> IOThrowsError [LispVal]
load filename = (liftIO $ readFile filename) >>= liftThrows . readExprList
readAll :: [LispVal] -> IOThrowsError LispVal
readAll [String filename] = liftM List $ load filename
primitives :: [(String, [LispVal] -> ThrowsError LispVal)]
primitives = [
("+", numericBinop (+))
, ("-", numericBinop (-))
, ("*", numericBinop (*))
, ("/", numericBinop div)
, ("mod", numericBinop mod)
, ("quotient", numericBinop quot)
, ("remainder", numericBinop rem)
, ("boolean?", booleanUnaryOp isBoolean)
, ("symbol?", booleanUnaryOp isSymbol)
, ("number?", booleanUnaryOp isNumber)
, ("string?", booleanUnaryOp isString)
, ("symbol->string", symbolToString)
, ("=", numBoolBinop (==))
, ("<", numBoolBinop (<))
, (">", numBoolBinop (>))
, ("/=", numBoolBinop (/=))
, ("<=", numBoolBinop (<=))
, (">=", numBoolBinop (>=))
, ("&&", boolBoolBinop (&&))
, ("||", boolBoolBinop (||))
, ("string=?", strBoolBinop (==))
, ("string<?", strBoolBinop (<))
, ("string>?", strBoolBinop (>))
, ("string<=?", strBoolBinop (<=))
, ("string>=?", strBoolBinop (>=))
, ("car", car)
, ("cdr", cdr)
, ("cons", cons)
, ("eq?", eqv)
, ("eqv?", eqv)
, ("equal?", equal)
]
numBoolBinop = boolBinop unpackNum
strBoolBinop = boolBinop unpackStr
boolBoolBinop = boolBinop unpackBool
boolBinop :: (LispVal -> ThrowsError a) -> (a -> a -> Bool) -> [LispVal] -> ThrowsError LispVal
boolBinop unpacker op [a1, a2] = do
left <- unpacker a1
right <- unpacker a2
return $ Bool $ left `op` right
boolBinop _ _ args = throwError $ NumArgs 2 args
numericBinop :: (Integer -> Integer -> Integer) -> [LispVal] -> ThrowsError LispVal
numericBinop op [] = throwError $ NumArgs 2 []
numericBinop op param@[_] = throwError $ NumArgs 2 param
numericBinop op params = mapM unpackNum params >>= return . Number . foldl1 op
unpackNum :: LispVal -> ThrowsError Integer
unpackNum (Number n) = return n
unpackNum (String n) =
let parsed = reads n in
if null parsed
then throwError $ TypeMismatch "number" $ String n
else return $ fst $ parsed !! 0
unpackNum (List [n]) = unpackNum n
unpackNum notNum = throwError $ TypeMismatch "number" notNum
unpackStr :: LispVal -> ThrowsError String
unpackStr (String s) = return s
unpackStr (Number s) = return $ show s
unpackStr (Bool s) = return $ show s
unpackStr notString = throwError $ TypeMismatch "string" notString
unpackBool :: LispVal -> ThrowsError Bool
unpackBool (Bool b) = return b
unpackBool notBool = throwError $ TypeMismatch "boolean" notBool
booleanUnaryOp :: (LispVal -> Bool) -> [LispVal] -> ThrowsError LispVal
booleanUnaryOp op [arg] = return $ Bool $ op arg
booleanUnaryOp op args = throwError $ NumArgs 2 args
isSymbol :: LispVal -> Bool
isSymbol (Atom _) = True
isSymbol _ = False
isBoolean :: LispVal -> Bool
isBoolean (Bool _) = True
isBoolean _ = False
isString :: LispVal -> Bool
isString (String _) = True
isString _ = False
isNumber :: LispVal -> Bool
isNumber (Number _) = True
isNumber _ = False
symbolToString :: [LispVal] -> ThrowsError LispVal
symbolToString [Atom s] = Right $ String s
symbolToString [term] = Left $ TypeMismatch "atom" term
symbolToString terms = Left $ NumArgs 1 terms
-- List-manipulation primitives:
car :: [LispVal] -> ThrowsError LispVal
car [List (x : xs)] = return x
car [DottedList (x : xs) _] = return x
car [badArg] = throwError $ TypeMismatch "pair" badArg
car badArgList = throwError $ NumArgs 1 badArgList
cdr :: [LispVal] -> ThrowsError LispVal
cdr [List (_ : xs)] = return $ List xs
cdr [DottedList [_] t] = return t
cdr [DottedList (_ : xs) t] = return $ DottedList xs t
cdr [badArg] = throwError $ TypeMismatch "pair" badArg
cdr badArgList = throwError $ NumArgs 1 badArgList
cons :: [LispVal] -> ThrowsError LispVal
cons [x, List xs] = return $ List $ x : xs
cons [x, DottedList xs t] = return $ DottedList (x : xs) t
cons [x, t] = return $ DottedList [x] t
cons badArgList = throwError $ NumArgs 2 badArgList
-- Equivalence
eqv :: [LispVal] -> ThrowsError LispVal
eqv [Bool arg1, Bool arg2] = return $ Bool $ arg1 == arg2
eqv [Number arg1, Number arg2] = return $ Bool $ arg1 == arg2
eqv [String arg1, String arg2] = return $ Bool $ arg1 == arg2
eqv [Atom arg1, Atom arg2] = return $ Bool $ arg1 == arg2
eqv [DottedList xs x, DottedList ys y] = eqv [List $ xs ++ [x], List $ ys ++ [y]]
eqv [a@(List xs), b@(List ys)] = listEquals (\x y -> eqv [x, y]) a b
eqv [_, _] = return $ Bool False
eqv badArgList = throwError $ NumArgs 2 badArgList
unpackEquals :: LispVal -> LispVal -> Unpacker -> ThrowsError Bool
unpackEquals arg1 arg2 (AnyUnpacker unpacker) = do
un1 <- unpacker arg1
un2 <- unpacker arg2
return $ un1 == un2
-- I like this curried const trick, used because catchError expects a function
`catchError` (const $ return False)
equal :: [LispVal] -> ThrowsError LispVal
equal [x@(List _), y@(List _)] = listEquals (\a b -> equal [a, b]) x y
equal [DottedList xs x, DottedList ys y] = listEquals (\a b -> equal [a, b]) (List $ xs ++ [x]) (List $ ys ++ [y])
equal [x, y] = do
primitiveEquals <- liftM or $ mapM (unpackEquals x y)
[AnyUnpacker unpackNum, AnyUnpacker unpackStr, AnyUnpacker unpackBool]
--eqvEquals <- eqv [x, y]
--return $ Bool $ (primitiveEquals || let (Bool x) = eqvEquals in x)
Bool x' <- eqv [x, y]
return $ Bool $ (primitiveEquals || x')
equal badArgList = throwError $ NumArgs 2 badArgList
listEquals :: (LispVal -> LispVal -> ThrowsError LispVal)
-> LispVal -> LispVal -> ThrowsError LispVal
listEquals cmp (List xs) (List ys) =
return $ Bool $ (length xs == length ys) && (all eqvPair $ zip xs ys)
where eqvPair (x, y) = case cmp x y of
Left err -> False
Right (Bool val) -> val
{-
-- TODO: Ensure `else` can only appear in the last place, would require manual recursion
-- TODO: NumArgs with range of arguments, e.g. > 1
cond :: Env -> [LispVal] -> ThrowsError LispVal
cond env [] = throwError $ NumArgs 1 []
cond env clauses = do
-- if result is [Nothing Nothing (Just x) ...], we want (Just x)
results <- mapM (clause env) clauses
case foldl1 (\r c -> case r of Nothing -> c; Just x -> Just x) results of
Nothing -> throwError $ BadSpecialForm "cond with no matching clause near" (head clauses)
Just x -> return x
--cond clauses = (mapM evalClause clauses) >>= return . last
-- cond clauses = foldl (\p e -> case p of Left erreval e) (return $ Bool True) clauses
clause :: Env -> LispVal -> IOThrowsError (Maybe LispVal)
clause env (List ((Atom "else") : exprs)) = clause env (List (Bool True : exprs))
clause env (List x@[test, Atom "=>", expr]) = throwError $ BadSpecialForm "not implemented yet" (Atom "=>")
clause env (List (test : exprs)) = do
testResult <- eval env test
case testResult of
Bool True -> clauseExpr exprs >>= return . Just
Bool False -> return Nothing
otherwise -> throwError $ TypeMismatch "bool" otherwise
clauseExpr :: Env -> [LispVal] -> IOThrowsError LispVal
clauseExpr env exprs = mapM (eval env) exprs >>= return . last
-}
| mpitid/scheme48 | src/Scheme48/Interpreter.hs | mit | 11,870 | 0 | 14 | 2,555 | 4,103 | 2,124 | 1,979 | 224 | 3 |
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE FlexibleContexts, FlexibleInstances, MultiParamTypeClasses #-}
{-# LANGUAGE UndecidableInstances #-}
{-# OPTIONS_GHC -fno-warn-orphans -fno-warn-missing-fields #-}
-- overlapping instances is for automatic lifting
-- while avoiding an orphan of Lift for Text
{-# LANGUAGE OverlappingInstances #-}
-- | This module provides utilities for creating backends. Regular users do not
-- need to use this module.
module Database.Persist.TH
( -- * Parse entity defs
persistWith
, persistUpperCase
, persistLowerCase
, persistFileWith
-- * Turn @EntityDef@s into types
, mkPersist
, MkPersistSettings
, mpsBackend
, mpsGeneric
, mpsPrefixFields
, mpsEntityJSON
, mpsGenerateLenses
, EntityJSON(..)
, mkPersistSettings
, sqlSettings
, sqlOnlySettings
-- * Various other TH functions
, mkMigrate
, mkSave
, mkDeleteCascade
, share
, derivePersistField
, derivePersistFieldJSON
, persistFieldFromEntity
-- * Internal
, packPTH
, lensPTH
) where
import Prelude hiding ((++), take, concat, splitAt, exp)
import Database.Persist
import Database.Persist.Sql (Migration, migrate, SqlBackend, PersistFieldSql)
import Database.Persist.Quasi
import Language.Haskell.TH.Lib (varE)
import Language.Haskell.TH.Quote
import Language.Haskell.TH.Syntax
import Data.Char (toLower, toUpper)
import Control.Monad (forM, (<=<), mzero)
import qualified System.IO as SIO
import Data.Text (pack, Text, append, unpack, concat, uncons, cons, stripPrefix, stripSuffix)
import Data.Text.Encoding (decodeUtf8)
import qualified Data.Text.IO as TIO
import Data.List (foldl')
import Data.Maybe (isJust, listToMaybe, mapMaybe, fromMaybe)
import Data.Monoid (mappend, mconcat)
import Text.Read (readPrec, lexP, step, prec, parens, Lexeme(Ident))
import qualified Data.Map as M
import qualified Data.HashMap.Strict as HM
import Data.Aeson
( ToJSON (toJSON), FromJSON (parseJSON), (.=), object
, Value (Object), (.:), (.:?)
, eitherDecodeStrict'
)
import Control.Applicative (pure, (<$>), (<*>))
import Database.Persist.Sql (sqlType)
import Data.Proxy (Proxy (Proxy))
import Web.PathPieces (PathPiece, toPathPiece, fromPathPiece)
import GHC.Generics (Generic)
import qualified Data.Text.Encoding as TE
-- | Converts a quasi-quoted syntax into a list of entity definitions, to be
-- used as input to the template haskell generation code (mkPersist).
persistWith :: PersistSettings -> QuasiQuoter
persistWith ps = QuasiQuoter
{ quoteExp = parseReferences ps . pack
}
-- | Apply 'persistWith' to 'upperCaseSettings'.
persistUpperCase :: QuasiQuoter
persistUpperCase = persistWith upperCaseSettings
-- | Apply 'persistWith' to 'lowerCaseSettings'.
persistLowerCase :: QuasiQuoter
persistLowerCase = persistWith lowerCaseSettings
-- | Same as 'persistWith', but uses an external file instead of a
-- quasiquotation.
persistFileWith :: PersistSettings -> FilePath -> Q Exp
persistFileWith ps fp = do
#ifdef GHC_7_4
qAddDependentFile fp
#endif
h <- qRunIO $ SIO.openFile fp SIO.ReadMode
qRunIO $ SIO.hSetEncoding h SIO.utf8_bom
s <- qRunIO $ TIO.hGetContents h
parseReferences ps s
-- calls parse to Quasi.parse individual entities in isolation
-- afterwards, sets references to other entities
parseReferences :: PersistSettings -> Text -> Q Exp
parseReferences ps s = lift $
map (mkEntityDefSqlTypeExp embedEntityMap entMap) noCycleEnts
where
entMap = M.fromList $ map (\ent -> (entityHaskell ent, ent)) noCycleEnts
noCycleEnts = map breakCycleEnt entsWithEmbeds
-- every EntityDef could reference each-other (as an EmbedRef)
-- let Haskell tie the knot
embedEntityMap = M.fromList $ map (\ent -> (entityHaskell ent, toEmbedEntityDef ent)) entsWithEmbeds
entsWithEmbeds = map setEmbedEntity rawEnts
setEmbedEntity ent = ent
{ entityFields = map (setEmbedField (entityHaskell ent) embedEntityMap) $ entityFields ent
}
rawEnts = parse ps s
-- self references are already broken
-- look at every emFieldEmbed to see if it refers to an already seen HaskellName
-- so start with entityHaskell ent and accumulate embeddedHaskell em
breakCycleEnt entDef =
let entName = entityHaskell entDef
in entDef { entityFields = map (breakCycleField entName) $ entityFields entDef }
breakCycleField entName f@(FieldDef { fieldReference = EmbedRef em }) =
f { fieldReference = EmbedRef $ breakCycleEmbed [entName] em }
breakCycleField _ f = f
breakCycleEmbed ancestors em =
em { embeddedFields = map (breakCycleEmField $ emName : ancestors)
(embeddedFields em)
}
where
emName = embeddedHaskell em
breakCycleEmField ancestors emf = case embeddedHaskell <$> membed of
Nothing -> emf
Just embName -> if embName `elem` ancestors
then emf { emFieldEmbed = Nothing, emFieldCycle = Just embName }
else emf { emFieldEmbed = breakCycleEmbed ancestors <$> membed }
where
membed = emFieldEmbed emf
stripId :: FieldType -> Maybe Text
stripId (FTTypeCon Nothing t) = stripSuffix "Id" t
stripId _ = Nothing
foreignReference :: FieldDef -> Maybe HaskellName
foreignReference field = case fieldReference field of
ForeignRef ref _ -> Just ref
_ -> Nothing
-- fieldSqlType at parse time can be an Exp
-- This helps delay setting fieldSqlType until lift time
data EntityDefSqlTypeExp = EntityDefSqlTypeExp EntityDef SqlTypeExp [SqlTypeExp]
deriving Show
data SqlTypeExp = SqlTypeExp FieldType
| SqlType' SqlType
deriving Show
instance Lift SqlTypeExp where
lift (SqlType' t) = lift t
lift (SqlTypeExp ftype) = return st
where
typ = ftToType ftype
mtyp = (ConT ''Proxy `AppT` typ)
typedNothing = SigE (ConE 'Proxy) mtyp
st = VarE 'sqlType `AppE` typedNothing
data FieldsSqlTypeExp = FieldsSqlTypeExp [FieldDef] [SqlTypeExp]
instance Lift FieldsSqlTypeExp where
lift (FieldsSqlTypeExp fields sqlTypeExps) =
lift $ zipWith FieldSqlTypeExp fields sqlTypeExps
data FieldSqlTypeExp = FieldSqlTypeExp FieldDef SqlTypeExp
instance Lift FieldSqlTypeExp where
lift (FieldSqlTypeExp (FieldDef{..}) sqlTypeExp) =
[|FieldDef fieldHaskell fieldDB fieldType $(lift sqlTypeExp) fieldAttrs fieldStrict fieldReference|]
instance Lift EntityDefSqlTypeExp where
lift (EntityDefSqlTypeExp ent sqlTypeExp sqlTypeExps) =
[|ent { entityFields = $(lift $ FieldsSqlTypeExp (entityFields ent) sqlTypeExps)
, entityId = $(lift $ FieldSqlTypeExp (entityId ent) sqlTypeExp)
}
|]
instance Lift ReferenceDef where
lift NoReference = [|NoReference|]
lift (ForeignRef name ft) = [|ForeignRef name ft|]
lift (EmbedRef em) = [|EmbedRef em|]
lift (CompositeRef cdef) = [|CompositeRef cdef|]
lift (SelfReference) = [|SelfReference|]
instance Lift EmbedEntityDef where
lift (EmbedEntityDef name fields) = [|EmbedEntityDef name fields|]
instance Lift EmbedFieldDef where
lift (EmbedFieldDef name em cyc) = [|EmbedFieldDef name em cyc|]
type EmbedEntityMap = M.Map HaskellName EmbedEntityDef
type EntityMap = M.Map HaskellName EntityDef
data FTTypeConDescr = FTKeyCon deriving Show
mEmbedded :: EmbedEntityMap -> FieldType -> Either (Maybe FTTypeConDescr) EmbedEntityDef
mEmbedded _ (FTTypeCon Just{} _) = Left Nothing
mEmbedded ents (FTTypeCon Nothing n) = let name = HaskellName n in
maybe (Left Nothing) Right $ M.lookup name ents
mEmbedded ents (FTList x) = mEmbedded ents x
mEmbedded ents (FTApp x y) =
-- Key convets an Record to a RecordId
-- special casing this is obviously a hack
-- This problem may not be solvable with the current QuasiQuoted approach though
if x == FTTypeCon Nothing "Key"
then Left $ Just FTKeyCon
else mEmbedded ents y
setEmbedField :: HaskellName -> EmbedEntityMap -> FieldDef -> FieldDef
setEmbedField entName allEntities field = field
{ fieldReference = case fieldReference field of
NoReference ->
case mEmbedded allEntities (fieldType field) of
Left _ -> case stripId $ fieldType field of
Nothing -> NoReference
Just name -> case M.lookup (HaskellName name) allEntities of
Nothing -> NoReference
Just x -> ForeignRef (HaskellName name)
-- This will get corrected in mkEntityDefSqlTypeExp
(FTTypeCon Nothing $ pack $ nameBase ''Int)
Right em -> if embeddedHaskell em /= entName
then EmbedRef em
else if maybeNullable field
then SelfReference
else error $ unpack $ unHaskellName entName `mappend` ": a self reference must be a Maybe"
existing@_ -> existing
}
mkEntityDefSqlTypeExp :: EmbedEntityMap -> EntityMap -> EntityDef -> EntityDefSqlTypeExp
mkEntityDefSqlTypeExp emEntities entMap ent = EntityDefSqlTypeExp ent
(getSqlType $ entityId ent)
$ (map getSqlType $ entityFields ent)
where
getSqlType field = maybe
(defaultSqlTypeExp field)
(SqlType' . SqlOther)
(listToMaybe $ mapMaybe (stripPrefix "sqltype=") $ fieldAttrs field)
-- In the case of embedding, there won't be any datatype created yet.
-- We just use SqlString, as the data will be serialized to JSON.
defaultSqlTypeExp field = case mEmbedded emEntities ftype of
Right _ -> SqlType' SqlString
Left (Just FTKeyCon) -> SqlType' SqlString
Left Nothing -> case fieldReference field of
ForeignRef refName ft -> case M.lookup refName entMap of
Nothing -> SqlTypeExp ft
-- A ForeignRef is blindly set to an Int in setEmbedField
-- correct that now
Just ent -> case entityPrimary ent of
Nothing -> SqlTypeExp ft
Just pdef -> case compositeFields pdef of
[] -> error "mkEntityDefSqlTypeExp: no composite fields"
[x] -> SqlTypeExp $ fieldType x
_ -> SqlType' $ SqlOther "Composite Reference"
CompositeRef _ -> SqlType' $ SqlOther "Composite Reference"
_ -> case ftype of
-- In the case of lists, we always serialize to a string
-- value (via JSON).
--
-- Normally, this would be determined automatically by
-- SqlTypeExp. However, there's one corner case: if there's
-- a list of entity IDs, the datatype for the ID has not
-- yet been created, so the compiler will fail. This extra
-- clause works around this limitation.
FTList _ -> SqlType' SqlString
_ -> SqlTypeExp ftype
where
ftype = fieldType field
-- | Create data types and appropriate 'PersistEntity' instances for the given
-- 'EntityDef's. Works well with the persist quasi-quoter.
mkPersist :: MkPersistSettings -> [EntityDef] -> Q [Dec]
mkPersist mps ents' = do
x <- fmap mconcat $ mapM (persistFieldFromEntity mps) ents
y <- fmap mconcat $ mapM (mkEntity mps) ents
z <- fmap mconcat $ mapM (mkJSON mps) ents
return $ mconcat [x, y, z]
where
ents = map fixEntityDef ents'
-- | Implement special preprocessing on EntityDef as necessary for 'mkPersist'.
-- For example, strip out any fields marked as MigrationOnly.
fixEntityDef :: EntityDef -> EntityDef
fixEntityDef ed =
ed { entityFields = filter keepField $ entityFields ed }
where
keepField fd = "MigrationOnly" `notElem` fieldAttrs fd &&
"SafeToRemove" `notElem` fieldAttrs fd
-- | Settings to be passed to the 'mkPersist' function.
data MkPersistSettings = MkPersistSettings
{ mpsBackend :: Type
-- ^ Which database backend we\'re using.
--
-- When generating data types, each type is given a generic version- which
-- works with any backend- and a type synonym for the commonly used
-- backend. This is where you specify that commonly used backend.
, mpsGeneric :: Bool
-- ^ Create generic types that can be used with multiple backends. Good for
-- reusable code, but makes error messages harder to understand. Default:
-- True.
, mpsPrefixFields :: Bool
-- ^ Prefix field names with the model name. Default: True.
, mpsEntityJSON :: Maybe EntityJSON
-- ^ Generate @ToJSON@/@FromJSON@ instances for each model types. If it's
-- @Nothing@, no instances will be generated. Default:
--
-- @
-- Just EntityJSON
-- { entityToJSON = 'keyValueEntityToJSON
-- , entityFromJSON = 'keyValueEntityFromJSON
-- }
-- @
, mpsGenerateLenses :: !Bool
-- ^ Instead of generating normal field accessors, generator lens-style accessors.
--
-- Default: False
--
-- Since 1.3.1
}
data EntityJSON = EntityJSON
{ entityToJSON :: Name
-- ^ Name of the @toJSON@ implementation for @Entity a@.
, entityFromJSON :: Name
-- ^ Name of the @fromJSON@ implementation for @Entity a@.
}
-- | Create an @MkPersistSettings@ with default values.
mkPersistSettings :: Type -- ^ Value for 'mpsBackend'
-> MkPersistSettings
mkPersistSettings t = MkPersistSettings
{ mpsBackend = t
, mpsGeneric = False
, mpsPrefixFields = True
, mpsEntityJSON = Just EntityJSON
{ entityToJSON = 'entityIdToJSON
, entityFromJSON = 'entityIdFromJSON
}
, mpsGenerateLenses = False
}
-- | Use the 'SqlPersist' backend.
sqlSettings :: MkPersistSettings
sqlSettings = mkPersistSettings $ ConT ''SqlBackend
-- | Same as 'sqlSettings'.
--
-- Since 1.1.1
sqlOnlySettings :: MkPersistSettings
sqlOnlySettings = sqlSettings
{-# DEPRECATED sqlOnlySettings "use sqlSettings" #-}
recNameNoUnderscore :: MkPersistSettings -> HaskellName -> HaskellName -> Text
recNameNoUnderscore mps dt f
| mpsPrefixFields mps = lowerFirst (unHaskellName dt) ++ upperFirst ft
| otherwise = lowerFirst ft
where ft = unHaskellName f
recName :: MkPersistSettings -> HaskellName -> HaskellName -> Text
recName mps dt f =
addUnderscore $ recNameNoUnderscore mps dt f
where
addUnderscore
| mpsGenerateLenses mps = ("_" ++)
| otherwise = id
lowerFirst :: Text -> Text
lowerFirst t =
case uncons t of
Just (a, b) -> cons (toLower a) b
Nothing -> t
upperFirst :: Text -> Text
upperFirst t =
case uncons t of
Just (a, b) -> cons (toUpper a) b
Nothing -> t
dataTypeDec :: MkPersistSettings -> EntityDef -> Dec
dataTypeDec mps t =
DataD [] nameFinal paramsFinal constrs
$ map (mkName . unpack) $ entityDerives t
where
mkCol x fd@FieldDef {..} =
(mkName $ unpack $ recName mps x fieldHaskell,
if fieldStrict then IsStrict else NotStrict,
maybeIdType mps fd Nothing Nothing
)
(nameFinal, paramsFinal)
| mpsGeneric mps = (nameG, [PlainTV backend])
| otherwise = (name, [])
nameG = mkName $ unpack $ unHaskellName (entityHaskell t) ++ "Generic"
name = mkName $ unpack $ unHaskellName $ entityHaskell t
cols = map (mkCol $ entityHaskell t) $ entityFields t
backend = backendName
constrs
| entitySum t = map sumCon $ entityFields t
| otherwise = [RecC name cols]
sumCon fd = NormalC
(sumConstrName mps t fd)
[(NotStrict, maybeIdType mps fd Nothing Nothing)]
sumConstrName :: MkPersistSettings -> EntityDef -> FieldDef -> Name
sumConstrName mps t FieldDef {..} = mkName $ unpack $ concat
[ if mpsPrefixFields mps
then unHaskellName $ entityHaskell t
else ""
, upperFirst $ unHaskellName fieldHaskell
, "Sum"
]
uniqueTypeDec :: MkPersistSettings -> EntityDef -> Dec
uniqueTypeDec mps t =
DataInstD [] ''Unique
[genericDataType mps (entityHaskell t) backendT]
(map (mkUnique mps t) $ entityUniques t)
[]
mkUnique :: MkPersistSettings -> EntityDef -> UniqueDef -> Con
mkUnique mps t (UniqueDef (HaskellName constr) _ fields attrs) =
NormalC (mkName $ unpack constr) types
where
types = map (go . flip lookup3 (entityFields t))
$ map (unHaskellName . fst) fields
force = "!force" `elem` attrs
go :: (FieldDef, IsNullable) -> (Strict, Type)
go (_, Nullable _) | not force = error nullErrMsg
go (fd, y) = (NotStrict, maybeIdType mps fd Nothing (Just y))
lookup3 :: Text -> [FieldDef] -> (FieldDef, IsNullable)
lookup3 s [] =
error $ unpack $ "Column not found: " ++ s ++ " in unique " ++ constr
lookup3 x (fd@FieldDef {..}:rest)
| x == unHaskellName fieldHaskell = (fd, nullable fieldAttrs)
| otherwise = lookup3 x rest
nullErrMsg =
mconcat [ "Error: By default we disallow NULLables in an uniqueness "
, "constraint. The semantics of how NULL interacts with those "
, "constraints is non-trivial: two NULL values are not "
, "considered equal for the purposes of an uniqueness "
, "constraint. If you understand this feature, it is possible "
, "to use it your advantage. *** Use a \"!force\" attribute "
, "on the end of the line that defines your uniqueness "
, "constraint in order to disable this check. ***" ]
maybeIdType :: MkPersistSettings
-> FieldDef
-> Maybe Name -- ^ backend
-> Maybe IsNullable
-> Type
maybeIdType mps fd mbackend mnull = maybeTyp mayNullable idtyp
where
mayNullable = case mnull of
(Just (Nullable ByMaybeAttr)) -> True
_ -> maybeNullable fd
idtyp = idType mps fd mbackend
backendDataType :: MkPersistSettings -> Type
backendDataType mps
| mpsGeneric mps = backendT
| otherwise = mpsBackend mps
genericDataType :: MkPersistSettings
-> HaskellName -- ^ entity name
-> Type -- ^ backend
-> Type
genericDataType mps (HaskellName typ') backend
| mpsGeneric mps = ConT (mkName $ unpack $ typ' ++ "Generic") `AppT` backend
| otherwise = ConT $ mkName $ unpack typ'
idType :: MkPersistSettings -> FieldDef -> Maybe Name -> Type
idType mps fd mbackend =
case foreignReference fd of
Just typ ->
ConT ''Key
`AppT` genericDataType mps typ (VarT $ fromMaybe backendName mbackend)
Nothing -> ftToType $ fieldType fd
degen :: [Clause] -> [Clause]
degen [] =
let err = VarE 'error `AppE` LitE (StringL
"Degenerate case, should never happen")
in [normalClause [WildP] err]
degen x = x
mkToPersistFields :: MkPersistSettings -> String -> EntityDef -> Q Dec
mkToPersistFields mps constr ed@EntityDef { entitySum = isSum, entityFields = fields } = do
clauses <-
if isSum
then sequence $ zipWith goSum fields [1..]
else fmap return go
return $ FunD 'toPersistFields clauses
where
go :: Q Clause
go = do
xs <- sequence $ replicate fieldCount $ newName "x"
let pat = ConP (mkName constr) $ map VarP xs
sp <- [|SomePersistField|]
let bod = ListE $ map (AppE sp . VarE) xs
return $ normalClause [pat] bod
fieldCount = length fields
goSum :: FieldDef -> Int -> Q Clause
goSum fd idx = do
let name = sumConstrName mps ed fd
enull <- [|SomePersistField PersistNull|]
let beforeCount = idx - 1
afterCount = fieldCount - idx
before = replicate beforeCount enull
after = replicate afterCount enull
x <- newName "x"
sp <- [|SomePersistField|]
let body = ListE $ mconcat
[ before
, [sp `AppE` VarE x]
, after
]
return $ normalClause [ConP name [VarP x]] body
mkToFieldNames :: [UniqueDef] -> Q Dec
mkToFieldNames pairs = do
pairs' <- mapM go pairs
return $ FunD 'persistUniqueToFieldNames $ degen pairs'
where
go (UniqueDef constr _ names _) = do
names' <- lift names
return $
normalClause
[RecP (mkName $ unpack $ unHaskellName constr) []]
names'
mkUniqueToValues :: [UniqueDef] -> Q Dec
mkUniqueToValues pairs = do
pairs' <- mapM go pairs
return $ FunD 'persistUniqueToValues $ degen pairs'
where
go :: UniqueDef -> Q Clause
go (UniqueDef constr _ names _) = do
xs <- mapM (const $ newName "x") names
let pat = ConP (mkName $ unpack $ unHaskellName constr) $ map VarP xs
tpv <- [|toPersistValue|]
let bod = ListE $ map (AppE tpv . VarE) xs
return $ normalClause [pat] bod
isNotNull :: PersistValue -> Bool
isNotNull PersistNull = False
isNotNull _ = True
mapLeft :: (a -> c) -> Either a b -> Either c b
mapLeft _ (Right r) = Right r
mapLeft f (Left l) = Left (f l)
fieldError :: Text -> Text -> Text
fieldError fieldName err = "field " `mappend` fieldName `mappend` ": " `mappend` err
mkFromPersistValues :: MkPersistSettings -> EntityDef -> Q [Clause]
mkFromPersistValues _ t@(EntityDef { entitySum = False }) =
fromValues t "fromPersistValues" entE $ entityFields t
where
entE = ConE $ mkName $ unpack entName
entName = unHaskellName $ entityHaskell t
mkFromPersistValues mps t@(EntityDef { entitySum = True }) = do
nothing <- [|Left ("Invalid fromPersistValues input: sum type with all nulls. Entity: " `mappend` entName)|]
clauses <- mkClauses [] $ entityFields t
return $ clauses `mappend` [normalClause [WildP] nothing]
where
entName = unHaskellName $ entityHaskell t
mkClauses _ [] = return []
mkClauses before (field:after) = do
x <- newName "x"
let null' = ConP 'PersistNull []
pat = ListP $ mconcat
[ map (const null') before
, [VarP x]
, map (const null') after
]
constr = ConE $ sumConstrName mps t field
fs <- [|fromPersistValue $(return $ VarE x)|]
let guard' = NormalG $ VarE 'isNotNull `AppE` VarE x
let clause = Clause [pat] (GuardedB [(guard', InfixE (Just constr) fmapE (Just fs))]) []
clauses <- mkClauses (field : before) after
return $ clause : clauses
type Lens s t a b = forall f. Functor f => (a -> f b) -> s -> f t
lensPTH :: (s -> a) -> (s -> b -> t) -> Lens s t a b
lensPTH sa sbt afb s = fmap (sbt s) (afb $ sa s)
fmapE :: Exp
fmapE = VarE 'fmap
mkLensClauses :: MkPersistSettings -> EntityDef -> Q [Clause]
mkLensClauses mps t = do
lens' <- [|lensPTH|]
getId <- [|entityKey|]
setId <- [|\(Entity _ value) key -> Entity key value|]
getVal <- [|entityVal|]
dot <- [|(.)|]
keyVar <- newName "key"
valName <- newName "value"
xName <- newName "x"
let idClause = normalClause
[ConP (keyIdName t) []]
(lens' `AppE` getId `AppE` setId)
if entitySum t
then return $ idClause : map (toSumClause lens' keyVar valName xName) (entityFields t)
else return $ idClause : map (toClause lens' getVal dot keyVar valName xName) (entityFields t)
where
toClause lens' getVal dot keyVar valName xName f = normalClause
[ConP (filterConName mps t f) []]
(lens' `AppE` getter `AppE` setter)
where
fieldName = mkName $ unpack $ recName mps (entityHaskell t) (fieldHaskell f)
getter = InfixE (Just $ VarE fieldName) dot (Just getVal)
setter = LamE
[ ConP 'Entity [VarP keyVar, VarP valName]
, VarP xName
]
$ ConE 'Entity `AppE` VarE keyVar `AppE` RecUpdE
(VarE valName)
[(fieldName, VarE xName)]
toSumClause lens' keyVar valName xName f = normalClause
[ConP (filterConName mps t f) []]
(lens' `AppE` getter `AppE` setter)
where
emptyMatch = Match WildP (NormalB $ VarE 'error `AppE` LitE (StringL "Tried to use fieldLens on a Sum type")) []
getter = LamE
[ ConP 'Entity [WildP, VarP valName]
] $ CaseE (VarE valName)
$ Match (ConP (sumConstrName mps t f) [VarP xName]) (NormalB $ VarE xName) []
-- FIXME It would be nice if the types expressed that the Field is
-- a sum type and therefore could result in Maybe.
: if length (entityFields t) > 1 then [emptyMatch] else []
setter = LamE
[ ConP 'Entity [VarP keyVar, WildP]
, VarP xName
]
$ ConE 'Entity `AppE` VarE keyVar `AppE` (ConE (sumConstrName mps t f) `AppE` VarE xName)
-- | declare the key type and associated instances
-- a PathPiece instance is only generated for a Key with one field
mkKeyTypeDec :: MkPersistSettings -> EntityDef -> Q (Dec, [Dec])
mkKeyTypeDec mps t = do
(instDecs, i) <-
if mpsGeneric mps
then if not useNewtype
then do pfDec <- pfInstD
return (pfDec, [''Generic])
else do gi <- genericNewtypeInstances
return (gi, [])
else if not useNewtype
then do pfDec <- pfInstD
return (pfDec, [''Show, ''Read, ''Eq, ''Ord, ''Generic])
else do
let allInstances = [''Show, ''Read, ''Eq, ''Ord, ''PathPiece, ''PersistField, ''PersistFieldSql, ''ToJSON, ''FromJSON]
if customKeyType
then return ([], allInstances)
else do
bi <- backendKeyI
return (bi, allInstances)
let kd = if useNewtype
then NewtypeInstD [] k [recordType] dec i
else DataInstD [] k [recordType] [dec] i
return (kd, instDecs)
where
keyConE = keyConExp t
unKeyE = unKeyExp t
dec = RecC (keyConName t) (keyFields mps t)
k = ''Key
recordType = genericDataType mps (entityHaskell t) backendT
pfInstD = -- FIXME: generate a PersistMap instead of PersistList
[d|instance PersistField (Key $(pure recordType)) where
toPersistValue = PersistList . keyToValues
fromPersistValue (PersistList l) = keyFromValues l
fromPersistValue got = error $ "fromPersistValue: expected PersistList, got: " `mappend` show got
instance PersistFieldSql (Key $(pure recordType)) where
sqlType _ = SqlString
instance ToJSON (Key $(pure recordType))
instance FromJSON (Key $(pure recordType))
|]
keyStringL = StringL . keyString
-- ghc 7.6 cannot parse the left arrow Ident $() <- lexP
keyPattern = BindS (ConP 'Ident [LitP $ keyStringL t])
backendKeyGenericI =
[d| instance PersistStore $(pure backendT) =>
ToBackendKey $(pure backendT) $(pure recordType) where
toBackendKey = $(return unKeyE)
fromBackendKey = $(return keyConE)
|]
backendKeyI = let bdt = backendDataType mps in
[d| instance ToBackendKey $(pure bdt) $(pure recordType) where
toBackendKey = $(return unKeyE)
fromBackendKey = $(return keyConE)
|]
-- truly unfortunate that TH doesn't support standalone deriving
-- https://ghc.haskell.org/trac/ghc/ticket/8100
genericNewtypeInstances = do
instances <- [|lexP|] >>= \lexPE -> [| step readPrec >>= return . ($(pure keyConE) )|] >>= \readE -> do
alwaysInstances <-
[d|instance Show (BackendKey $(pure backendT)) => Show (Key $(pure recordType)) where
showsPrec i x = showParen (i > app_prec) $
(showString $ $(pure $ LitE $ keyStringL t) `mappend` " ") .
showsPrec i ($(return unKeyE) x)
where app_prec = (10::Int)
instance Read (BackendKey $(pure backendT)) => Read (Key $(pure recordType)) where
readPrec = parens $ (prec app_prec $ $(pure $ DoE [keyPattern lexPE, NoBindS readE]))
where app_prec = (10::Int)
instance Eq (BackendKey $(pure backendT)) => Eq (Key $(pure recordType)) where
x == y =
($(return unKeyE) x) ==
($(return unKeyE) y)
x /= y =
($(return unKeyE) x) ==
($(return unKeyE) y)
instance Ord (BackendKey $(pure backendT)) => Ord (Key $(pure recordType)) where
compare x y = compare
($(return unKeyE) x)
($(return unKeyE) y)
instance PathPiece (BackendKey $(pure backendT)) => PathPiece (Key $(pure recordType)) where
toPathPiece = toPathPiece . $(return unKeyE)
fromPathPiece = fmap $(return keyConE) . fromPathPiece
instance PersistField (BackendKey $(pure backendT)) => PersistField (Key $(pure recordType)) where
toPersistValue = toPersistValue . $(return unKeyE)
fromPersistValue = fmap $(return keyConE) . fromPersistValue
instance PersistFieldSql (BackendKey $(pure backendT)) => PersistFieldSql (Key $(pure recordType)) where
sqlType = sqlType . fmap $(return unKeyE)
instance ToJSON (BackendKey $(pure backendT)) => ToJSON (Key $(pure recordType)) where
toJSON = toJSON . $(return unKeyE)
instance FromJSON (BackendKey $(pure backendT)) => FromJSON (Key $(pure recordType)) where
parseJSON = fmap $(return keyConE) . parseJSON
|]
if customKeyType then return alwaysInstances
else fmap (alwaysInstances `mappend`) backendKeyGenericI
return instances
useNewtype = pkNewtype mps t
customKeyType = not (defaultIdType t) || not useNewtype || isJust (entityPrimary t)
keyIdName :: EntityDef -> Name
keyIdName = mkName . unpack . keyIdText
keyIdText :: EntityDef -> Text
keyIdText t = (unHaskellName $ entityHaskell t) `mappend` "Id"
unKeyName :: EntityDef -> Name
unKeyName t = mkName $ "un" `mappend` keyString t
unKeyExp :: EntityDef -> Exp
unKeyExp = VarE . unKeyName
backendT :: Type
backendT = VarT backendName
backendName :: Name
backendName = mkName "backend"
keyConName :: EntityDef -> Name
keyConName t = mkName $ resolveConflict $ keyString t
where
resolveConflict kn = if conflict then kn `mappend` "'" else kn
conflict = any ((== HaskellName "key") . fieldHaskell) $ entityFields t
keyConExp :: EntityDef -> Exp
keyConExp = ConE . keyConName
keyString :: EntityDef -> String
keyString = unpack . keyText
keyText :: EntityDef -> Text
keyText t = unHaskellName (entityHaskell t) ++ "Key"
pkNewtype :: MkPersistSettings -> EntityDef -> Bool
pkNewtype mps t = length (keyFields mps t) < 2
defaultIdType :: EntityDef -> Bool
defaultIdType t = fieldType (entityId t) == FTTypeCon Nothing (keyIdText t)
keyFields :: MkPersistSettings -> EntityDef -> [(Name, Strict, Type)]
keyFields mps t = case entityPrimary t of
Just pdef -> map primaryKeyVar $ (compositeFields pdef)
Nothing -> if defaultIdType t
then [idKeyVar backendKeyType]
else [idKeyVar $ ftToType $ fieldType $ entityId t]
where
backendKeyType
| mpsGeneric mps = ConT ''BackendKey `AppT` backendT
| otherwise = ConT ''BackendKey `AppT` mpsBackend mps
idKeyVar ft = (unKeyName t, NotStrict, ft)
primaryKeyVar fd = ( keyFieldName mps t fd
, NotStrict
, ftToType $ fieldType fd
)
keyFieldName :: MkPersistSettings -> EntityDef -> FieldDef -> Name
keyFieldName mps t fd
| pkNewtype mps t = unKeyName t
| otherwise = mkName $ unpack
$ lowerFirst (keyText t) `mappend` (unHaskellName $ fieldHaskell fd)
mkKeyToValues :: MkPersistSettings -> EntityDef -> Q Dec
mkKeyToValues mps t = do
(p, e) <- case entityPrimary t of
Nothing ->
([],) <$> [|(:[]) . toPersistValue . $(return $ unKeyExp t)|]
Just pdef ->
return $ toValuesPrimary pdef
return $ FunD 'keyToValues $ return $ normalClause p e
where
toValuesPrimary pdef =
( [VarP recordName]
, ListE $ map (\fd -> VarE 'toPersistValue `AppE` (VarE (keyFieldName mps t fd) `AppE` VarE recordName)) $ compositeFields pdef
)
recordName = mkName "record"
normalClause :: [Pat] -> Exp -> Clause
normalClause p e = Clause p (NormalB e) []
mkKeyFromValues :: MkPersistSettings -> EntityDef -> Q Dec
mkKeyFromValues _mps t = do
clauses <- case entityPrimary t of
Nothing -> do
e <- [|fmap $(return $ keyConE) . fromPersistValue . headNote|]
return $ [normalClause [] e]
Just pdef ->
fromValues t "keyFromValues" keyConE (compositeFields pdef)
return $ FunD 'keyFromValues clauses
where
keyConE = keyConExp t
headNote :: [PersistValue] -> PersistValue
headNote (x:[]) = x
headNote xs = error $ "mkKeyFromValues: expected a list of one element, got: "
`mappend` show xs
fromValues :: EntityDef -> Text -> Exp -> [FieldDef] -> Q [Clause]
fromValues t funName conE fields = do
x <- newName "x"
let funMsg = entityText t `mappend` ": " `mappend` funName `mappend` " failed on: "
patternMatchFailure <-
[|Left $ mappend funMsg (pack $ show $(return $ VarE x))|]
suc <- patternSuccess fields
return [ suc, normalClause [VarP x] patternMatchFailure ]
where
patternSuccess [] = do
rightE <- [|Right|]
return $ normalClause [ListP []] (rightE `AppE` conE)
patternSuccess fieldsNE = do
x1 <- newName "x1"
restNames <- mapM (\i -> newName $ "x" `mappend` show i) [2..length fieldsNE]
(fpv1:mkPersistValues) <- mapM mkPvFromFd fieldsNE
app1E <- [|(<$>)|]
let conApp = infixFromPersistValue app1E fpv1 conE x1
applyE <- [|(<*>)|]
let applyFromPersistValue = infixFromPersistValue applyE
return $ normalClause
[ListP $ map VarP (x1:restNames)]
(foldl' (\exp (name, fpv) -> applyFromPersistValue fpv exp name) conApp (zip restNames mkPersistValues))
where
infixFromPersistValue applyE fpv exp name =
UInfixE exp applyE (fpv `AppE` VarE name)
mkPvFromFd = mkPersistValue . unHaskellName . fieldHaskell
mkPersistValue fieldName = [|mapLeft (fieldError fieldName) . fromPersistValue|]
mkEntity :: MkPersistSettings -> EntityDef -> Q [Dec]
mkEntity mps t = do
t' <- lift t
let nameT = unHaskellName entName
let nameS = unpack nameT
let clazz = ConT ''PersistEntity `AppT` genDataType
tpf <- mkToPersistFields mps nameS t
fpv <- mkFromPersistValues mps t
utv <- mkUniqueToValues $ entityUniques t
puk <- mkUniqueKeys t
fkc <- mapM (mkForeignKeysComposite mps t) $ entityForeigns t
let primaryField = entityId t
fields <- mapM (mkField mps t) $ primaryField : entityFields t
toFieldNames <- mkToFieldNames $ entityUniques t
(keyTypeDec, keyInstanceDecs) <- mkKeyTypeDec mps t
keyToValues' <- mkKeyToValues mps t
keyFromValues' <- mkKeyFromValues mps t
let addSyn -- FIXME maybe remove this
| mpsGeneric mps = (:) $
TySynD (mkName nameS) [] $
genericDataType mps entName $ mpsBackend mps
| otherwise = id
lensClauses <- mkLensClauses mps t
lenses <- mkLenses mps t
let instanceConstraint = if not (mpsGeneric mps) then [] else
[mkClassP ''PersistStore [backendT]]
return $ addSyn $
dataTypeDec mps t : mconcat fkc `mappend`
([ TySynD (keyIdName t) [] $
ConT ''Key `AppT` ConT (mkName nameS)
, InstanceD instanceConstraint clazz $
[ uniqueTypeDec mps t
, keyTypeDec
, keyToValues'
, keyFromValues'
, FunD 'entityDef [normalClause [WildP] t']
, tpf
, FunD 'fromPersistValues fpv
, toFieldNames
, utv
, puk
, DataInstD
[]
''EntityField
[ genDataType
, VarT $ mkName "typ"
]
(map fst fields)
[]
, FunD 'persistFieldDef (map snd fields)
, TySynInstD
''PersistEntityBackend
#if MIN_VERSION_template_haskell(2,9,0)
(TySynEqn
[genDataType]
(backendDataType mps))
#else
[genDataType]
(backendDataType mps)
#endif
, FunD 'persistIdField [normalClause [] (ConE $ keyIdName t)]
, FunD 'fieldLens lensClauses
]
] `mappend` lenses) `mappend` keyInstanceDecs
where
genDataType = genericDataType mps entName backendT
entName = entityHaskell t
entityText :: EntityDef -> Text
entityText = unHaskellName . entityHaskell
mkLenses :: MkPersistSettings -> EntityDef -> Q [Dec]
mkLenses mps _ | not (mpsGenerateLenses mps) = return []
mkLenses _ ent | entitySum ent = return []
mkLenses mps ent = fmap mconcat $ forM (entityFields ent) $ \field -> do
let lensName' = recNameNoUnderscore mps (entityHaskell ent) (fieldHaskell field)
lensName = mkName $ unpack lensName'
fieldName = mkName $ unpack $ "_" ++ lensName'
needleN <- newName "needle"
setterN <- newName "setter"
fN <- newName "f"
aN <- newName "a"
yN <- newName "y"
let needle = VarE needleN
setter = VarE setterN
f = VarE fN
a = VarE aN
y = VarE yN
fT = mkName "f"
-- FIXME if we want to get really fancy, then: if this field is the
-- *only* Id field present, then set backend1 and backend2 to different
-- values
backend1 = backendName
backend2 = backendName
aT = maybeIdType mps field (Just backend1) Nothing
bT = maybeIdType mps field (Just backend2) Nothing
mkST backend = genericDataType mps (entityHaskell ent) (VarT backend)
sT = mkST backend1
tT = mkST backend2
t1 `arrow` t2 = ArrowT `AppT` t1 `AppT` t2
vars = PlainTV fT
: (if mpsGeneric mps then [PlainTV backend1{-, PlainTV backend2-}] else [])
return
[ SigD lensName $ ForallT vars [mkClassP ''Functor [VarT fT]] $
(aT `arrow` (VarT fT `AppT` bT)) `arrow`
(sT `arrow` (VarT fT `AppT` tT))
, FunD lensName $ return $ Clause
[VarP fN, VarP aN]
(NormalB $ fmapE
`AppE` setter
`AppE` (f `AppE` needle))
[ FunD needleN [normalClause [] (VarE fieldName `AppE` a)]
, FunD setterN $ return $ normalClause
[VarP yN]
(RecUpdE a
[ (fieldName, y)
])
]
]
mkForeignKeysComposite :: MkPersistSettings -> EntityDef -> ForeignDef -> Q [Dec]
mkForeignKeysComposite mps t ForeignDef {..} = do
let fieldName f = mkName $ unpack $ recName mps (entityHaskell t) f
let fname = fieldName foreignConstraintNameHaskell
let reftableString = unpack $ unHaskellName $ foreignRefTableHaskell
let reftableKeyName = mkName $ reftableString `mappend` "Key"
let tablename = mkName $ unpack $ entityText t
recordName <- newName "record"
let fldsE = map (\((foreignName, _),_) -> VarE (fieldName $ foreignName)
`AppE` VarE recordName) foreignFields
let mkKeyE = foldl' AppE (maybeExp foreignNullable $ ConE reftableKeyName) fldsE
let fn = FunD fname [normalClause [VarP recordName] mkKeyE]
let t2 = maybeTyp foreignNullable $ ConT ''Key `AppT` ConT (mkName reftableString)
let sig = SigD fname $ (ArrowT `AppT` (ConT tablename)) `AppT` t2
return [sig, fn]
maybeExp :: Bool -> Exp -> Exp
maybeExp may exp | may = fmapE `AppE` exp
| otherwise = exp
maybeTyp :: Bool -> Type -> Type
maybeTyp may typ | may = ConT ''Maybe `AppT` typ
| otherwise = typ
-- | produce code similar to the following:
--
-- @
-- instance PersistEntity e => PersistField e where
-- toPersistValue = PersistMap $ zip columNames (map toPersistValue . toPersistFields)
-- fromPersistValue (PersistMap o) =
-- let columns = HM.fromList o
-- in fromPersistValues $ map (\name ->
-- case HM.lookup name columns of
-- Just v -> v
-- Nothing -> PersistNull
-- fromPersistValue x = Left $ "Expected PersistMap, received: " ++ show x
-- sqlType _ = SqlString
-- @
persistFieldFromEntity :: MkPersistSettings -> EntityDef -> Q [Dec]
persistFieldFromEntity mps e = do
ss <- [|SqlString|]
obj <- [|\ent -> PersistMap $ zip (map pack columnNames) (map toPersistValue $ toPersistFields ent)|]
fpv <- [|\x -> let columns = HM.fromList x
in fromPersistValues $ map
(\(name) ->
case HM.lookup (pack name) columns of
Just v -> v
Nothing -> PersistNull)
$ columnNames
|]
compose <- [|(<=<)|]
getPersistMap' <- [|getPersistMap|]
return
[ persistFieldInstanceD (mpsGeneric mps) typ
[ FunD 'toPersistValue [ normalClause [] obj ]
, FunD 'fromPersistValue
[ normalClause [] (InfixE (Just fpv) compose $ Just getPersistMap')
]
]
, persistFieldSqlInstanceD (mpsGeneric mps) typ
[ sqlTypeFunD ss
]
]
where
typ = genericDataType mps (entityHaskell e) backendT
entFields = entityFields e
columnNames = map (unpack . unHaskellName . fieldHaskell) entFields
-- | Apply the given list of functions to the same @EntityDef@s.
--
-- This function is useful for cases such as:
--
-- >>> share [mkSave "myDefs", mkPersist sqlSettings] [persistLowerCase|...|]
share :: [[EntityDef] -> Q [Dec]] -> [EntityDef] -> Q [Dec]
share fs x = fmap mconcat $ mapM ($ x) fs
-- | Save the @EntityDef@s passed in under the given name.
mkSave :: String -> [EntityDef] -> Q [Dec]
mkSave name' defs' = do
let name = mkName name'
defs <- lift defs'
return [ SigD name $ ListT `AppT` ConT ''EntityDef
, FunD name [normalClause [] defs]
]
data Dep = Dep
{ depTarget :: HaskellName
, depSourceTable :: HaskellName
, depSourceField :: HaskellName
, depSourceNull :: IsNullable
}
-- | Generate a 'DeleteCascade' instance for the given @EntityDef@s.
mkDeleteCascade :: MkPersistSettings -> [EntityDef] -> Q [Dec]
mkDeleteCascade mps defs = do
let deps = concatMap getDeps defs
mapM (go deps) defs
where
getDeps :: EntityDef -> [Dep]
getDeps def =
concatMap getDeps' $ entityFields $ fixEntityDef def
where
getDeps' :: FieldDef -> [Dep]
getDeps' field@FieldDef {..} =
case foreignReference field of
Just name ->
return Dep
{ depTarget = name
, depSourceTable = entityHaskell def
, depSourceField = fieldHaskell
, depSourceNull = nullable fieldAttrs
}
Nothing -> []
go :: [Dep] -> EntityDef -> Q Dec
go allDeps EntityDef{entityHaskell = name} = do
let deps = filter (\x -> depTarget x == name) allDeps
key <- newName "key"
let del = VarE 'delete
let dcw = VarE 'deleteCascadeWhere
just <- [|Just|]
filt <- [|Filter|]
eq <- [|Eq|]
left <- [|Left|]
let mkStmt :: Dep -> Stmt
mkStmt dep = NoBindS
$ dcw `AppE`
ListE
[ filt `AppE` ConE filtName
`AppE` (left `AppE` val (depSourceNull dep))
`AppE` eq
]
where
filtName = filterConName' mps (depSourceTable dep) (depSourceField dep)
val (Nullable ByMaybeAttr) = just `AppE` VarE key
val _ = VarE key
let stmts :: [Stmt]
stmts = map mkStmt deps `mappend`
[NoBindS $ del `AppE` VarE key]
let entityT = genericDataType mps name backendT
return $
InstanceD
[ mkClassP ''PersistQuery [backendT]
, mkEqualP (ConT ''PersistEntityBackend `AppT` entityT) backendT
]
(ConT ''DeleteCascade `AppT` entityT `AppT` backendT)
[ FunD 'deleteCascade
[normalClause [VarP key] (DoE stmts)]
]
mkUniqueKeys :: EntityDef -> Q Dec
mkUniqueKeys def | entitySum def =
return $ FunD 'persistUniqueKeys [normalClause [WildP] (ListE [])]
mkUniqueKeys def = do
c <- clause
return $ FunD 'persistUniqueKeys [c]
where
clause = do
xs <- forM (entityFields def) $ \fd -> do
let x = fieldHaskell fd
x' <- newName $ '_' : unpack (unHaskellName x)
return (x, x')
let pcs = map (go xs) $ entityUniques def
let pat = ConP
(mkName $ unpack $ unHaskellName $ entityHaskell def)
(map (VarP . snd) xs)
return $ normalClause [pat] (ListE pcs)
go :: [(HaskellName, Name)] -> UniqueDef -> Exp
go xs (UniqueDef name _ cols _) =
foldl' (go' xs) (ConE (mkName $ unpack $ unHaskellName name)) (map fst cols)
go' :: [(HaskellName, Name)] -> Exp -> HaskellName -> Exp
go' xs front col =
let Just col' = lookup col xs
in front `AppE` VarE col'
sqlTypeFunD :: Exp -> Dec
sqlTypeFunD st = FunD 'sqlType
[ normalClause [WildP] st ]
typeInstanceD :: Name
-> Bool -- ^ include PersistStore backend constraint
-> Type -> [Dec] -> Dec
typeInstanceD clazz hasBackend typ =
InstanceD ctx (ConT clazz `AppT` typ)
where
ctx
| hasBackend = [mkClassP ''PersistStore [backendT]]
| otherwise = []
persistFieldInstanceD :: Bool -- ^ include PersistStore backend constraint
-> Type -> [Dec] -> Dec
persistFieldInstanceD = typeInstanceD ''PersistField
persistFieldSqlInstanceD :: Bool -- ^ include PersistStore backend constraint
-> Type -> [Dec] -> Dec
persistFieldSqlInstanceD = typeInstanceD ''PersistFieldSql
-- | Automatically creates a valid 'PersistField' instance for any datatype
-- that has valid 'Show' and 'Read' instances. Can be very convenient for
-- 'Enum' types.
derivePersistField :: String -> Q [Dec]
derivePersistField s = do
ss <- [|SqlString|]
tpv <- [|PersistText . pack . show|]
fpv <- [|\dt v ->
case fromPersistValue v of
Left e -> Left e
Right s' ->
case reads $ unpack s' of
(x, _):_ -> Right x
[] -> Left $ pack "Invalid " ++ pack dt ++ pack ": " ++ s'|]
return
[ persistFieldInstanceD False (ConT $ mkName s)
[ FunD 'toPersistValue
[ normalClause [] tpv
]
, FunD 'fromPersistValue
[ normalClause [] (fpv `AppE` LitE (StringL s))
]
]
, persistFieldSqlInstanceD False (ConT $ mkName s)
[ sqlTypeFunD ss
]
]
-- | Automatically creates a valid 'PersistField' instance for any datatype
-- that has valid 'ToJSON' and 'FromJSON' instances. For a datatype @T@ it
-- generates instances similar to these:
--
-- @
-- instance PersistField T where
-- toPersistValue = PersistByteString . L.toStrict . encode
-- fromPersistValue = (left T.pack) . eitherDecodeStrict' <=< fromPersistValue
-- instance PersistFieldSql T where
-- sqlType _ = SqlString
-- @
derivePersistFieldJSON :: String -> Q [Dec]
derivePersistFieldJSON s = do
ss <- [|SqlString|]
tpv <- [|PersistText . toJsonText|]
fpv <- [|\dt v -> do
text <- fromPersistValue v
let bs' = TE.encodeUtf8 text
case eitherDecodeStrict' bs' of
Left e -> Left $ pack "JSON decoding error for " ++ pack dt ++ pack ": " ++ pack e ++ pack ". On Input: " ++ decodeUtf8 bs'
Right x -> Right x|]
return
[ persistFieldInstanceD False (ConT $ mkName s)
[ FunD 'toPersistValue
[ normalClause [] tpv
]
, FunD 'fromPersistValue
[ normalClause [] (fpv `AppE` LitE (StringL s))
]
]
, persistFieldSqlInstanceD False (ConT $ mkName s)
[ sqlTypeFunD ss
]
]
-- | Creates a single function to perform all migrations for the entities
-- defined here. One thing to be aware of is dependencies: if you have entities
-- with foreign references, make sure to place those definitions after the
-- entities they reference.
mkMigrate :: String -> [EntityDef] -> Q [Dec]
mkMigrate fun allDefs = do
body' <- body
return
[ SigD (mkName fun) typ
, FunD (mkName fun) [normalClause [] body']
]
where
defs = filter isMigrated allDefs
isMigrated def = not $ "no-migrate" `elem` entityAttrs def
typ = ConT ''Migration
body :: Q Exp
body =
case defs of
[] -> [|return ()|]
_ -> do
defsName <- newName "defs"
defsStmt <- do
defs' <- mapM lift defs
let defsExp = ListE defs'
return $ LetS [ValD (VarP defsName) (NormalB defsExp) []]
stmts <- mapM (toStmt $ VarE defsName) defs
return (DoE $ defsStmt : stmts)
toStmt :: Exp -> EntityDef -> Q Stmt
toStmt defsExp ed = do
u <- lift ed
m <- [|migrate|]
return $ NoBindS $ m `AppE` defsExp `AppE` u
instance Lift EntityDef where
lift EntityDef{..} =
[|EntityDef
entityHaskell
entityDB
entityId
entityAttrs
entityFields
entityUniques
entityForeigns
entityDerives
entityExtra
entitySum
|]
instance Lift FieldDef where
lift (FieldDef a b c d e f g) = [|FieldDef a b c d e f g|]
instance Lift UniqueDef where
lift (UniqueDef a b c d) = [|UniqueDef a b c d|]
instance Lift CompositeDef where
lift (CompositeDef a b) = [|CompositeDef a b|]
instance Lift ForeignDef where
lift (ForeignDef a b c d e f g) = [|ForeignDef a b c d e f g|]
-- | A hack to avoid orphans.
class Lift' a where
lift' :: a -> Q Exp
instance Lift' Text where
lift' = liftT
instance Lift' a => Lift' [a] where
lift' xs = do { xs' <- mapM lift' xs; return (ListE xs') }
instance (Lift' k, Lift' v) => Lift' (M.Map k v) where
lift' m = [|M.fromList $(fmap ListE $ mapM liftPair $ M.toList m)|]
-- auto-lifting, means instances are overlapping
instance Lift' a => Lift a where
lift = lift'
packPTH :: String -> Text
packPTH = pack
#if !MIN_VERSION_text(0, 11, 2)
{-# NOINLINE packPTH #-}
#endif
liftT :: Text -> Q Exp
liftT t = [|packPTH $(lift (unpack t))|]
liftPair :: (Lift' k, Lift' v) => (k, v) -> Q Exp
liftPair (k, v) = [|($(lift' k), $(lift' v))|]
instance Lift HaskellName where
lift (HaskellName t) = [|HaskellName t|]
instance Lift DBName where
lift (DBName t) = [|DBName t|]
instance Lift FieldType where
lift (FTTypeCon Nothing t) = [|FTTypeCon Nothing t|]
lift (FTTypeCon (Just x) t) = [|FTTypeCon (Just x) t|]
lift (FTApp x y) = [|FTApp x y|]
lift (FTList x) = [|FTList x|]
instance Lift PersistFilter where
lift Eq = [|Eq|]
lift Ne = [|Ne|]
lift Gt = [|Gt|]
lift Lt = [|Lt|]
lift Ge = [|Ge|]
lift Le = [|Le|]
lift In = [|In|]
lift NotIn = [|NotIn|]
lift (BackendSpecificFilter x) = [|BackendSpecificFilter x|]
instance Lift PersistUpdate where
lift Assign = [|Assign|]
lift Add = [|Add|]
lift Subtract = [|Subtract|]
lift Multiply = [|Multiply|]
lift Divide = [|Divide|]
lift (BackendSpecificUpdate x) = [|BackendSpecificUpdate x|]
instance Lift SqlType where
lift SqlString = [|SqlString|]
lift SqlInt32 = [|SqlInt32|]
lift SqlInt64 = [|SqlInt64|]
lift SqlReal = [|SqlReal|]
lift (SqlNumeric x y) =
[|SqlNumeric (fromInteger x') (fromInteger y')|]
where
x' = fromIntegral x :: Integer
y' = fromIntegral y :: Integer
lift SqlBool = [|SqlBool|]
lift SqlDay = [|SqlDay|]
lift SqlTime = [|SqlTime|]
lift SqlDayTime = [|SqlDayTime|]
lift SqlBlob = [|SqlBlob|]
lift (SqlOther a) = [|SqlOther a|]
-- Ent
-- fieldName FieldType
--
-- forall . typ ~ FieldType => EntFieldName
--
-- EntFieldName = FieldDef ....
mkField :: MkPersistSettings -> EntityDef -> FieldDef -> Q (Con, Clause)
mkField mps et cd = do
let con = ForallC
[]
[mkEqualP (VarT $ mkName "typ") $ maybeIdType mps cd Nothing Nothing]
$ NormalC name []
bod <- lift cd
let cla = normalClause
[ConP name []]
bod
return (con, cla)
where
name = filterConName mps et cd
maybeNullable :: FieldDef -> Bool
maybeNullable fd = nullable (fieldAttrs fd) == Nullable ByMaybeAttr
filterConName :: MkPersistSettings
-> EntityDef
-> FieldDef
-> Name
filterConName mps entity field = filterConName' mps (entityHaskell entity) (fieldHaskell field)
filterConName' :: MkPersistSettings
-> HaskellName -- ^ table
-> HaskellName -- ^ field
-> Name
filterConName' mps entity field = mkName $ unpack $ concat
[ if mpsPrefixFields mps || field == HaskellName "Id"
then unHaskellName entity
else ""
, upperFirst $ unHaskellName field
]
ftToType :: FieldType -> Type
ftToType (FTTypeCon Nothing t) = ConT $ mkName $ unpack t
ftToType (FTTypeCon (Just m) t) = ConT $ mkName $ unpack $ concat [m, ".", t]
ftToType (FTApp x y) = ftToType x `AppT` ftToType y
ftToType (FTList x) = ListT `AppT` ftToType x
infixr 5 ++
(++) :: Text -> Text -> Text
(++) = append
mkJSON :: MkPersistSettings -> EntityDef -> Q [Dec]
mkJSON _ def | not ("json" `elem` entityAttrs def) = return []
mkJSON mps def = do
pureE <- [|pure|]
apE' <- [|(<*>)|]
packE <- [|pack|]
dotEqualE <- [|(.=)|]
dotColonE <- [|(.:)|]
dotColonQE <- [|(.:?)|]
objectE <- [|object|]
obj <- newName "obj"
mzeroE <- [|mzero|]
xs <- mapM (newName . unpack . unHaskellName . fieldHaskell)
$ entityFields def
let conName = mkName $ unpack $ unHaskellName $ entityHaskell def
typ = genericDataType mps (entityHaskell def) backendT
toJSONI = typeInstanceD ''ToJSON (mpsGeneric mps) typ [toJSON']
toJSON' = FunD 'toJSON $ return $ normalClause
[ConP conName $ map VarP xs]
(objectE `AppE` ListE pairs)
pairs = zipWith toPair (entityFields def) xs
toPair f x = InfixE
(Just (packE `AppE` LitE (StringL $ unpack $ unHaskellName $ fieldHaskell f)))
dotEqualE
(Just $ VarE x)
fromJSONI = typeInstanceD ''FromJSON (mpsGeneric mps) typ [parseJSON']
parseJSON' = FunD 'parseJSON
[ normalClause [ConP 'Object [VarP obj]]
(foldl'
(\x y -> InfixE (Just x) apE' (Just y))
(pureE `AppE` ConE conName)
pulls
)
, normalClause [WildP] mzeroE
]
pulls = map toPull $ entityFields def
toPull f = InfixE
(Just $ VarE obj)
(if maybeNullable f then dotColonQE else dotColonE)
(Just $ AppE packE $ LitE $ StringL $ unpack $ unHaskellName $ fieldHaskell f)
case mpsEntityJSON mps of
Nothing -> return [toJSONI, fromJSONI]
Just entityJSON -> do
entityJSONIs <- if mpsGeneric mps
then [d|
#if MIN_VERSION_base(4, 6, 0)
instance PersistStore backend => ToJSON (Entity $(pure typ)) where
toJSON = $(varE (entityToJSON entityJSON))
instance PersistStore backend => FromJSON (Entity $(pure typ)) where
parseJSON = $(varE (entityFromJSON entityJSON))
#endif
|]
else [d|
instance ToJSON (Entity $(pure typ)) where
toJSON = $(varE (entityToJSON entityJSON))
instance FromJSON (Entity $(pure typ)) where
parseJSON = $(varE (entityFromJSON entityJSON))
|]
return $ toJSONI : fromJSONI : entityJSONIs
mkClassP :: Name -> [Type] -> Pred
#if MIN_VERSION_template_haskell(2,10,0)
mkClassP cla tys = foldl AppT (ConT cla) tys
#else
mkClassP = ClassP
#endif
mkEqualP :: Type -> Type -> Pred
#if MIN_VERSION_template_haskell(2,10,0)
mkEqualP tleft tright = foldl AppT EqualityT [tleft, tright]
#else
mkEqualP = EqualP
#endif
-- entityUpdates :: EntityDef -> [(HaskellName, FieldType, IsNullable, PersistUpdate)]
-- entityUpdates =
-- concatMap go . entityFields
-- where
-- go FieldDef {..} = map (\a -> (fieldHaskell, fieldType, nullable fieldAttrs, a)) [minBound..maxBound]
-- mkToUpdate :: String -> [(String, PersistUpdate)] -> Q Dec
-- mkToUpdate name pairs = do
-- pairs' <- mapM go pairs
-- return $ FunD (mkName name) $ degen pairs'
-- where
-- go (constr, pu) = do
-- pu' <- lift pu
-- return $ normalClause [RecP (mkName constr) []] pu'
-- mkToFieldName :: String -> [(String, String)] -> Dec
-- mkToFieldName func pairs =
-- FunD (mkName func) $ degen $ map go pairs
-- where
-- go (constr, name) =
-- normalClause [RecP (mkName constr) []] (LitE $ StringL name)
-- mkToValue :: String -> [String] -> Dec
-- mkToValue func = FunD (mkName func) . degen . map go
-- where
-- go constr =
-- let x = mkName "x"
-- in normalClause [ConP (mkName constr) [VarP x]]
-- (VarE 'toPersistValue `AppE` VarE x)
| jcristovao/persistent | persistent-template/Database/Persist/TH.hs | mit | 58,887 | 0 | 23 | 17,368 | 14,794 | 7,760 | 7,034 | -1 | -1 |
{-# LANGUAGE OverloadedStrings #-}
module Main where
import Criterion.Main
import qualified Dissent.Crypto.Rsa as R
import qualified Data.ByteString as BS
recrypt :: R.KeyPair -> BS.ByteString -> IO BS.ByteString
recrypt pair secret = do
encrypted <- R.encrypt (R.public pair) secret
R.decrypt (R.private pair) encrypted
encrypt :: R.KeyPair -> BS.ByteString -> IO R.Encrypted
encrypt pair secret = do
R.encrypt (R.public pair) secret
generateBS :: Int -> BS.ByteString
generateBS count =
BS.replicate count 3 -- randomly chosen
main :: IO ()
main = do
pair <- R.generateKeyPair
let kb1 = (generateBS 1024)
mb1 = (generateBS 1048576)
mb8 = (generateBS 8388608)
mb16 = (generateBS 16777216)
mb32 = (generateBS 33554432)
mb64 = (generateBS 67108864)
defaultMain
[ bgroup "rsa/encrypt" [ bench "1kb" $ whnfIO (encrypt pair kb1)
, bench "1mb" $ whnfIO (encrypt pair mb1)
, bench "8mb" $ whnfIO (encrypt pair mb8)
, bench "16mb" $ whnfIO (encrypt pair mb16)
, bench "32mb" $ whnfIO (encrypt pair mb32)
, bench "64mb" $ whnfIO (encrypt pair mb64)
]
, bgroup "rsa/recrypt" [ bench "1kb" $ whnfIO (recrypt pair kb1)
, bench "1mb" $ whnfIO (recrypt pair mb1)
, bench "8mb" $ whnfIO (recrypt pair mb8)
, bench "16mb" $ whnfIO (recrypt pair mb16)
, bench "32mb" $ whnfIO (recrypt pair mb32)
, bench "64mb" $ whnfIO (recrypt pair mb64)
]
]
| solatis/dissent | bench/Crypto.hs | mit | 1,775 | 0 | 14 | 661 | 544 | 271 | 273 | 37 | 1 |
{-# htermination (lookup :: MyBool -> (List (Tup2 MyBool a)) -> Maybe a) #-}
import qualified Prelude
data MyBool = MyTrue | MyFalse
data List a = Cons a (List a) | Nil
data Tup2 a b = Tup2 a b ;
data Maybe a = Nothing | Just a ;
esEsMyBool :: MyBool -> MyBool -> MyBool
esEsMyBool MyFalse MyFalse = MyTrue;
esEsMyBool MyFalse MyTrue = MyFalse;
esEsMyBool MyTrue MyFalse = MyFalse;
esEsMyBool MyTrue MyTrue = MyTrue;
lookup0 k x y xys MyTrue = lookup k xys;
otherwise :: MyBool;
otherwise = MyTrue;
lookup1 k x y xys MyTrue = Just y;
lookup1 k x y xys MyFalse = lookup0 k x y xys otherwise;
lookup2 k (Cons (Tup2 x y) xys) = lookup1 k x y xys (esEsMyBool k x);
lookup3 k Nil = Nothing;
lookup3 vy vz = lookup2 vy vz;
lookup k Nil = lookup3 k Nil;
lookup k (Cons (Tup2 x y) xys) = lookup2 k (Cons (Tup2 x y) xys);
| ComputationWithBoundedResources/ara-inference | doc/tpdb_trs/Haskell/basic_haskell/lookup_2.hs | mit | 835 | 0 | 9 | 188 | 341 | 183 | 158 | 20 | 1 |
{-# LANGUAGE DeriveDataTypeable #-}
{-
Copyright (C) 2012-2014 Kacper Bak, Jimmy Liang <http://gsd.uwaterloo.ca>
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
-}
{- | Command Line Arguments of the compiler.
See also <http://t3-necsis.cs.uwaterloo.ca:8091/ClaferTools/CommandLineArguments a model of the arguments in Clafer>, including constraints and examples.
-}
module Language.Clafer.ClaferArgs where
import System.IO ( stdin, hGetContents )
import System.Console.CmdArgs
import System.Console.CmdArgs.Explicit hiding (mode)
import Data.List
import Data.Maybe
import Language.Clafer.SplitJoin
import Paths_clafer (version)
import Data.Version (showVersion)
-- | Type of output to be generated at the end of compilation
data ClaferMode = Alloy42 | Alloy | Xml | Clafer | Html | Graph | CVLGraph | Python | Choco
deriving (Eq, Show, Ord, Data, Typeable)
instance Default ClaferMode where
def = Alloy
-- | Scope inference strategy
data ScopeStrategy = None | Simple | Full
deriving (Eq, Show, Data, Typeable)
instance Default ScopeStrategy where
def = Simple
data ClaferArgs = ClaferArgs {
mode :: [ ClaferMode ],
console_output :: Bool,
flatten_inheritance :: Bool,
timeout_analysis :: Int,
no_layout :: Bool,
new_layout :: Bool,
check_duplicates :: Bool,
skip_resolver :: Bool,
keep_unused :: Bool,
no_stats :: Bool,
schema :: Bool,
validate :: Bool,
noalloyruncommand :: Bool,
tooldir :: FilePath,
alloy_mapping :: Bool,
self_contained :: Bool,
add_graph :: Bool,
show_references :: Bool,
add_comments :: Bool,
ecore2clafer :: Bool,
scope_strategy :: ScopeStrategy,
afm :: Bool,
skip_goals :: Bool,
meta_data :: Bool,
file :: FilePath
} deriving (Show, Data, Typeable)
clafer :: ClaferArgs
clafer = ClaferArgs {
mode = [] &= help "Generated output type. Available CLAFERMODEs are: 'alloy' (default, Alloy 4.1); 'alloy42' (Alloy 4.2); 'xml' (intermediate representation of Clafer model); 'clafer' (analyzed and desugared clafer model); 'html' (original model in HTML); 'graph' (graphical representation written in DOT language); 'cvlgraph' (cvl notation representation written in DOT language); 'python' (generates IR in python); 'choco' (Choco constraint programming solver). Multiple modes can be specified at the same time, e.g., '-m alloy -m html'." &= name "m",
console_output = def &= help "Output code on console." &= name "o",
flatten_inheritance = def &= help "Flatten inheritance ('alloy' and 'alloy42' modes only)." &= name "i",
timeout_analysis = def &= help "Timeout for analysis.",
no_layout = def &= help "Don't resolve off-side rule layout." &= name "l",
new_layout = def &= help "Use new fast layout resolver (experimental)." &= name "nl",
check_duplicates = def &= help "Check duplicated clafer names in the entire model." &= name "c",
skip_resolver = def &= help "Skip name resolution." &= name "f",
keep_unused = def &= help "Keep uninstantated abstract clafers ('alloy' and 'alloy42' modes only)." &= name "k",
no_stats = def &= help "Don't print statistics." &= name "s",
schema = def &= help "Show Clafer IR (intermediate representation) XML schema.",
validate = def &= help "Validate outputs of all modes. Uses 'tools/XsdCheck.class' for XML, 'tools/alloy4.jar' and 'tools/alloy4.2.jar' for Alloy models, and Clafer translator for desugared Clafer models. Use '--tooldir' to override the default location of these tools." &= name "v",
noalloyruncommand = def &= help "For usage with partial instances: Don't generate the alloy 'run show for ... ' command, and rename @.ref with unique names ('alloy' and 'alloy42' modes only)." &= name "nr",
tooldir = def &= typDir &= help "Specify the tools directory ('validate' only). Default: 'tools/'.",
alloy_mapping = def &= help "Generate mapping to Alloy source code ('alloy' and 'alloy42' modes only)." &= name "a",
self_contained = def &= help "Generate a self-contained html document ('html' mode only).",
add_graph = def &= help "Add a graph to the generated html model ('html' mode only). Requires the \"dot\" executable to be on the system path.",
show_references = def &= help "Whether the links for references should be rendered. ('html' and 'graph' modes only)." &= name "sr",
add_comments = def &= help "Include comments from the source file in the html output ('html' mode only).",
ecore2clafer = def &= help "Translate an ECore model into Clafer.",
scope_strategy = def &= help "Use scope computation strategy: none, simple (default), or full." &= name "ss",
afm = def &= help "Throws an error if the cardinality of any of the clafers is above 1." &= name "check-afm",
skip_goals = def &= help "Skip generation of Alloy code for goals. Useful for all tools working with standard Alloy." &= name "sg",
meta_data = def &= help "Generate a 'fully qualified name'-'least-partially-qualified name'-'unique ID' map ('.cfr-map'). In Alloy, Alloy42, and Choco modes, generate the scopes map ('.cfr-scope').",
file = def &= args &= typ "FILE"
} &= summary ("Clafer " ++ showVersion Paths_clafer.version) &= program "clafer"
mergeArgs :: ClaferArgs -> ClaferArgs -> ClaferArgs
mergeArgs a1 a2 = ClaferArgs (mode a1) (coMergeArg)
(mergeArg flatten_inheritance) (mergeArg timeout_analysis)
(mergeArg no_layout) (mergeArg new_layout)
(mergeArg check_duplicates) (mergeArg skip_resolver)
(mergeArg keep_unused) (mergeArg no_stats) (mergeArg schema)
(mergeArg validate) (mergeArg noalloyruncommand) (toolMergeArg)
(mergeArg alloy_mapping) (mergeArg self_contained)
(mergeArg add_graph) (mergeArg show_references)
(mergeArg add_comments) (mergeArg ecore2clafer)
(mergeArg scope_strategy) (mergeArg afm) (mergeArg skip_goals)
(mergeArg meta_data) (mergeArg file)
where
coMergeArg :: Bool
coMergeArg = if (r1 /= False) then r1 else
if (r2 /= False) then r2 else (null $ file a1)
where r1 = console_output a1;r2 = console_output a2
toolMergeArg :: String
toolMergeArg = if (r1 /= "") then r1 else
if (r2 /= "") then r2 else "/tools"
where r1 = tooldir a1;r2 = tooldir a2
mergeArg :: (Default a, Eq a) => (ClaferArgs -> a) -> a
mergeArg f = (\r -> if (r /= def) then r else f a2) $ f a1
mainArgs :: IO (ClaferArgs, String)
mainArgs = do
args' <- cmdArgs clafer
model <- case file args' of
"" -> hGetContents stdin
f -> readFile f
let args'' = argsWithOPTIONS args' model
-- Alloy should be the default mode but only if nothing else was specified
-- cannot use [ Alloy ] as the default in the definition of `clafer :: ClaferArgs` since
-- Alloy will always be a mode in addition to the other specified modes (it will become mandatory)
let args''' = if null $ mode args''
then args''{mode = [ Alloy ]}
else args''
return $ (args''', model)
argsWithOPTIONS :: ClaferArgs -> String -> ClaferArgs
argsWithOPTIONS args' model =
let
firstLine = case lines model of
[] -> ""
(s:_) -> s
options = fromMaybe "" $ stripPrefix "//# OPTIONS " firstLine
in
either (const args') (mergeArgs args' . cmdArgsValue) $
process (cmdArgsMode clafer) $ Language.Clafer.SplitJoin.splitArgs options
defaultClaferArgs :: ClaferArgs
defaultClaferArgs = ClaferArgs [ def ] True False 0 False False False False False False False False False "tools/" False False False False False False Simple False False False ""
| juodaspaulius/clafer-old-customBNFC | src/Language/Clafer/ClaferArgs.hs | mit | 8,812 | 0 | 13 | 1,923 | 1,586 | 859 | 727 | 117 | 6 |
-- | Function module
{-# LANGUAGE UnicodeSyntax #-}
module Test.Function where
import Data.Foldable (toList)
import Data.Maybe (catMaybes)
import Data.Proof (base1)
import Data.TSTP
import T2A.Core
import Test.Proof
func1 ∷ [Formula]
func1 = do
f ← base1
return . formula $ f
map1 ∷ ProofMap
map1 = buildProofMap base1
tree1 ∷ ProofTree
tree1 = buildProofTree map1 (last base1)
signature1 ∷ [AgdaSignature]
signature1 = catMaybes . toList . fmap (buildSignature map1) $ tree1
| agomezl/tstp2agda | test/Test/Function.hs | mit | 567 | 0 | 9 | 150 | 152 | 85 | 67 | 18 | 1 |
{-# LANGUAGE FlexibleInstances #-}
{- |
Module : HaskBF.Tape
Description : Implement the brainfuck tape
Copyright : (c) Sebastian Galkin, 2014
License : MIT
Maintainer : [email protected]
Stability : experimental
Provides a type and operations to implement the brainfuck tape. The tape has
the concept of a pointer, and the pointer can be incremented or decremented.
-}
module HaskBF.Tape (
Tape (Tape)
, ExecutionError (errMsg, errTape)
, rTape, wTape
, inc, dec
, right, left
, BFExError
, BFTape
, blankTape
) where
import Data.Int
( Int8 )
import Control.Monad.Error
( Error, strMsg )
{- | Brainfuck tape. Constructor arguments correspond to
-
- 1. left of the current pointer
- 2. current pointed value
- 3. right of the current pointer
-
- The left part of the tape is reversed, so the first element of the list
- is the rightmost position. The right list is normal order, its first element
- is the leftmost one. -}
data Tape t = Tape [t] t [t]
deriving (Show)
-- | Write element to the current position in the tape
wTape :: t -- ^ The element to write
-> Tape t -- ^ The tape
-> Tape t -- ^ The modified tape
wTape b (Tape l _ r) = Tape l b r
-- | Read the pointed element
rTape :: Tape t -- ^ The tape
-> t -- ^ The element currently pointed by the pointer
rTape (Tape _ current _) = current
update :: (t -> t) -> Tape t -> Tape t
update f t = wTape (f $ rTape t) t
-- | Increment the currently pointed element
inc :: Num a
=> Tape a -- ^ The tape
-> Tape a -- ^ The tape with the current position incremented
inc = update (+ 1)
-- | Decrement the currently pointed element
dec :: Num a
=> Tape a -- ^ The tape
-> Tape a -- ^ The tape with the current position decremented
dec = update (+ (- 1))
{- | Type for execution errors, trying to move the tape beyond one of its
- ends. The 'String' argument is the error message and the 'Tape' is in
- the state right before the faulting operation -}
data ExecutionError a = ExecutionError {errMsg :: String, errTape :: Tape a}
-- | Move the pinter to the right
right :: Tape a -- ^ The tape
-> Either (ExecutionError a) (Tape a)
{- ^ A new tape with its pointer pointing to the
- element to the right of the pointer in the
- original tape; or an execution error if the
- tape to the right is exhausted -}
right t@(Tape _ _ []) =
Left $ ExecutionError "Error trying to go right on an empty tape" t
right (Tape l c (r : rs)) = Right $ Tape (c : l) r rs
-- | Move the pinter to the left
left :: Tape a -- ^ The tape
-> Either (ExecutionError a) (Tape a)
{- ^ A new tape with its pointer pointing to
- the element to the left of the pointer in
- the original tape; or an execution error if
- the tape to the left is exhausted -}
left t@(Tape [] _ _) =
Left $ ExecutionError "Error trying to go left on an empty tape" t
left (Tape (l : ls) c r) = Right $ Tape ls l (c : r)
constTape :: t -> Tape t
constTape b = Tape [] b (repeat b)
-- | Execution error type for basic Brainfuck tapes
type BFExError = ExecutionError Int8
-- | Brainfuck tapes type
type BFTape = Tape Int8
instance Error BFExError where
strMsg s = ExecutionError s (Tape [] 0 [])
{- | A @(0 :: 'Int8')@ initialized, infinite 'Tape' pointing to its
- leftmost position. An attemp to move the pointer left will result
- in an error -}
blankTape :: BFTape
blankTape = constTape 0
| paraseba/haskell-brainfuck | src/HaskBF/Tape.hs | mit | 3,479 | 0 | 9 | 854 | 662 | 361 | 301 | 57 | 1 |
{-# LANGUAGE TypeFamilies, PatternGuards, CPP #-}
module Yesod.Core.Internal.LiteApp where
#if __GLASGOW_HASKELL__ < 710
import Data.Monoid
#endif
#if !(MIN_VERSION_base(4,11,0))
import Data.Semigroup (Semigroup(..))
#endif
import Yesod.Routes.Class
import Yesod.Core.Class.Yesod
import Yesod.Core.Class.Dispatch
import Yesod.Core.Types
import Yesod.Core.Content
import Data.Text (Text)
import Web.PathPieces
import Network.Wai
import Yesod.Core.Handler
import Yesod.Core.Internal.Run
import Network.HTTP.Types (Method)
import Data.Maybe (fromMaybe)
import Control.Applicative ((<|>))
import Control.Monad.Trans.Writer
newtype LiteApp = LiteApp
{ unLiteApp :: Method -> [Text] -> Maybe (LiteHandler TypedContent)
}
instance Yesod LiteApp
instance YesodDispatch LiteApp where
yesodDispatch yre req =
yesodRunner
(fromMaybe notFound $ f (requestMethod req) (pathInfo req))
yre
(Just $ LiteAppRoute $ pathInfo req)
req
where
LiteApp f = yreSite yre
instance RenderRoute LiteApp where
data Route LiteApp = LiteAppRoute [Text]
deriving (Show, Eq, Read, Ord)
renderRoute (LiteAppRoute x) = (x, [])
instance ParseRoute LiteApp where
parseRoute (x, _) = Just $ LiteAppRoute x
instance Semigroup LiteApp where
LiteApp x <> LiteApp y = LiteApp $ \m ps -> x m ps <|> y m ps
instance Monoid LiteApp where
mempty = LiteApp $ \_ _ -> Nothing
#if !(MIN_VERSION_base(4,11,0))
mappend = (<>)
#endif
type LiteHandler = HandlerFor LiteApp
type LiteWidget = WidgetFor LiteApp
liteApp :: Writer LiteApp () -> LiteApp
liteApp = execWriter
dispatchTo :: ToTypedContent a => LiteHandler a -> Writer LiteApp ()
dispatchTo handler = tell $ LiteApp $ \_ ps ->
if null ps
then Just $ fmap toTypedContent handler
else Nothing
onMethod :: Method -> Writer LiteApp () -> Writer LiteApp ()
onMethod method f = tell $ LiteApp $ \m ps ->
if method == m
then unLiteApp (liteApp f) m ps
else Nothing
onStatic :: Text -> Writer LiteApp () -> Writer LiteApp ()
onStatic p0 f = tell $ LiteApp $ \m ps0 ->
case ps0 of
p:ps | p == p0 -> unLiteApp (liteApp f) m ps
_ -> Nothing
withDynamic :: PathPiece p => (p -> Writer LiteApp ()) -> Writer LiteApp ()
withDynamic f = tell $ LiteApp $ \m ps0 ->
case ps0 of
p:ps | Just v <- fromPathPiece p -> unLiteApp (liteApp $ f v) m ps
_ -> Nothing
withDynamicMulti :: PathMultiPiece ps => (ps -> Writer LiteApp ()) -> Writer LiteApp ()
withDynamicMulti f = tell $ LiteApp $ \m ps ->
case fromPathMultiPiece ps of
Nothing -> Nothing
Just v -> unLiteApp (liteApp $ f v) m []
| psibi/yesod | yesod-core/Yesod/Core/Internal/LiteApp.hs | mit | 2,700 | 0 | 14 | 615 | 930 | 488 | 442 | 69 | 2 |
module Language.Haskell.Format.HIndent
( autoSettings
, formatter
, defaultFormatter
) where
import Data.ByteString.Builder
import Data.ByteString.Lazy as L
import qualified Data.Text as Text
import Data.Text.Encoding as Encoding
import qualified Data.Yaml as Y
import HIndent
import HIndent.Types
import Language.Haskell.Exts.Extension (Extension)
import Path
import qualified Path.Find as Path
import qualified Path.IO as Path
import Language.Haskell.Format.Internal
import Language.Haskell.Format.Types
data Settings =
Settings Config (Maybe [Extension])
defaultFormatter :: IO Formatter
defaultFormatter = formatter <$> autoSettings
autoSettings :: IO Settings
autoSettings = do
config <- getConfig
return $ Settings config $ Just defaultExtensions
-- | Read config from a config file, or return 'defaultConfig'.
getConfig :: IO Config
getConfig = do
cur <- Path.getCurrentDir
homeDir <- Path.getHomeDir
mfile <-
Path.findFileUp
cur
((== ".hindent.yaml") . toFilePath . filename)
(Just homeDir)
case mfile of
Nothing -> return defaultConfig
Just file -> do
result <- Y.decodeFileEither (toFilePath file)
case result of
Left e -> error (show e)
Right config -> return config
formatter :: Settings -> Formatter
formatter = mkFormatter . hindent
hindent :: Settings -> HaskellSource -> Either String HaskellSource
hindent (Settings config extensions) (HaskellSource filepath source) =
HaskellSource filepath . unpackBuilder <$>
reformat config extensions Nothing sourceText
where
sourceText = Encoding.encodeUtf8 . Text.pack $ source
unpackBuilder =
Text.unpack . Encoding.decodeUtf8 . L.toStrict . toLazyByteString
| danstiner/hfmt | src/Language/Haskell/Format/HIndent.hs | mit | 1,942 | 0 | 17 | 531 | 457 | 248 | 209 | 50 | 3 |
import Data.Function(on)
-- IV) First qst
s :: (a -> a -> Ordering) -> [a] -> [a]
s _ [] = []
s cmp (x:xs) = (s cmp $ filter lessThanX xs) ++ x : (s cmp $ filter (not . lessThanX) xs)
where lessThanX = (\y -> (cmp y x) == LT)
-- IV) Second qst
-- s (compare `on` length) ["xjkh", "jfh", "dgj", "jihghui", "jkh", "j", "kh"]
| NMouad21/HaskellSamples | HaskellFinalExIV.hs | mit | 352 | 0 | 11 | 98 | 154 | 80 | 74 | 5 | 1 |
module Main where
import Graphics.Rendering.Chart
import Graphics.Rendering.Chart.Backend.Diagrams
import Control.Lens
import Data.Default.Class
import Data.List
import Data.Complex
import ComplexShapes
import ComplexPlots
import Mappings
intercircle :: Polygon
intercircle = fmap (zeroOut 0.01)
$ circle ((-0.25) :+ 0.0) 0.25 40
lemniscate :: Polygon
lemniscate = nub
$ adaptiveSqrt (0.1) (0.000001 :+ 0.00000)
$ intercircle
main :: IO (PickFn ())
main = do
print intercircle
print lemniscate
print $ length lemniscate
renderableToFile def "square.png" (toRenderable lemniscate)
| ChristoSilvia/conform | src/Main.hs | mit | 621 | 0 | 10 | 112 | 182 | 98 | 84 | 23 | 1 |
{-# LANGUAGE RankNTypes, ImpredicativeTypes, ScopedTypeVariables, FlexibleContexts #-}
module State.Operations where
import Control.Applicative
import Control.Arrow
import Control.Lens
import Control.Monad
import Control.Monad.State
import Data.Functor.Identity
import Data.List
import qualified Data.Map as Map
import qualified Data.Map.Lazy as Map.Lazy
import Data.Monoid
import Debug.Trace
import Mana
import State.Types
liftState :: Monad m => State a b -> StateT a m b
liftState f = do
s <- get
let (a, s') = runState f s
put s'
return a
playerControllingCard :: Monad m => CardID -> StateT GameState m PlayerID
playerControllingCard cID = do
state <- get
return (state^._card cID.controllerID)
colors :: Card -> [Mana]
colors c = case c^.castCost of
ManaCost mana -> nub (mana <> (c^.tokenColor))
_ -> [Colorless]
instance Eq Player where
p1 == p2 = (p1^.playerID) == (p2^.playerID)
currentPlayer :: (Monad m) => StateT GameState m Player
currentPlayer = do
state <- get
use (playerWithID (state^.currentPlayerID))
transformPlayer :: (Monad m) => Int -> (Player -> Player) -> StateT GameState m ()
transformPlayer pID f = do
state <- get
let players' = map runAction' (state^.players)
runAction' player = if player^.playerID == pID
then f player
else player
put state {_players = players'}
allCards :: (Monad m) => StateT GameState m [Card]
allCards = do
state <- get
return $ Map.Lazy.elems (state^.cards)
-- selectCard :: CardID -> [Card] -> Maybe Card
-- selectCard cID cards =
-- let list = filter (\card -> card^.cardID == cID) cards
-- in if null list
-- then Nothing
-- else Just (head list)
removeCard :: CardID -> [Card] -> [Card]
removeCard cID = filter (\card -> card^.cardID /= cID)
addCardToPlayerHand pID card = playerWithID pID.hand <>= [card]
endTurn :: (Monad m) => StateT GameState m ()
endTurn = do
pID <- liftM (view currentPlayerID) get
playerWithID pID.hasPlayedLand .= False
playerList <- use players
currentPlayerID .= ((pID + 1) `mod` length playerList)
checkVictory :: (Monad m) => StateT GameState m (Maybe PlayerID)
checkVictory = do
state <- get
return $ if (state^.playerWithID 0.hp) <= 0
then Just 1
else if (state^.playerWithID 1.hp) <= 0
then Just 0
else Nothing
removeDeadCreatures :: StateT GameState IO ()
removeDeadCreatures = do
state <- get
let
idsOnField :: [CardID]
idsOnField = state^..players.traversed.field.traversed
dead :: [CardID]
dead = filter (\c -> (state^.card c.stats._2) <= state^.card c.damage &&
Creature `elem` state^.card c.cardType)
idsOnField
attackerID = state^.currentPlayerID
forM_ dead $ \deadID -> do
attackers %= delete deadID
blockers %= filter (\(b,a) -> b /= deadID)
killCard deadID
damageCreature :: (CardID, CardID) -> StateT GameState IO ()
damageCreature (blocker, attacker) = do
s <- get
aPower <- use (card attacker.stats._1)
bPower <- use (card blocker.stats._1)
let aDmg = s^.card attacker.damage
bDmg = s^.card blocker.damage
attackerID = s^.currentPlayerID
defender = 1 - attackerID
when (Lifelink `elem` (s^.card attacker.attributes)) $
gainLife attackerID aPower
when (Lifelink `elem` (s^.card blocker.attributes)) $
gainLife defender bPower
when (s^.card attacker.takesCombatDamage && s^.card blocker.dealsCombatDamage) $
damageCard attacker bPower
when (s^.card blocker.takesCombatDamage && s^.card attacker.dealsCombatDamage) $
damageCard blocker aPower
-- Kinda hackish, there's conditions where this won't work.
when (Deathtouch `elem` (s^.card attacker.attributes) &&
s^.card blocker.damage > 0)
(killCard blocker)
when (Deathtouch `elem` (s^.card blocker.attributes) &&
s^.card attacker.damage > 0)
(killCard attacker)
combatDamage :: StateT GameState IO ()
combatDamage = do
s <- get
blockerList <- mapM lookupCardPair (s^.blockers)
let damageCreatures :: StateT GameState IO ()
damageCreatures =
mapM_ damageCreature (s^.blockers)
-- foldl (\s stats -> execState (damageCreature stats) s) state (s^.blockers)
damageDefender defender state = foldM (damageDefender' defender) state attackerList
damageDefender' :: PlayerID -> GameState -> Card -> IO GameState
damageDefender' defender state attacker = flip execStateT state $
when (attacker^.cardID `notElem` state^..blockers.traversed._2) $ do
when (attacker^.dealsCombatDamage) $
damagePlayer defender (attacker^.stats._1)
when (Lifelink `elem` attacker^.attributes) $
gainLife (s^.currentPlayerID) (attacker^.stats._1)
attackerID = s^.currentPlayerID
attackerList = map (\c->s^.card c) (s^.attackers)
damageCreatures
state' <- get >>= (liftIO . damageDefender (1-attackerID))
put state'
removeDeadCreatures
blockers .= []
attackers .= []
chainStates :: (Monad m) => [StateT a m b] -> StateT a m ()
chainStates [] = return ()
chainStates (x:xs) = do x
chainStates xs
lookupCardPair :: (Monad m) => (CardID,CardID) -> StateT GameState m (Card,Card)
lookupCardPair pair = do let (b,a) = pair
attacker <- use (card a)
blocker <- use (card b)
return (blocker,attacker)
nextTokenID :: Monad m => StateT GameState m Int
nextTokenID = do
result <- use nextTokenIDCounter
nextTokenIDCounter -= 1
return result
mill pID howMany = do
oldDeck <- use (playerWithID pID.deck)
playerWithID pID.graveyard <>= take howMany oldDeck
playerWithID pID.deck %= drop howMany
zoneToLens :: Zone -> Lens' Player [CardID]
zoneToLens Hand = hand
zoneToLens Battlefield = field
zoneToLens Library = deck
zoneToLens Graveyard = graveyard
addPlus1Plus1 :: Monad m => CardID -> StateT GameState m ()
addPlus1Plus1 cID = _card cID.counters <>= [(Plus1Plus1, 1)]
--------------------------------------------------------------------------------
-- Actions that can trigger abilities --
--------------------------------------------------------------------------------
killCard :: CardID -> StateT GameState IO ()
killCard cID = do
state <- get
unless (Indestructible `elem` state^.card cID.attributes)
(sendToGraveyard cID)
forM_ (state^.card cID.attachedCards) $ \attachmentID -> do
detach attachmentID
when (Aura `elem` state^.card attachmentID.cardType) (killCard attachmentID)
sendToGraveyard :: CardID -> StateT GameState IO ()
sendToGraveyard cID = do
state <- get
triggeredAbilities <- allTriggeredAbilities -- get abilities before killing card
players.traversed.field %= delete cID
unless (state^.card cID.token) $
playerWithID (state^.card cID.ownerID).graveyard <>= [cID]
let withCorrectTrigger =
filter (\ (_, Triggered t _) -> t == OnDeath) triggeredAbilities
forM_ withCorrectTrigger $ \(cardWithAbility, Triggered _ f) ->
f $ OnDeathInfo cID
sacrifice = sendToGraveyard
exileCard :: CardID -> StateT GameState IO ()
exileCard cID = do
state <- get
players.traversed.field %= delete cID
unless (state^.card cID.token) $
exile <>= [cID]
enterBattlefield :: PlayerID -> Zone -> CardID -> StateT GameState IO ()
enterBattlefield pID zone cID = do
-- Note that the card entering the battlefield can use "On Enters the Battlefield"
-- triggered abilities.
playerWithID pID.zoneToLens zone %= delete cID
playerWithID pID.field <>= [cID]
s <- get
triggeredAbilities <- allTriggeredAbilities
let withCorrectTrigger =
filter (\ (_, Triggered t _) -> t == OnEnterBattlefield) triggeredAbilities
forM_ withCorrectTrigger $ \(cardWithAbility, Triggered _ f) -> do
trace "Running trigger OnEnterBattlefield" (return ())
f $ OnEnterBattlefieldInfo cID zone cardWithAbility
runOnAttackTriggers :: CardID -> StateT GameState IO ()
runOnAttackTriggers cID = do
s <- get
let triggeredAbilities = filter abilityIsTriggered (s^.card cID.abilities)
let withCorrectTrigger =
filter (\ (Triggered t _) -> t == OnAttack) triggeredAbilities
forM_ withCorrectTrigger $ \(Triggered _ f) ->
when (cID `elem` (s^.attackers)) $
f $ OnAttackInfo cID
-- runAttackerTriggers :: Monad m => StateT GameState m ()
-- runAttackerTriggers = do
-- s <- get
-- triggeredAbilities <- allTriggeredAbilities
-- let withCorrectTrigger =
-- filter (\ (_,(Triggered t _)) -> t == OnAttack) triggeredAbilities
-- forM_ withCorrectTrigger $ \(cardWithAbility, (Triggered _ f)) ->
-- when (cardWithAbility `elem` (s^.attackers)) $
-- f $ OnAttackInfo cardWithAbility
runOnEndStepTriggers :: StateT GameState IO ()
runOnEndStepTriggers = do
s <- get
triggeredAbilities <- allTriggeredAbilities
let withCorrectTrigger =
filter (\ (_,(Triggered t _)) -> t == OnEndStep) triggeredAbilities
forM_ withCorrectTrigger $ \(cardWithAbility, (Triggered _ f)) -> do
pID <- playerControllingCard cardWithAbility
f $ OnEndStepInfo cardWithAbility pID
gainLife :: PlayerID -> Int -> StateT GameState IO ()
gainLife pID amount = do
s <- get
triggeredAbilities <- allTriggeredAbilities
let withCorrectTrigger =
filter (\ (_, Triggered t _) -> t == OnLifeGain) triggeredAbilities
playerWithID pID.hp += amount
playerWithID pID.turnLifeGained += amount
forM_ withCorrectTrigger $ \(cardWithAbility, Triggered _ f) ->
f $ OnLifeGainInfo cardWithAbility pID amount
damagePlayer :: Monad m => PlayerID -> Int -> StateT GameState m ()
damagePlayer pID amount = do
prevent <- use $ playerWithID pID.playerDamageToPrevent
process prevent
where
process prevent
| prevent >= amount =
playerWithID pID.playerDamageToPrevent -= amount
| prevent == 0 = do
playerWithID pID.hp -= amount
playerWithID pID.turnDamageTaken += amount
| prevent < amount = do
playerWithID pID.playerDamageToPrevent .= 0
playerWithID pID.hp -= (amount - prevent)
playerWithID pID.turnDamageTaken += (amount - prevent)
loseLife :: Monad m => PlayerID -> Int -> StateT GameState m ()
loseLife pID amount = playerWithID pID.hp -= amount
damageCard :: Monad m => CardID -> Int -> StateT GameState m ()
damageCard cID amount = do
prevent <- use $ card cID.damageToPrevent
process prevent
where
process prevent
| prevent >= amount =
_card cID.damageToPrevent -= amount
| prevent == 0 = do
_card cID.damage += amount
| prevent < amount = do
_card cID.damageToPrevent .= 0
_card cID.damage += (amount - prevent)
attachTo :: Monad m => CardID -> CardID -> StateT GameState m ()
attachTo attachment host = do
s <- get
detach attachment
_card attachment.attachedTo .= Just host
_card host.attachedCards <>= [attachment]
detach :: Monad m => CardID -> StateT GameState m ()
detach cID = do
s <- get
case s^.card cID.attachedTo of
Nothing -> return ()
Just host -> do
_card host.attachedCards %= delete cID
_card cID.attachedTo .= Nothing
tapCard :: Monad m => CardID -> StateT GameState m ()
tapCard cID = _card cID.tapped .= True
untapCard :: Monad m => CardID -> StateT GameState m ()
untapCard cID = _card cID.tapped .= False
--------------------------------------------------------------------------------
-- CardMod stuff --
--------------------------------------------------------------------------------
applyMod :: CardMod -> Card -> Card
applyMod (StatMod (p,t)) = (stats._1 +~ p) . (stats._2 +~ t)
applyMod (SetStats s) = stats .~ s
applyMod (AddAttribute attr) = execState $ do
cannotHave <- use cannotHaveAttributes
unless (attr `elem` cannotHave) $ attributes <>= [attr]
applyMod (RemoveAttribute attr) = attributes %~ delete attr
applyMod (CannotHaveAttribute attr) = execState $ do
attributes %= delete attr
cannotHaveAttributes <>= [attr]
applyMod (Union []) = id
applyMod (Union (attr:attrs)) = applyMod (Union attrs) . applyMod attr
applyMod (PreventCombatDamage Nothing) = takesCombatDamage .~ False
applyMod (PreventCombatDamage (Just x)) = damageToPrevent .~ x
applyMod (PreventDealingCombatDamage) = dealsCombatDamage .~ False
applyMod (AddAbility ability) = abilities <>~ [ability]
applyMod (AddType cType) = cardType <>~ [cType]
applyMod (AddColor mana) = tokenColor <>~ [mana]
applyMod (MustBeBlocked) = mustBeBlocked .~ True
applyMod (CannotBlock) = canBlock .~ False
applyMod (CannotAttack) = canAttack .~ False
applyMod (ReduceCost mana) = castCost %~ modifyCost
where modifyCost cost = case cost of
ManaCost m -> ManaCost (f m)
_ -> cost
f = \cost -> foldr delete cost mana
removeMod :: CardMod -> Card -> Card
removeMod (StatMod (p,t)) = (stats._1 -~ p) . (stats._2 -~ t)
removeMod (AddAttribute attr) = applyMod (RemoveAttribute attr)
removeMod (RemoveAttribute attr) = applyMod (AddAttribute attr)
card' abilityGetter cID = to getter
where getter :: GameState -> Card
filterFunc (sourceID, Static pred _) = pred sourceID (CardTarget cID)
filterFunc (sourceID, RecursiveStatic pred _) = pred sourceID (CardTarget cID)
modFilterFunc (sourceID, Static _ f) = f sourceID cID
modFilterFunc (sourceID, RecursiveStatic _ f) = f sourceID cID
modsForCard :: State GameState [CardMod]
modsForCard = do
staticAbilities <- abilityGetter
filtered <- filterM filterFunc staticAbilities
forM filtered modFilterFunc
getter state = flip evalState state $ do
s <- get
let baseCard = execState applyCounters (s^._card cID)
mods <- modsForCard
return $ foldl' (flip applyMod) baseCard mods
applyCounters :: State Card ()
applyCounters = do
card <- get
forM_ (card^.counters) $ \counter -> case counter of
(Plus1Plus1, n) -> stats.both += n
(Minus1Minus1, n) -> stats.both -= n
-- Use this to refer to cards by CardIDs in most cases.
-- It applies all relevant static abilities, until end
-- of turn effects, etc. and then returns the result.
card :: CardID -> Getter GameState Card
card = card' allStaticAbilities
-- What happens here is that some abilities rely on the results
-- of other abilities to work. For example, say an enchantment says
-- "All creatures you control are slivers in addition to their normal types".
-- Then any ability of the form "All slivers you control get _______" depend
-- on the result of the first ability. Thus, the sliver ability is RecursiveStatic,
-- and the enchantment's ability, which does not depend on other abilities, is
-- just Static.
--
-- Recursive abilities CANNOT depend on other recursive abilities. If Wizards
-- ever creates a card that says "If you have an even number of land on the
-- field, all creatures you control are slivers in addition to their normal types",
-- any "All slivers" ability will simply ignore that card, since they would both
-- be recursive abilities. If Wizards ever does this, I take no responsibility for
-- making their madness work.
nonRecursiveCard :: CardID -> Getter GameState Card
nonRecursiveCard = card' allNonRecursiveStaticAbilities
--------------------------------------------------------------------------------
-- Targeting Information --
--------------------------------------------------------------------------------
hasValidTarget :: CardID -> TargetInfo -> StateT GameState IO Bool
hasValidTarget cID (TargetInfo minTargets maxTargets pred) = do
s <- get
let
keys :: [CardID]
keys = Map.Lazy.keys (s^.cards)
targets :: [Targetable]
targets = map CardTarget keys ++ [PlayerTarget 0, PlayerTarget 1]
bools <- mapM (liftState . pred cID) targets
return $ or bools
withChoice :: Monad m => [CardID] -> (CardID -> StateT GameState m ()) ->
StateT GameState m()
withChoice cards f = do
s <- get
case s^.ioRequest of
Just (IOReqChooseCard _ (Just card)) -> do
trace ("Chosen card is " ++ show card) (return ())
ioRequest .= Nothing
f card
_ -> ioRequest .= (Just $ IOReqChooseCard cards Nothing)
-- withColorChoice :: Monad m => (Mana -> StateT GameState m ()) ->
-- StateT GameState m ()
-- withColorChoice f = do
-- s <- get
-- case s^.ioRequest of
-- Just (IOReqChooseColor (Just color)) -> do
-- ioRequest .= Nothing
-- f color
-- _ -> ioRequest .= (Just $ IOReqChooseColor Nothing)
-- withCardFromLibrary :: Monad m => PlayerID -> CardSelector ->
-- (CardID -> StateT GameState m ()) ->
-- StateT GameState m ()
-- withCardFromLibrary pID pred f = do
-- s <- get
-- let cIDWorks :: CardID -> Bool
-- cIDWorks = (`evalState` s) . pred . CardTarget
-- filteredDeck = filter cIDWorks
-- (s^.playerWithID pID.deck)
-- withChoice filteredDeck f
--------------------------------------------------------------------------------
-- Ability Utility --
--------------------------------------------------------------------------------
abilityIsTriggered (Triggered _ _) = True
abilityIsTriggered _ = False
abilityIsActivated (Activated _ _ _) = True
abilityIsActivated _ = False
abilityIsStatic (Static _ _) = True
abilityIsStatic (RecursiveStatic _ _) = True
abilityIsStatic _ = False
abilityIsNonRecursiveStatic (Static _ _) = True
abilityIsNonRecursiveStatic _ = False
allAbilitiesOnField :: Monad m => StateT GameState m [(CardID, Ability)]
allAbilitiesOnField = do
s <- get
let allCardIDs = s^..players.traversed.field.traversed
allCards = map (\cID -> s^._card cID) allCardIDs
cardToAbilityList card = map (\a->(card^.cardID, a)) (card^.abilities)
return $ concatMap cardToAbilityList allCards ++ (s^.untilEndOfTurnEffects)
filteredAbilitiesOnField :: Monad m => (Ability -> Bool) -> StateT GameState m [(CardID, Ability)]
filteredAbilitiesOnField pred = do
all <- allAbilitiesOnField
return $ filter (\(_,ability) -> pred ability) all
allStaticAbilities :: Monad m => StateT GameState m [(CardID, Ability)]
allStaticAbilities = filteredAbilitiesOnField abilityIsStatic
allNonRecursiveStaticAbilities :: Monad m => StateT GameState m [(CardID, Ability)]
allNonRecursiveStaticAbilities = filteredAbilitiesOnField abilityIsNonRecursiveStatic
allTriggeredAbilities :: Monad m => StateT GameState m [(CardID, Ability)]
allTriggeredAbilities = filteredAbilitiesOnField abilityIsTriggered
allActivatedAbilities :: Monad m => StateT GameState m [(CardID, Ability)]
allActivatedAbilities = filteredAbilitiesOnField abilityIsActivated
-- Applies a static ability to the game until the end of the current turn
-- cID is the cardID that has this ability. ability is the ability to
-- apply. The standard rules for Static vs RecursiveStatic apply here.
untilEndOfTurn :: Monad m => CardID -> Ability -> StateT GameState m ()
untilEndOfTurn cID ability = untilEndOfTurnEffects <>= [(cID, ability)]
--------------------------------------------------------------------------------
-- Generic Actions --
--------------------------------------------------------------------------------
reveal :: Monad m => CardID -> StateT GameState m ()
reveal = (revealedCard .=) <=< (return . Just)
shuffleLibrary :: Monad m => PlayerID -> StateT GameState m ()
shuffleLibrary = const $ return ()
drawCard :: (Monad m) => PlayerID -> StateT GameState m ()
drawCard pID =
zoom (playerWithID pID) $ do
oldDeck <- use deck
when (null oldDeck) $ error "drawCard taking head of empty deck"
hand <>= [head oldDeck]
deck .= tail oldDeck
| mplamann/magic-spieler | src/State/Operations.hs | mit | 20,141 | 0 | 22 | 4,411 | 5,815 | 2,904 | 2,911 | -1 | -1 |
module Main (main) where
import Test.Tasty (defaultMain, testGroup)
import qualified Test.Parser.SPF as TPS
main :: IO ()
main = defaultMain tests
tests = testGroup "Collected" [ TPS.tests ]
| ilexius/spf-ips | tests/tests.hs | gpl-3.0 | 195 | 0 | 7 | 32 | 64 | 38 | 26 | 6 | 1 |
{- Copyright 2012 Dustin DeWeese
This file is part of peg.
peg is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
peg is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with peg. If not, see <http://www.gnu.org/licenses/>.
-}
{-# LANGUAGE CPP, ScopedTypeVariables #-}
#ifdef MAIN
module Main where
#else
module Peg where
#endif
import Peg.Types
import Peg.BuiltIn
import Peg.Monad
import Peg.Parse
import Peg.Utils
import Control.Applicative
import System.Console.Haskeline hiding (throwIO, handle)
import System.Environment
import System.FilePath
import System.IO
import Control.Monad.State
import qualified Data.Set as S
import Data.Map (Map)
import qualified Data.Map as M
import Data.Maybe
import Data.List
import Control.Monad.Identity
import Debug.Trace
import Search
evalStack (s, m, c) = runBFSAll $ do
PegState s _ m _ c _ _ <- execStateT force $ PegState s [] m 0 c M.empty []
return (s, m, c)
hGetLines h = do
e <- hIsEOF h
if e
then return []
else (:) <$> hGetLine h <*> hGetLines h
getLinesFromFile f = withFile f ReadMode hGetLines
main = do
args <- getArgs
let files = filter ((==".peg").takeExtension) args
m <- foldM (\m f -> do
l <- getLinesFromFile f
load [] m l) builtins files
runInputT defaultSettings $ evalLoop [] m
load :: Stack
-> Env
-> [String]
-> IO Env
load s m [] = return m
load s m (input:r) =
case parseStack input of
Left e -> print e >> return m
Right s -> do
let x = runIdentity $ evalStack (s, m, ([],[]))
case x of
(s', m', _) : _ -> load s' m' r
[] -> load s m r
evalLoop :: Stack -> Env -> InputT IO ()
evalLoop p m = do
let text = case p of
[] -> ""
s -> showStack s ++ " "
minput <- getInputLineWithInitial ": " (text, "")
case minput of
Nothing -> return ()
Just "" -> return ()
Just input -> case parseStack input of
Left e -> outputStrLn (show e) >> evalLoop p m
Right s -> do
let x' = runIdentity $ evalStack (subst (A "IO") Io s, m, ([], []))
case take 5 x' of
[] -> evalLoop s m
((s',m',c'):r) -> do
mapM_ printAlt $ reverse r
printConstraints c'
evalLoop s' m'
where printConstraints (c,_) =
mapM_ (\(x, y) -> outputStrLn $ showStack x ++ " <-- " ++ showStack y) $ reverse c
printAlt (s,_,c) = do
printConstraints c
outputStrLn . ("| "++) . showStack $ s
uncycle [] = []
uncycle s@(t:xs) | lambda == 0 = s
| otherwise = map fst p ++ map fst (take lambda c)
where (p, c) = span (uncurry (/=)) . zip s $ drop lambda s
lambda = brent 1 1 t xs
brent _ _ _ [] = 0
brent l p t (h:xs)
| t == h = l
| l == p = brent 1 (p*2) h xs
| otherwise = brent (l+1) p t xs
| HackerFoo/peg | Peg.hs | gpl-3.0 | 3,347 | 0 | 23 | 982 | 1,166 | 589 | 577 | 84 | 6 |
{-# LANGUAGE CPP, DeriveDataTypeable #-}
-----------------------------------------------------------------------------
-- |
-- Module : Hie.Language.Haskell.Exts.SrcLoc
-- Copyright : (c) Niklas Broberg 2009
-- License : BSD-style (see the file LICENSE.txt)
--
-- Maintainer : Niklas Broberg, [email protected]
-- Stability : stable
-- Portability : portable
--
-- This module defines various data types representing source location
-- information, of varying degree of preciseness.
--
-----------------------------------------------------------------------------
module Hie.Language.Haskell.Exts.SrcLoc where
#ifdef __GLASGOW_HASKELL__
#ifdef BASE4
import Data.Data
#else
import Data.Generics (Data(..),Typeable(..))
#endif
#endif
-- | A single position in the source.
data SrcLoc = SrcLoc
{ srcFilename :: String
, srcLine :: Int
, srcColumn :: Int
}
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Ord,Show,Typeable,Data)
#else
deriving (Eq,Ord,Show)
#endif
-- | A portion of the source, spanning one or more lines and zero or more columns.
data SrcSpan = SrcSpan
{ srcSpanFilename :: String
, srcSpanStartLine :: Int
, srcSpanStartColumn :: Int
, srcSpanEndLine :: Int
, srcSpanEndColumn :: Int
}
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Ord,Show,Typeable,Data)
#else
deriving (Eq,Ord,Show)
#endif
-- | Returns 'srcSpanStartLine' and 'srcSpanStartColumn' in a pair.
srcSpanStart :: SrcSpan -> (Int,Int)
srcSpanStart x = (srcSpanStartLine x, srcSpanStartColumn x)
-- | Returns 'srcSpanEndLine' and 'srcSpanEndColumn' in a pair.
srcSpanEnd :: SrcSpan -> (Int,Int)
srcSpanEnd x = (srcSpanEndLine x, srcSpanEndColumn x)
-- | Combine two locations in the source to denote a span.
mkSrcSpan :: SrcLoc -> SrcLoc -> SrcSpan
mkSrcSpan (SrcLoc fn sl sc) (SrcLoc _ el ec) = SrcSpan fn sl sc el ec
-- | Merge two source spans into a single span from the start of the first
-- to the end of the second. Assumes that the two spans relate to the
-- same source file.
mergeSrcSpan :: SrcSpan -> SrcSpan -> SrcSpan
mergeSrcSpan (SrcSpan fn sl1 sc1 el1 ec1) (SrcSpan _ sl2 sc2 el2 ec2) =
let (sl,sc) = min (sl1,sc1) (sl2,sc2)
(el,ec) = max (el1,ec1) (el2,ec2)
in SrcSpan fn sl sc el ec
-- | Test if a given span starts and ends at the same location.
isNullSpan :: SrcSpan -> Bool
isNullSpan ss = srcSpanStartLine ss == srcSpanEndLine ss &&
srcSpanStartColumn ss >= srcSpanEndColumn ss
-- | An entity located in the source.
data Loc a = Loc
{ loc :: SrcSpan
, unLoc :: a
}
deriving (Eq,Ord,Show)
-- | A portion of the source, extended with information on the position of entities within the span.
data SrcSpanInfo = SrcSpanInfo
{ srcInfoSpan :: SrcSpan
-- , explLayout :: Bool
, srcInfoPoints :: [SrcSpan] -- Marks the location of specific entities inside the span
}
#ifdef __GLASGOW_HASKELL__
deriving (Eq,Ord,Show,Typeable,Data)
#else
deriving (Eq,Ord,Show)
#endif
-- | Generate a 'SrcSpanInfo' with no positional information for entities.
noInfoSpan :: SrcSpan -> SrcSpanInfo
noInfoSpan ss = SrcSpanInfo ss []
-- | Generate a 'SrcSpanInfo' with the supplied positional information for entities.
infoSpan :: SrcSpan -> [SrcSpan] -> SrcSpanInfo
infoSpan = SrcSpanInfo
-- | Combine two 'SrcSpanInfo's into one that spans the combined source area of
-- the two arguments, leaving positional information blank.
combSpanInfo :: SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo
combSpanInfo s1 s2 = SrcSpanInfo
(mergeSrcSpan (srcInfoSpan s1) (srcInfoSpan s2))
[]
-- | Short name for 'combSpanInfo'
(<++>) :: SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo
(<++>) = combSpanInfo
-- | Optionally combine the first argument with the second,
-- or return it unchanged if the second argument is 'Nothing'.
(<+?>) :: SrcSpanInfo -> Maybe SrcSpanInfo -> SrcSpanInfo
a <+?> b = case b of {Nothing -> a; Just b -> a <++> b}
-- | Optionally combine the second argument with the first,
-- or return it unchanged if the first argument is 'Nothing'.
(<?+>) :: Maybe SrcSpanInfo -> SrcSpanInfo -> SrcSpanInfo
a <?+> b = case a of {Nothing -> b; Just a -> a <++> b}
-- | Add more positional information for entities of a span.
(<**) :: SrcSpanInfo -> [SrcSpan] -> SrcSpanInfo
ss@(SrcSpanInfo {srcInfoPoints = ps}) <** xs = ss {srcInfoPoints = ps ++ xs}
-- | Merge two 'SrcSpan's and lift them to a 'SrcInfoSpan' with
-- no positional information for entities.
(<^^>) :: SrcSpan -> SrcSpan -> SrcSpanInfo
a <^^> b = noInfoSpan (mergeSrcSpan a b)
infixl 6 <^^>
infixl 5 <++>
infixl 4 <**, <+?>, <?+>
-- | A class to work over all kinds of source location information.
class SrcInfo si where
toSrcInfo :: SrcLoc -> [SrcSpan] -> SrcLoc -> si
fromSrcInfo :: SrcSpanInfo -> si
getPointLoc :: si -> SrcLoc
fileName :: si -> String
startLine :: si -> Int
startColumn :: si -> Int
getPointLoc si = SrcLoc (fileName si) (startLine si) (startColumn si)
instance SrcInfo SrcLoc where
toSrcInfo s _ _ = s
fromSrcInfo si = SrcLoc (fileName si) (startLine si) (startColumn si)
fileName = srcFilename
startLine = srcLine
startColumn = srcColumn
instance SrcInfo SrcSpan where
toSrcInfo st _ end = mkSrcSpan st end
fromSrcInfo = srcInfoSpan
fileName = srcSpanFilename
startLine = srcSpanStartLine
startColumn = srcSpanStartColumn
instance SrcInfo SrcSpanInfo where
toSrcInfo st pts end = SrcSpanInfo (mkSrcSpan st end) pts
fromSrcInfo = id
fileName = fileName . srcInfoSpan
startLine = startLine . srcInfoSpan
startColumn = startColumn . srcInfoSpan
| monsanto/hie | Hie/Language/Haskell/Exts/SrcLoc.hs | gpl-3.0 | 5,813 | 0 | 10 | 1,266 | 1,182 | 665 | 517 | 83 | 2 |
module Model.Classes where
import qualified Linear as L
import Model.Types
class Transformable a where
translationVector :: a -> TransformationVector
rotationVector :: a -> TransformationVector
scaleVector :: a -> TransformationVector
mkTransMat :: a -> TransformationMatrix
mkTransMat a = transMat L.!*! rotMat L.!*! scaleMat
where (L.V3 tx ty tz) = translationVector a
-- (L.V3 rx ry rz) = rotationVector a
(L.V3 sx sy sz) = scaleVector a
transMat = (L.V4
(L.V4 1 0 0 tx)
(L.V4 0 1 0 ty)
(L.V4 0 0 1 tz)
(L.V4 0 0 0 1 ))
rotMat = (L.V4 -- TODO: Handle rotation of objects.
(L.V4 1 0 0 0)
(L.V4 0 1 0 0)
(L.V4 0 0 1 0)
(L.V4 0 0 0 1))
scaleMat = (L.V4
(L.V4 sx 0 0 0)
(L.V4 0 sy 0 0)
(L.V4 0 0 sz 0)
(L.V4 0 0 0 1))
| halvorgb/AO2D | src/Model/Classes.hs | gpl-3.0 | 1,165 | 0 | 13 | 589 | 353 | 183 | 170 | 26 | 0 |
module CircuitDiagram (circuitToSvg) where
import Prelude
import Diagrams.Prelude
import Diagrams.Backend.SVG
import Graphics.SVGFonts
import Data.List (foldl')
import Circuit
lWidth, targetRad, charSize, ctrlRad, colSpace :: Double
lWidth = 0.07
targetRad = 0.5
charSize = 1
ctrlRad = 0.2
colSpace = 0.2
-- | Takes a circuit, filename, and width then writes out a
-- diagram of the circuit as an SVG
circuitToSvg :: Circuit -> String -> Double -> IO ()
circuitToSvg c f w = renderSVG f (mkWidth w) $ drawCirc c
drawCirc :: Circuit -> Diagram B
drawCirc c = hsep 0.0 [ txt
, gs # centerX <> ls
, txt
] # frame 1
where gs = drawGates (gates c)
ls = mconcat . map (mkLine.fromIntegral) $ [0..Circuit.size c]
where mkLine y = ( hrule . width ) gs
# lwL lWidth
# lc grey
# translateY y
txt = mconcat . zipWith placeText (lineNames c) $ map fromIntegral [0..length (lineNames c)]
where placeText s y = (mkText s <> phantom (rect 4 1 :: D V2 Double))
# translateY y
mkText s = text s
# fontSize (local 0.5)
drawGates = hsep colSpace . map (mconcat . map drawGate) . getDrawCols
drawGate g =
case g of
Not t -> drawCnot (fromIntegral t) []
Cnot c1 t -> drawCnot (fromIntegral t) [fromIntegral c1]
Toff c1 c2 t -> drawCnot (fromIntegral t) $ map fromIntegral [c1,c2]
Fred c1 t1 t2 -> drawSwap (fromIntegral t1) (fromIntegral t2) [fromIntegral c1]
Swap t1 t2 -> drawSwap (fromIntegral t1) (fromIntegral t2) []
Hadamard n -> drawH (fromIntegral n)
drawChar :: Char -> Diagram B
drawChar c = strokeP (textSVG' (TextOpts bit INSIDE_H KERN False charSize charSize) [c])
# lw 0.0
# fc black
drawH :: Double -> Diagram B
drawH t = (symb <> base) # translateY t
where symb = drawChar 'H'
base = square (1.7*targetRad)
# lw thin
# fc white
drawCnot :: Double -> [Double] -> Diagram B
drawCnot t cs = circle targetRad # lwL lWidth # translateY t
<> controls
<> line
where line = drawLine 0 (top - bottom)
# translateY bottom
where top | maxY == t = maxY + targetRad
| otherwise = maxY
bottom | minY == t = minY - targetRad
| otherwise = minY
maxY = maximum (t:cs)
minY = minimum (t:cs)
controls = mconcat $ map drawCtrl cs
drawCtrl :: Double -> Diagram B
drawCtrl y = circle ctrlRad # fc black # translateY y
drawSwap :: Double -> Double -> [Double] -> Diagram B
drawSwap t1 t2 cs = targ # translateY t1
<> targ # translateY t2
<> controls
<> line
where targ = drawLine 1 1 # center
<> drawLine 1 (-1) # center
line = drawLine 0 (top - bottom)
# translateY bottom
where top = maximum (t1:t2:cs)
bottom = minimum (t1:t2:cs)
controls = mconcat . map drawCtrl $ cs
drawLine :: Double -> Double -> Diagram B
drawLine x y = fromSegments [straight $ r2(x,y) ] # lwL lWidth
lineNames :: Circuit -> [String]
lineNames circ = concatMap inputStrings $ inputs circ
where inputStrings inp = map (\y -> inp ++ "[" ++ show y ++ "]") [0..circIntSize circ - 1]
-- | Groups a list of gates such that each group can be drawn without
-- overlap in the same column
getDrawCols :: [Gate] -> [[Gate]]
getDrawCols = (\(x,y) -> x ++ [y]) . foldl' colFold ([[]],[])
where colFold (res,curr) next =
if fits (map gateToRange curr) (gateToRange next)
then (res, next : curr)
else (res ++ [curr], [next])
gateToRange g =
case g of
Not n -> (n,n)
Cnot n1 n2 -> (max n1 n2 , min n1 n2)
Toff n1 n2 n3 -> (maximum [n1, n2, n3] , minimum [n1, n2, n3])
Fred n1 n2 n3 -> (maximum [n1, n2, n3] , minimum [n1, n2, n3])
Swap n1 n2 -> (max n1 n2 , min n1 n2)
Hadamard n -> (n,n)
fits [] _ = True
fits rs r = all (notInRange r) rs
where notInRange x y = minT x > maxT y || maxT x < minT y
maxT = uncurry max
minT = uncurry min
| aparent/jcc | src/CircuitDiagram.hs | gpl-3.0 | 4,461 | 0 | 14 | 1,579 | 1,670 | 848 | 822 | 101 | 8 |
module SpecHelper
( module Test.Hspec
, module TruthTable
) where
import Test.Hspec
import TruthTable | adamschoenemann/truth-table | test/SpecHelper.hs | gpl-3.0 | 114 | 0 | 5 | 26 | 24 | 16 | 8 | 5 | 0 |
-- Find the last element of a list
-- myLast [1,2,3,4] -> 4
-- myLast ['x', 'y', 'z'] -> 'z'
myLast :: [a] -> a
myLast [a] = a
myLast (_:xs) = myLast xs
-- Find the last but on element of a list
-- myButLast [1,2,3,4] -> 3
-- myButLast ['x', 'y', 'z'] -> 'y'
myButLast :: [a] -> a
myButLast (x:[_]) = x
myButLast (_:xs) = myButLast xs
-- Find the K'th element of a list. The first element index is 1
-- elementAt [1,2,3] 2 -> 2
-- elementAt "haskell" 5 -> 'e'
elementAt :: [a] -> Int -> a
elementAt (x:_) 1 = x
elementAt (_:arr) index = elementAt arr (index-1)
elementAt' arr index = arr !! (index-1)
-- Find the number of elements of a list
myLength :: [a] -> Int
myLength [] = 0
myLength (_:xs) = 1 + myLength xs
-- Reverse a list
myReverse :: [a] -> [a]
myReverse [] = []
myReverse (x:xs) = myReverse(xs)++[x]
myReverse' :: [a] -> [a]
myReverse' list = myReverse'' list []
where
myReverse'' [] reverse = reverse
myReverse'' (x:xs) reverse = myReverse'' xs (x:reverse)
-- Palindrome or not
-- A palindrome can be read forward or backward; e.g. (x a m a x).
isPalindrome :: Eq a => [a] -> Bool
isPalindrome [] = True
isPalindrome [_] = True
isPalindrome x = if ((head x) == (last x))
then isPalindrome (tail (reverse (tail x)))
else False
isPalindrome' list = list == (reverse list)
isPalindrome'' [] = True
isPalindrome'' [_] = True
isPalindrome'' x = if ((head x) == (last x))
then isPalindrome'' (init (tail x))
else False
| muralikrishna8/Haskell-problems | lists.hs | gpl-3.0 | 1,475 | 1 | 12 | 319 | 543 | 292 | 251 | 32 | 2 |
-- grid is a game written in Haskell
-- Copyright (C) 2018 [email protected]
--
-- This file is part of grid.
--
-- grid is free software: you can redistribute it and/or modify
-- it under the terms of the GNU General Public License as published by
-- the Free Software Foundation, either version 3 of the License, or
-- (at your option) any later version.
--
-- grid is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-- GNU General Public License for more details.
--
-- You should have received a copy of the GNU General Public License
-- along with grid. If not, see <http://www.gnu.org/licenses/>.
--
module Game.Run.RunWorld.Face
(
Face (..),
turnFaceLevelMode,
turnFacePuzzleMode,
turnFaceMemoryMode,
turnFaceForeign,
turnFaceAbout,
turnFaceSettings,
) where
import MyPrelude
import Game.Grid
data Face =
FaceLevelMode |
FacePuzzleMode |
FaceMemoryMode |
FaceForeign |
FaceAbout |
FaceSettings
turnFaceLevelMode :: Turn
turnFaceLevelMode =
straightTurn
turnFacePuzzleMode :: Turn
turnFacePuzzleMode =
backTurn
turnFaceMemoryMode :: Turn
turnFaceMemoryMode =
rightTurn
turnFaceForeign :: Turn
turnFaceForeign =
leftTurn
turnFaceAbout :: Turn
turnFaceAbout =
upTurn
turnFaceSettings :: Turn
turnFaceSettings =
downTurn
| karamellpelle/grid | source/Game/Run/RunWorld/Face.hs | gpl-3.0 | 1,482 | 0 | 5 | 318 | 144 | 98 | 46 | 36 | 1 |
{- |
Module : $Header$
Description : Benchmark for Crypto.Phec.Primes.
Copyright : 2015 Stian Ellingsen <[email protected]>
License : LGPL-3
Maintainer : Stian Ellingsen <[email protected]>
-}
module Crypto.Phec.PrimesBench (benchmarks) where
import Crypto.Phec.Primes (isGermainPrime')
import Math.NumberTheory.Primes.Testing (isPrime)
import Criterion (Benchmark, bench, bgroup, nf)
withGermainCandidates :: (Integer -> a) -> Int -> [a]
withGermainCandidates f b = fmap f (take 5000 [x, x + 6 ..])
where x = 6 * (2^b `quot` 6) + 5
bmigp :: Int -> [Bool]
bmigp = withGermainCandidates isGermainPrime'
bmigpn :: Int -> [Bool]
bmigpn = withGermainCandidates (\n -> isPrime n && isPrime (2 * n + 1))
benchmarks :: [Benchmark]
benchmarks =
[ bgroup "isGermainPrime'-5k"
[ bench "256" $ nf bmigp 256
, bench "512" $ nf bmigp 512
, bench "1024" $ nf bmigp 1024
]
, bgroup "isPrime-isPrime-5k"
[ bench "256" $ nf bmigpn 256
, bench "512" $ nf bmigpn 512
]
]
| stiell/phec | benchmark/Crypto/Phec/PrimesBench.hs | gpl-3.0 | 1,011 | 0 | 12 | 211 | 311 | 170 | 141 | 20 | 1 |
module Lib
( run1
, run2
) where
-- express any monoid as a list in some "language"
runMonoid :: Monoid b => (a -> b) -> [a] -> b
runMonoid f [] = mempty
runMonoid f (a:as) = mappend (f a) (runMonoid f as)
data Move = Back Integer | Forth Integer
moves = [Forth 7, Forth 3, Back 1, Forth 2, Back 19]
instance Monoid Integer where
mempty = 0
mappend = (+)
sem1 :: Move -> Integer
sem1 (Forth x) = x
sem1 (Back x) = -x
run1 = runMonoid sem1 moves
sem2 :: Move -> [String]
sem2 (Forth x) = ["forward " ++ show x]
sem2 (Back x) = ["backward " ++ show x]
run2 = runMonoid sem2 moves
| aztecrex/haskell-experiments-free-monoid | src/Lib.hs | unlicense | 602 | 0 | 8 | 147 | 279 | 148 | 131 | 19 | 1 |
{-# OPTIONS -fglasgow-exts #-}
-----------------------------------------------------------------------------
{-| Module : QGraphicsPathItem_h.hs
Copyright : (c) David Harley 2010
Project : qtHaskell
Version : 1.1.4
Modified : 2010-09-02 17:02:25
Warning : this file is machine generated - do not modify.
--}
-----------------------------------------------------------------------------
module Qtc.Gui.QGraphicsPathItem_h where
import Qtc.Enums.Base
import Qtc.Enums.Core.Qt
import Qtc.Enums.Gui.QGraphicsItem
import Qtc.Classes.Base
import Qtc.Classes.Qccs_h
import Qtc.Classes.Core_h
import Qtc.ClassTypes.Core
import Qth.ClassTypes.Core
import Qtc.Classes.Gui_h
import Qtc.ClassTypes.Gui
import Foreign.Marshal.Array
instance QunSetUserMethod (QGraphicsPathItem ()) where
unSetUserMethod qobj evid
= withBoolResult $
withObjectPtr qobj $ \cobj_qobj ->
qtc_QGraphicsPathItem_unSetUserMethod cobj_qobj (toCInt 0) (toCInt evid)
foreign import ccall "qtc_QGraphicsPathItem_unSetUserMethod" qtc_QGraphicsPathItem_unSetUserMethod :: Ptr (TQGraphicsPathItem a) -> CInt -> CInt -> IO (CBool)
instance QunSetUserMethod (QGraphicsPathItemSc a) where
unSetUserMethod qobj evid
= withBoolResult $
withObjectPtr qobj $ \cobj_qobj ->
qtc_QGraphicsPathItem_unSetUserMethod cobj_qobj (toCInt 0) (toCInt evid)
instance QunSetUserMethodVariant (QGraphicsPathItem ()) where
unSetUserMethodVariant qobj evid
= withBoolResult $
withObjectPtr qobj $ \cobj_qobj ->
qtc_QGraphicsPathItem_unSetUserMethod cobj_qobj (toCInt 1) (toCInt evid)
instance QunSetUserMethodVariant (QGraphicsPathItemSc a) where
unSetUserMethodVariant qobj evid
= withBoolResult $
withObjectPtr qobj $ \cobj_qobj ->
qtc_QGraphicsPathItem_unSetUserMethod cobj_qobj (toCInt 1) (toCInt evid)
instance QunSetUserMethodVariantList (QGraphicsPathItem ()) where
unSetUserMethodVariantList qobj evid
= withBoolResult $
withObjectPtr qobj $ \cobj_qobj ->
qtc_QGraphicsPathItem_unSetUserMethod cobj_qobj (toCInt 2) (toCInt evid)
instance QunSetUserMethodVariantList (QGraphicsPathItemSc a) where
unSetUserMethodVariantList qobj evid
= withBoolResult $
withObjectPtr qobj $ \cobj_qobj ->
qtc_QGraphicsPathItem_unSetUserMethod cobj_qobj (toCInt 2) (toCInt evid)
instance QsetUserMethod (QGraphicsPathItem ()) (QGraphicsPathItem x0 -> IO ()) where
setUserMethod _eobj _eid _handler
= do
funptr <- wrapSetUserMethod_QGraphicsPathItem setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetUserMethod_QGraphicsPathItem_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
qtc_QGraphicsPathItem_setUserMethod cobj_eobj (toCInt _eid) (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return ()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> IO ()
setHandlerWrapper x0
= do
x0obj <- objectFromPtr_nf x0
if (objectIsNull x0obj)
then return ()
else _handler x0obj
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QGraphicsPathItem_setUserMethod" qtc_QGraphicsPathItem_setUserMethod :: Ptr (TQGraphicsPathItem a) -> CInt -> Ptr (Ptr (TQGraphicsPathItem x0) -> IO ()) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetUserMethod_QGraphicsPathItem :: (Ptr (TQGraphicsPathItem x0) -> IO ()) -> IO (FunPtr (Ptr (TQGraphicsPathItem x0) -> IO ()))
foreign import ccall "wrapper" wrapSetUserMethod_QGraphicsPathItem_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetUserMethod (QGraphicsPathItemSc a) (QGraphicsPathItem x0 -> IO ()) where
setUserMethod _eobj _eid _handler
= do
funptr <- wrapSetUserMethod_QGraphicsPathItem setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetUserMethod_QGraphicsPathItem_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
qtc_QGraphicsPathItem_setUserMethod cobj_eobj (toCInt _eid) (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return ()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> IO ()
setHandlerWrapper x0
= do
x0obj <- objectFromPtr_nf x0
if (objectIsNull x0obj)
then return ()
else _handler x0obj
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance QsetUserMethod (QGraphicsPathItem ()) (QGraphicsPathItem x0 -> QVariant () -> IO (QVariant ())) where
setUserMethod _eobj _eid _handler
= do
funptr <- wrapSetUserMethodVariant_QGraphicsPathItem setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetUserMethodVariant_QGraphicsPathItem_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
qtc_QGraphicsPathItem_setUserMethodVariant cobj_eobj (toCInt _eid) (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return ()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQVariant ()) -> IO (Ptr (TQVariant ()))
setHandlerWrapper x0 x1
= do
x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
rv <- if (objectIsNull x0obj)
then return $ objectCast x0obj
else _handler x0obj x1obj
withObjectPtr rv $ \cobj_rv -> return cobj_rv
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QGraphicsPathItem_setUserMethodVariant" qtc_QGraphicsPathItem_setUserMethodVariant :: Ptr (TQGraphicsPathItem a) -> CInt -> Ptr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQVariant ()) -> IO (Ptr (TQVariant ()))) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetUserMethodVariant_QGraphicsPathItem :: (Ptr (TQGraphicsPathItem x0) -> Ptr (TQVariant ()) -> IO (Ptr (TQVariant ()))) -> IO (FunPtr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQVariant ()) -> IO (Ptr (TQVariant ()))))
foreign import ccall "wrapper" wrapSetUserMethodVariant_QGraphicsPathItem_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetUserMethod (QGraphicsPathItemSc a) (QGraphicsPathItem x0 -> QVariant () -> IO (QVariant ())) where
setUserMethod _eobj _eid _handler
= do
funptr <- wrapSetUserMethodVariant_QGraphicsPathItem setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetUserMethodVariant_QGraphicsPathItem_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
qtc_QGraphicsPathItem_setUserMethodVariant cobj_eobj (toCInt _eid) (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return ()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQVariant ()) -> IO (Ptr (TQVariant ()))
setHandlerWrapper x0 x1
= do
x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
rv <- if (objectIsNull x0obj)
then return $ objectCast x0obj
else _handler x0obj x1obj
withObjectPtr rv $ \cobj_rv -> return cobj_rv
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance QunSetHandler (QGraphicsPathItem ()) where
unSetHandler qobj evid
= withBoolResult $
withObjectPtr qobj $ \cobj_qobj ->
withCWString evid $ \cstr_evid ->
qtc_QGraphicsPathItem_unSetHandler cobj_qobj cstr_evid
foreign import ccall "qtc_QGraphicsPathItem_unSetHandler" qtc_QGraphicsPathItem_unSetHandler :: Ptr (TQGraphicsPathItem a) -> CWString -> IO (CBool)
instance QunSetHandler (QGraphicsPathItemSc a) where
unSetHandler qobj evid
= withBoolResult $
withObjectPtr qobj $ \cobj_qobj ->
withCWString evid $ \cstr_evid ->
qtc_QGraphicsPathItem_unSetHandler cobj_qobj cstr_evid
instance QsetHandler (QGraphicsPathItem ()) (QGraphicsPathItem x0 -> IO (QRectF t0)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem1 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem1_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler1 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> IO (Ptr (TQRectF t0))
setHandlerWrapper x0
= do x0obj <- objectFromPtr_nf x0
let rv =
if (objectIsNull x0obj)
then return $ objectCast x0obj
else _handler x0obj
rvf <- rv
withObjectPtr rvf $ \cobj_rvf -> return (cobj_rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QGraphicsPathItem_setHandler1" qtc_QGraphicsPathItem_setHandler1 :: Ptr (TQGraphicsPathItem a) -> CWString -> Ptr (Ptr (TQGraphicsPathItem x0) -> IO (Ptr (TQRectF t0))) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem1 :: (Ptr (TQGraphicsPathItem x0) -> IO (Ptr (TQRectF t0))) -> IO (FunPtr (Ptr (TQGraphicsPathItem x0) -> IO (Ptr (TQRectF t0))))
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem1_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetHandler (QGraphicsPathItemSc a) (QGraphicsPathItem x0 -> IO (QRectF t0)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem1 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem1_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler1 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> IO (Ptr (TQRectF t0))
setHandlerWrapper x0
= do x0obj <- objectFromPtr_nf x0
let rv =
if (objectIsNull x0obj)
then return $ objectCast x0obj
else _handler x0obj
rvf <- rv
withObjectPtr rvf $ \cobj_rvf -> return (cobj_rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance QqqboundingRect_h (QGraphicsPathItem ()) (()) where
qqboundingRect_h x0 ()
= withQRectFResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QGraphicsPathItem_boundingRect cobj_x0
foreign import ccall "qtc_QGraphicsPathItem_boundingRect" qtc_QGraphicsPathItem_boundingRect :: Ptr (TQGraphicsPathItem a) -> IO (Ptr (TQRectF ()))
instance QqqboundingRect_h (QGraphicsPathItemSc a) (()) where
qqboundingRect_h x0 ()
= withQRectFResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QGraphicsPathItem_boundingRect cobj_x0
instance QqboundingRect_h (QGraphicsPathItem ()) (()) where
qboundingRect_h x0 ()
= withRectFResult $ \crectf_ret_x crectf_ret_y crectf_ret_w crectf_ret_h ->
withObjectPtr x0 $ \cobj_x0 ->
qtc_QGraphicsPathItem_boundingRect_qth cobj_x0 crectf_ret_x crectf_ret_y crectf_ret_w crectf_ret_h
foreign import ccall "qtc_QGraphicsPathItem_boundingRect_qth" qtc_QGraphicsPathItem_boundingRect_qth :: Ptr (TQGraphicsPathItem a) -> Ptr CDouble -> Ptr CDouble -> Ptr CDouble -> Ptr CDouble -> IO ()
instance QqboundingRect_h (QGraphicsPathItemSc a) (()) where
qboundingRect_h x0 ()
= withRectFResult $ \crectf_ret_x crectf_ret_y crectf_ret_w crectf_ret_h ->
withObjectPtr x0 $ \cobj_x0 ->
qtc_QGraphicsPathItem_boundingRect_qth cobj_x0 crectf_ret_x crectf_ret_y crectf_ret_w crectf_ret_h
instance QsetHandler (QGraphicsPathItem ()) (QGraphicsPathItem x0 -> QPointF t1 -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem2 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem2_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler2 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQPointF t1) -> IO (CBool)
setHandlerWrapper x0 x1
= do x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QGraphicsPathItem_setHandler2" qtc_QGraphicsPathItem_setHandler2 :: Ptr (TQGraphicsPathItem a) -> CWString -> Ptr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQPointF t1) -> IO (CBool)) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem2 :: (Ptr (TQGraphicsPathItem x0) -> Ptr (TQPointF t1) -> IO (CBool)) -> IO (FunPtr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQPointF t1) -> IO (CBool)))
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem2_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetHandler (QGraphicsPathItemSc a) (QGraphicsPathItem x0 -> QPointF t1 -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem2 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem2_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler2 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQPointF t1) -> IO (CBool)
setHandlerWrapper x0 x1
= do x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance Qqcontains_h (QGraphicsPathItem ()) ((PointF)) where
qcontains_h x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withCPointF x1 $ \cpointf_x1_x cpointf_x1_y ->
qtc_QGraphicsPathItem_contains_qth cobj_x0 cpointf_x1_x cpointf_x1_y
foreign import ccall "qtc_QGraphicsPathItem_contains_qth" qtc_QGraphicsPathItem_contains_qth :: Ptr (TQGraphicsPathItem a) -> CDouble -> CDouble -> IO CBool
instance Qqcontains_h (QGraphicsPathItemSc a) ((PointF)) where
qcontains_h x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withCPointF x1 $ \cpointf_x1_x cpointf_x1_y ->
qtc_QGraphicsPathItem_contains_qth cobj_x0 cpointf_x1_x cpointf_x1_y
instance Qqqcontains_h (QGraphicsPathItem ()) ((QPointF t1)) where
qqcontains_h x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_contains cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_contains" qtc_QGraphicsPathItem_contains :: Ptr (TQGraphicsPathItem a) -> Ptr (TQPointF t1) -> IO CBool
instance Qqqcontains_h (QGraphicsPathItemSc a) ((QPointF t1)) where
qqcontains_h x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_contains cobj_x0 cobj_x1
instance QsetHandler (QGraphicsPathItem ()) (QGraphicsPathItem x0 -> QGraphicsItem t1 -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem3 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem3_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler3 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQGraphicsItem t1) -> IO (CBool)
setHandlerWrapper x0 x1
= do x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QGraphicsPathItem_setHandler3" qtc_QGraphicsPathItem_setHandler3 :: Ptr (TQGraphicsPathItem a) -> CWString -> Ptr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQGraphicsItem t1) -> IO (CBool)) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem3 :: (Ptr (TQGraphicsPathItem x0) -> Ptr (TQGraphicsItem t1) -> IO (CBool)) -> IO (FunPtr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQGraphicsItem t1) -> IO (CBool)))
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem3_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetHandler (QGraphicsPathItemSc a) (QGraphicsPathItem x0 -> QGraphicsItem t1 -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem3 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem3_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler3 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQGraphicsItem t1) -> IO (CBool)
setHandlerWrapper x0 x1
= do x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance QsetHandler (QGraphicsPathItem ()) (QGraphicsPathItem x0 -> QObject t1 -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem4 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem4_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler4 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQObject t1) -> IO (CBool)
setHandlerWrapper x0 x1
= do x0obj <- objectFromPtr_nf x0
x1obj <- qObjectFromPtr x1
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QGraphicsPathItem_setHandler4" qtc_QGraphicsPathItem_setHandler4 :: Ptr (TQGraphicsPathItem a) -> CWString -> Ptr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQObject t1) -> IO (CBool)) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem4 :: (Ptr (TQGraphicsPathItem x0) -> Ptr (TQObject t1) -> IO (CBool)) -> IO (FunPtr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQObject t1) -> IO (CBool)))
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem4_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetHandler (QGraphicsPathItemSc a) (QGraphicsPathItem x0 -> QObject t1 -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem4 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem4_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler4 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQObject t1) -> IO (CBool)
setHandlerWrapper x0 x1
= do x0obj <- objectFromPtr_nf x0
x1obj <- qObjectFromPtr x1
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance QisObscuredBy_h (QGraphicsPathItem ()) ((QGraphicsItem t1)) where
isObscuredBy_h x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_isObscuredBy cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_isObscuredBy" qtc_QGraphicsPathItem_isObscuredBy :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsItem t1) -> IO CBool
instance QisObscuredBy_h (QGraphicsPathItemSc a) ((QGraphicsItem t1)) where
isObscuredBy_h x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_isObscuredBy cobj_x0 cobj_x1
instance QisObscuredBy_h (QGraphicsPathItem ()) ((QGraphicsTextItem t1)) where
isObscuredBy_h x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_isObscuredBy_graphicstextitem cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_isObscuredBy_graphicstextitem" qtc_QGraphicsPathItem_isObscuredBy_graphicstextitem :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsTextItem t1) -> IO CBool
instance QisObscuredBy_h (QGraphicsPathItemSc a) ((QGraphicsTextItem t1)) where
isObscuredBy_h x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_isObscuredBy_graphicstextitem cobj_x0 cobj_x1
instance QsetHandler (QGraphicsPathItem ()) (QGraphicsPathItem x0 -> IO (QPainterPath t0)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem5 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem5_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler5 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> IO (Ptr (TQPainterPath t0))
setHandlerWrapper x0
= do x0obj <- objectFromPtr_nf x0
let rv =
if (objectIsNull x0obj)
then return $ objectCast x0obj
else _handler x0obj
rvf <- rv
withObjectPtr rvf $ \cobj_rvf -> return (cobj_rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QGraphicsPathItem_setHandler5" qtc_QGraphicsPathItem_setHandler5 :: Ptr (TQGraphicsPathItem a) -> CWString -> Ptr (Ptr (TQGraphicsPathItem x0) -> IO (Ptr (TQPainterPath t0))) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem5 :: (Ptr (TQGraphicsPathItem x0) -> IO (Ptr (TQPainterPath t0))) -> IO (FunPtr (Ptr (TQGraphicsPathItem x0) -> IO (Ptr (TQPainterPath t0))))
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem5_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetHandler (QGraphicsPathItemSc a) (QGraphicsPathItem x0 -> IO (QPainterPath t0)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem5 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem5_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler5 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> IO (Ptr (TQPainterPath t0))
setHandlerWrapper x0
= do x0obj <- objectFromPtr_nf x0
let rv =
if (objectIsNull x0obj)
then return $ objectCast x0obj
else _handler x0obj
rvf <- rv
withObjectPtr rvf $ \cobj_rvf -> return (cobj_rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance QopaqueArea_h (QGraphicsPathItem ()) (()) where
opaqueArea_h x0 ()
= withQPainterPathResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QGraphicsPathItem_opaqueArea cobj_x0
foreign import ccall "qtc_QGraphicsPathItem_opaqueArea" qtc_QGraphicsPathItem_opaqueArea :: Ptr (TQGraphicsPathItem a) -> IO (Ptr (TQPainterPath ()))
instance QopaqueArea_h (QGraphicsPathItemSc a) (()) where
opaqueArea_h x0 ()
= withQPainterPathResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QGraphicsPathItem_opaqueArea cobj_x0
instance QsetHandler (QGraphicsPathItem ()) (QGraphicsPathItem x0 -> QPainter t1 -> QStyleOption t2 -> QObject t3 -> IO ()) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem6 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem6_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler6 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQPainter t1) -> Ptr (TQStyleOption t2) -> Ptr (TQObject t3) -> IO ()
setHandlerWrapper x0 x1 x2 x3
= do x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
x2obj <- objectFromPtr_nf x2
x3obj <- qObjectFromPtr x3
if (objectIsNull x0obj)
then return ()
else _handler x0obj x1obj x2obj x3obj
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QGraphicsPathItem_setHandler6" qtc_QGraphicsPathItem_setHandler6 :: Ptr (TQGraphicsPathItem a) -> CWString -> Ptr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQPainter t1) -> Ptr (TQStyleOption t2) -> Ptr (TQObject t3) -> IO ()) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem6 :: (Ptr (TQGraphicsPathItem x0) -> Ptr (TQPainter t1) -> Ptr (TQStyleOption t2) -> Ptr (TQObject t3) -> IO ()) -> IO (FunPtr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQPainter t1) -> Ptr (TQStyleOption t2) -> Ptr (TQObject t3) -> IO ()))
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem6_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetHandler (QGraphicsPathItemSc a) (QGraphicsPathItem x0 -> QPainter t1 -> QStyleOption t2 -> QObject t3 -> IO ()) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem6 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem6_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler6 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQPainter t1) -> Ptr (TQStyleOption t2) -> Ptr (TQObject t3) -> IO ()
setHandlerWrapper x0 x1 x2 x3
= do x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
x2obj <- objectFromPtr_nf x2
x3obj <- qObjectFromPtr x3
if (objectIsNull x0obj)
then return ()
else _handler x0obj x1obj x2obj x3obj
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance Qpaint_h (QGraphicsPathItem ()) ((QPainter t1, QStyleOptionGraphicsItem t2, QWidget t3)) where
paint_h x0 (x1, x2, x3)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
withObjectPtr x2 $ \cobj_x2 ->
withObjectPtr x3 $ \cobj_x3 ->
qtc_QGraphicsPathItem_paint1 cobj_x0 cobj_x1 cobj_x2 cobj_x3
foreign import ccall "qtc_QGraphicsPathItem_paint1" qtc_QGraphicsPathItem_paint1 :: Ptr (TQGraphicsPathItem a) -> Ptr (TQPainter t1) -> Ptr (TQStyleOptionGraphicsItem t2) -> Ptr (TQWidget t3) -> IO ()
instance Qpaint_h (QGraphicsPathItemSc a) ((QPainter t1, QStyleOptionGraphicsItem t2, QWidget t3)) where
paint_h x0 (x1, x2, x3)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
withObjectPtr x2 $ \cobj_x2 ->
withObjectPtr x3 $ \cobj_x3 ->
qtc_QGraphicsPathItem_paint1 cobj_x0 cobj_x1 cobj_x2 cobj_x3
instance Qshape_h (QGraphicsPathItem ()) (()) where
shape_h x0 ()
= withQPainterPathResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QGraphicsPathItem_shape cobj_x0
foreign import ccall "qtc_QGraphicsPathItem_shape" qtc_QGraphicsPathItem_shape :: Ptr (TQGraphicsPathItem a) -> IO (Ptr (TQPainterPath ()))
instance Qshape_h (QGraphicsPathItemSc a) (()) where
shape_h x0 ()
= withQPainterPathResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QGraphicsPathItem_shape cobj_x0
instance QsetHandler (QGraphicsPathItem ()) (QGraphicsPathItem x0 -> IO (Int)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem7 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem7_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler7 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> IO (CInt)
setHandlerWrapper x0
= do x0obj <- objectFromPtr_nf x0
let rv =
if (objectIsNull x0obj)
then return 0
else _handler x0obj
rvf <- rv
return (toCInt rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QGraphicsPathItem_setHandler7" qtc_QGraphicsPathItem_setHandler7 :: Ptr (TQGraphicsPathItem a) -> CWString -> Ptr (Ptr (TQGraphicsPathItem x0) -> IO (CInt)) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem7 :: (Ptr (TQGraphicsPathItem x0) -> IO (CInt)) -> IO (FunPtr (Ptr (TQGraphicsPathItem x0) -> IO (CInt)))
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem7_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetHandler (QGraphicsPathItemSc a) (QGraphicsPathItem x0 -> IO (Int)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem7 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem7_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler7 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> IO (CInt)
setHandlerWrapper x0
= do x0obj <- objectFromPtr_nf x0
let rv =
if (objectIsNull x0obj)
then return 0
else _handler x0obj
rvf <- rv
return (toCInt rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance Qqtype_h (QGraphicsPathItem ()) (()) where
qtype_h x0 ()
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QGraphicsPathItem_type cobj_x0
foreign import ccall "qtc_QGraphicsPathItem_type" qtc_QGraphicsPathItem_type :: Ptr (TQGraphicsPathItem a) -> IO CInt
instance Qqtype_h (QGraphicsPathItemSc a) (()) where
qtype_h x0 ()
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QGraphicsPathItem_type cobj_x0
instance QsetHandler (QGraphicsPathItem ()) (QGraphicsPathItem x0 -> Int -> IO ()) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem8 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem8_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler8 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> CInt -> IO ()
setHandlerWrapper x0 x1
= do x0obj <- objectFromPtr_nf x0
let x1int = fromCInt x1
if (objectIsNull x0obj)
then return ()
else _handler x0obj x1int
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QGraphicsPathItem_setHandler8" qtc_QGraphicsPathItem_setHandler8 :: Ptr (TQGraphicsPathItem a) -> CWString -> Ptr (Ptr (TQGraphicsPathItem x0) -> CInt -> IO ()) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem8 :: (Ptr (TQGraphicsPathItem x0) -> CInt -> IO ()) -> IO (FunPtr (Ptr (TQGraphicsPathItem x0) -> CInt -> IO ()))
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem8_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetHandler (QGraphicsPathItemSc a) (QGraphicsPathItem x0 -> Int -> IO ()) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem8 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem8_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler8 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> CInt -> IO ()
setHandlerWrapper x0 x1
= do x0obj <- objectFromPtr_nf x0
let x1int = fromCInt x1
if (objectIsNull x0obj)
then return ()
else _handler x0obj x1int
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance Qadvance_h (QGraphicsPathItem ()) ((Int)) where
advance_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QGraphicsPathItem_advance cobj_x0 (toCInt x1)
foreign import ccall "qtc_QGraphicsPathItem_advance" qtc_QGraphicsPathItem_advance :: Ptr (TQGraphicsPathItem a) -> CInt -> IO ()
instance Qadvance_h (QGraphicsPathItemSc a) ((Int)) where
advance_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QGraphicsPathItem_advance cobj_x0 (toCInt x1)
instance QsetHandler (QGraphicsPathItem ()) (QGraphicsPathItem x0 -> QGraphicsItem t1 -> ItemSelectionMode -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem9 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem9_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler9 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQGraphicsItem t1) -> CLong -> IO (CBool)
setHandlerWrapper x0 x1 x2
= do x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
let x2enum = qEnum_fromInt $ fromCLong x2
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj x2enum
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QGraphicsPathItem_setHandler9" qtc_QGraphicsPathItem_setHandler9 :: Ptr (TQGraphicsPathItem a) -> CWString -> Ptr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQGraphicsItem t1) -> CLong -> IO (CBool)) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem9 :: (Ptr (TQGraphicsPathItem x0) -> Ptr (TQGraphicsItem t1) -> CLong -> IO (CBool)) -> IO (FunPtr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQGraphicsItem t1) -> CLong -> IO (CBool)))
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem9_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetHandler (QGraphicsPathItemSc a) (QGraphicsPathItem x0 -> QGraphicsItem t1 -> ItemSelectionMode -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem9 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem9_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler9 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQGraphicsItem t1) -> CLong -> IO (CBool)
setHandlerWrapper x0 x1 x2
= do x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
let x2enum = qEnum_fromInt $ fromCLong x2
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj x2enum
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance QsetHandler (QGraphicsPathItem ()) (QGraphicsPathItem x0 -> QObject t1 -> ItemSelectionMode -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem10 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem10_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler10 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQObject t1) -> CLong -> IO (CBool)
setHandlerWrapper x0 x1 x2
= do x0obj <- objectFromPtr_nf x0
x1obj <- qObjectFromPtr x1
let x2enum = qEnum_fromInt $ fromCLong x2
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj x2enum
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QGraphicsPathItem_setHandler10" qtc_QGraphicsPathItem_setHandler10 :: Ptr (TQGraphicsPathItem a) -> CWString -> Ptr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQObject t1) -> CLong -> IO (CBool)) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem10 :: (Ptr (TQGraphicsPathItem x0) -> Ptr (TQObject t1) -> CLong -> IO (CBool)) -> IO (FunPtr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQObject t1) -> CLong -> IO (CBool)))
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem10_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetHandler (QGraphicsPathItemSc a) (QGraphicsPathItem x0 -> QObject t1 -> ItemSelectionMode -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem10 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem10_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler10 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQObject t1) -> CLong -> IO (CBool)
setHandlerWrapper x0 x1 x2
= do x0obj <- objectFromPtr_nf x0
x1obj <- qObjectFromPtr x1
let x2enum = qEnum_fromInt $ fromCLong x2
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj x2enum
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance QcollidesWithItem_h (QGraphicsPathItem ()) ((QGraphicsItem t1)) where
collidesWithItem_h x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_collidesWithItem cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_collidesWithItem" qtc_QGraphicsPathItem_collidesWithItem :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsItem t1) -> IO CBool
instance QcollidesWithItem_h (QGraphicsPathItemSc a) ((QGraphicsItem t1)) where
collidesWithItem_h x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_collidesWithItem cobj_x0 cobj_x1
instance QcollidesWithItem_h (QGraphicsPathItem ()) ((QGraphicsItem t1, ItemSelectionMode)) where
collidesWithItem_h x0 (x1, x2)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_collidesWithItem1 cobj_x0 cobj_x1 (toCLong $ qEnum_toInt x2)
foreign import ccall "qtc_QGraphicsPathItem_collidesWithItem1" qtc_QGraphicsPathItem_collidesWithItem1 :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsItem t1) -> CLong -> IO CBool
instance QcollidesWithItem_h (QGraphicsPathItemSc a) ((QGraphicsItem t1, ItemSelectionMode)) where
collidesWithItem_h x0 (x1, x2)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_collidesWithItem1 cobj_x0 cobj_x1 (toCLong $ qEnum_toInt x2)
instance QcollidesWithItem_h (QGraphicsPathItem ()) ((QGraphicsTextItem t1)) where
collidesWithItem_h x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_collidesWithItem_graphicstextitem cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_collidesWithItem_graphicstextitem" qtc_QGraphicsPathItem_collidesWithItem_graphicstextitem :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsTextItem t1) -> IO CBool
instance QcollidesWithItem_h (QGraphicsPathItemSc a) ((QGraphicsTextItem t1)) where
collidesWithItem_h x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_collidesWithItem_graphicstextitem cobj_x0 cobj_x1
instance QcollidesWithItem_h (QGraphicsPathItem ()) ((QGraphicsTextItem t1, ItemSelectionMode)) where
collidesWithItem_h x0 (x1, x2)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_collidesWithItem1_graphicstextitem cobj_x0 cobj_x1 (toCLong $ qEnum_toInt x2)
foreign import ccall "qtc_QGraphicsPathItem_collidesWithItem1_graphicstextitem" qtc_QGraphicsPathItem_collidesWithItem1_graphicstextitem :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsTextItem t1) -> CLong -> IO CBool
instance QcollidesWithItem_h (QGraphicsPathItemSc a) ((QGraphicsTextItem t1, ItemSelectionMode)) where
collidesWithItem_h x0 (x1, x2)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_collidesWithItem1_graphicstextitem cobj_x0 cobj_x1 (toCLong $ qEnum_toInt x2)
instance QsetHandler (QGraphicsPathItem ()) (QGraphicsPathItem x0 -> QPainterPath t1 -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem11 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem11_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler11 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQPainterPath t1) -> IO (CBool)
setHandlerWrapper x0 x1
= do x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QGraphicsPathItem_setHandler11" qtc_QGraphicsPathItem_setHandler11 :: Ptr (TQGraphicsPathItem a) -> CWString -> Ptr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQPainterPath t1) -> IO (CBool)) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem11 :: (Ptr (TQGraphicsPathItem x0) -> Ptr (TQPainterPath t1) -> IO (CBool)) -> IO (FunPtr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQPainterPath t1) -> IO (CBool)))
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem11_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetHandler (QGraphicsPathItemSc a) (QGraphicsPathItem x0 -> QPainterPath t1 -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem11 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem11_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler11 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQPainterPath t1) -> IO (CBool)
setHandlerWrapper x0 x1
= do x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance QsetHandler (QGraphicsPathItem ()) (QGraphicsPathItem x0 -> QPainterPath t1 -> ItemSelectionMode -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem12 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem12_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler12 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQPainterPath t1) -> CLong -> IO (CBool)
setHandlerWrapper x0 x1 x2
= do x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
let x2enum = qEnum_fromInt $ fromCLong x2
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj x2enum
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QGraphicsPathItem_setHandler12" qtc_QGraphicsPathItem_setHandler12 :: Ptr (TQGraphicsPathItem a) -> CWString -> Ptr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQPainterPath t1) -> CLong -> IO (CBool)) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem12 :: (Ptr (TQGraphicsPathItem x0) -> Ptr (TQPainterPath t1) -> CLong -> IO (CBool)) -> IO (FunPtr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQPainterPath t1) -> CLong -> IO (CBool)))
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem12_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetHandler (QGraphicsPathItemSc a) (QGraphicsPathItem x0 -> QPainterPath t1 -> ItemSelectionMode -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem12 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem12_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler12 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQPainterPath t1) -> CLong -> IO (CBool)
setHandlerWrapper x0 x1 x2
= do x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
let x2enum = qEnum_fromInt $ fromCLong x2
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj x2enum
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance QcollidesWithPath_h (QGraphicsPathItem ()) ((QPainterPath t1)) where
collidesWithPath_h x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_collidesWithPath cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_collidesWithPath" qtc_QGraphicsPathItem_collidesWithPath :: Ptr (TQGraphicsPathItem a) -> Ptr (TQPainterPath t1) -> IO CBool
instance QcollidesWithPath_h (QGraphicsPathItemSc a) ((QPainterPath t1)) where
collidesWithPath_h x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_collidesWithPath cobj_x0 cobj_x1
instance QcollidesWithPath_h (QGraphicsPathItem ()) ((QPainterPath t1, ItemSelectionMode)) where
collidesWithPath_h x0 (x1, x2)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_collidesWithPath1 cobj_x0 cobj_x1 (toCLong $ qEnum_toInt x2)
foreign import ccall "qtc_QGraphicsPathItem_collidesWithPath1" qtc_QGraphicsPathItem_collidesWithPath1 :: Ptr (TQGraphicsPathItem a) -> Ptr (TQPainterPath t1) -> CLong -> IO CBool
instance QcollidesWithPath_h (QGraphicsPathItemSc a) ((QPainterPath t1, ItemSelectionMode)) where
collidesWithPath_h x0 (x1, x2)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_collidesWithPath1 cobj_x0 cobj_x1 (toCLong $ qEnum_toInt x2)
instance QsetHandler (QGraphicsPathItem ()) (QGraphicsPathItem x0 -> QEvent t1 -> IO ()) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem13 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem13_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler13 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQEvent t1) -> IO ()
setHandlerWrapper x0 x1
= do x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
if (objectIsNull x0obj)
then return ()
else _handler x0obj x1obj
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QGraphicsPathItem_setHandler13" qtc_QGraphicsPathItem_setHandler13 :: Ptr (TQGraphicsPathItem a) -> CWString -> Ptr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQEvent t1) -> IO ()) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem13 :: (Ptr (TQGraphicsPathItem x0) -> Ptr (TQEvent t1) -> IO ()) -> IO (FunPtr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQEvent t1) -> IO ()))
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem13_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetHandler (QGraphicsPathItemSc a) (QGraphicsPathItem x0 -> QEvent t1 -> IO ()) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem13 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem13_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler13 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQEvent t1) -> IO ()
setHandlerWrapper x0 x1
= do x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
if (objectIsNull x0obj)
then return ()
else _handler x0obj x1obj
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance QcontextMenuEvent_h (QGraphicsPathItem ()) ((QGraphicsSceneContextMenuEvent t1)) where
contextMenuEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_contextMenuEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_contextMenuEvent" qtc_QGraphicsPathItem_contextMenuEvent :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsSceneContextMenuEvent t1) -> IO ()
instance QcontextMenuEvent_h (QGraphicsPathItemSc a) ((QGraphicsSceneContextMenuEvent t1)) where
contextMenuEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_contextMenuEvent cobj_x0 cobj_x1
instance QdragEnterEvent_h (QGraphicsPathItem ()) ((QGraphicsSceneDragDropEvent t1)) where
dragEnterEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_dragEnterEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_dragEnterEvent" qtc_QGraphicsPathItem_dragEnterEvent :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsSceneDragDropEvent t1) -> IO ()
instance QdragEnterEvent_h (QGraphicsPathItemSc a) ((QGraphicsSceneDragDropEvent t1)) where
dragEnterEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_dragEnterEvent cobj_x0 cobj_x1
instance QdragLeaveEvent_h (QGraphicsPathItem ()) ((QGraphicsSceneDragDropEvent t1)) where
dragLeaveEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_dragLeaveEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_dragLeaveEvent" qtc_QGraphicsPathItem_dragLeaveEvent :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsSceneDragDropEvent t1) -> IO ()
instance QdragLeaveEvent_h (QGraphicsPathItemSc a) ((QGraphicsSceneDragDropEvent t1)) where
dragLeaveEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_dragLeaveEvent cobj_x0 cobj_x1
instance QdragMoveEvent_h (QGraphicsPathItem ()) ((QGraphicsSceneDragDropEvent t1)) where
dragMoveEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_dragMoveEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_dragMoveEvent" qtc_QGraphicsPathItem_dragMoveEvent :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsSceneDragDropEvent t1) -> IO ()
instance QdragMoveEvent_h (QGraphicsPathItemSc a) ((QGraphicsSceneDragDropEvent t1)) where
dragMoveEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_dragMoveEvent cobj_x0 cobj_x1
instance QdropEvent_h (QGraphicsPathItem ()) ((QGraphicsSceneDragDropEvent t1)) where
dropEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_dropEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_dropEvent" qtc_QGraphicsPathItem_dropEvent :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsSceneDragDropEvent t1) -> IO ()
instance QdropEvent_h (QGraphicsPathItemSc a) ((QGraphicsSceneDragDropEvent t1)) where
dropEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_dropEvent cobj_x0 cobj_x1
instance QfocusInEvent_h (QGraphicsPathItem ()) ((QFocusEvent t1)) where
focusInEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_focusInEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_focusInEvent" qtc_QGraphicsPathItem_focusInEvent :: Ptr (TQGraphicsPathItem a) -> Ptr (TQFocusEvent t1) -> IO ()
instance QfocusInEvent_h (QGraphicsPathItemSc a) ((QFocusEvent t1)) where
focusInEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_focusInEvent cobj_x0 cobj_x1
instance QfocusOutEvent_h (QGraphicsPathItem ()) ((QFocusEvent t1)) where
focusOutEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_focusOutEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_focusOutEvent" qtc_QGraphicsPathItem_focusOutEvent :: Ptr (TQGraphicsPathItem a) -> Ptr (TQFocusEvent t1) -> IO ()
instance QfocusOutEvent_h (QGraphicsPathItemSc a) ((QFocusEvent t1)) where
focusOutEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_focusOutEvent cobj_x0 cobj_x1
instance QhoverEnterEvent_h (QGraphicsPathItem ()) ((QGraphicsSceneHoverEvent t1)) where
hoverEnterEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_hoverEnterEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_hoverEnterEvent" qtc_QGraphicsPathItem_hoverEnterEvent :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsSceneHoverEvent t1) -> IO ()
instance QhoverEnterEvent_h (QGraphicsPathItemSc a) ((QGraphicsSceneHoverEvent t1)) where
hoverEnterEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_hoverEnterEvent cobj_x0 cobj_x1
instance QhoverLeaveEvent_h (QGraphicsPathItem ()) ((QGraphicsSceneHoverEvent t1)) where
hoverLeaveEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_hoverLeaveEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_hoverLeaveEvent" qtc_QGraphicsPathItem_hoverLeaveEvent :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsSceneHoverEvent t1) -> IO ()
instance QhoverLeaveEvent_h (QGraphicsPathItemSc a) ((QGraphicsSceneHoverEvent t1)) where
hoverLeaveEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_hoverLeaveEvent cobj_x0 cobj_x1
instance QhoverMoveEvent_h (QGraphicsPathItem ()) ((QGraphicsSceneHoverEvent t1)) where
hoverMoveEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_hoverMoveEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_hoverMoveEvent" qtc_QGraphicsPathItem_hoverMoveEvent :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsSceneHoverEvent t1) -> IO ()
instance QhoverMoveEvent_h (QGraphicsPathItemSc a) ((QGraphicsSceneHoverEvent t1)) where
hoverMoveEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_hoverMoveEvent cobj_x0 cobj_x1
instance QinputMethodEvent_h (QGraphicsPathItem ()) ((QInputMethodEvent t1)) where
inputMethodEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_inputMethodEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_inputMethodEvent" qtc_QGraphicsPathItem_inputMethodEvent :: Ptr (TQGraphicsPathItem a) -> Ptr (TQInputMethodEvent t1) -> IO ()
instance QinputMethodEvent_h (QGraphicsPathItemSc a) ((QInputMethodEvent t1)) where
inputMethodEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_inputMethodEvent cobj_x0 cobj_x1
instance QsetHandler (QGraphicsPathItem ()) (QGraphicsPathItem x0 -> InputMethodQuery -> IO (QVariant t0)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem14 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem14_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler14 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> CLong -> IO (Ptr (TQVariant t0))
setHandlerWrapper x0 x1
= do x0obj <- objectFromPtr_nf x0
let x1enum = qEnum_fromInt $ fromCLong x1
let rv =
if (objectIsNull x0obj)
then return $ objectCast x0obj
else _handler x0obj x1enum
rvf <- rv
withObjectPtr rvf $ \cobj_rvf -> return (cobj_rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QGraphicsPathItem_setHandler14" qtc_QGraphicsPathItem_setHandler14 :: Ptr (TQGraphicsPathItem a) -> CWString -> Ptr (Ptr (TQGraphicsPathItem x0) -> CLong -> IO (Ptr (TQVariant t0))) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem14 :: (Ptr (TQGraphicsPathItem x0) -> CLong -> IO (Ptr (TQVariant t0))) -> IO (FunPtr (Ptr (TQGraphicsPathItem x0) -> CLong -> IO (Ptr (TQVariant t0))))
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem14_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetHandler (QGraphicsPathItemSc a) (QGraphicsPathItem x0 -> InputMethodQuery -> IO (QVariant t0)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem14 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem14_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler14 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> CLong -> IO (Ptr (TQVariant t0))
setHandlerWrapper x0 x1
= do x0obj <- objectFromPtr_nf x0
let x1enum = qEnum_fromInt $ fromCLong x1
let rv =
if (objectIsNull x0obj)
then return $ objectCast x0obj
else _handler x0obj x1enum
rvf <- rv
withObjectPtr rvf $ \cobj_rvf -> return (cobj_rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance QinputMethodQuery_h (QGraphicsPathItem ()) ((InputMethodQuery)) where
inputMethodQuery_h x0 (x1)
= withQVariantResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QGraphicsPathItem_inputMethodQuery cobj_x0 (toCLong $ qEnum_toInt x1)
foreign import ccall "qtc_QGraphicsPathItem_inputMethodQuery" qtc_QGraphicsPathItem_inputMethodQuery :: Ptr (TQGraphicsPathItem a) -> CLong -> IO (Ptr (TQVariant ()))
instance QinputMethodQuery_h (QGraphicsPathItemSc a) ((InputMethodQuery)) where
inputMethodQuery_h x0 (x1)
= withQVariantResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QGraphicsPathItem_inputMethodQuery cobj_x0 (toCLong $ qEnum_toInt x1)
instance QsetHandler (QGraphicsPathItem ()) (QGraphicsPathItem x0 -> GraphicsItemChange -> QVariant t2 -> IO (QVariant t0)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem15 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem15_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler15 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> CLong -> Ptr (TQVariant t2) -> IO (Ptr (TQVariant t0))
setHandlerWrapper x0 x1 x2
= do x0obj <- objectFromPtr_nf x0
let x1enum = qEnum_fromInt $ fromCLong x1
x2obj <- objectFromPtr_nf x2
let rv =
if (objectIsNull x0obj)
then return $ objectCast x0obj
else _handler x0obj x1enum x2obj
rvf <- rv
withObjectPtr rvf $ \cobj_rvf -> return (cobj_rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QGraphicsPathItem_setHandler15" qtc_QGraphicsPathItem_setHandler15 :: Ptr (TQGraphicsPathItem a) -> CWString -> Ptr (Ptr (TQGraphicsPathItem x0) -> CLong -> Ptr (TQVariant t2) -> IO (Ptr (TQVariant t0))) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem15 :: (Ptr (TQGraphicsPathItem x0) -> CLong -> Ptr (TQVariant t2) -> IO (Ptr (TQVariant t0))) -> IO (FunPtr (Ptr (TQGraphicsPathItem x0) -> CLong -> Ptr (TQVariant t2) -> IO (Ptr (TQVariant t0))))
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem15_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetHandler (QGraphicsPathItemSc a) (QGraphicsPathItem x0 -> GraphicsItemChange -> QVariant t2 -> IO (QVariant t0)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem15 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem15_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler15 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> CLong -> Ptr (TQVariant t2) -> IO (Ptr (TQVariant t0))
setHandlerWrapper x0 x1 x2
= do x0obj <- objectFromPtr_nf x0
let x1enum = qEnum_fromInt $ fromCLong x1
x2obj <- objectFromPtr_nf x2
let rv =
if (objectIsNull x0obj)
then return $ objectCast x0obj
else _handler x0obj x1enum x2obj
rvf <- rv
withObjectPtr rvf $ \cobj_rvf -> return (cobj_rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance QitemChange_h (QGraphicsPathItem ()) ((GraphicsItemChange, QVariant t2)) where
itemChange_h x0 (x1, x2)
= withQVariantResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x2 $ \cobj_x2 ->
qtc_QGraphicsPathItem_itemChange cobj_x0 (toCLong $ qEnum_toInt x1) cobj_x2
foreign import ccall "qtc_QGraphicsPathItem_itemChange" qtc_QGraphicsPathItem_itemChange :: Ptr (TQGraphicsPathItem a) -> CLong -> Ptr (TQVariant t2) -> IO (Ptr (TQVariant ()))
instance QitemChange_h (QGraphicsPathItemSc a) ((GraphicsItemChange, QVariant t2)) where
itemChange_h x0 (x1, x2)
= withQVariantResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x2 $ \cobj_x2 ->
qtc_QGraphicsPathItem_itemChange cobj_x0 (toCLong $ qEnum_toInt x1) cobj_x2
instance QkeyPressEvent_h (QGraphicsPathItem ()) ((QKeyEvent t1)) where
keyPressEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_keyPressEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_keyPressEvent" qtc_QGraphicsPathItem_keyPressEvent :: Ptr (TQGraphicsPathItem a) -> Ptr (TQKeyEvent t1) -> IO ()
instance QkeyPressEvent_h (QGraphicsPathItemSc a) ((QKeyEvent t1)) where
keyPressEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_keyPressEvent cobj_x0 cobj_x1
instance QkeyReleaseEvent_h (QGraphicsPathItem ()) ((QKeyEvent t1)) where
keyReleaseEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_keyReleaseEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_keyReleaseEvent" qtc_QGraphicsPathItem_keyReleaseEvent :: Ptr (TQGraphicsPathItem a) -> Ptr (TQKeyEvent t1) -> IO ()
instance QkeyReleaseEvent_h (QGraphicsPathItemSc a) ((QKeyEvent t1)) where
keyReleaseEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_keyReleaseEvent cobj_x0 cobj_x1
instance QmouseDoubleClickEvent_h (QGraphicsPathItem ()) ((QGraphicsSceneMouseEvent t1)) where
mouseDoubleClickEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_mouseDoubleClickEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_mouseDoubleClickEvent" qtc_QGraphicsPathItem_mouseDoubleClickEvent :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsSceneMouseEvent t1) -> IO ()
instance QmouseDoubleClickEvent_h (QGraphicsPathItemSc a) ((QGraphicsSceneMouseEvent t1)) where
mouseDoubleClickEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_mouseDoubleClickEvent cobj_x0 cobj_x1
instance QmouseMoveEvent_h (QGraphicsPathItem ()) ((QGraphicsSceneMouseEvent t1)) where
mouseMoveEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_mouseMoveEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_mouseMoveEvent" qtc_QGraphicsPathItem_mouseMoveEvent :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsSceneMouseEvent t1) -> IO ()
instance QmouseMoveEvent_h (QGraphicsPathItemSc a) ((QGraphicsSceneMouseEvent t1)) where
mouseMoveEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_mouseMoveEvent cobj_x0 cobj_x1
instance QmousePressEvent_h (QGraphicsPathItem ()) ((QGraphicsSceneMouseEvent t1)) where
mousePressEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_mousePressEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_mousePressEvent" qtc_QGraphicsPathItem_mousePressEvent :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsSceneMouseEvent t1) -> IO ()
instance QmousePressEvent_h (QGraphicsPathItemSc a) ((QGraphicsSceneMouseEvent t1)) where
mousePressEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_mousePressEvent cobj_x0 cobj_x1
instance QmouseReleaseEvent_h (QGraphicsPathItem ()) ((QGraphicsSceneMouseEvent t1)) where
mouseReleaseEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_mouseReleaseEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_mouseReleaseEvent" qtc_QGraphicsPathItem_mouseReleaseEvent :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsSceneMouseEvent t1) -> IO ()
instance QmouseReleaseEvent_h (QGraphicsPathItemSc a) ((QGraphicsSceneMouseEvent t1)) where
mouseReleaseEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_mouseReleaseEvent cobj_x0 cobj_x1
instance QsetHandler (QGraphicsPathItem ()) (QGraphicsPathItem x0 -> QEvent t1 -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem16 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem16_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler16 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQEvent t1) -> IO (CBool)
setHandlerWrapper x0 x1
= do x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QGraphicsPathItem_setHandler16" qtc_QGraphicsPathItem_setHandler16 :: Ptr (TQGraphicsPathItem a) -> CWString -> Ptr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQEvent t1) -> IO (CBool)) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem16 :: (Ptr (TQGraphicsPathItem x0) -> Ptr (TQEvent t1) -> IO (CBool)) -> IO (FunPtr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQEvent t1) -> IO (CBool)))
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem16_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetHandler (QGraphicsPathItemSc a) (QGraphicsPathItem x0 -> QEvent t1 -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem16 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem16_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler16 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQEvent t1) -> IO (CBool)
setHandlerWrapper x0 x1
= do x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance QsceneEvent_h (QGraphicsPathItem ()) ((QEvent t1)) where
sceneEvent_h x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_sceneEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_sceneEvent" qtc_QGraphicsPathItem_sceneEvent :: Ptr (TQGraphicsPathItem a) -> Ptr (TQEvent t1) -> IO CBool
instance QsceneEvent_h (QGraphicsPathItemSc a) ((QEvent t1)) where
sceneEvent_h x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_sceneEvent cobj_x0 cobj_x1
instance QsetHandler (QGraphicsPathItem ()) (QGraphicsPathItem x0 -> QGraphicsItem t1 -> QEvent t2 -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem17 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem17_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler17 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQGraphicsItem t1) -> Ptr (TQEvent t2) -> IO (CBool)
setHandlerWrapper x0 x1 x2
= do x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
x2obj <- objectFromPtr_nf x2
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj x2obj
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QGraphicsPathItem_setHandler17" qtc_QGraphicsPathItem_setHandler17 :: Ptr (TQGraphicsPathItem a) -> CWString -> Ptr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQGraphicsItem t1) -> Ptr (TQEvent t2) -> IO (CBool)) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem17 :: (Ptr (TQGraphicsPathItem x0) -> Ptr (TQGraphicsItem t1) -> Ptr (TQEvent t2) -> IO (CBool)) -> IO (FunPtr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQGraphicsItem t1) -> Ptr (TQEvent t2) -> IO (CBool)))
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem17_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetHandler (QGraphicsPathItemSc a) (QGraphicsPathItem x0 -> QGraphicsItem t1 -> QEvent t2 -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem17 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem17_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler17 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQGraphicsItem t1) -> Ptr (TQEvent t2) -> IO (CBool)
setHandlerWrapper x0 x1 x2
= do x0obj <- objectFromPtr_nf x0
x1obj <- objectFromPtr_nf x1
x2obj <- objectFromPtr_nf x2
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj x2obj
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance QsetHandler (QGraphicsPathItem ()) (QGraphicsPathItem x0 -> QObject t1 -> QEvent t2 -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem18 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem18_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler18 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQObject t1) -> Ptr (TQEvent t2) -> IO (CBool)
setHandlerWrapper x0 x1 x2
= do x0obj <- objectFromPtr_nf x0
x1obj <- qObjectFromPtr x1
x2obj <- objectFromPtr_nf x2
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj x2obj
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
foreign import ccall "qtc_QGraphicsPathItem_setHandler18" qtc_QGraphicsPathItem_setHandler18 :: Ptr (TQGraphicsPathItem a) -> CWString -> Ptr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQObject t1) -> Ptr (TQEvent t2) -> IO (CBool)) -> Ptr () -> Ptr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO ()
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem18 :: (Ptr (TQGraphicsPathItem x0) -> Ptr (TQObject t1) -> Ptr (TQEvent t2) -> IO (CBool)) -> IO (FunPtr (Ptr (TQGraphicsPathItem x0) -> Ptr (TQObject t1) -> Ptr (TQEvent t2) -> IO (CBool)))
foreign import ccall "wrapper" wrapSetHandler_QGraphicsPathItem18_d :: (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()) -> IO (FunPtr (Ptr fun -> Ptr state -> Ptr fun_d -> IO ()))
instance QsetHandler (QGraphicsPathItemSc a) (QGraphicsPathItem x0 -> QObject t1 -> QEvent t2 -> IO (Bool)) where
setHandler _eobj _eid _handler
= do
funptr <- wrapSetHandler_QGraphicsPathItem18 setHandlerWrapper
stptr <- newStablePtr (Wrap _handler)
funptr_d <- wrapSetHandler_QGraphicsPathItem18_d setHandlerWrapper_d
withObjectPtr _eobj $ \cobj_eobj ->
withCWString _eid $ \cstr_eid ->
qtc_QGraphicsPathItem_setHandler18 cobj_eobj cstr_eid (toCFunPtr funptr) (castStablePtrToPtr stptr) (toCFunPtr funptr_d)
return()
where
setHandlerWrapper :: Ptr (TQGraphicsPathItem x0) -> Ptr (TQObject t1) -> Ptr (TQEvent t2) -> IO (CBool)
setHandlerWrapper x0 x1 x2
= do x0obj <- objectFromPtr_nf x0
x1obj <- qObjectFromPtr x1
x2obj <- objectFromPtr_nf x2
let rv =
if (objectIsNull x0obj)
then return False
else _handler x0obj x1obj x2obj
rvf <- rv
return (toCBool rvf)
setHandlerWrapper_d :: Ptr fun -> Ptr () -> Ptr fun_d -> IO ()
setHandlerWrapper_d funptr stptr funptr_d
= do when (stptr/=ptrNull)
(freeStablePtr (castPtrToStablePtr stptr))
when (funptr/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr))
when (funptr_d/=ptrNull)
(freeHaskellFunPtr (castPtrToFunPtr funptr_d))
return ()
instance QsceneEventFilter_h (QGraphicsPathItem ()) ((QGraphicsItem t1, QEvent t2)) where
sceneEventFilter_h x0 (x1, x2)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
withObjectPtr x2 $ \cobj_x2 ->
qtc_QGraphicsPathItem_sceneEventFilter cobj_x0 cobj_x1 cobj_x2
foreign import ccall "qtc_QGraphicsPathItem_sceneEventFilter" qtc_QGraphicsPathItem_sceneEventFilter :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsItem t1) -> Ptr (TQEvent t2) -> IO CBool
instance QsceneEventFilter_h (QGraphicsPathItemSc a) ((QGraphicsItem t1, QEvent t2)) where
sceneEventFilter_h x0 (x1, x2)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
withObjectPtr x2 $ \cobj_x2 ->
qtc_QGraphicsPathItem_sceneEventFilter cobj_x0 cobj_x1 cobj_x2
instance QsceneEventFilter_h (QGraphicsPathItem ()) ((QGraphicsTextItem t1, QEvent t2)) where
sceneEventFilter_h x0 (x1, x2)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
withObjectPtr x2 $ \cobj_x2 ->
qtc_QGraphicsPathItem_sceneEventFilter_graphicstextitem cobj_x0 cobj_x1 cobj_x2
foreign import ccall "qtc_QGraphicsPathItem_sceneEventFilter_graphicstextitem" qtc_QGraphicsPathItem_sceneEventFilter_graphicstextitem :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsTextItem t1) -> Ptr (TQEvent t2) -> IO CBool
instance QsceneEventFilter_h (QGraphicsPathItemSc a) ((QGraphicsTextItem t1, QEvent t2)) where
sceneEventFilter_h x0 (x1, x2)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
withObjectPtr x2 $ \cobj_x2 ->
qtc_QGraphicsPathItem_sceneEventFilter_graphicstextitem cobj_x0 cobj_x1 cobj_x2
instance QwheelEvent_h (QGraphicsPathItem ()) ((QGraphicsSceneWheelEvent t1)) where
wheelEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_wheelEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QGraphicsPathItem_wheelEvent" qtc_QGraphicsPathItem_wheelEvent :: Ptr (TQGraphicsPathItem a) -> Ptr (TQGraphicsSceneWheelEvent t1) -> IO ()
instance QwheelEvent_h (QGraphicsPathItemSc a) ((QGraphicsSceneWheelEvent t1)) where
wheelEvent_h x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QGraphicsPathItem_wheelEvent cobj_x0 cobj_x1
| uduki/hsQt | Qtc/Gui/QGraphicsPathItem_h.hs | bsd-2-clause | 98,020 | 0 | 18 | 20,810 | 30,658 | 14,667 | 15,991 | -1 | -1 |
{-# OPTIONS -fglasgow-exts #-}
-----------------------------------------------------------------------------
{-| Module : QBoxLayout.hs
Copyright : (c) David Harley 2010
Project : qtHaskell
Version : 1.1.4
Modified : 2010-09-02 17:02:30
Warning : this file is machine generated - do not modify.
--}
-----------------------------------------------------------------------------
module Qtc.Gui.QBoxLayout (
QqBoxLayout(..)
,addSpacing
,QaddStretch(..)
,addStrut
,QinsertLayout(..)
,insertSpacing
,QinsertStretch(..)
,qBoxLayout_delete
,qBoxLayout_deleteLater
)
where
import Foreign.C.Types
import Qth.ClassTypes.Core
import Qtc.Enums.Base
import Qtc.Enums.Core.Qt
import Qtc.Enums.Gui.QBoxLayout
import Qtc.Classes.Base
import Qtc.Classes.Qccs
import Qtc.Classes.Core
import Qtc.ClassTypes.Core
import Qth.ClassTypes.Core
import Qtc.Classes.Gui
import Qtc.ClassTypes.Gui
instance QuserMethod (QBoxLayout ()) (()) (IO ()) where
userMethod qobj evid ()
= withObjectPtr qobj $ \cobj_qobj ->
qtc_QBoxLayout_userMethod cobj_qobj (toCInt evid)
foreign import ccall "qtc_QBoxLayout_userMethod" qtc_QBoxLayout_userMethod :: Ptr (TQBoxLayout a) -> CInt -> IO ()
instance QuserMethod (QBoxLayoutSc a) (()) (IO ()) where
userMethod qobj evid ()
= withObjectPtr qobj $ \cobj_qobj ->
qtc_QBoxLayout_userMethod cobj_qobj (toCInt evid)
instance QuserMethod (QBoxLayout ()) (QVariant ()) (IO (QVariant ())) where
userMethod qobj evid qvoj
= withObjectRefResult $
withObjectPtr qobj $ \cobj_qobj ->
withObjectPtr qvoj $ \cobj_qvoj ->
qtc_QBoxLayout_userMethodVariant cobj_qobj (toCInt evid) cobj_qvoj
foreign import ccall "qtc_QBoxLayout_userMethodVariant" qtc_QBoxLayout_userMethodVariant :: Ptr (TQBoxLayout a) -> CInt -> Ptr (TQVariant ()) -> IO (Ptr (TQVariant ()))
instance QuserMethod (QBoxLayoutSc a) (QVariant ()) (IO (QVariant ())) where
userMethod qobj evid qvoj
= withObjectRefResult $
withObjectPtr qobj $ \cobj_qobj ->
withObjectPtr qvoj $ \cobj_qvoj ->
qtc_QBoxLayout_userMethodVariant cobj_qobj (toCInt evid) cobj_qvoj
class QqBoxLayout x1 where
qBoxLayout :: x1 -> IO (QBoxLayout ())
instance QqBoxLayout ((QBoxLayoutDirection)) where
qBoxLayout (x1)
= withQBoxLayoutResult $
qtc_QBoxLayout (toCLong $ qEnum_toInt x1)
foreign import ccall "qtc_QBoxLayout" qtc_QBoxLayout :: CLong -> IO (Ptr (TQBoxLayout ()))
instance QqBoxLayout ((QBoxLayoutDirection, QWidget t2)) where
qBoxLayout (x1, x2)
= withQBoxLayoutResult $
withObjectPtr x2 $ \cobj_x2 ->
qtc_QBoxLayout1 (toCLong $ qEnum_toInt x1) cobj_x2
foreign import ccall "qtc_QBoxLayout1" qtc_QBoxLayout1 :: CLong -> Ptr (TQWidget t2) -> IO (Ptr (TQBoxLayout ()))
instance QaddItem (QBoxLayout ()) ((QLayoutItem t1)) (IO ()) where
addItem x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_addItem_h cobj_x0 cobj_x1
foreign import ccall "qtc_QBoxLayout_addItem_h" qtc_QBoxLayout_addItem_h :: Ptr (TQBoxLayout a) -> Ptr (TQLayoutItem t1) -> IO ()
instance QaddItem (QBoxLayoutSc a) ((QLayoutItem t1)) (IO ()) where
addItem x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_addItem_h cobj_x0 cobj_x1
instance QaddLayout (QBoxLayout a) ((QLayout t1)) where
addLayout x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_addLayout cobj_x0 cobj_x1
foreign import ccall "qtc_QBoxLayout_addLayout" qtc_QBoxLayout_addLayout :: Ptr (TQBoxLayout a) -> Ptr (TQLayout t1) -> IO ()
instance QaddLayout (QBoxLayout a) ((QLayout t1, Int)) where
addLayout x0 (x1, x2)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_addLayout1 cobj_x0 cobj_x1 (toCInt x2)
foreign import ccall "qtc_QBoxLayout_addLayout1" qtc_QBoxLayout_addLayout1 :: Ptr (TQBoxLayout a) -> Ptr (TQLayout t1) -> CInt -> IO ()
addSpacing :: QBoxLayout a -> ((Int)) -> IO ()
addSpacing x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_addSpacing cobj_x0 (toCInt x1)
foreign import ccall "qtc_QBoxLayout_addSpacing" qtc_QBoxLayout_addSpacing :: Ptr (TQBoxLayout a) -> CInt -> IO ()
class QaddStretch x1 where
addStretch :: QBoxLayout a -> x1 -> IO ()
instance QaddStretch (()) where
addStretch x0 ()
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_addStretch cobj_x0
foreign import ccall "qtc_QBoxLayout_addStretch" qtc_QBoxLayout_addStretch :: Ptr (TQBoxLayout a) -> IO ()
instance QaddStretch ((Int)) where
addStretch x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_addStretch1 cobj_x0 (toCInt x1)
foreign import ccall "qtc_QBoxLayout_addStretch1" qtc_QBoxLayout_addStretch1 :: Ptr (TQBoxLayout a) -> CInt -> IO ()
addStrut :: QBoxLayout a -> ((Int)) -> IO ()
addStrut x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_addStrut cobj_x0 (toCInt x1)
foreign import ccall "qtc_QBoxLayout_addStrut" qtc_QBoxLayout_addStrut :: Ptr (TQBoxLayout a) -> CInt -> IO ()
instance QaddWidget (QBoxLayout ()) ((QWidget t1)) (IO ()) where
addWidget x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_addWidget cobj_x0 cobj_x1
foreign import ccall "qtc_QBoxLayout_addWidget" qtc_QBoxLayout_addWidget :: Ptr (TQBoxLayout a) -> Ptr (TQWidget t1) -> IO ()
instance QaddWidget (QBoxLayoutSc a) ((QWidget t1)) (IO ()) where
addWidget x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_addWidget cobj_x0 cobj_x1
instance QaddWidget (QBoxLayout ()) ((QWidget t1, Int)) (IO ()) where
addWidget x0 (x1, x2)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_addWidget1 cobj_x0 cobj_x1 (toCInt x2)
foreign import ccall "qtc_QBoxLayout_addWidget1" qtc_QBoxLayout_addWidget1 :: Ptr (TQBoxLayout a) -> Ptr (TQWidget t1) -> CInt -> IO ()
instance QaddWidget (QBoxLayoutSc a) ((QWidget t1, Int)) (IO ()) where
addWidget x0 (x1, x2)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_addWidget1 cobj_x0 cobj_x1 (toCInt x2)
instance QaddWidget (QBoxLayout ()) ((QWidget t1, Int, Alignment)) (IO ()) where
addWidget x0 (x1, x2, x3)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_addWidget2 cobj_x0 cobj_x1 (toCInt x2) (toCLong $ qFlags_toInt x3)
foreign import ccall "qtc_QBoxLayout_addWidget2" qtc_QBoxLayout_addWidget2 :: Ptr (TQBoxLayout a) -> Ptr (TQWidget t1) -> CInt -> CLong -> IO ()
instance QaddWidget (QBoxLayoutSc a) ((QWidget t1, Int, Alignment)) (IO ()) where
addWidget x0 (x1, x2, x3)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_addWidget2 cobj_x0 cobj_x1 (toCInt x2) (toCLong $ qFlags_toInt x3)
instance Qcount (QBoxLayout ()) (()) where
count x0 ()
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_count_h cobj_x0
foreign import ccall "qtc_QBoxLayout_count_h" qtc_QBoxLayout_count_h :: Ptr (TQBoxLayout a) -> IO CInt
instance Qcount (QBoxLayoutSc a) (()) where
count x0 ()
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_count_h cobj_x0
instance Qdirection (QBoxLayout a) (()) (IO (QBoxLayoutDirection)) where
direction x0 ()
= withQEnumResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_direction cobj_x0
foreign import ccall "qtc_QBoxLayout_direction" qtc_QBoxLayout_direction :: Ptr (TQBoxLayout a) -> IO CLong
instance QexpandingDirections (QBoxLayout ()) (()) where
expandingDirections x0 ()
= withQFlagsResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_expandingDirections_h cobj_x0
foreign import ccall "qtc_QBoxLayout_expandingDirections_h" qtc_QBoxLayout_expandingDirections_h :: Ptr (TQBoxLayout a) -> IO CLong
instance QexpandingDirections (QBoxLayoutSc a) (()) where
expandingDirections x0 ()
= withQFlagsResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_expandingDirections_h cobj_x0
instance QhasHeightForWidth (QBoxLayout ()) (()) where
hasHeightForWidth x0 ()
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_hasHeightForWidth_h cobj_x0
foreign import ccall "qtc_QBoxLayout_hasHeightForWidth_h" qtc_QBoxLayout_hasHeightForWidth_h :: Ptr (TQBoxLayout a) -> IO CBool
instance QhasHeightForWidth (QBoxLayoutSc a) (()) where
hasHeightForWidth x0 ()
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_hasHeightForWidth_h cobj_x0
instance QheightForWidth (QBoxLayout ()) ((Int)) where
heightForWidth x0 (x1)
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_heightForWidth_h cobj_x0 (toCInt x1)
foreign import ccall "qtc_QBoxLayout_heightForWidth_h" qtc_QBoxLayout_heightForWidth_h :: Ptr (TQBoxLayout a) -> CInt -> IO CInt
instance QheightForWidth (QBoxLayoutSc a) ((Int)) where
heightForWidth x0 (x1)
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_heightForWidth_h cobj_x0 (toCInt x1)
instance QinsertItem (QBoxLayout ()) ((Int, QLayoutItem t2)) (IO ()) where
insertItem x0 (x1, x2)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x2 $ \cobj_x2 ->
qtc_QBoxLayout_insertItem cobj_x0 (toCInt x1) cobj_x2
foreign import ccall "qtc_QBoxLayout_insertItem" qtc_QBoxLayout_insertItem :: Ptr (TQBoxLayout a) -> CInt -> Ptr (TQLayoutItem t2) -> IO ()
instance QinsertItem (QBoxLayoutSc a) ((Int, QLayoutItem t2)) (IO ()) where
insertItem x0 (x1, x2)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x2 $ \cobj_x2 ->
qtc_QBoxLayout_insertItem cobj_x0 (toCInt x1) cobj_x2
class QinsertLayout x1 where
insertLayout :: QBoxLayout a -> x1 -> IO ()
instance QinsertLayout ((Int, QLayout t2)) where
insertLayout x0 (x1, x2)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x2 $ \cobj_x2 ->
qtc_QBoxLayout_insertLayout cobj_x0 (toCInt x1) cobj_x2
foreign import ccall "qtc_QBoxLayout_insertLayout" qtc_QBoxLayout_insertLayout :: Ptr (TQBoxLayout a) -> CInt -> Ptr (TQLayout t2) -> IO ()
instance QinsertLayout ((Int, QLayout t2, Int)) where
insertLayout x0 (x1, x2, x3)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x2 $ \cobj_x2 ->
qtc_QBoxLayout_insertLayout1 cobj_x0 (toCInt x1) cobj_x2 (toCInt x3)
foreign import ccall "qtc_QBoxLayout_insertLayout1" qtc_QBoxLayout_insertLayout1 :: Ptr (TQBoxLayout a) -> CInt -> Ptr (TQLayout t2) -> CInt -> IO ()
insertSpacing :: QBoxLayout a -> ((Int, Int)) -> IO ()
insertSpacing x0 (x1, x2)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_insertSpacing cobj_x0 (toCInt x1) (toCInt x2)
foreign import ccall "qtc_QBoxLayout_insertSpacing" qtc_QBoxLayout_insertSpacing :: Ptr (TQBoxLayout a) -> CInt -> CInt -> IO ()
class QinsertStretch x1 where
insertStretch :: QBoxLayout a -> x1 -> IO ()
instance QinsertStretch ((Int)) where
insertStretch x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_insertStretch cobj_x0 (toCInt x1)
foreign import ccall "qtc_QBoxLayout_insertStretch" qtc_QBoxLayout_insertStretch :: Ptr (TQBoxLayout a) -> CInt -> IO ()
instance QinsertStretch ((Int, Int)) where
insertStretch x0 (x1, x2)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_insertStretch1 cobj_x0 (toCInt x1) (toCInt x2)
foreign import ccall "qtc_QBoxLayout_insertStretch1" qtc_QBoxLayout_insertStretch1 :: Ptr (TQBoxLayout a) -> CInt -> CInt -> IO ()
instance QinsertWidget (QBoxLayout a) ((Int, QWidget t2)) (IO ()) where
insertWidget x0 (x1, x2)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x2 $ \cobj_x2 ->
qtc_QBoxLayout_insertWidget cobj_x0 (toCInt x1) cobj_x2
foreign import ccall "qtc_QBoxLayout_insertWidget" qtc_QBoxLayout_insertWidget :: Ptr (TQBoxLayout a) -> CInt -> Ptr (TQWidget t2) -> IO ()
instance QinsertWidget (QBoxLayout a) ((Int, QWidget t2, Int)) (IO ()) where
insertWidget x0 (x1, x2, x3)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x2 $ \cobj_x2 ->
qtc_QBoxLayout_insertWidget1 cobj_x0 (toCInt x1) cobj_x2 (toCInt x3)
foreign import ccall "qtc_QBoxLayout_insertWidget1" qtc_QBoxLayout_insertWidget1 :: Ptr (TQBoxLayout a) -> CInt -> Ptr (TQWidget t2) -> CInt -> IO ()
instance QinsertWidget (QBoxLayout a) ((Int, QWidget t2, Int, Alignment)) (IO ()) where
insertWidget x0 (x1, x2, x3, x4)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x2 $ \cobj_x2 ->
qtc_QBoxLayout_insertWidget2 cobj_x0 (toCInt x1) cobj_x2 (toCInt x3) (toCLong $ qFlags_toInt x4)
foreign import ccall "qtc_QBoxLayout_insertWidget2" qtc_QBoxLayout_insertWidget2 :: Ptr (TQBoxLayout a) -> CInt -> Ptr (TQWidget t2) -> CInt -> CLong -> IO ()
instance Qinvalidate (QBoxLayout ()) (()) where
invalidate x0 ()
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_invalidate_h cobj_x0
foreign import ccall "qtc_QBoxLayout_invalidate_h" qtc_QBoxLayout_invalidate_h :: Ptr (TQBoxLayout a) -> IO ()
instance Qinvalidate (QBoxLayoutSc a) (()) where
invalidate x0 ()
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_invalidate_h cobj_x0
instance QitemAt (QBoxLayout ()) ((Int)) (IO (QLayoutItem ())) where
itemAt x0 (x1)
= withObjectRefResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_itemAt_h cobj_x0 (toCInt x1)
foreign import ccall "qtc_QBoxLayout_itemAt_h" qtc_QBoxLayout_itemAt_h :: Ptr (TQBoxLayout a) -> CInt -> IO (Ptr (TQLayoutItem ()))
instance QitemAt (QBoxLayoutSc a) ((Int)) (IO (QLayoutItem ())) where
itemAt x0 (x1)
= withObjectRefResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_itemAt_h cobj_x0 (toCInt x1)
instance QqmaximumSize (QBoxLayout ()) (()) where
qmaximumSize x0 ()
= withQSizeResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_maximumSize_h cobj_x0
foreign import ccall "qtc_QBoxLayout_maximumSize_h" qtc_QBoxLayout_maximumSize_h :: Ptr (TQBoxLayout a) -> IO (Ptr (TQSize ()))
instance QqmaximumSize (QBoxLayoutSc a) (()) where
qmaximumSize x0 ()
= withQSizeResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_maximumSize_h cobj_x0
instance QmaximumSize (QBoxLayout ()) (()) where
maximumSize x0 ()
= withSizeResult $ \csize_ret_w csize_ret_h ->
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_maximumSize_qth_h cobj_x0 csize_ret_w csize_ret_h
foreign import ccall "qtc_QBoxLayout_maximumSize_qth_h" qtc_QBoxLayout_maximumSize_qth_h :: Ptr (TQBoxLayout a) -> Ptr CInt -> Ptr CInt -> IO ()
instance QmaximumSize (QBoxLayoutSc a) (()) where
maximumSize x0 ()
= withSizeResult $ \csize_ret_w csize_ret_h ->
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_maximumSize_qth_h cobj_x0 csize_ret_w csize_ret_h
instance QminimumHeightForWidth (QBoxLayout ()) ((Int)) where
minimumHeightForWidth x0 (x1)
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_minimumHeightForWidth_h cobj_x0 (toCInt x1)
foreign import ccall "qtc_QBoxLayout_minimumHeightForWidth_h" qtc_QBoxLayout_minimumHeightForWidth_h :: Ptr (TQBoxLayout a) -> CInt -> IO CInt
instance QminimumHeightForWidth (QBoxLayoutSc a) ((Int)) where
minimumHeightForWidth x0 (x1)
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_minimumHeightForWidth_h cobj_x0 (toCInt x1)
instance QqminimumSize (QBoxLayout ()) (()) where
qminimumSize x0 ()
= withQSizeResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_minimumSize_h cobj_x0
foreign import ccall "qtc_QBoxLayout_minimumSize_h" qtc_QBoxLayout_minimumSize_h :: Ptr (TQBoxLayout a) -> IO (Ptr (TQSize ()))
instance QqminimumSize (QBoxLayoutSc a) (()) where
qminimumSize x0 ()
= withQSizeResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_minimumSize_h cobj_x0
instance QminimumSize (QBoxLayout ()) (()) where
minimumSize x0 ()
= withSizeResult $ \csize_ret_w csize_ret_h ->
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_minimumSize_qth_h cobj_x0 csize_ret_w csize_ret_h
foreign import ccall "qtc_QBoxLayout_minimumSize_qth_h" qtc_QBoxLayout_minimumSize_qth_h :: Ptr (TQBoxLayout a) -> Ptr CInt -> Ptr CInt -> IO ()
instance QminimumSize (QBoxLayoutSc a) (()) where
minimumSize x0 ()
= withSizeResult $ \csize_ret_w csize_ret_h ->
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_minimumSize_qth_h cobj_x0 csize_ret_w csize_ret_h
instance QsetDirection (QBoxLayout a) ((QBoxLayoutDirection)) where
setDirection x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_setDirection cobj_x0 (toCLong $ qEnum_toInt x1)
foreign import ccall "qtc_QBoxLayout_setDirection" qtc_QBoxLayout_setDirection :: Ptr (TQBoxLayout a) -> CLong -> IO ()
instance QqsetGeometry (QBoxLayout ()) ((QRect t1)) where
qsetGeometry x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_setGeometry_h cobj_x0 cobj_x1
foreign import ccall "qtc_QBoxLayout_setGeometry_h" qtc_QBoxLayout_setGeometry_h :: Ptr (TQBoxLayout a) -> Ptr (TQRect t1) -> IO ()
instance QqsetGeometry (QBoxLayoutSc a) ((QRect t1)) where
qsetGeometry x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_setGeometry_h cobj_x0 cobj_x1
instance QsetGeometry (QBoxLayout ()) ((Rect)) where
setGeometry x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withCRect x1 $ \crect_x1_x crect_x1_y crect_x1_w crect_x1_h ->
qtc_QBoxLayout_setGeometry_qth_h cobj_x0 crect_x1_x crect_x1_y crect_x1_w crect_x1_h
foreign import ccall "qtc_QBoxLayout_setGeometry_qth_h" qtc_QBoxLayout_setGeometry_qth_h :: Ptr (TQBoxLayout a) -> CInt -> CInt -> CInt -> CInt -> IO ()
instance QsetGeometry (QBoxLayoutSc a) ((Rect)) where
setGeometry x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withCRect x1 $ \crect_x1_x crect_x1_y crect_x1_w crect_x1_h ->
qtc_QBoxLayout_setGeometry_qth_h cobj_x0 crect_x1_x crect_x1_y crect_x1_w crect_x1_h
instance QsetSpacing (QBoxLayout ()) ((Int)) where
setSpacing x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_setSpacing cobj_x0 (toCInt x1)
foreign import ccall "qtc_QBoxLayout_setSpacing" qtc_QBoxLayout_setSpacing :: Ptr (TQBoxLayout a) -> CInt -> IO ()
instance QsetSpacing (QBoxLayoutSc a) ((Int)) where
setSpacing x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_setSpacing cobj_x0 (toCInt x1)
instance QsetStretchFactor (QBoxLayout a) ((QLayout t1, Int)) (IO (Bool)) where
setStretchFactor x0 (x1, x2)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_setStretchFactor1 cobj_x0 cobj_x1 (toCInt x2)
foreign import ccall "qtc_QBoxLayout_setStretchFactor1" qtc_QBoxLayout_setStretchFactor1 :: Ptr (TQBoxLayout a) -> Ptr (TQLayout t1) -> CInt -> IO CBool
instance QsetStretchFactor (QBoxLayout a) ((QWidget t1, Int)) (IO (Bool)) where
setStretchFactor x0 (x1, x2)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_setStretchFactor cobj_x0 cobj_x1 (toCInt x2)
foreign import ccall "qtc_QBoxLayout_setStretchFactor" qtc_QBoxLayout_setStretchFactor :: Ptr (TQBoxLayout a) -> Ptr (TQWidget t1) -> CInt -> IO CBool
instance QqsizeHint (QBoxLayout ()) (()) where
qsizeHint x0 ()
= withQSizeResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_sizeHint_h cobj_x0
foreign import ccall "qtc_QBoxLayout_sizeHint_h" qtc_QBoxLayout_sizeHint_h :: Ptr (TQBoxLayout a) -> IO (Ptr (TQSize ()))
instance QqsizeHint (QBoxLayoutSc a) (()) where
qsizeHint x0 ()
= withQSizeResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_sizeHint_h cobj_x0
instance QsizeHint (QBoxLayout ()) (()) where
sizeHint x0 ()
= withSizeResult $ \csize_ret_w csize_ret_h ->
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_sizeHint_qth_h cobj_x0 csize_ret_w csize_ret_h
foreign import ccall "qtc_QBoxLayout_sizeHint_qth_h" qtc_QBoxLayout_sizeHint_qth_h :: Ptr (TQBoxLayout a) -> Ptr CInt -> Ptr CInt -> IO ()
instance QsizeHint (QBoxLayoutSc a) (()) where
sizeHint x0 ()
= withSizeResult $ \csize_ret_w csize_ret_h ->
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_sizeHint_qth_h cobj_x0 csize_ret_w csize_ret_h
instance Qspacing (QBoxLayout ()) (()) where
spacing x0 ()
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_spacing cobj_x0
foreign import ccall "qtc_QBoxLayout_spacing" qtc_QBoxLayout_spacing :: Ptr (TQBoxLayout a) -> IO CInt
instance Qspacing (QBoxLayoutSc a) (()) where
spacing x0 ()
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_spacing cobj_x0
instance QtakeAt (QBoxLayout ()) ((Int)) where
takeAt x0 (x1)
= withObjectRefResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_takeAt_h cobj_x0 (toCInt x1)
foreign import ccall "qtc_QBoxLayout_takeAt_h" qtc_QBoxLayout_takeAt_h :: Ptr (TQBoxLayout a) -> CInt -> IO (Ptr (TQLayoutItem ()))
instance QtakeAt (QBoxLayoutSc a) ((Int)) where
takeAt x0 (x1)
= withObjectRefResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_takeAt_h cobj_x0 (toCInt x1)
qBoxLayout_delete :: QBoxLayout a -> IO ()
qBoxLayout_delete x0
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_delete cobj_x0
foreign import ccall "qtc_QBoxLayout_delete" qtc_QBoxLayout_delete :: Ptr (TQBoxLayout a) -> IO ()
qBoxLayout_deleteLater :: QBoxLayout a -> IO ()
qBoxLayout_deleteLater x0
= withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_deleteLater cobj_x0
foreign import ccall "qtc_QBoxLayout_deleteLater" qtc_QBoxLayout_deleteLater :: Ptr (TQBoxLayout a) -> IO ()
instance QaddChildLayout (QBoxLayout ()) ((QLayout t1)) where
addChildLayout x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_addChildLayout cobj_x0 cobj_x1
foreign import ccall "qtc_QBoxLayout_addChildLayout" qtc_QBoxLayout_addChildLayout :: Ptr (TQBoxLayout a) -> Ptr (TQLayout t1) -> IO ()
instance QaddChildLayout (QBoxLayoutSc a) ((QLayout t1)) where
addChildLayout x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_addChildLayout cobj_x0 cobj_x1
instance QaddChildWidget (QBoxLayout ()) ((QWidget t1)) where
addChildWidget x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_addChildWidget cobj_x0 cobj_x1
foreign import ccall "qtc_QBoxLayout_addChildWidget" qtc_QBoxLayout_addChildWidget :: Ptr (TQBoxLayout a) -> Ptr (TQWidget t1) -> IO ()
instance QaddChildWidget (QBoxLayoutSc a) ((QWidget t1)) where
addChildWidget x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_addChildWidget cobj_x0 cobj_x1
instance QqalignmentRect (QBoxLayout ()) ((QRect t1)) where
qalignmentRect x0 (x1)
= withQRectResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_alignmentRect cobj_x0 cobj_x1
foreign import ccall "qtc_QBoxLayout_alignmentRect" qtc_QBoxLayout_alignmentRect :: Ptr (TQBoxLayout a) -> Ptr (TQRect t1) -> IO (Ptr (TQRect ()))
instance QqalignmentRect (QBoxLayoutSc a) ((QRect t1)) where
qalignmentRect x0 (x1)
= withQRectResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_alignmentRect cobj_x0 cobj_x1
instance QalignmentRect (QBoxLayout ()) ((Rect)) where
alignmentRect x0 (x1)
= withRectResult $ \crect_ret_x crect_ret_y crect_ret_w crect_ret_h ->
withObjectPtr x0 $ \cobj_x0 ->
withCRect x1 $ \crect_x1_x crect_x1_y crect_x1_w crect_x1_h ->
qtc_QBoxLayout_alignmentRect_qth cobj_x0 crect_x1_x crect_x1_y crect_x1_w crect_x1_h crect_ret_x crect_ret_y crect_ret_w crect_ret_h
foreign import ccall "qtc_QBoxLayout_alignmentRect_qth" qtc_QBoxLayout_alignmentRect_qth :: Ptr (TQBoxLayout a) -> CInt -> CInt -> CInt -> CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
instance QalignmentRect (QBoxLayoutSc a) ((Rect)) where
alignmentRect x0 (x1)
= withRectResult $ \crect_ret_x crect_ret_y crect_ret_w crect_ret_h ->
withObjectPtr x0 $ \cobj_x0 ->
withCRect x1 $ \crect_x1_x crect_x1_y crect_x1_w crect_x1_h ->
qtc_QBoxLayout_alignmentRect_qth cobj_x0 crect_x1_x crect_x1_y crect_x1_w crect_x1_h crect_ret_x crect_ret_y crect_ret_w crect_ret_h
instance QchildEvent (QBoxLayout ()) ((QChildEvent t1)) where
childEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_childEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QBoxLayout_childEvent" qtc_QBoxLayout_childEvent :: Ptr (TQBoxLayout a) -> Ptr (TQChildEvent t1) -> IO ()
instance QchildEvent (QBoxLayoutSc a) ((QChildEvent t1)) where
childEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_childEvent cobj_x0 cobj_x1
instance QindexOf (QBoxLayout ()) ((QWidget t1)) where
indexOf x0 (x1)
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_indexOf_h cobj_x0 cobj_x1
foreign import ccall "qtc_QBoxLayout_indexOf_h" qtc_QBoxLayout_indexOf_h :: Ptr (TQBoxLayout a) -> Ptr (TQWidget t1) -> IO CInt
instance QindexOf (QBoxLayoutSc a) ((QWidget t1)) where
indexOf x0 (x1)
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_indexOf_h cobj_x0 cobj_x1
instance QqisEmpty (QBoxLayout ()) (()) where
qisEmpty x0 ()
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_isEmpty_h cobj_x0
foreign import ccall "qtc_QBoxLayout_isEmpty_h" qtc_QBoxLayout_isEmpty_h :: Ptr (TQBoxLayout a) -> IO CBool
instance QqisEmpty (QBoxLayoutSc a) (()) where
qisEmpty x0 ()
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_isEmpty_h cobj_x0
instance Qlayout (QBoxLayout ()) (()) (IO (QLayout ())) where
layout x0 ()
= withQLayoutResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_layout_h cobj_x0
foreign import ccall "qtc_QBoxLayout_layout_h" qtc_QBoxLayout_layout_h :: Ptr (TQBoxLayout a) -> IO (Ptr (TQLayout ()))
instance Qlayout (QBoxLayoutSc a) (()) (IO (QLayout ())) where
layout x0 ()
= withQLayoutResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_layout_h cobj_x0
instance QwidgetEvent (QBoxLayout ()) ((QEvent t1)) where
widgetEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_widgetEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QBoxLayout_widgetEvent" qtc_QBoxLayout_widgetEvent :: Ptr (TQBoxLayout a) -> Ptr (TQEvent t1) -> IO ()
instance QwidgetEvent (QBoxLayoutSc a) ((QEvent t1)) where
widgetEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_widgetEvent cobj_x0 cobj_x1
instance Qqgeometry (QBoxLayout ()) (()) where
qgeometry x0 ()
= withQRectResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_geometry_h cobj_x0
foreign import ccall "qtc_QBoxLayout_geometry_h" qtc_QBoxLayout_geometry_h :: Ptr (TQBoxLayout a) -> IO (Ptr (TQRect ()))
instance Qqgeometry (QBoxLayoutSc a) (()) where
qgeometry x0 ()
= withQRectResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_geometry_h cobj_x0
instance Qgeometry (QBoxLayout ()) (()) where
geometry x0 ()
= withRectResult $ \crect_ret_x crect_ret_y crect_ret_w crect_ret_h ->
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_geometry_qth_h cobj_x0 crect_ret_x crect_ret_y crect_ret_w crect_ret_h
foreign import ccall "qtc_QBoxLayout_geometry_qth_h" qtc_QBoxLayout_geometry_qth_h :: Ptr (TQBoxLayout a) -> Ptr CInt -> Ptr CInt -> Ptr CInt -> Ptr CInt -> IO ()
instance Qgeometry (QBoxLayoutSc a) (()) where
geometry x0 ()
= withRectResult $ \crect_ret_x crect_ret_y crect_ret_w crect_ret_h ->
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_geometry_qth_h cobj_x0 crect_ret_x crect_ret_y crect_ret_w crect_ret_h
instance QspacerItem (QBoxLayout ()) (()) where
spacerItem x0 ()
= withObjectRefResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_spacerItem_h cobj_x0
foreign import ccall "qtc_QBoxLayout_spacerItem_h" qtc_QBoxLayout_spacerItem_h :: Ptr (TQBoxLayout a) -> IO (Ptr (TQSpacerItem ()))
instance QspacerItem (QBoxLayoutSc a) (()) where
spacerItem x0 ()
= withObjectRefResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_spacerItem_h cobj_x0
instance Qwidget (QBoxLayout ()) (()) where
widget x0 ()
= withQWidgetResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_widget_h cobj_x0
foreign import ccall "qtc_QBoxLayout_widget_h" qtc_QBoxLayout_widget_h :: Ptr (TQBoxLayout a) -> IO (Ptr (TQWidget ()))
instance Qwidget (QBoxLayoutSc a) (()) where
widget x0 ()
= withQWidgetResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_widget_h cobj_x0
instance QconnectNotify (QBoxLayout ()) ((String)) where
connectNotify x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withCWString x1 $ \cstr_x1 ->
qtc_QBoxLayout_connectNotify cobj_x0 cstr_x1
foreign import ccall "qtc_QBoxLayout_connectNotify" qtc_QBoxLayout_connectNotify :: Ptr (TQBoxLayout a) -> CWString -> IO ()
instance QconnectNotify (QBoxLayoutSc a) ((String)) where
connectNotify x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withCWString x1 $ \cstr_x1 ->
qtc_QBoxLayout_connectNotify cobj_x0 cstr_x1
instance QcustomEvent (QBoxLayout ()) ((QEvent t1)) where
customEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_customEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QBoxLayout_customEvent" qtc_QBoxLayout_customEvent :: Ptr (TQBoxLayout a) -> Ptr (TQEvent t1) -> IO ()
instance QcustomEvent (QBoxLayoutSc a) ((QEvent t1)) where
customEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_customEvent cobj_x0 cobj_x1
instance QdisconnectNotify (QBoxLayout ()) ((String)) where
disconnectNotify x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withCWString x1 $ \cstr_x1 ->
qtc_QBoxLayout_disconnectNotify cobj_x0 cstr_x1
foreign import ccall "qtc_QBoxLayout_disconnectNotify" qtc_QBoxLayout_disconnectNotify :: Ptr (TQBoxLayout a) -> CWString -> IO ()
instance QdisconnectNotify (QBoxLayoutSc a) ((String)) where
disconnectNotify x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withCWString x1 $ \cstr_x1 ->
qtc_QBoxLayout_disconnectNotify cobj_x0 cstr_x1
instance Qevent (QBoxLayout ()) ((QEvent t1)) where
event x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_event_h cobj_x0 cobj_x1
foreign import ccall "qtc_QBoxLayout_event_h" qtc_QBoxLayout_event_h :: Ptr (TQBoxLayout a) -> Ptr (TQEvent t1) -> IO CBool
instance Qevent (QBoxLayoutSc a) ((QEvent t1)) where
event x0 (x1)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_event_h cobj_x0 cobj_x1
instance QeventFilter (QBoxLayout ()) ((QObject t1, QEvent t2)) where
eventFilter x0 (x1, x2)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
withObjectPtr x2 $ \cobj_x2 ->
qtc_QBoxLayout_eventFilter_h cobj_x0 cobj_x1 cobj_x2
foreign import ccall "qtc_QBoxLayout_eventFilter_h" qtc_QBoxLayout_eventFilter_h :: Ptr (TQBoxLayout a) -> Ptr (TQObject t1) -> Ptr (TQEvent t2) -> IO CBool
instance QeventFilter (QBoxLayoutSc a) ((QObject t1, QEvent t2)) where
eventFilter x0 (x1, x2)
= withBoolResult $
withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
withObjectPtr x2 $ \cobj_x2 ->
qtc_QBoxLayout_eventFilter_h cobj_x0 cobj_x1 cobj_x2
instance Qreceivers (QBoxLayout ()) ((String)) where
receivers x0 (x1)
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
withCWString x1 $ \cstr_x1 ->
qtc_QBoxLayout_receivers cobj_x0 cstr_x1
foreign import ccall "qtc_QBoxLayout_receivers" qtc_QBoxLayout_receivers :: Ptr (TQBoxLayout a) -> CWString -> IO CInt
instance Qreceivers (QBoxLayoutSc a) ((String)) where
receivers x0 (x1)
= withIntResult $
withObjectPtr x0 $ \cobj_x0 ->
withCWString x1 $ \cstr_x1 ->
qtc_QBoxLayout_receivers cobj_x0 cstr_x1
instance Qsender (QBoxLayout ()) (()) where
sender x0 ()
= withQObjectResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_sender cobj_x0
foreign import ccall "qtc_QBoxLayout_sender" qtc_QBoxLayout_sender :: Ptr (TQBoxLayout a) -> IO (Ptr (TQObject ()))
instance Qsender (QBoxLayoutSc a) (()) where
sender x0 ()
= withQObjectResult $
withObjectPtr x0 $ \cobj_x0 ->
qtc_QBoxLayout_sender cobj_x0
instance QtimerEvent (QBoxLayout ()) ((QTimerEvent t1)) where
timerEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_timerEvent cobj_x0 cobj_x1
foreign import ccall "qtc_QBoxLayout_timerEvent" qtc_QBoxLayout_timerEvent :: Ptr (TQBoxLayout a) -> Ptr (TQTimerEvent t1) -> IO ()
instance QtimerEvent (QBoxLayoutSc a) ((QTimerEvent t1)) where
timerEvent x0 (x1)
= withObjectPtr x0 $ \cobj_x0 ->
withObjectPtr x1 $ \cobj_x1 ->
qtc_QBoxLayout_timerEvent cobj_x0 cobj_x1
| keera-studios/hsQt | Qtc/Gui/QBoxLayout.hs | bsd-2-clause | 32,997 | 0 | 16 | 5,444 | 10,827 | 5,490 | 5,337 | -1 | -1 |
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TemplateHaskell #-}
import Control.Exception
import Control.Monad.Writer.Lazy
import Data.List
import Data.Version
import Development.GitRev (gitCommitCount)
import Distribution.System (buildArch)
import Distribution.Text (display)
import Language.Haskell.Refact.HaRe
import Options.Applicative.Simple
import qualified Language.Haskell.GhcMod as GM
import qualified Paths_HaRe as Meta
-- temporary until exposed by ghc-mod
import Options
main :: IO ()
main = do
-- Version code from stack. Maybe move this stuff into optparse-simple ?
let commitCount = $gitCommitCount
versionString' = concat $ concat
[ [$(simpleVersion Meta.version)]
-- Leave out number of commits for --depth=1 clone
-- See https://github.com/commercialhaskell/stack/issues/792
, [" (" ++ commitCount ++ " commits)" | commitCount /= ("1"::String) &&
commitCount /= ("UNKNOWN" :: String)]
, [" ", display buildArch]
]
numericVersion :: Parser (a -> a)
numericVersion =
infoOption
(showVersion Meta.version)
(long "numeric-version" <>
help "Show only version number")
-- Parse the options and run the specified command.
(global, run) <-
simpleOptions
versionString'
"HaRe - the haskell refactorer"
""
-- (numericVersion <*> globalOptsParser) $
(numericVersion <*> allOptsParser) $
do
addCommand "demote"
"Demote a declaration"
runCmd
demoteCmdOpts
addCommand "dupdef"
"Duplicate a definition"
runCmd
dupDefCmdOpts
addCommand "iftocase"
"Convert an if statement to a case statement"
runCmd
ifToCaseCmdOpts
addCommand "liftOneLevel"
"Lift a definition up one level"
runCmd
liftOneLevelCmdOpts
addCommand "liftToTopLevel"
"Lift a definition to the top level"
runCmd
liftToTopLevelCmdOpts
addCommand "rename"
"Rename an identifier"
runCmd
renameCmdOpts
addCommand "addOneParam"
"Add a new parameter to a function in first position"
runCmd
addOneParamCmdOpts
addCommand "rmOneParam"
"Remove a new parameter from a function"
runCmd
rmOneParamCmdOpts
run global
-- ---------------------------------------------------------------------
type Row = Int
type Col = Int
data HareParams = DemoteCmd FilePath Row Col
| DupDefCmd FilePath String Row Col
| IfToCaseCmd FilePath Row Col Row Col
| LiftOneLevel FilePath Row Col
| LiftToTopLevel FilePath Row Col
| RenameCmd FilePath String Row Col
| AddOneParam FilePath String Row Col
| RmOneParam FilePath Row Col
deriving Show
runCmd :: HareParams -> (RefactSettings,GM.Options) -> IO ()
runCmd (DemoteCmd fileName r c) (opt, gOpt)
= runFunc $ demote opt gOpt fileName (r,c)
runCmd (DupDefCmd fileName newname r c) (opt, gOpt)
= runFunc $ duplicateDef opt gOpt fileName newname (r,c)
runCmd (IfToCaseCmd fileName sr sc er ec) (opt, gOpt)
= runFunc $ ifToCase opt gOpt fileName (sr,sc) (er,ec)
runCmd (LiftOneLevel fileName r c) (opt, gOpt)
= runFunc $ liftOneLevel opt gOpt fileName (r,c)
runCmd (LiftToTopLevel fileName r c) (opt, gOpt)
= runFunc $ liftToTopLevel opt gOpt fileName (r,c)
runCmd (RenameCmd fileName newname r c) (opt, gOpt)
= runFunc $ rename opt gOpt fileName newname (r,c)
runCmd (AddOneParam fileName newname r c) (opt, gOpt)
= runFunc $ addOneParameter opt gOpt fileName newname (r,c)
runCmd (RmOneParam fileName r c) (opt, gOpt)
= runFunc $ rmOneParameter opt gOpt fileName (r,c)
-- ---------------------------------------------------------------------
rmOneParamCmdOpts :: Parser HareParams
rmOneParamCmdOpts =
LiftOneLevel
<$> strArgument
( metavar "FILE"
<> help "Specify Haskell file to process"
)
<*> argument auto
( metavar "line"
<> help "The line the function name is on")
<*> argument auto
( metavar "col"
<> help "The col the function name starts at")
-- ---------------------------------------------------------------------
addOneParamCmdOpts :: Parser HareParams
addOneParamCmdOpts =
AddOneParam
<$> strArgument
( metavar "FILE"
<> help "Specify Haskell file to process"
)
<*> strArgument
( metavar "NAME"
<> help "The name for the parameter"
)
<*> argument auto
( metavar "line"
<> help "The line the function name is on")
<*> argument auto
( metavar "col"
<> help "A col inside the function name name")
-- ---------------------------------------------------------------------
renameCmdOpts :: Parser HareParams
renameCmdOpts =
RenameCmd
<$> strArgument
( metavar "FILE"
<> help "Specify Haskell file to process"
)
<*> strArgument
( metavar "NEWNAME"
<> help "The new name for the identifier"
)
<*> argument auto
( metavar "line"
<> help "The line the identifier is on")
<*> argument auto
( metavar "col"
<> help "A col inside the identifier name")
-- ---------------------------------------------------------------------
liftToTopLevelCmdOpts :: Parser HareParams
liftToTopLevelCmdOpts =
LiftOneLevel
<$> strArgument
( metavar "FILE"
<> help "Specify Haskell file to process"
)
<*> argument auto
( metavar "line"
<> help "The line the declaration is on")
<*> argument auto
( metavar "col"
<> help "The col the declaration starts at")
-- ---------------------------------------------------------------------
liftOneLevelCmdOpts :: Parser HareParams
liftOneLevelCmdOpts =
LiftOneLevel
<$> strArgument
( metavar "FILE"
<> help "Specify Haskell file to process"
)
<*> argument auto
( metavar "line"
<> help "The line the declaration is on")
<*> argument auto
( metavar "col"
<> help "The col the declaration starts at")
-- ---------------------------------------------------------------------
ifToCaseCmdOpts :: Parser HareParams
ifToCaseCmdOpts =
IfToCaseCmd
<$> strArgument
( metavar "FILE"
<> help "Specify Haskell file to process"
)
<*> argument auto
( metavar "startline"
<> help "The line the if statement starts on")
<*> argument auto
( metavar "startcol"
<> help "The col the if statement starts at")
<*> argument auto
( metavar "endline"
<> help "The line the if statement ends on")
<*> argument auto
( metavar "endcol"
<> help "The col the if statement ends at")
-- ---------------------------------------------------------------------
demoteCmdOpts :: Parser HareParams
demoteCmdOpts =
DemoteCmd
<$> strArgument
( metavar "FILE"
<> help "Specify Haskell file to process"
)
<*> argument auto
( metavar "line"
<> help "The line the declaration is on")
<*> argument auto
( metavar "col"
<> help "The col the declaration starts at")
-- ---------------------------------------------------------------------
dupDefCmdOpts :: Parser HareParams
dupDefCmdOpts =
DupDefCmd
<$> strArgument
( metavar "FILE"
<> help "Specify Haskell file to process"
)
<*> strArgument
( metavar "NEWNAME"
<> help "The name for the new definition"
)
<*> argument auto
( metavar "line"
<> help "The line the definition is on")
<*> argument auto
( metavar "col"
<> help "A col inside the definition name")
-- ---------------------------------------------------------------------
allOptsParser :: Parser (RefactSettings,GM.Options)
allOptsParser = (,) <$> globalOptsParser <*> globalArgSpec
globalOptsParser :: Parser RefactSettings
globalOptsParser = mkRefSet
<$> ((\b -> if b then Debug else Normal) <$> switch
( long "debug"
<> short 'd'
<> help "Generate debug output" ))
where
mkRefSet v = RefSet v (True,True,True,True)
-- ---------------------------------------------------------------------
-- | Return the result of an Either as a sexp for emacs etc.
runFunc :: IO [String] -> IO ()
runFunc f = do
r <- catchException f
let ret = case r of
Left s -> "(error " ++ (show s) ++ ")"
Right mfs -> "(ok " ++ showLisp mfs ++ ")"
putStrLn ret
showLisp :: [String] -> String
showLisp xs = "(" ++ (intercalate " " $ map show xs) ++ ")"
catchException :: (IO t) -> IO (Either String t)
catchException f = do
res <- handle handler (f >>= \r -> return $ Right r)
return res
where
handler:: SomeException -> IO (Either String t)
handler e = return (Left (show e))
| kmate/HaRe | src/MainHaRe.hs | bsd-3-clause | 10,213 | 82 | 18 | 3,513 | 2,082 | 1,059 | 1,023 | 233 | 2 |
module Main where
import System.IO
import System.Exit
import Data.Lectures
import Data.DB
import Timetabling
{- |
'main' is the main-function of spiritcore
-}
main :: IO ()
main = do
let loL = mkListOfLectures timetable lectures wishList allRooms
let allOneLP = mkAllOneLecturePossibilities startLectureList
let sortBySS = sortByStudents allOneLP
let sortByRELP = sortByRoomEconomy sortBySS
let all = allTimetables startLectureList
mainloop loL allOneLP sortByRELP sortBySS all True
{- |
'mainloop' is the mainloop-function with the menu
-}
mainloop :: (Show a1, Show a2, Show a3, Show a4, Eq a, Show a) =>
a1 -> a2 -> a4 -> a3 -> [a] -> Bool -> IO ()
mainloop loL allOneLP sortByRELP sortBySS all status
| status == False = do putStrLn "bye bye"
exitWith ExitSuccess
| status == True =
do
putStrLn "\nThis is Spirit-Core"
putStrLn "==================="
putStrLn "\nPleace select a Action:"
putStrLn "-----------------------"
putStrLn "[1] List of all Lectures"
putStrLn "[2] List of all OneLecture-Lists"
putStrLn "[3] OneLecture-List after sortByStudents - size"
putStrLn "[4] OneLecture-List after sortByRoomEconomy"
putStrLn "[5] check possibilities in crossProductLectureList"
putStrLn "[6] count all possible timetables"
putStrLn "[7] One Timetable"
putStrLn "[0] exit"
putStrLn "-----------------------"
input <- getLine
checkInput input
mainloop loL allOneLP sortByRELP sortBySS all status
| otherwise = error "error!"
where checkInput :: String -> IO ()
checkInput input
| input == "0" =
do putStrLn "shutdown now"
mainloop loL allOneLP sortByRELP sortBySS all False
| input == "1" =
do putStrLn $ "\nList of all Lectures" ++
"\n--------------------"
print loL
mainloop loL allOneLP sortByRELP sortBySS all status
| input == "2" =
do putStrLn $ "\nList of all OneLecture-Lists" ++
"\n----------------------------"
print allOneLP
mainloop loL allOneLP sortByRELP sortBySS all status
| input == "3" =
do putStrLn $ "\nsorteByStudents - size" ++
"\n-----------------------"
print sortBySS
mainloop loL allOneLP sortByRELP sortBySS all status
| input == "4" =
do putStrLn $ "\nsortByRoomEconomy" ++
"\n-----------------"
print sortByRELP
mainloop loL allOneLP sortByRELP sortBySS all status
| input == "5" =
do putStrLn $ "\npossibilities in corssProductLectureList" ++
"\n----------------------------------------"
print $ map checkRDTSL $ crossProductLectureList
startLectureList
mainloop loL allOneLP sortByRELP sortBySS all status
| input == "6" =
do putStrLn $ "\ncount all possible timetables" ++
"\n-----------------------------"
putStrLn $ (show $ length all) ++ " timetables counted"
mainloop loL allOneLP sortByRELP sortBySS all status
| input == "7" =
getOneTimetable all "n"
| otherwise = putStrLn "wrong input!"
getOneTimetable all stat
| all == [] = putStrLn "no timetable found"
| stat == "0" = putStrLn "back"
| stat == "n" = do putStrLn $ "\nOne Timetable:\n" ++
"--------------\n\n"
print $ head all
putStrLn $ "\npress n for the next timetable " ++
"or 0 to leave"
putStrLn $ "-------------------------------" ++
"-------------"
input <- getLine
getOneTimetable (tail all) input
| otherwise = putStrLn "wrong input!"
| spirit-fhs/core | SpiritCore.hs | bsd-3-clause | 4,475 | 0 | 14 | 1,789 | 892 | 395 | 497 | 90 | 1 |
module ProjectEuler.Problem203 (solution203) where
import Data.List
import Data.Numbers.Primes
import Util
pascal :: [[Integer]]
pascal = iterate (map sum . clump 2 . (:) 0 . flip (++) [0]) [1]
squareFree :: Integer -> Bool
squareFree = all (== 1) . map length . group . primeFactors
genericSolution203 :: Int -> Integer
genericSolution203 = sum . filter squareFree . nub . concat . flip take pascal
solution203 :: Integer
solution203 = genericSolution203 51
| guillaume-nargeot/project-euler-haskell | src/ProjectEuler/Problem203.hs | bsd-3-clause | 464 | 0 | 10 | 77 | 172 | 94 | 78 | 12 | 1 |
module Exercises.ChapterSevenSpec
( spec
) where
-- import Control.Exception (evaluate)
import Test.Hspec
import Test.QuickCheck
import Exercises.ChapterSeven
spec :: Spec
spec =
describe "Chapter Seven" $ do
describe "channel" $ do
it "chop8 equals mychop8" $ property $ \l -> chop8 l == mychop8 l
it "mymap" $ mymap (* 2) [1, 2, 3] `shouldBe` ([2, 4, 6] :: [Int])
it "myiterate" $
take 3 (myiterate (* 2) 1) `shouldBe` ([1, 2, 4] :: [Int])
it "encode 'a'" $
encodeWithParity "a" `shouldBe` [1, 1, 0, 0, 0, 0, 1, 1, 0]
it "decode 'a'" $
decodeWithParity [1, 1, 0, 0, 0, 0, 1, 1, 0] `shouldBe` "a"
it "transmit is idempotent" $ property $ \l -> transmit l == l
it "transmitWithParity is idempotent" $
property $ \l -> transmitWithParity l == l
-- can't get hspec to catch these errors correctly
-- it "Parity error" $ evaluate (decodeWithParity [0, 1, 0, 0, 0, 0, 1, 1, 0]) `shouldThrow` anyErrorCall
-- it "faultyTransmit" $ evaluate (faultyTransmit "Hi") `shouldThrow` anyErrorCall
describe "luhn" $ do
it "altMap" $
altMap (+ 10) (+ 100) [0, 1, 2, 3, 4] `shouldBe`
([10, 101, 12, 103, 14] :: [Int])
it "luhn true" $ anyLuhn [4, 2, 3, 4] `shouldBe` True
it "luhn false" $ anyLuhn [1, 2, 3, 4] `shouldBe` False
| philipcraig/hutton | test/Exercises/ChapterSevenSpec.hs | bsd-3-clause | 1,355 | 0 | 16 | 358 | 475 | 265 | 210 | 26 | 1 |
{-# LANGUAGE DeriveDataTypeable, TypeFamilies, CPP #-}
-- |
-- Module : Data.UUID
-- Copyright : (c) 2008-2009, 2012 Antoine Latter
-- (c) 2009 Mark Lentczner
--
-- License : BSD-style
--
-- Maintainer : [email protected]
-- Stability : experimental
-- Portability : portable
module Data.UUID.Internal
(UUID(..)
,null
,nil
,fromByteString
,toByteString
,fromString
,toString
,fromWords
,toWords
,toList
,buildFromBytes
,buildFromWords
) where
import Prelude hiding (null)
import Control.Monad (liftM4)
import Data.Char
import Data.Maybe
import Data.Bits
import Data.List (elemIndices)
#if MIN_VERSION_base(4,0,0)
import Data.Data
#else
import Data.Generics.Basics
#endif
import Foreign.Storable
import Data.Binary
import Data.Binary.Put
import Data.Binary.Get
import qualified Data.ByteString.Lazy as Lazy
import Data.UUID.Builder
import System.Random
-- |The UUID type. A 'Random' instance is provided which produces
-- version 4 UUIDs as specified in RFC 4122. The 'Storable' and
-- 'Binary' instances are compatible with RFC 4122, storing the fields
-- in network order as 16 bytes.
data UUID
= UUID
{-# UNPACK #-} !Word32
{-# UNPACK #-} !Word32
{-# UNPACK #-} !Word32
{-# UNPACK #-} !Word32
deriving (Eq, Ord, Typeable)
{-
Other representations that we tried are:
Mimic V1 structure: !Word32 !Word16 !Word16 !Word16
!Word8 !Word8 !Word8 !Word8 !Word8 !Word8
Sixteen bytes: !Word8 ... (x 16)
Simple list of bytes: [Word8]
ByteString (strict) ByteString
Immutable array: UArray Int Word8
Vector: UArr Word8
None was as fast, overall, as the representation used here.
-}
-- | Covert a 'UUID' into a sequence of 'Word32' values.
-- Usefull for when you need to serialize a UUID and
-- neither 'Storable' nor 'Binary' are appropriate.
-- Introduced in version 1.2.2.
toWords :: UUID -> (Word32, Word32, Word32, Word32)
toWords (UUID w1 w2 w3 w4) = (w1, w2, w3, w4)
-- | Create a 'UUID' from a sequence of 'Word32'. The
-- opposite of 'toWords'. Useful when you need a total
-- function for constructing 'UUID' values.
-- Introduced in version 1.2.2.
fromWords :: Word32 -> Word32 -> Word32 -> Word32 -> UUID
fromWords = UUID
--
-- UTILITIES
--
-- |Build a Word32 from four Word8 values, presented in big-endian order
word :: Word8 -> Word8 -> Word8 -> Word8 -> Word32
word a b c d = (fromIntegral a `shiftL` 24)
.|. (fromIntegral b `shiftL` 16)
.|. (fromIntegral c `shiftL` 8)
.|. (fromIntegral d )
-- |Extract a Word8 from a Word32. Bytes, high to low, are numbered from 3 to 0,
byte :: Int -> Word32 -> Word8
byte i w = fromIntegral (w `shiftR` (i * 8))
-- |Make a UUID from sixteen Word8 values
makeFromBytes :: Word8 -> Word8 -> Word8 -> Word8
-> Word8 -> Word8 -> Word8 -> Word8
-> Word8 -> Word8 -> Word8 -> Word8
-> Word8 -> Word8 -> Word8 -> Word8
-> UUID
makeFromBytes b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf
= UUID w0 w1 w2 w3
where w0 = word b0 b1 b2 b3
w1 = word b4 b5 b6 b7
w2 = word b8 b9 ba bb
w3 = word bc bd be bf
-- |Make a UUID from four Word32 values
makeFromWords :: Word32 -> Word32 -> Word32 -> Word32 -> UUID
makeFromWords = UUID
-- |A Builder for constructing a UUID of a given version.
buildFromBytes :: Word8
-> Word8 -> Word8 -> Word8 -> Word8
-> Word8 -> Word8 -> Word8 -> Word8
-> Word8 -> Word8 -> Word8 -> Word8
-> Word8 -> Word8 -> Word8 -> Word8
-> UUID
buildFromBytes v b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf =
makeFromBytes b0 b1 b2 b3 b4 b5 b6' b7 b8' b9 ba bb bc bd be bf
where b6' = b6 .&. 0x0f .|. (v `shiftL` 4)
b8' = b8 .&. 0x3f .|. 0x80
-- |Build a UUID of a given version from Word32 values.
buildFromWords :: Word8 -> Word32 -> Word32 -> Word32 -> Word32 -> UUID
buildFromWords v w0 w1 w2 w3 = makeFromWords w0 w1' w2' w3
where w1' = w1 .&. 0xffff0fff .|. ((fromIntegral v) `shiftL` 12)
w2' = w2 .&. 0x3fffffff .|. 0x80000000
-- |Return the bytes that make up the UUID
toList :: UUID -> [Word8]
toList (UUID w0 w1 w2 w3) =
[byte 3 w0, byte 2 w0, byte 1 w0, byte 0 w0,
byte 3 w1, byte 2 w1, byte 1 w1, byte 0 w1,
byte 3 w2, byte 2 w2, byte 1 w2, byte 0 w2,
byte 3 w3, byte 2 w3, byte 1 w3, byte 0 w3]
-- |Construct a UUID from a list of Word8. Returns Nothing if the list isn't
-- exactly sixteen bytes long
fromList :: [Word8] -> Maybe UUID
fromList [b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, ba, bb, bc, bd, be, bf] =
Just $ makeFromBytes b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf
fromList _ = Nothing
--
-- UUID API
--
-- |Returns true if the passed-in UUID is the 'nil' UUID.
null :: UUID -> Bool
null = (== nil)
-- Note: This actually faster than:
-- null (UUID 0 0 0 0) = True
-- null _ = False
-- |The nil UUID, as defined in RFC 4122.
-- It is a UUID of all zeros. @'null' u@ iff @'u' == 'nil'@.
nil :: UUID
nil = UUID 0 0 0 0
-- |Extract a UUID from a 'ByteString' in network byte order.
-- The argument must be 16 bytes long, otherwise 'Nothing' is returned.
fromByteString :: Lazy.ByteString -> Maybe UUID
fromByteString = fromList . Lazy.unpack
-- |Encode a UUID into a 'ByteString' in network order.
toByteString :: UUID -> Lazy.ByteString
toByteString = Lazy.pack . toList
-- |If the passed in 'String' can be parsed as a 'UUID', it will be.
-- The hyphens may not be omitted.
-- Example:
--
-- @
-- fromString \"c2cc10e1-57d6-4b6f-9899-38d972112d8c\"
-- @
--
-- Hex digits may be upper or lower-case.
fromString :: String -> Maybe UUID
fromString xs | validFmt = fromString' xs
| otherwise = Nothing
where validFmt = elemIndices '-' xs == [8,13,18,23]
fromString' :: String -> Maybe UUID
fromString' s0 = do
(w0, s1) <- hexWord s0
(w1, s2) <- hexWord s1
(w2, s3) <- hexWord s2
(w3, s4) <- hexWord s3
if s4 /= "" then Nothing
else Just $ UUID w0 w1 w2 w3
where hexWord :: String -> Maybe (Word32, String)
hexWord s = Just (0, s) >>= hexByte >>= hexByte
>>= hexByte >>= hexByte
hexByte :: (Word32, String) -> Maybe (Word32, String)
hexByte (w, '-':ds) = hexByte (w, ds)
hexByte (w, hi:lo:ds)
| bothHex = Just ((w `shiftL` 8) .|. octet, ds)
| otherwise = Nothing
where bothHex = isHexDigit hi && isHexDigit lo
octet = fromIntegral (16 * digitToInt hi + digitToInt lo)
hexByte _ = Nothing
-- | Convert a UUID into a hypenated string using lower-case letters.
-- Example:
--
-- @
-- toString $ fromString \"550e8400-e29b-41d4-a716-446655440000\"
-- @
toString :: UUID -> String
toString (UUID w0 w1 w2 w3) = hexw w0 $ hexw' w1 $ hexw' w2 $ hexw w3 ""
where hexw :: Word32 -> String -> String
hexw w s = hexn w 28 : hexn w 24 : hexn w 20 : hexn w 16
: hexn w 12 : hexn w 8 : hexn w 4 : hexn w 0 : s
hexw' :: Word32 -> String -> String
hexw' w s = '-' : hexn w 28 : hexn w 24 : hexn w 20 : hexn w 16
: '-' : hexn w 12 : hexn w 8 : hexn w 4 : hexn w 0 : s
hexn :: Word32 -> Int -> Char
hexn w r = intToDigit $ fromIntegral ((w `shiftR` r) .&. 0xf)
--
-- Class Instances
--
instance Random UUID where
random g = (fromGenNext w0 w1 w2 w3 w4, g4)
where (w0, g0) = next g
(w1, g1) = next g0
(w2, g2) = next g1
(w3, g3) = next g2
(w4, g4) = next g3
randomR _ = random -- range is ignored
-- |Build a UUID from the results of five calls to next on a StdGen.
-- While next on StdGet returns an Int, it doesn't provide 32 bits of
-- randomness. This code relies on at last 28 bits of randomness in the
-- and optimizes its use so as to make only five random values, not six.
fromGenNext :: Int -> Int -> Int -> Int -> Int -> UUID
fromGenNext w0 w1 w2 w3 w4 =
buildFromBytes 4 /-/ (ThreeByte w0)
/-/ (ThreeByte w1)
/-/ w2 -- use all 4 bytes because we know the version
-- field will "cover" the upper, non-random bits
/-/ (ThreeByte w3)
/-/ (ThreeByte w4)
-- |A ByteSource to extract only three bytes from an Int, since next on StdGet
-- only returns 31 bits of randomness.
type instance ByteSink ThreeByte g = Takes3Bytes g
newtype ThreeByte = ThreeByte Int
instance ByteSource ThreeByte where
f /-/ (ThreeByte w) = f b1 b2 b3
where b1 = fromIntegral (w `shiftR` 16)
b2 = fromIntegral (w `shiftR` 8)
b3 = fromIntegral w
instance Show UUID where
show = toString
instance Read UUID where
readsPrec _ str =
let noSpaces = dropWhile isSpace str
in case fromString (take 36 noSpaces) of
Nothing -> []
Just u -> [(u,drop 36 noSpaces)]
instance Storable UUID where
sizeOf _ = 16
alignment _ = 1 -- UUIDs are stored as individual octets
peekByteOff p off =
mapM (peekByteOff p) [off..(off+15)] >>= return . fromJust . fromList
pokeByteOff p off u =
sequence_ $ zipWith (pokeByteOff p) [off..] (toList u)
instance Binary UUID where
put (UUID w0 w1 w2 w3) =
putWord32be w0 >> putWord32be w1 >> putWord32be w2 >> putWord32be w3
get = liftM4 UUID getWord32be getWord32be getWord32be getWord32be
-- My goal with this instance was to make it work just enough to do what
-- I want when used with the HStringTemplate library.
instance Data UUID where
toConstr uu = mkConstr uuidType (show uu) [] (error "fixity")
gunfold _ _ = error "gunfold"
dataTypeOf _ = uuidType
uuidType :: DataType
uuidType = mkNoRepType "Data.UUID.UUID"
#if !(MIN_VERSION_base(4,2,0))
mkNoRepType :: String -> DataType
mkNoRepType = mkNorepType
#endif
| necrobious/uuid | Data/UUID/Internal.hs | bsd-3-clause | 10,254 | 0 | 21 | 2,978 | 2,659 | 1,427 | 1,232 | 173 | 4 |
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE RecordWildCards #-}
module Main where
import Control.Monad.Reader
import Control.Monad.Except
import Control.Concurrent.Async
import Control.Exception ( throwIO )
import Data.Aeson
import Data.Pool
import qualified Data.ByteString.Lazy as LBS
import Data.Text ( Text )
import qualified Data.Text as T
import qualified Data.Text.Lazy as TL
import qualified Data.Text.Encoding as T
import Data.Time.Clock
import Network.Mail.Mime ( Address(..) )
import Network.Mail.SMTP ( sendMail, simpleMail, plainTextPart )
import Network.Wai.Handler.Warp ( run )
import Network.Wai ( Application )
import Network.Wai.Middleware.RequestLogger ( logStdoutDev )
import Servant hiding ( NoSuchUser )
import System.Environment ( getEnv )
import System.Directory ( getCurrentDirectory )
import Database.PostgreSQL.Simple.Transaction
import Server
import Renewal.Types
import Renewal.Monad
defaultPayment :: Int
defaultPayment = 100
service :: NominalDiffTime
service = fromInteger $ 86400 * 120
main :: IO ()
main = do
cwd <- getCurrentDirectory
putStrLn $ "working in " ++ cwd
connstr <- T.encodeUtf8 . T.pack <$> getEnv "BOOKS_PSQL"
key <- T.encodeUtf8 . T.pack <$> getEnv "BOOKS_STRIPE_KEY_SECRET"
config <- newConfig connstr key defaultPayment service
efrom <- addr . T.pack <$> getEnv "BOOKS_EMAIL_FROM"
eto <- map (addr . T.pack) . read <$> getEnv "BOOKS_EMAIL_TO"
let emailConfig = EmailConfig { emailFrom = efrom, emailTo = eto }
run 8084 (logStdoutDev (app emailConfig config))
bookRenewalT :: EmailConfig -> RequestConfig -> BookRenewalMonad :~> Handler
bookRenewalT emailConf RequestConfig{..} = NT $ \ma ->
withResource reqDbconn $ \conn -> do
let sconf = ServerConfig
{ serverStripeConfig = reqStripeConfig
, serverDbconn = conn
, serverPayment = reqPayment
, serverServiceTime = reqServiceTime
}
let io = flip runReaderT sconf (runExceptT (runRenewal ma))
let transacted = withTransaction conn (emailBracket emailConf io)
liftIO transacted >>= \case
Right a -> pure a
Left err -> throwError $ toServantErr err
emailBracket :: EmailConfig -> IO a -> IO a
emailBracket EmailConfig{..} m = do
async m >>= waitCatch >>= \case
Left e -> do
sendMail "localhost" $
simpleMail
emailFrom
emailTo
[]
[]
"500 internal server error"
[ plainTextPart . TL.pack $
"A fatal error has occurred.\n\n" ++ show e
]
throwIO e
Right x -> pure x
data EmailConfig
= EmailConfig
{ emailFrom :: Address
, emailTo :: [Address]
}
toServantErr :: RenewalError -> ServantErr
toServantErr (Unknown s)
= err500
{ errBody = LBS.fromStrict $ T.encodeUtf8 $ T.pack s }
toServantErr (NoSuchUser u) = err404 { errBody = encode u }
app :: EmailConfig -> RequestConfig -> Application
app e c = serve api (enter (bookRenewalT e c) renewalServer) where
api :: Proxy RenewalApi
api = Proxy
addr :: Text -> Address
addr email = Address { addressName = Nothing, addressEmail = email }
| kevin-li-195/books | webservice/Main.hs | bsd-3-clause | 3,213 | 0 | 19 | 697 | 919 | 494 | 425 | 87 | 2 |
{-# LANGUAGE OverloadedStrings #-}
module Web.XING.API.Error
(
mapError
, handleError
, handleStatusCodeException
) where
import Web.XING.Types
import Network.HTTP.Types (ResponseHeaders)
import Data.Maybe (fromMaybe)
import qualified Data.ByteString.Lazy.Char8 as BSL
import qualified Data.ByteString.Char8 as BS
import Control.Applicative ((<$>), (<*>))
import Data.Aeson (decode, FromJSON(parseJSON), Value(Object) , (.:))
import Control.Exception (throw)
import Network.HTTP.Conduit (HttpException(StatusCodeException))
mapError
:: XINGError
-> APIError
mapError (XINGError "INVALID_OAUTH_SIGNATURE" _) = OAuthError "Invalid oauth signature. Check your consumer and access token secret."
mapError (XINGError "INVALID_OAUTH_CONSUMER" _) = OAuthError "Invalid oauth consumer key. Check your config."
mapError (XINGError "INSUFFICIENT_PRIVILEGES" _) = OAuthError "Required permission missing"
mapError (XINGError "INVALID_OAUTH_VERSION" _) = OAuthError "Invalid oauth version"
mapError (XINGError "INVALID_OAUTH_SIGNATURE_METHOD" _) = OAuthError "Invalid oauth version"
mapError (XINGError "REQUIRED_PARAMETER_MISSING" _) = OAuthError "Required parameter missing. Should never have happened."
mapError (XINGError "INVALID_REQUEST_TOKEN" _) = OAuthError "Invalid request token. Maybe the verifier was wrong?"
mapError (XINGError "INVALID_OAUTH_TOKEN" _) = TokenError "The oauth token was invalid. Maybe the user revoked it?"
mapError (XINGError "TIME_EXPIRED" _) = OAuthError "Time was too old. Make sure that your local clock is set correctly."
mapError (XINGError "RATE_LIMIT_EXCEEDED" _) = Throttled
mapError (XINGError "CALLBACK_URL_NOT_ALLOWED" _) = CallError "The callback URL was not allowed" -- TOOD API shows better error message
mapError _ = CallError "unknown"
data XINGError =
XINGError BSL.ByteString BSL.ByteString
deriving (Show, Eq)
instance FromJSON XINGError where
parseJSON (Object response) =
XINGError <$> (response .: "error_name")
<*> (response .: "message")
parseJSON _ = fail "no parse"
handleStatusCodeException
:: BS.ByteString
-> HttpException
-> a
handleStatusCodeException call (StatusCodeException status headers _) = throw $ handleError status headers call
handleStatusCodeException _ e = throw e
handleError
:: Status
-> ResponseHeaders
-> BS.ByteString
-> APIError
handleError _ headers _ =
case decode $ BSL.fromChunks [fromMaybe "{}" (lookup "X-Response-Body-Start" headers)] of
Just e -> mapError e
Nothing -> CallError "unknown"
| JanAhrens/xing-api-haskell | lib/Web/XING/API/Error.hs | bsd-3-clause | 2,726 | 0 | 11 | 552 | 585 | 313 | 272 | 53 | 2 |
module Scurry.Console.Parser (
parseConsole
) where
import Text.Parsec
import Text.Parsec.String
import Scurry.Util
import Scurry.Types.Network
import Scurry.Types.Console
parseConsole :: String -> Either ParseError ConsoleCmd
parseConsole = parse consoleCmd "Console"
consoleCmd :: Parser ConsoleCmd
consoleCmd = try cmdShutdown <|>
try cmdListPeers <|>
try cmdNewPeer <|>
try cmdRemovePeer <|>
fail "Command not recognized"
cmdShutdown :: Parser ConsoleCmd
cmdShutdown = do
string "shutdown"
return CmdShutdown
cmdListPeers :: Parser ConsoleCmd
cmdListPeers = do
string "peers"
return CmdListPeers
cmdNewPeer :: Parser ConsoleCmd
cmdNewPeer = do
string "new"
spaces
(ip,port) <- ip_port_pair
return $ CmdNewPeer ip port
cmdRemovePeer :: Parser ConsoleCmd
cmdRemovePeer = do
string "remove"
spaces
(ip,port) <- ip_port_pair
return $ CmdRemovePeer ip port
{- Mostly helper parsers that don't exist in the Parsec libary -}
ip_port_pair :: Parser (ScurryAddress,ScurryPort)
ip_port_pair = do
ip <- ip_str
char ':'
port <- many1 digit
let ip' = inet_addr ip
port' = (read port :: Integer)
if port' > 65535 || port' < 0
then parserFail "Not a valid port."
else case ip' of
(Just ip'') -> return (ip'',ScurryPort $ fromIntegral port')
Nothing -> parserFail "Not an ip address."
ip_str :: Parser String
ip_str = do
q1 <- quad
char '.'
q2 <- quad
char '.'
q3 <- quad
char '.'
q4 <- quad
return $ let dot = "."
in concat [q1,dot,q2,dot,q3,dot,q4]
where
quad = choice [try $ count 3 digit,
try $ count 2 digit,
try $ count 1 digit]
| dmagyar/scurry | src/Scurry/Console/Parser.hs | bsd-3-clause | 1,833 | 0 | 14 | 543 | 535 | 262 | 273 | 61 | 3 |
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE TupleSections #-}
module Language.Haskell.Liquid.Bare.Plugged (
makePluggedSigs
, makePluggedAsmSigs
, makePluggedDataCons
) where
import DataCon
import Module
import Name
import NameSet
import TyCon
import Type (expandTypeSynonyms)
import Var
import Control.Applicative ((<$>), (<*>))
import Control.Monad
import Control.Monad.Error
import Data.Generics.Aliases (mkT)
import Data.Generics.Schemes (everywhere)
import Data.Monoid
import qualified Data.HashMap.Strict as M
import Language.Fixpoint.Types.Names (dummySymbol)
import Language.Fixpoint.Types (mapPredReft, pAnd, conjuncts, TCEmb)
-- import Language.Fixpoint.Types (traceFix, showFix)
import Language.Haskell.Liquid.GHC.Misc (sourcePosSrcSpan)
import Language.Haskell.Liquid.Types.RefType (addTyConInfo, ofType, rVar, rTyVar, subts, toType, uReft)
import Language.Haskell.Liquid.Types
import Language.Haskell.Liquid.Bare.Env
import Language.Haskell.Liquid.Bare.Misc
makePluggedSigs name embs tcEnv exports sigs
= forM sigs $ \(x,t) -> do
let τ = expandTypeSynonyms $ varType x
let r = maybeTrue x name exports
(x,) <$> plugHoles embs tcEnv x r τ t
makePluggedAsmSigs embs tcEnv sigs
= forM sigs $ \(x,t) -> do
let τ = expandTypeSynonyms $ varType x
let r = const killHoles
(x,) <$> plugHoles embs tcEnv x r τ t
makePluggedDataCons embs tcEnv dcs
= forM dcs $ \(dc, Loc l l' dcp) -> do
let (das, _, dts, dt) = dataConSig dc
tyArgs <- zipWithM (\t1 (x,t2) ->
(x,) . val <$> plugHoles embs tcEnv (dataConName dc) (const killHoles) t1 (Loc l l' t2))
dts (reverse $ tyArgs dcp)
tyRes <- val <$> plugHoles embs tcEnv (dataConName dc) (const killHoles) dt (Loc l l' (tyRes dcp))
return (dc, Loc l l' dcp { freeTyVars = map rTyVar das
, freePred = map (subts (zip (freeTyVars dcp) (map (rVar :: TyVar -> RSort) das))) (freePred dcp)
, tyArgs = reverse tyArgs
, tyRes = tyRes})
plugHoles tce tyi x f t (Loc l l' st)
= do tyvsmap <- case runMapTyVars (mapTyVars (toType rt') st'') initvmap of
Left e -> throwError e
Right s -> return $ vmap s
let su = [(y, rTyVar x) | (x, y) <- tyvsmap]
st''' = subts su st''
ps' = fmap (subts su') <$> ps
su' = [(y, RVar (rTyVar x) ()) | (x, y) <- tyvsmap] :: [(RTyVar, RSort)]
Loc l l' . mkArrow αs ps' (ls1 ++ ls2) [] . makeCls cs' <$> go rt' st'''
where
(αs, _, ls1, rt) = bkUniv (ofType t :: SpecType)
(cs, rt') = bkClass rt
(_, ps, ls2, st') = bkUniv st
(_, st'') = bkClass st'
cs' = [(dummySymbol, RApp c t [] mempty) | (c,t) <- cs]
initvmap = initMapSt $ ErrMismatch (sourcePosSrcSpan l) (pprint x) t (toType st)
go :: SpecType -> SpecType -> BareM SpecType
go t (RHole r) = return $ (addHoles t') { rt_reft = f t r }
where
t' = everywhere (mkT $ addRefs tce tyi) t
addHoles = everywhere (mkT $ addHole)
-- NOTE: make sure we only add holes to RVar and RApp (NOT RFun)
addHole :: SpecType -> SpecType
addHole t@(RVar v _) = RVar v (f t (uReft ("v", hole)))
addHole t@(RApp c ts ps _) = RApp c ts ps (f t (uReft ("v", hole)))
addHole t = t
go (RVar _ _) v@(RVar _ _) = return v
go (RFun _ i o _) (RFun x i' o' r) = RFun x <$> go i i' <*> go o o' <*> return r
go (RAllT _ t) (RAllT a t') = RAllT a <$> go t t'
go (RAllT a t) t' = RAllT a <$> go t t'
go t (RAllP p t') = RAllP p <$> go t t'
go t (RAllS s t') = RAllS s <$> go t t'
go t (RAllE b a t') = RAllE b a <$> go t t'
go t (REx b x t') = REx b x <$> go t t'
go t (RRTy e r o t') = RRTy e r o <$> go t t'
go (RAppTy t1 t2 _) (RAppTy t1' t2' r) = RAppTy <$> go t1 t1' <*> go t2 t2' <*> return r
go (RApp _ t _ _) (RApp c t' p r) = RApp c <$> (zipWithM go t t') <*> return p <*> return r
-- If we reach the default case, there's probably an error, but we defer
-- throwing it as checkGhcSpec does a much better job of reporting the
-- problem to the user.
go _ st = return st
makeCls cs t = foldr (uncurry rFun) t cs
addRefs :: TCEmb TyCon
-> M.HashMap TyCon RTyCon
-> SpecType
-> SpecType
addRefs tce tyi (RApp c ts _ r) = RApp c' ts ps r
where
RApp c' _ ps _ = addTyConInfo tce tyi (RApp c ts [] r)
addRefs _ _ t = t
maybeTrue :: NamedThing a => a -> ModName -> NameSet -> SpecType -> RReft -> RReft
maybeTrue x target exports t r
| not (isFunTy t) && (isInternalName name || inTarget && notExported)
= r
| otherwise
= killHoles r
where
inTarget = moduleName (nameModule name) == getModName target
name = getName x
notExported = not $ getName x `elemNameSet` exports
-- killHoles r@(U (Reft (v, rs)) _ _) = r { ur_reft = Reft (v, filter (not . isHole) rs) }
killHoles ur = ur { ur_reft = tx $ ur_reft ur }
where
tx r = {- traceFix ("killholes: r = " ++ showFix r) $ -} mapPredReft dropHoles r
dropHoles = pAnd . filter (not . isHole) . conjuncts
| abakst/liquidhaskell | src/Language/Haskell/Liquid/Bare/Plugged.hs | bsd-3-clause | 5,503 | 0 | 22 | 1,741 | 2,103 | 1,091 | 1,012 | 103 | 16 |
-- | Generators for "Prelude" types.
--
-- This module also contains function generators, like 'function1' and
-- 'function2'. These generate random functions. To use these, get a
-- coarbitrary function from one of the modules whose name ends in
-- @Coarbitrary@ or by using the QuickCheck 'coarbitrary' function,
-- along with using a generator for the function's result type. For
-- example:
--
-- @
-- module MyModule where
--
-- import Test.QuickCheck
-- import qualified Prelude.Generators as G
-- import qualified Data.Text.Coarbitrary as C
-- import qualified Data.Text.Generators as G
--
-- genTextToMaybeText :: Gen (Text -> Maybe Text)
-- genTextToMaybeText = function1 C.text (G.maybe (G.text arbitrary))
-- @
module Prelude.Generators where
import Test.QuickCheck
( Gen, frequency, oneof )
import Prelude hiding (maybe, either)
import Barecheck.Promote
import Control.Monad
maybe :: Gen a -> Gen (Maybe a)
maybe g = frequency [(3, fmap Just g), (1, return Nothing)]
either :: Gen a -> Gen b -> Gen (Either a b)
either a b = oneof [ fmap Left a, fmap Right b ]
function1
:: (a -> Gen b -> Gen b)
-> Gen b
-> Gen (a -> b)
function1 perturb gen = promote (`perturb` gen)
function2
:: (a -> Gen r -> Gen r)
-> (b -> Gen r -> Gen r)
-> Gen r
-> Gen (a -> b -> r)
function2 p1 p2 = fmap f . function1 p'
where
p' (a, b) = p1 a . p2 b
f g = \a b -> g (a, b)
function3
:: (a -> Gen r -> Gen r)
-> (b -> Gen r -> Gen r)
-> (c -> Gen r -> Gen r)
-> Gen r
-> Gen (a -> b -> c -> r)
function3 p1 p2 p3 = fmap f . function1 p'
where
p' (a, b, c) = p1 a . p2 b . p3 c
f g = \a b c -> g (a, b, c)
function4
:: (a -> Gen r -> Gen r)
-> (b -> Gen r -> Gen r)
-> (c -> Gen r -> Gen r)
-> (d -> Gen r -> Gen r)
-> Gen r
-> Gen (a -> b -> c -> d -> r)
function4 p1 p2 p3 p4 = fmap f . function1 p'
where
p' (a, b, c, d) = p1 a . p2 b . p3 c . p4 d
f g = \a b c d -> g (a, b, c, d)
function5
:: (a -> Gen r -> Gen r)
-> (b -> Gen r -> Gen r)
-> (c -> Gen r -> Gen r)
-> (d -> Gen r -> Gen r)
-> (e -> Gen r -> Gen r)
-> Gen r
-> Gen (a -> b -> c -> d -> e -> r)
function5 p1 p2 p3 p4 p5 = fmap f . function1 p'
where
p' (a, b, c, d, e) = p1 a . p2 b . p3 c . p4 d . p5 e
f g = \a b c d e -> g (a, b, c, d, e)
tuple2 :: Gen a -> Gen b -> Gen (a, b)
tuple2 a b = liftM2 (,) a b
tuple3 :: Gen a -> Gen b -> Gen c -> Gen (a, b, c)
tuple3 a b c = liftM3 (,,) a b c
tuple4 :: Gen a -> Gen b -> Gen c -> Gen d -> Gen (a, b, c, d)
tuple4 a b c d = liftM4 (,,,) a b c d
tuple5 :: Gen a -> Gen b -> Gen c -> Gen d -> Gen e -> Gen (a, b, c, d, e)
tuple5 a b c d e = liftM5 (,,,,) a b c d e
| massysett/barecheck | lib/Prelude/Generators.hs | bsd-3-clause | 2,702 | 0 | 17 | 763 | 1,329 | 680 | 649 | 61 | 1 |
{-The arithmetic sequence, 1487, 4817, 8147, in which each of the terms increases by 3330, is unusual in two ways: (i) each of the three terms are prime, and, (ii) each of the 4-digit numbers are permutations of one another.
There are no arithmetic sequences made up of three 1-, 2-, or 3-digit primes, exhibiting this property, but there is one other 4-digit increasing sequence.
What 12-digit number do you form by concatenating the three terms in this sequence?-}
import qualified Zora.Math as ZMath
import qualified Zora.List as ZList
seqprimes :: [Integer]
seqprimes = filter
(\p -> ((p + 3330) `elem` smallprimes) &&
((p + 3330 + 3330) `elem` smallprimes))
smallprimes
where
smallprimes :: [Integer]
smallprimes
= filter (\n -> (length $ show n) == 4)
. takeWhile (\n -> (length $ show n) <= 4)
$ ZMath.primes
is_permutation_triple :: (Integer, Integer, Integer) -> Bool
is_permutation_triple (a, b, _) = (show b) `elem` (ZList.permutations $ show a)
seqprime_triples :: [(Integer, Integer, Integer)]
seqprime_triples = map (\n -> (n, n+3330, n+3330+3330)) seqprimes
perms :: [(Integer, Integer, Integer)]
perms = filter is_permutation_triple seqprime_triples
main :: IO ()
main = do
putStrLn . show $ perms | bgwines/project-euler | src/solved/problem49.hs | bsd-3-clause | 1,252 | 9 | 12 | 231 | 348 | 191 | 157 | 21 | 1 |
{-# LANGUAGE TupleSections #-}
module System.Metrics.Prometheus.Metric.Histogram
( Histogram
, HistogramSample (..)
, Buckets
, UpperBound
, new
, observe
, sample
, observeAndSample
) where
import Control.Applicative ((<$>))
import Control.Monad (void)
import Data.Bool (bool)
import Data.IORef (IORef, atomicModifyIORef', newIORef,
readIORef)
import Data.Map.Strict (Map)
import qualified Data.Map.Strict as Map
newtype Histogram = Histogram { unHistogram :: IORef HistogramSample }
type UpperBound = Double -- Inclusive upper bounds
type Buckets = Map UpperBound Double
data HistogramSample =
HistogramSample
{ histBuckets :: !Buckets
, histSum :: !Double
, histCount :: !Int
}
new :: [UpperBound] -> IO Histogram
new buckets = Histogram <$> newIORef empty
where
empty = HistogramSample (Map.fromList $ map (, 0) (read "Infinity" : buckets)) zeroSum zeroCount
zeroSum = 0.0
zeroCount = 0
observeAndSample :: Double -> Histogram -> IO HistogramSample
observeAndSample x = flip atomicModifyIORef' update . unHistogram
where
update histData = (hist' histData, histData)
hist' histData =
histData { histBuckets = updateBuckets x $ histBuckets histData
, histSum = histSum histData + x
, histCount = histCount histData + 1
}
observe :: Double -> Histogram -> IO ()
observe x = void . observeAndSample x
updateBuckets :: Double -> Buckets -> Buckets
updateBuckets x = Map.mapWithKey updateBucket
where updateBucket key val = bool val (val + 1) (x <= key)
sample :: Histogram -> IO HistogramSample
sample = readIORef . unHistogram
| LukeHoersten/prometheus | src/System/Metrics/Prometheus/Metric/Histogram.hs | bsd-3-clause | 1,841 | 0 | 13 | 538 | 474 | 265 | 209 | 50 | 1 |
{-
(c) The University of Glasgow 2006
(c) The GRASP/AQUA Project, Glasgow University, 1992-1998
HsTypes: Abstract syntax: user-defined types
-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TypeSynonymInstances #-}
{-# LANGUAGE UndecidableInstances #-} -- Note [Pass sensitive types]
-- in module PlaceHolder
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE CPP #-}
module HsTypes (
HsType(..), LHsType, HsKind, LHsKind,
HsTyVarBndr(..), LHsTyVarBndr,
LHsQTyVars(..),
HsImplicitBndrs(..),
HsWildCardBndrs(..),
LHsSigType, LHsSigWcType, LHsWcType,
HsTupleSort(..),
HsContext, LHsContext,
HsTyLit(..),
HsIPName(..), hsIPNameFS,
HsAppType(..),LHsAppType,
LBangType, BangType,
HsSrcBang(..), HsImplBang(..),
SrcStrictness(..), SrcUnpackedness(..),
getBangType, getBangStrictness,
ConDeclField(..), LConDeclField, pprConDeclFields, updateGadtResult,
HsConDetails(..),
FieldOcc(..), LFieldOcc, mkFieldOcc,
AmbiguousFieldOcc(..), mkAmbiguousFieldOcc,
rdrNameAmbiguousFieldOcc, selectorAmbiguousFieldOcc,
unambiguousFieldOcc, ambiguousFieldOcc,
HsWildCardInfo(..), mkAnonWildCardTy,
wildCardName, sameWildCard,
mkHsImplicitBndrs, mkHsWildCardBndrs, hsImplicitBody,
mkEmptyImplicitBndrs, mkEmptyWildCardBndrs,
mkHsQTvs, hsQTvExplicit, emptyLHsQTvs, isEmptyLHsQTvs,
isHsKindedTyVar, hsTvbAllKinded,
hsScopedTvs, hsWcScopedTvs, dropWildCards,
hsTyVarName, hsAllLTyVarNames, hsLTyVarLocNames,
hsLTyVarName, hsLTyVarLocName, hsExplicitLTyVarNames,
splitLHsInstDeclTy, getLHsInstDeclHead, getLHsInstDeclClass_maybe,
splitLHsPatSynTy,
splitLHsForAllTy, splitLHsQualTy, splitLHsSigmaTy,
splitHsFunType, splitHsAppsTy,
splitHsAppTys, getAppsTyHead_maybe, hsTyGetAppHead_maybe,
mkHsOpTy, mkHsAppTy, mkHsAppTys,
ignoreParens, hsSigType, hsSigWcType,
hsLTyVarBndrToType, hsLTyVarBndrsToTypes,
-- Printing
pprParendHsType, pprHsForAll, pprHsForAllTvs, pprHsForAllExtra,
pprHsContext, pprHsContextNoArrow, pprHsContextMaybe
) where
import {-# SOURCE #-} HsExpr ( HsSplice, pprSplice )
import PlaceHolder ( PostTc,PostRn,DataId,PlaceHolder(..) )
import Id ( Id )
import Name( Name )
import RdrName ( RdrName )
import NameSet ( NameSet, emptyNameSet )
import DataCon( HsSrcBang(..), HsImplBang(..),
SrcStrictness(..), SrcUnpackedness(..) )
import TysPrim( funTyConName )
import Type
import HsDoc
import BasicTypes
import SrcLoc
import StaticFlags
import Outputable
import FastString
import Maybes( isJust )
import Data.Data hiding ( Fixity )
import Data.Maybe ( fromMaybe )
import Control.Monad ( unless )
#if __GLASGOW_HASKELL > 710
import Data.Semigroup ( Semigroup )
import qualified Data.Semigroup as Semigroup
#endif
{-
************************************************************************
* *
\subsection{Bang annotations}
* *
************************************************************************
-}
type LBangType name = Located (BangType name)
type BangType name = HsType name -- Bangs are in the HsType data type
getBangType :: LHsType a -> LHsType a
getBangType (L _ (HsBangTy _ ty)) = ty
getBangType ty = ty
getBangStrictness :: LHsType a -> HsSrcBang
getBangStrictness (L _ (HsBangTy s _)) = s
getBangStrictness _ = (HsSrcBang Nothing NoSrcUnpack NoSrcStrict)
{-
************************************************************************
* *
\subsection{Data types}
* *
************************************************************************
This is the syntax for types as seen in type signatures.
Note [HsBSig binder lists]
~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider a binder (or pattern) decorated with a type or kind,
\ (x :: a -> a). blah
forall (a :: k -> *) (b :: k). blah
Then we use a LHsBndrSig on the binder, so that the
renamer can decorate it with the variables bound
by the pattern ('a' in the first example, 'k' in the second),
assuming that neither of them is in scope already
See also Note [Kind and type-variable binders] in RnTypes
Note [HsType binders]
~~~~~~~~~~~~~~~~~~~~~
The system for recording type and kind-variable binders in HsTypes
is a bit complicated. Here's how it works.
* In a HsType,
HsForAllTy represents an /explicit, user-written/ 'forall'
e.g. forall a b. ...
HsQualTy represents an /explicit, user-written/ context
e.g. (Eq a, Show a) => ...
The context can be empty if that's what the user wrote
These constructors represent what the user wrote, no more
and no less.
* HsTyVarBndr describes a quantified type variable written by the
user. For example
f :: forall a (b :: *). blah
here 'a' and '(b::*)' are each a HsTyVarBndr. A HsForAllTy has
a list of LHsTyVarBndrs.
* HsImplicitBndrs is a wrapper that gives the implicitly-quantified
kind and type variables of the wrapped thing. It is filled in by
the renamer. For example, if the user writes
f :: a -> a
the HsImplicitBinders binds the 'a' (not a HsForAllTy!).
NB: this implicit quantification is purely lexical: we bind any
type or kind variables that are not in scope. The type checker
may subsequently quantify over further kind variables.
* HsWildCardBndrs is a wrapper that binds the wildcard variables
of the wrapped thing. It is filled in by the renamer
f :: _a -> _
The enclosing HsWildCardBndrs binds the wildcards _a and _.
* The explicit presence of these wrappers specifies, in the HsSyn,
exactly where implicit quantification is allowed, and where
wildcards are allowed.
* LHsQTyVars is used in data/class declarations, where the user gives
explicit *type* variable bindings, but we need to implicitly bind
*kind* variables. For example
class C (a :: k -> *) where ...
The 'k' is implicitly bound in the hsq_tvs field of LHsQTyVars
Note [The wildcard story for types]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Types can have wildcards in them, to support partial type signatures,
like f :: Int -> (_ , _a) -> _a
A wildcard in a type can be
* An anonymous wildcard,
written '_'
In HsType this is represented by HsWildCardTy.
After the renamer, this contains a Name which uniquely
identifies this particular occurrence.
* A named wildcard,
written '_a', '_foo', etc
In HsType this is represented by (HsTyVar "_a")
i.e. a perfectly ordinary type variable that happens
to start with an underscore
Note carefully:
* When NamedWildCards is off, type variables that start with an
underscore really /are/ ordinary type variables. And indeed, even
when NamedWildCards is on you can bind _a explicitly as an ordinary
type variable:
data T _a _b = MkT _b _a
Or even:
f :: forall _a. _a -> _b
Here _a is an ordinary forall'd binder, but (With NamedWildCards)
_b is a named wildcard. (See the comments in Trac #10982)
* All wildcards, whether named or anonymous, are bound by the
HsWildCardBndrs construct, which wraps types that are allowed
to have wildcards.
* After type checking is done, we report what types the wildcards
got unified with.
-}
type LHsContext name = Located (HsContext name)
-- ^ 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnUnit'
-- For details on above see note [Api annotations] in ApiAnnotation
type HsContext name = [LHsType name]
type LHsType name = Located (HsType name)
-- ^ May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma' when
-- in a list
-- For details on above see note [Api annotations] in ApiAnnotation
type HsKind name = HsType name
type LHsKind name = Located (HsKind name)
-- ^ 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnDcolon'
-- For details on above see note [Api annotations] in ApiAnnotation
--------------------------------------------------
-- LHsQTyVars
-- The explicitly-quantified binders in a data/type declaration
type LHsTyVarBndr name = Located (HsTyVarBndr name)
-- See Note [HsType binders]
data LHsQTyVars name -- See Note [HsType binders]
= HsQTvs { hsq_implicit :: PostRn name [Name] -- implicit (dependent) variables
, hsq_explicit :: [LHsTyVarBndr name] -- explicit variables
-- See Note [HsForAllTy tyvar binders]
, hsq_dependent :: PostRn name NameSet
-- which explicit vars are dependent
-- See Note [Dependent LHsQTyVars] in TcHsType
}
deriving instance (DataId name) => Data (LHsQTyVars name)
mkHsQTvs :: [LHsTyVarBndr RdrName] -> LHsQTyVars RdrName
mkHsQTvs tvs = HsQTvs { hsq_implicit = PlaceHolder, hsq_explicit = tvs
, hsq_dependent = PlaceHolder }
hsQTvExplicit :: LHsQTyVars name -> [LHsTyVarBndr name]
hsQTvExplicit = hsq_explicit
emptyLHsQTvs :: LHsQTyVars Name
emptyLHsQTvs = HsQTvs [] [] emptyNameSet
isEmptyLHsQTvs :: LHsQTyVars Name -> Bool
isEmptyLHsQTvs (HsQTvs [] [] _) = True
isEmptyLHsQTvs _ = False
------------------------------------------------
-- HsImplicitBndrs
-- Used to quantify the binders of a type in cases
-- when a HsForAll isn't appropriate:
-- * Patterns in a type/data family instance (HsTyPats)
-- * Type of a rule binder (RuleBndr)
-- * Pattern type signatures (SigPatIn)
-- In the last of these, wildcards can happen, so we must accommodate them
data HsImplicitBndrs name thing -- See Note [HsType binders]
= HsIB { hsib_vars :: PostRn name [Name] -- Implicitly-bound kind & type vars
, hsib_body :: thing -- Main payload (type or list of types)
}
data HsWildCardBndrs name thing
-- See Note [HsType binders]
-- See Note [The wildcard story for types]
= HsWC { hswc_wcs :: PostRn name [Name]
-- Wild cards, both named and anonymous
, hswc_ctx :: Maybe SrcSpan
-- Indicates whether hswc_body has an
-- extra-constraint wildcard, and if so where
-- e.g. (Eq a, _) => a -> a
-- NB: the wildcard stays in HsQualTy inside the type!
-- So for pretty printing purposes you can ignore
-- hswc_ctx
, hswc_body :: thing -- Main payload (type or list of types)
}
deriving instance (Data name, Data thing, Data (PostRn name [Name]))
=> Data (HsImplicitBndrs name thing)
deriving instance (Data name, Data thing, Data (PostRn name [Name]))
=> Data (HsWildCardBndrs name thing)
type LHsSigType name = HsImplicitBndrs name (LHsType name) -- Implicit only
type LHsWcType name = HsWildCardBndrs name (LHsType name) -- Wildcard only
type LHsSigWcType name = HsImplicitBndrs name (LHsWcType name) -- Both
-- See Note [Representing type signatures]
hsImplicitBody :: HsImplicitBndrs name thing -> thing
hsImplicitBody (HsIB { hsib_body = body }) = body
hsSigType :: LHsSigType name -> LHsType name
hsSigType = hsImplicitBody
hsSigWcType :: LHsSigWcType name -> LHsType name
hsSigWcType sig_ty = hswc_body (hsib_body sig_ty)
dropWildCards :: LHsSigWcType name -> LHsSigType name
-- Drop the wildcard part of a LHsSigWcType
dropWildCards sig_ty = sig_ty { hsib_body = hsSigWcType sig_ty }
{- Note [Representing type signatures]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
HsSigType is used to represent an explicit user type signature
such as f :: a -> a
or g (x :: a -> a) = x
A HsSigType is just a HsImplicitBndrs wrapping a LHsType.
* The HsImplicitBndrs binds the /implicitly/ quantified tyvars
* The LHsType binds the /explictly/ quantified tyvars
E.g. For a signature like
f :: forall (a::k). blah
we get
HsIB { hsib_vars = [k]
, hsib_body = HsForAllTy { hst_bndrs = [(a::*)]
, hst_body = blah }
The implicit kind variable 'k' is bound by the HsIB;
the explictly forall'd tyvar 'a' is bounnd by the HsForAllTy
-}
mkHsImplicitBndrs :: thing -> HsImplicitBndrs RdrName thing
mkHsImplicitBndrs x = HsIB { hsib_body = x
, hsib_vars = PlaceHolder }
mkHsWildCardBndrs :: thing -> HsWildCardBndrs RdrName thing
mkHsWildCardBndrs x = HsWC { hswc_body = x
, hswc_wcs = PlaceHolder
, hswc_ctx = Nothing }
-- Add empty binders. This is a bit suspicious; what if
-- the wrapped thing had free type variables?
mkEmptyImplicitBndrs :: thing -> HsImplicitBndrs Name thing
mkEmptyImplicitBndrs x = HsIB { hsib_body = x
, hsib_vars = [] }
mkEmptyWildCardBndrs :: thing -> HsWildCardBndrs Name thing
mkEmptyWildCardBndrs x = HsWC { hswc_body = x
, hswc_wcs = []
, hswc_ctx = Nothing }
--------------------------------------------------
-- | These names are used early on to store the names of implicit
-- parameters. They completely disappear after type-checking.
newtype HsIPName = HsIPName FastString
deriving( Eq, Data )
hsIPNameFS :: HsIPName -> FastString
hsIPNameFS (HsIPName n) = n
instance Outputable HsIPName where
ppr (HsIPName n) = char '?' <> ftext n -- Ordinary implicit parameters
instance OutputableBndr HsIPName where
pprBndr _ n = ppr n -- Simple for now
pprInfixOcc n = ppr n
pprPrefixOcc n = ppr n
--------------------------------------------------
data HsTyVarBndr name
= UserTyVar -- no explicit kinding
(Located name)
-- See Note [Located RdrNames] in HsExpr
| KindedTyVar
(Located name)
(LHsKind name) -- The user-supplied kind signature
-- ^
-- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen',
-- 'ApiAnnotation.AnnDcolon', 'ApiAnnotation.AnnClose'
-- For details on above see note [Api annotations] in ApiAnnotation
deriving instance (DataId name) => Data (HsTyVarBndr name)
-- | Does this 'HsTyVarBndr' come with an explicit kind annotation?
isHsKindedTyVar :: HsTyVarBndr name -> Bool
isHsKindedTyVar (UserTyVar {}) = False
isHsKindedTyVar (KindedTyVar {}) = True
-- | Do all type variables in this 'LHsQTyVars' come with kind annotations?
hsTvbAllKinded :: LHsQTyVars name -> Bool
hsTvbAllKinded = all (isHsKindedTyVar . unLoc) . hsQTvExplicit
data HsType name
= HsForAllTy -- See Note [HsType binders]
{ hst_bndrs :: [LHsTyVarBndr name] -- Explicit, user-supplied 'forall a b c'
, hst_body :: LHsType name -- body type
}
-- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnForall',
-- 'ApiAnnotation.AnnDot','ApiAnnotation.AnnDarrow'
-- For details on above see note [Api annotations] in ApiAnnotation
| HsQualTy -- See Note [HsType binders]
{ hst_ctxt :: LHsContext name -- Context C => blah
, hst_body :: LHsType name }
| HsTyVar (Located name)
-- Type variable, type constructor, or data constructor
-- see Note [Promotions (HsTyVar)]
-- See Note [Located RdrNames] in HsExpr
-- ^ - 'ApiAnnotation.AnnKeywordId' : None
-- For details on above see note [Api annotations] in ApiAnnotation
| HsAppsTy [LHsAppType name] -- Used only before renaming,
-- Note [HsAppsTy]
-- ^ - 'ApiAnnotation.AnnKeywordId' : None
| HsAppTy (LHsType name)
(LHsType name)
-- ^ - 'ApiAnnotation.AnnKeywordId' : None
-- For details on above see note [Api annotations] in ApiAnnotation
| HsFunTy (LHsType name) -- function type
(LHsType name)
-- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnRarrow',
-- For details on above see note [Api annotations] in ApiAnnotation
| HsListTy (LHsType name) -- Element type
-- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'['@,
-- 'ApiAnnotation.AnnClose' @']'@
-- For details on above see note [Api annotations] in ApiAnnotation
| HsPArrTy (LHsType name) -- Elem. type of parallel array: [:t:]
-- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'[:'@,
-- 'ApiAnnotation.AnnClose' @':]'@
-- For details on above see note [Api annotations] in ApiAnnotation
| HsTupleTy HsTupleSort
[LHsType name] -- Element types (length gives arity)
-- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'(' or '(#'@,
-- 'ApiAnnotation.AnnClose' @')' or '#)'@
-- For details on above see note [Api annotations] in ApiAnnotation
| HsOpTy (LHsType name) (Located name) (LHsType name)
-- ^ - 'ApiAnnotation.AnnKeywordId' : None
-- For details on above see note [Api annotations] in ApiAnnotation
| HsParTy (LHsType name) -- See Note [Parens in HsSyn] in HsExpr
-- Parenthesis preserved for the precedence re-arrangement in RnTypes
-- It's important that a * (b + c) doesn't get rearranged to (a*b) + c!
-- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'('@,
-- 'ApiAnnotation.AnnClose' @')'@
-- For details on above see note [Api annotations] in ApiAnnotation
| HsIParamTy HsIPName -- (?x :: ty)
(LHsType name) -- Implicit parameters as they occur in contexts
-- ^
-- > (?x :: ty)
--
-- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnDcolon'
-- For details on above see note [Api annotations] in ApiAnnotation
| HsEqTy (LHsType name) -- ty1 ~ ty2
(LHsType name) -- Always allowed even without TypeOperators, and has special kinding rule
-- ^
-- > ty1 ~ ty2
--
-- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnTilde'
-- For details on above see note [Api annotations] in ApiAnnotation
| HsKindSig (LHsType name) -- (ty :: kind)
(LHsKind name) -- A type with a kind signature
-- ^
-- > (ty :: kind)
--
-- - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'('@,
-- 'ApiAnnotation.AnnDcolon','ApiAnnotation.AnnClose' @')'@
-- For details on above see note [Api annotations] in ApiAnnotation
| HsSpliceTy (HsSplice name) -- Includes quasi-quotes
(PostTc name Kind)
-- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'$('@,
-- 'ApiAnnotation.AnnClose' @')'@
-- For details on above see note [Api annotations] in ApiAnnotation
| HsDocTy (LHsType name) LHsDocString -- A documented type
-- ^ - 'ApiAnnotation.AnnKeywordId' : None
-- For details on above see note [Api annotations] in ApiAnnotation
| HsBangTy HsSrcBang (LHsType name) -- Bang-style type annotations
-- ^ - 'ApiAnnotation.AnnKeywordId' :
-- 'ApiAnnotation.AnnOpen' @'{-\# UNPACK' or '{-\# NOUNPACK'@,
-- 'ApiAnnotation.AnnClose' @'#-}'@
-- 'ApiAnnotation.AnnBang' @\'!\'@
-- For details on above see note [Api annotations] in ApiAnnotation
| HsRecTy [LConDeclField name] -- Only in data type declarations
-- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @'{'@,
-- 'ApiAnnotation.AnnClose' @'}'@
-- For details on above see note [Api annotations] in ApiAnnotation
| HsCoreTy Type -- An escape hatch for tunnelling a *closed*
-- Core Type through HsSyn.
-- ^ - 'ApiAnnotation.AnnKeywordId' : None
-- For details on above see note [Api annotations] in ApiAnnotation
| HsExplicitListTy -- A promoted explicit list
(PostTc name Kind) -- See Note [Promoted lists and tuples]
[LHsType name]
-- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @"'["@,
-- 'ApiAnnotation.AnnClose' @']'@
-- For details on above see note [Api annotations] in ApiAnnotation
| HsExplicitTupleTy -- A promoted explicit tuple
[PostTc name Kind] -- See Note [Promoted lists and tuples]
[LHsType name]
-- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnOpen' @"'("@,
-- 'ApiAnnotation.AnnClose' @')'@
-- For details on above see note [Api annotations] in ApiAnnotation
| HsTyLit HsTyLit -- A promoted numeric literal.
-- ^ - 'ApiAnnotation.AnnKeywordId' : None
-- For details on above see note [Api annotations] in ApiAnnotation
| HsWildCardTy (HsWildCardInfo name) -- A type wildcard
-- See Note [The wildcard story for types]
-- ^ - 'ApiAnnotation.AnnKeywordId' : None
-- For details on above see note [Api annotations] in ApiAnnotation
deriving instance (DataId name) => Data (HsType name)
-- Note [Literal source text] in BasicTypes for SourceText fields in
-- the following
data HsTyLit
= HsNumTy SourceText Integer
| HsStrTy SourceText FastString
deriving Data
newtype HsWildCardInfo name -- See Note [The wildcard story for types]
= AnonWildCard (PostRn name (Located Name))
-- A anonymous wild card ('_'). A fresh Name is generated for
-- each individual anonymous wildcard during renaming
deriving instance (DataId name) => Data (HsWildCardInfo name)
type LHsAppType name = Located (HsAppType name)
-- ^ 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnSimpleQuote'
data HsAppType name
= HsAppInfix (Located name) -- either a symbol or an id in backticks
| HsAppPrefix (LHsType name) -- anything else, including things like (+)
deriving instance (DataId name) => Data (HsAppType name)
instance OutputableBndr name => Outputable (HsAppType name) where
ppr = ppr_app_ty TopPrec
{-
Note [HsForAllTy tyvar binders]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
After parsing:
* Implicit => empty
Explicit => the variables the user wrote
After renaming
* Implicit => the *type* variables free in the type
Explicit => the variables the user wrote (renamed)
Qualified currently behaves exactly as Implicit,
but it is deprecated to use it for implicit quantification.
In this case, GHC 7.10 gives a warning; see
Note [Context quantification] in RnTypes, and Trac #4426.
In GHC 8.0, Qualified will no longer bind variables
and this will become an error.
The kind variables bound in the hsq_implicit field come both
a) from the kind signatures on the kind vars (eg k1)
b) from the scope of the forall (eg k2)
Example: f :: forall (a::k1) b. T a (b::k2)
Note [Unit tuples]
~~~~~~~~~~~~~~~~~~
Consider the type
type instance F Int = ()
We want to parse that "()"
as HsTupleTy HsBoxedOrConstraintTuple [],
NOT as HsTyVar unitTyCon
Why? Because F might have kind (* -> Constraint), so we when parsing we
don't know if that tuple is going to be a constraint tuple or an ordinary
unit tuple. The HsTupleSort flag is specifically designed to deal with
that, but it has to work for unit tuples too.
Note [Promotions (HsTyVar)]
~~~~~~~~~~~~~~~~~~~~~~~~~~~
HsTyVar: A name in a type or kind.
Here are the allowed namespaces for the name.
In a type:
Var: not allowed
Data: promoted data constructor
Tv: type variable
TcCls before renamer: type constructor, class constructor, or promoted data constructor
TcCls after renamer: type constructor or class constructor
In a kind:
Var, Data: not allowed
Tv: kind variable
TcCls: kind constructor or promoted type constructor
Note [HsAppsTy]
~~~~~~~~~~~~~~~
How to parse
Foo * Int
? Is it `(*) Foo Int` or `Foo GHC.Types.* Int`? There's no way to know until renaming.
So we just take type expressions like this and put each component in a list, so be
sorted out in the renamer. The sorting out is done by RnTypes.mkHsOpTyRn. This means
that the parser should never produce HsAppTy or HsOpTy.
Note [Promoted lists and tuples]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Notice the difference between
HsListTy HsExplicitListTy
HsTupleTy HsExplicitListTupleTy
E.g. f :: [Int] HsListTy
g3 :: T '[] All these use
g2 :: T '[True] HsExplicitListTy
g1 :: T '[True,False]
g1a :: T [True,False] (can omit ' where unambiguous)
kind of T :: [Bool] -> * This kind uses HsListTy!
E.g. h :: (Int,Bool) HsTupleTy; f is a pair
k :: S '(True,False) HsExplicitTypleTy; S is indexed by
a type-level pair of booleans
kind of S :: (Bool,Bool) -> * This kind uses HsExplicitTupleTy
Note [Distinguishing tuple kinds]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Apart from promotion, tuples can have one of three different kinds:
x :: (Int, Bool) -- Regular boxed tuples
f :: Int# -> (# Int#, Int# #) -- Unboxed tuples
g :: (Eq a, Ord a) => a -- Constraint tuples
For convenience, internally we use a single constructor for all of these,
namely HsTupleTy, but keep track of the tuple kind (in the first argument to
HsTupleTy, a HsTupleSort). We can tell if a tuple is unboxed while parsing,
because of the #. However, with -XConstraintKinds we can only distinguish
between constraint and boxed tuples during type checking, in general. Hence the
four constructors of HsTupleSort:
HsUnboxedTuple -> Produced by the parser
HsBoxedTuple -> Certainly a boxed tuple
HsConstraintTuple -> Certainly a constraint tuple
HsBoxedOrConstraintTuple -> Could be a boxed or a constraint
tuple. Produced by the parser only,
disappears after type checking
-}
data HsTupleSort = HsUnboxedTuple
| HsBoxedTuple
| HsConstraintTuple
| HsBoxedOrConstraintTuple
deriving Data
type LConDeclField name = Located (ConDeclField name)
-- ^ May have 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnComma' when
-- in a list
-- For details on above see note [Api annotations] in ApiAnnotation
data ConDeclField name -- Record fields have Haddoc docs on them
= ConDeclField { cd_fld_names :: [LFieldOcc name],
-- ^ See Note [ConDeclField names]
cd_fld_type :: LBangType name,
cd_fld_doc :: Maybe LHsDocString }
-- ^ - 'ApiAnnotation.AnnKeywordId' : 'ApiAnnotation.AnnDcolon'
-- For details on above see note [Api annotations] in ApiAnnotation
deriving instance (DataId name) => Data (ConDeclField name)
instance (OutputableBndr name) => Outputable (ConDeclField name) where
ppr (ConDeclField fld_n fld_ty _) = ppr fld_n <+> dcolon <+> ppr fld_ty
-- HsConDetails is used for patterns/expressions *and* for data type
-- declarations
data HsConDetails arg rec
= PrefixCon [arg] -- C p1 p2 p3
| RecCon rec -- C { x = p1, y = p2 }
| InfixCon arg arg -- p1 `C` p2
deriving Data
instance (Outputable arg, Outputable rec)
=> Outputable (HsConDetails arg rec) where
ppr (PrefixCon args) = text "PrefixCon" <+> ppr args
ppr (RecCon rec) = text "RecCon:" <+> ppr rec
ppr (InfixCon l r) = text "InfixCon:" <+> ppr [l, r]
-- Takes details and result type of a GADT data constructor as created by the
-- parser and rejigs them using information about fixities from the renamer.
-- See Note [Sorting out the result type] in RdrHsSyn
updateGadtResult
:: (Monad m)
=> (SDoc -> m ())
-> SDoc
-> HsConDetails (LHsType Name) (Located [LConDeclField Name])
-- ^ Original details
-> LHsType Name -- ^ Original result type
-> m (HsConDetails (LHsType Name) (Located [LConDeclField Name]),
LHsType Name)
updateGadtResult failWith doc details ty
= do { let (arg_tys, res_ty) = splitHsFunType ty
badConSig = text "Malformed constructor signature"
; case details of
InfixCon {} -> pprPanic "updateGadtResult" (ppr ty)
RecCon {} -> do { unless (null arg_tys)
(failWith (doc <+> badConSig))
; return (details, res_ty) }
PrefixCon {} -> return (PrefixCon arg_tys, res_ty)}
{-
Note [ConDeclField names]
~~~~~~~~~~~~~~~~~~~~~~~~~
A ConDeclField contains a list of field occurrences: these always
include the field label as the user wrote it. After the renamer, it
will additionally contain the identity of the selector function in the
second component.
Due to DuplicateRecordFields, the OccName of the selector function
may have been mangled, which is why we keep the original field label
separately. For example, when DuplicateRecordFields is enabled
data T = MkT { x :: Int }
gives
ConDeclField { cd_fld_names = [L _ (FieldOcc "x" $sel:x:MkT)], ... }.
-}
-----------------------
-- A valid type must have a for-all at the top of the type, or of the fn arg
-- types
---------------------
hsWcScopedTvs :: LHsSigWcType Name -> [Name]
-- Get the lexically-scoped type variables of a HsSigType
-- - the explicitly-given forall'd type variables
-- - the implicitly-bound kind variables
-- - the named wildcars; see Note [Scoping of named wildcards]
-- because they scope in the same way
hsWcScopedTvs sig_ty
| HsIB { hsib_vars = vars, hsib_body = sig_ty1 } <- sig_ty
, HsWC { hswc_wcs = nwcs, hswc_body = sig_ty2 } <- sig_ty1
= case sig_ty2 of
L _ (HsForAllTy { hst_bndrs = tvs }) -> vars ++ nwcs ++
map hsLTyVarName tvs
-- include kind variables only if the type is headed by forall
-- (this is consistent with GHC 7 behaviour)
_ -> nwcs
hsScopedTvs :: LHsSigType Name -> [Name]
-- Same as hsWcScopedTvs, but for a LHsSigType
hsScopedTvs sig_ty
| HsIB { hsib_vars = vars, hsib_body = sig_ty2 } <- sig_ty
, L _ (HsForAllTy { hst_bndrs = tvs }) <- sig_ty2
= vars ++ map hsLTyVarName tvs
| otherwise
= []
{- Note [Scoping of named wildcards]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider
f :: _a -> _a
f x = let g :: _a -> _a
g = ...
in ...
Currently, for better or worse, the "_a" variables are all the same. So
although there is no explicit forall, the "_a" scopes over the definition.
I don't know if this is a good idea, but there it is.
-}
---------------------
hsTyVarName :: HsTyVarBndr name -> name
hsTyVarName (UserTyVar (L _ n)) = n
hsTyVarName (KindedTyVar (L _ n) _) = n
hsLTyVarName :: LHsTyVarBndr name -> name
hsLTyVarName = hsTyVarName . unLoc
hsExplicitLTyVarNames :: LHsQTyVars name -> [name]
-- Explicit variables only
hsExplicitLTyVarNames qtvs = map hsLTyVarName (hsQTvExplicit qtvs)
hsAllLTyVarNames :: LHsQTyVars Name -> [Name]
-- All variables
hsAllLTyVarNames (HsQTvs { hsq_implicit = kvs, hsq_explicit = tvs })
= kvs ++ map hsLTyVarName tvs
hsLTyVarLocName :: LHsTyVarBndr name -> Located name
hsLTyVarLocName = fmap hsTyVarName
hsLTyVarLocNames :: LHsQTyVars name -> [Located name]
hsLTyVarLocNames qtvs = map hsLTyVarLocName (hsQTvExplicit qtvs)
-- | Convert a LHsTyVarBndr to an equivalent LHsType.
hsLTyVarBndrToType :: LHsTyVarBndr name -> LHsType name
hsLTyVarBndrToType = fmap cvt
where cvt (UserTyVar n) = HsTyVar n
cvt (KindedTyVar (L name_loc n) kind)
= HsKindSig (L name_loc (HsTyVar (L name_loc n))) kind
-- | Convert a LHsTyVarBndrs to a list of types.
-- Works on *type* variable only, no kind vars.
hsLTyVarBndrsToTypes :: LHsQTyVars name -> [LHsType name]
hsLTyVarBndrsToTypes (HsQTvs { hsq_explicit = tvbs }) = map hsLTyVarBndrToType tvbs
---------------------
wildCardName :: HsWildCardInfo Name -> Name
wildCardName (AnonWildCard (L _ n)) = n
-- Two wild cards are the same when they have the same location
sameWildCard :: Located (HsWildCardInfo name)
-> Located (HsWildCardInfo name) -> Bool
sameWildCard (L l1 (AnonWildCard _)) (L l2 (AnonWildCard _)) = l1 == l2
ignoreParens :: LHsType name -> LHsType name
ignoreParens (L _ (HsParTy ty)) = ignoreParens ty
ignoreParens (L _ (HsAppsTy [L _ (HsAppPrefix ty)])) = ignoreParens ty
ignoreParens ty = ty
{-
************************************************************************
* *
Building types
* *
************************************************************************
-}
mkAnonWildCardTy :: HsType RdrName
mkAnonWildCardTy = HsWildCardTy (AnonWildCard PlaceHolder)
mkHsOpTy :: LHsType name -> Located name -> LHsType name -> HsType name
mkHsOpTy ty1 op ty2 = HsOpTy ty1 op ty2
mkHsAppTy :: LHsType name -> LHsType name -> LHsType name
mkHsAppTy t1 t2 = addCLoc t1 t2 (HsAppTy t1 t2)
mkHsAppTys :: LHsType name -> [LHsType name] -> LHsType name
mkHsAppTys = foldl mkHsAppTy
{-
************************************************************************
* *
Decomposing HsTypes
* *
************************************************************************
-}
---------------------------------
-- splitHsFunType decomposes a type (t1 -> t2 ... -> tn)
-- Breaks up any parens in the result type:
-- splitHsFunType (a -> (b -> c)) = ([a,b], c)
-- Also deals with (->) t1 t2; that is why it only works on LHsType Name
-- (see Trac #9096)
splitHsFunType :: LHsType Name -> ([LHsType Name], LHsType Name)
splitHsFunType (L _ (HsParTy ty))
= splitHsFunType ty
splitHsFunType (L _ (HsFunTy x y))
| (args, res) <- splitHsFunType y
= (x:args, res)
splitHsFunType orig_ty@(L _ (HsAppTy t1 t2))
= go t1 [t2]
where -- Look for (->) t1 t2, possibly with parenthesisation
go (L _ (HsTyVar (L _ fn))) tys | fn == funTyConName
, [t1,t2] <- tys
, (args, res) <- splitHsFunType t2
= (t1:args, res)
go (L _ (HsAppTy t1 t2)) tys = go t1 (t2:tys)
go (L _ (HsParTy ty)) tys = go ty tys
go _ _ = ([], orig_ty) -- Failure to match
splitHsFunType other = ([], other)
--------------------------------
-- | Retrieves the head of an HsAppsTy, if this can be done unambiguously,
-- without consulting fixities.
getAppsTyHead_maybe :: [LHsAppType name] -> Maybe (LHsType name, [LHsType name])
getAppsTyHead_maybe tys = case splitHsAppsTy tys of
([app1:apps], []) -> -- no symbols, some normal types
Just (mkHsAppTys app1 apps, [])
([app1l:appsl, app1r:appsr], [L loc op]) -> -- one operator
Just (L loc (HsTyVar (L loc op)), [mkHsAppTys app1l appsl, mkHsAppTys app1r appsr])
_ -> -- can't figure it out
Nothing
-- | Splits a [HsAppType name] (the payload of an HsAppsTy) into regions of prefix
-- types (normal types) and infix operators.
-- If @splitHsAppsTy tys = (non_syms, syms)@, then @tys@ starts with the first
-- element of @non_syms@ followed by the first element of @syms@ followed by
-- the next element of @non_syms@, etc. It is guaranteed that the non_syms list
-- has one more element than the syms list.
splitHsAppsTy :: [LHsAppType name] -> ([[LHsType name]], [Located name])
splitHsAppsTy = go [] [] []
where
go acc acc_non acc_sym [] = (reverse (reverse acc : acc_non), reverse acc_sym)
go acc acc_non acc_sym (L _ (HsAppPrefix ty) : rest)
= go (ty : acc) acc_non acc_sym rest
go acc acc_non acc_sym (L _ (HsAppInfix op) : rest)
= go [] (reverse acc : acc_non) (op : acc_sym) rest
-- Retrieve the name of the "head" of a nested type application
-- somewhat like splitHsAppTys, but a little more thorough
-- used to examine the result of a GADT-like datacon, so it doesn't handle
-- *all* cases (like lists, tuples, (~), etc.)
hsTyGetAppHead_maybe :: LHsType name -> Maybe (Located name, [LHsType name])
hsTyGetAppHead_maybe = go []
where
go tys (L _ (HsTyVar ln)) = Just (ln, tys)
go tys (L _ (HsAppsTy apps))
| Just (head, args) <- getAppsTyHead_maybe apps
= go (args ++ tys) head
go tys (L _ (HsAppTy l r)) = go (r : tys) l
go tys (L _ (HsOpTy l (L loc n) r)) = Just (L loc n, l : r : tys)
go tys (L _ (HsParTy t)) = go tys t
go tys (L _ (HsKindSig t _)) = go tys t
go _ _ = Nothing
splitHsAppTys :: LHsType Name -> [LHsType Name] -> (LHsType Name, [LHsType Name])
-- no need to worry about HsAppsTy here
splitHsAppTys (L _ (HsAppTy f a)) as = splitHsAppTys f (a:as)
splitHsAppTys (L _ (HsParTy f)) as = splitHsAppTys f as
splitHsAppTys f as = (f,as)
--------------------------------
splitLHsPatSynTy :: LHsType name
-> ( [LHsTyVarBndr name] -- universals
, LHsContext name -- required constraints
, [LHsTyVarBndr name] -- existentials
, LHsContext name -- provided constraints
, LHsType name) -- body type
splitLHsPatSynTy ty = (univs, reqs, exis, provs, ty4)
where
(univs, ty1) = splitLHsForAllTy ty
(reqs, ty2) = splitLHsQualTy ty1
(exis, ty3) = splitLHsForAllTy ty2
(provs, ty4) = splitLHsQualTy ty3
splitLHsSigmaTy :: LHsType name -> ([LHsTyVarBndr name], LHsContext name, LHsType name)
splitLHsSigmaTy ty
| (tvs, ty1) <- splitLHsForAllTy ty
, (ctxt, ty2) <- splitLHsQualTy ty1
= (tvs, ctxt, ty2)
splitLHsForAllTy :: LHsType name -> ([LHsTyVarBndr name], LHsType name)
splitLHsForAllTy (L _ (HsForAllTy { hst_bndrs = tvs, hst_body = body })) = (tvs, body)
splitLHsForAllTy body = ([], body)
splitLHsQualTy :: LHsType name -> (LHsContext name, LHsType name)
splitLHsQualTy (L _ (HsQualTy { hst_ctxt = ctxt, hst_body = body })) = (ctxt, body)
splitLHsQualTy body = (noLoc [], body)
splitLHsInstDeclTy :: LHsSigType Name
-> ([Name], LHsContext Name, LHsType Name)
-- Split up an instance decl type, returning the pieces
splitLHsInstDeclTy (HsIB { hsib_vars = itkvs
, hsib_body = inst_ty })
| (tvs, cxt, body_ty) <- splitLHsSigmaTy inst_ty
= (itkvs ++ map hsLTyVarName tvs, cxt, body_ty)
-- Return implicitly bound type and kind vars
-- For an instance decl, all of them are in scope
where
getLHsInstDeclHead :: LHsSigType name -> LHsType name
getLHsInstDeclHead inst_ty
| (_tvs, _cxt, body_ty) <- splitLHsSigmaTy (hsSigType inst_ty)
= body_ty
getLHsInstDeclClass_maybe :: LHsSigType name -> Maybe (Located name)
-- Works on (HsSigType RdrName)
getLHsInstDeclClass_maybe inst_ty
= do { let head_ty = getLHsInstDeclHead inst_ty
; (cls, _) <- hsTyGetAppHead_maybe head_ty
; return cls }
{-
************************************************************************
* *
FieldOcc
* *
************************************************************************
-}
type LFieldOcc name = Located (FieldOcc name)
-- | Represents an *occurrence* of an unambiguous field. We store
-- both the 'RdrName' the user originally wrote, and after the
-- renamer, the selector function.
data FieldOcc name = FieldOcc { rdrNameFieldOcc :: Located RdrName
-- ^ See Note [Located RdrNames] in HsExpr
, selectorFieldOcc :: PostRn name name
}
deriving instance Eq (PostRn name name) => Eq (FieldOcc name)
deriving instance Ord (PostRn name name) => Ord (FieldOcc name)
deriving instance (Data name, Data (PostRn name name)) => Data (FieldOcc name)
instance Outputable (FieldOcc name) where
ppr = ppr . rdrNameFieldOcc
mkFieldOcc :: Located RdrName -> FieldOcc RdrName
mkFieldOcc rdr = FieldOcc rdr PlaceHolder
-- | Represents an *occurrence* of a field that is potentially
-- ambiguous after the renamer, with the ambiguity resolved by the
-- typechecker. We always store the 'RdrName' that the user
-- originally wrote, and store the selector function after the renamer
-- (for unambiguous occurrences) or the typechecker (for ambiguous
-- occurrences).
--
-- See Note [HsRecField and HsRecUpdField] in HsPat and
-- Note [Disambiguating record fields] in TcExpr.
-- See Note [Located RdrNames] in HsExpr
data AmbiguousFieldOcc name
= Unambiguous (Located RdrName) (PostRn name name)
| Ambiguous (Located RdrName) (PostTc name name)
deriving instance ( Data name
, Data (PostRn name name)
, Data (PostTc name name))
=> Data (AmbiguousFieldOcc name)
instance Outputable (AmbiguousFieldOcc name) where
ppr = ppr . rdrNameAmbiguousFieldOcc
instance OutputableBndr (AmbiguousFieldOcc name) where
pprInfixOcc = pprInfixOcc . rdrNameAmbiguousFieldOcc
pprPrefixOcc = pprPrefixOcc . rdrNameAmbiguousFieldOcc
mkAmbiguousFieldOcc :: Located RdrName -> AmbiguousFieldOcc RdrName
mkAmbiguousFieldOcc rdr = Unambiguous rdr PlaceHolder
rdrNameAmbiguousFieldOcc :: AmbiguousFieldOcc name -> RdrName
rdrNameAmbiguousFieldOcc (Unambiguous (L _ rdr) _) = rdr
rdrNameAmbiguousFieldOcc (Ambiguous (L _ rdr) _) = rdr
selectorAmbiguousFieldOcc :: AmbiguousFieldOcc Id -> Id
selectorAmbiguousFieldOcc (Unambiguous _ sel) = sel
selectorAmbiguousFieldOcc (Ambiguous _ sel) = sel
unambiguousFieldOcc :: AmbiguousFieldOcc Id -> FieldOcc Id
unambiguousFieldOcc (Unambiguous rdr sel) = FieldOcc rdr sel
unambiguousFieldOcc (Ambiguous rdr sel) = FieldOcc rdr sel
ambiguousFieldOcc :: FieldOcc name -> AmbiguousFieldOcc name
ambiguousFieldOcc (FieldOcc rdr sel) = Unambiguous rdr sel
{-
************************************************************************
* *
\subsection{Pretty printing}
* *
************************************************************************
-}
instance (OutputableBndr name) => Outputable (HsType name) where
ppr ty = pprHsType ty
instance Outputable HsTyLit where
ppr = ppr_tylit
instance (OutputableBndr name) => Outputable (LHsQTyVars name) where
ppr (HsQTvs { hsq_explicit = tvs }) = interppSP tvs
instance (OutputableBndr name) => Outputable (HsTyVarBndr name) where
ppr (UserTyVar n) = ppr n
ppr (KindedTyVar n k) = parens $ hsep [ppr n, dcolon, ppr k]
instance (Outputable thing) => Outputable (HsImplicitBndrs name thing) where
ppr (HsIB { hsib_body = ty }) = ppr ty
instance (Outputable thing) => Outputable (HsWildCardBndrs name thing) where
ppr (HsWC { hswc_body = ty }) = ppr ty
instance Outputable (HsWildCardInfo name) where
ppr (AnonWildCard _) = char '_'
pprHsForAll :: OutputableBndr name => [LHsTyVarBndr name] -> LHsContext name -> SDoc
pprHsForAll = pprHsForAllExtra Nothing
-- | Version of 'pprHsForAll' that can also print an extra-constraints
-- wildcard, e.g. @_ => a -> Bool@ or @(Show a, _) => a -> String@. This
-- underscore will be printed when the 'Maybe SrcSpan' argument is a 'Just'
-- containing the location of the extra-constraints wildcard. A special
-- function for this is needed, as the extra-constraints wildcard is removed
-- from the actual context and type, and stored in a separate field, thus just
-- printing the type will not print the extra-constraints wildcard.
pprHsForAllExtra :: OutputableBndr name => Maybe SrcSpan -> [LHsTyVarBndr name] -> LHsContext name -> SDoc
pprHsForAllExtra extra qtvs cxt
= pprHsForAllTvs qtvs <+> pprHsContextExtra show_extra (unLoc cxt)
where
show_extra = isJust extra
pprHsForAllTvs :: OutputableBndr name => [LHsTyVarBndr name] -> SDoc
pprHsForAllTvs qtvs
| show_forall = forAllLit <+> interppSP qtvs <> dot
| otherwise = empty
where
show_forall = opt_PprStyle_Debug || not (null qtvs)
pprHsContext :: (OutputableBndr name) => HsContext name -> SDoc
pprHsContext = maybe empty (<+> darrow) . pprHsContextMaybe
pprHsContextNoArrow :: (OutputableBndr name) => HsContext name -> SDoc
pprHsContextNoArrow = fromMaybe empty . pprHsContextMaybe
pprHsContextMaybe :: (OutputableBndr name) => HsContext name -> Maybe SDoc
pprHsContextMaybe [] = Nothing
pprHsContextMaybe [L _ pred] = Just $ ppr_mono_ty FunPrec pred
pprHsContextMaybe cxt = Just $ parens (interpp'SP cxt)
-- True <=> print an extra-constraints wildcard, e.g. @(Show a, _) =>@
pprHsContextExtra :: (OutputableBndr name) => Bool -> HsContext name -> SDoc
pprHsContextExtra show_extra ctxt
| not show_extra
= pprHsContext ctxt
| null ctxt
= char '_' <+> darrow
| otherwise
= parens (sep (punctuate comma ctxt')) <+> darrow
where
ctxt' = map ppr ctxt ++ [char '_']
pprConDeclFields :: OutputableBndr name => [LConDeclField name] -> SDoc
pprConDeclFields fields = braces (sep (punctuate comma (map ppr_fld fields)))
where
ppr_fld (L _ (ConDeclField { cd_fld_names = ns, cd_fld_type = ty,
cd_fld_doc = doc }))
= ppr_names ns <+> dcolon <+> ppr ty <+> ppr_mbDoc doc
ppr_names [n] = ppr n
ppr_names ns = sep (punctuate comma (map ppr ns))
{-
Note [Printing KindedTyVars]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Trac #3830 reminded me that we should really only print the kind
signature on a KindedTyVar if the kind signature was put there by the
programmer. During kind inference GHC now adds a PostTcKind to UserTyVars,
rather than converting to KindedTyVars as before.
(As it happens, the message in #3830 comes out a different way now,
and the problem doesn't show up; but having the flag on a KindedTyVar
seems like the Right Thing anyway.)
-}
-- Printing works more-or-less as for Types
pprHsType, pprParendHsType :: (OutputableBndr name) => HsType name -> SDoc
pprHsType ty = ppr_mono_ty TopPrec (prepare ty)
pprParendHsType ty = ppr_mono_ty TyConPrec ty
-- Before printing a type, remove outermost HsParTy parens
prepare :: HsType name -> HsType name
prepare (HsParTy ty) = prepare (unLoc ty)
prepare (HsAppsTy [L _ (HsAppPrefix (L _ ty))]) = prepare ty
prepare ty = ty
ppr_mono_lty :: (OutputableBndr name) => TyPrec -> LHsType name -> SDoc
ppr_mono_lty ctxt_prec ty = ppr_mono_ty ctxt_prec (unLoc ty)
ppr_mono_ty :: (OutputableBndr name) => TyPrec -> HsType name -> SDoc
ppr_mono_ty ctxt_prec (HsForAllTy { hst_bndrs = tvs, hst_body = ty })
= maybeParen ctxt_prec FunPrec $
sep [pprHsForAllTvs tvs, ppr_mono_lty TopPrec ty]
ppr_mono_ty ctxt_prec (HsQualTy { hst_ctxt = L _ ctxt, hst_body = ty })
= maybeParen ctxt_prec FunPrec $
sep [pprHsContext ctxt, ppr_mono_lty TopPrec ty]
ppr_mono_ty _ (HsBangTy b ty) = ppr b <> ppr_mono_lty TyConPrec ty
ppr_mono_ty _ (HsRecTy flds) = pprConDeclFields flds
ppr_mono_ty _ (HsTyVar (L _ name))= pprPrefixOcc name
ppr_mono_ty prec (HsFunTy ty1 ty2) = ppr_fun_ty prec ty1 ty2
ppr_mono_ty _ (HsTupleTy con tys) = tupleParens std_con (pprWithCommas ppr tys)
where std_con = case con of
HsUnboxedTuple -> UnboxedTuple
_ -> BoxedTuple
ppr_mono_ty _ (HsKindSig ty kind) = parens (ppr_mono_lty TopPrec ty <+> dcolon <+> ppr kind)
ppr_mono_ty _ (HsListTy ty) = brackets (ppr_mono_lty TopPrec ty)
ppr_mono_ty _ (HsPArrTy ty) = paBrackets (ppr_mono_lty TopPrec ty)
ppr_mono_ty prec (HsIParamTy n ty) = maybeParen prec FunPrec (ppr n <+> dcolon <+> ppr_mono_lty TopPrec ty)
ppr_mono_ty _ (HsSpliceTy s _) = pprSplice s
ppr_mono_ty _ (HsCoreTy ty) = ppr ty
ppr_mono_ty _ (HsExplicitListTy _ tys) = quote $ brackets (interpp'SP tys)
ppr_mono_ty _ (HsExplicitTupleTy _ tys) = quote $ parens (interpp'SP tys)
ppr_mono_ty _ (HsTyLit t) = ppr_tylit t
ppr_mono_ty _ (HsWildCardTy (AnonWildCard _)) = char '_'
ppr_mono_ty ctxt_prec (HsEqTy ty1 ty2)
= maybeParen ctxt_prec TyOpPrec $
ppr_mono_lty TyOpPrec ty1 <+> char '~' <+> ppr_mono_lty TyOpPrec ty2
ppr_mono_ty ctxt_prec (HsAppsTy tys)
= maybeParen ctxt_prec TyConPrec $
hsep (map (ppr_app_ty TopPrec . unLoc) tys)
ppr_mono_ty ctxt_prec (HsAppTy fun_ty arg_ty)
= maybeParen ctxt_prec TyConPrec $
hsep [ppr_mono_lty FunPrec fun_ty, ppr_mono_lty TyConPrec arg_ty]
ppr_mono_ty ctxt_prec (HsOpTy ty1 (L _ op) ty2)
= maybeParen ctxt_prec TyOpPrec $
sep [ ppr_mono_lty TyOpPrec ty1
, sep [pprInfixOcc op, ppr_mono_lty TyOpPrec ty2 ] ]
ppr_mono_ty _ (HsParTy ty)
= parens (ppr_mono_lty TopPrec ty)
-- Put the parens in where the user did
-- But we still use the precedence stuff to add parens because
-- toHsType doesn't put in any HsParTys, so we may still need them
ppr_mono_ty ctxt_prec (HsDocTy ty doc)
= maybeParen ctxt_prec TyOpPrec $
ppr_mono_lty TyOpPrec ty <+> ppr (unLoc doc)
-- we pretty print Haddock comments on types as if they were
-- postfix operators
--------------------------
ppr_fun_ty :: (OutputableBndr name) => TyPrec -> LHsType name -> LHsType name -> SDoc
ppr_fun_ty ctxt_prec ty1 ty2
= let p1 = ppr_mono_lty FunPrec ty1
p2 = ppr_mono_lty TopPrec ty2
in
maybeParen ctxt_prec FunPrec $
sep [p1, text "->" <+> p2]
--------------------------
ppr_app_ty :: OutputableBndr name => TyPrec -> HsAppType name -> SDoc
ppr_app_ty _ (HsAppInfix (L _ n)) = pprInfixOcc n
ppr_app_ty _ (HsAppPrefix (L _ (HsTyVar (L _ n)))) = pprPrefixOcc n
ppr_app_ty ctxt (HsAppPrefix ty) = ppr_mono_lty ctxt ty
--------------------------
ppr_tylit :: HsTyLit -> SDoc
ppr_tylit (HsNumTy _ i) = integer i
ppr_tylit (HsStrTy _ s) = text (show s)
| vikraman/ghc | compiler/hsSyn/HsTypes.hs | bsd-3-clause | 51,142 | 1 | 17 | 13,131 | 8,516 | 4,577 | 3,939 | 536 | 7 |
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DoAndIfThenElse #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE ScopedTypeVariables #-}
--------------------------------------------------------------------------------
-- |
-- Module : DagSimple
-- Copyright : (c) 2014 Patrick Bahr, Emil Axelsson
-- License : BSD3
-- Maintainer : Patrick Bahr <[email protected]>
-- Stability : experimental
-- Portability : non-portable (GHC Extensions)
--
-- This module implements a naive representation of directed acyclic
-- graphs (DAGs) as compact representations of trees (or 'Tree's).
--
--------------------------------------------------------------------------------
module DagSimple
( Dag
, termTree
, reifyDag
, unravelDag
, toSimple
, fromSimple
) where
import Control.Applicative
import Control.Monad.State
import DagSimple.Internal
import Tree
import qualified Dag
import qualified Dag.Internal as Dag
import Data.Foldable (Foldable)
import qualified Data.Foldable as Foldable (toList)
import qualified Data.HashMap.Lazy as HashMap
import Data.IntMap
import qualified Data.IntMap as IntMap
import Data.Traversable (Traversable)
import qualified Data.Traversable as Traversable
import System.Mem.StableName
import Control.Monad.Writer
import Data.HashMap.Lazy (HashMap)
import Data.List
import Safe
-- | Internal function used to lookup the nodes in a dag. It assumes
-- a node of a dag that is either the root node or a target node of
-- one of the edges. The implementation of this function makes use of
-- the invariant that each such node must also be in the domain of the
-- IntMap of the dag.
lookupNode :: Node -> IntMap (f Node) -> f Node
lookupNode n imap = fromJustNote "edge leading to an undefined node" $ IntMap.lookup n imap
eqF :: (Eq (f ()), Functor f) => f a -> f b -> Bool
eqF s t = (() <$ s) == (() <$ t)
{-| This function implements equality of values of type @f a@ modulo
the equality of @a@ itself. If two functorial values are equal in this
sense, 'eqMod' returns a 'Just' value containing a list of pairs
consisting of corresponding components of the two functorial
values. -}
eqMod :: (Eq (f ()), Functor f, Foldable f) => f a -> f b -> Maybe [(a,b)]
eqMod s t
| s `eqF` t = Just args
| otherwise = Nothing
where args = Foldable.toList s `zip` Foldable.toList t
instance (Show (f String), Functor f) => Show (Dag f)
where
show (Dag r es _) = unwords
[ "mkDag"
, show r
, showLst ["(" ++ show n ++ "," ++ show (fmap show f) ++ ")" | (n,f) <- IntMap.toList es ]
]
where
showLst ss = "[" ++ intercalate "," ss ++ "]"
-- | Turn a term into a graph without sharing.
termTree :: Traversable f => Tree f -> Dag f
termTree t = Dag 0 imap nx
where (imap,nx) = runState (liftM snd $ runWriterT $ build t) 0
build :: Traversable f => Tree f -> WriterT (IntMap (f Node)) (State Node) Node
build (In t) = do n <- get
put (n+1)
res <- Traversable.mapM build t
tell $ IntMap.singleton n res
return n
-- | This function takes a term, and returns a 'Dag' with the
-- implicit sharing of the input data structure made explicit.
reifyDag :: Traversable f => Tree f -> IO (Dag f)
reifyDag m = do (root, state) <- runStateT (findNodes m) init
return (Dag root (rsEqs state) (rsNext state))
where init = ReifyState
{ rsStable = HashMap.empty
, rsEqs = IntMap.empty
, rsNext = 0 }
data ReifyState f = ReifyState
{ rsStable :: HashMap (StableName (f (Tree f))) Node
, rsEqs :: IntMap (f Node)
, rsNext :: Node
}
findNodes :: Traversable f => Tree f -> StateT (ReifyState f) IO Node
findNodes (In !j) = do
st <- liftIO $ makeStableName j
tab <- liftM rsStable get
case HashMap.lookup st tab of
Just var -> return $ var
Nothing -> do var <- liftM rsNext get
modify (\s -> s{ rsNext = var + 1
, rsStable = HashMap.insert st var tab})
res <- Traversable.mapM findNodes j
modify (\s -> s { rsEqs = IntMap.insert var res (rsEqs s)})
return var
-- | This function unravels a given graph to the term it
-- represents.
unravelDag :: forall f. Functor f => Dag f -> Tree f
unravelDag g = build (root g)
where build :: Node -> Tree f
build n = In $ fmap build $ lookupNode n (edges g)
toSimple :: Traversable f => Dag.Dag f -> Dag f
toSimple dag = Dag count (IntMap.insert count root edges) (count + 1)
where (root, edges, count) = Dag.flatten dag
-- | Conversion from a simple 'Dag'. The resulting 'Dag.Dag' has a single node
-- in each tree segment.
fromSimple :: Traversable f => Dag f -> Dag.Dag f
fromSimple dag = Dag.Dag r es' (nodeCount dag)
where
es = fmap (fmap Ret) $ edges dag
es' = IntMap.delete (root dag) es
r = es IntMap.! root dag
-- | Checks whether two dags are bisimilar. In particular, we have
-- the following equality
--
-- @
-- bisim g1 g2 = (unravel g1 == unravel g2)
-- @
--
-- That is, two dags are bisimilar iff they have the same unravelling.
-- TODO implement
-- bisim :: forall f . (Eq (f ()), Functor f, Foldable f) => Dag f -> Dag f -> Bool
-- bisim Dag {root=r1,edges=e1} Dag {root=r2,edges=e2} = runF r1 r2
-- where run :: (Free f Node, Free f Node) -> Bool
-- run (t1, t2) = runF (step e1 t1) (step e2 t2)
-- step :: Edges f -> Free f Node -> f (Free f Node)
-- step e (Ret n) = e IntMap.! n
-- step _ (In t) = t
-- runF :: f (Free f Node) -> f (Free f Node) -> Bool
-- runF f1 f2 = case eqMod f1 f2 of
-- Nothing -> False
-- Just l -> all run l
-- | Checks whether the two given DAGs are isomorphic.
-- iso :: (Traversable f, Foldable f, Eq (f ())) => Dag f -> Dag f -> Bool
-- iso g1 g2 = checkIso eqMod (flatten g1) (flatten g2)
-- | Checks whether the two given DAGs are strongly isomorphic, i.e.
-- their internal representation is the same modulo renaming of
-- nodes.
-- strongIso :: (Functor f, Foldable f, Eq (f (Free f ()))) => Dag f -> Dag f -> Bool
-- strongIso Dag {root=r1,edges=e1,nodeCount=nx1}
-- Dag {root=r2,edges=e2,nodeCount=nx2}
-- = checkIso checkEq (r1,e1,nx1) (r2,e2,nx2)
-- where checkEq t1 t2 = eqMod (In t1) (In t2)
| emilaxelsson/ag-graph | src/DagSimple.hs | bsd-3-clause | 6,757 | 0 | 19 | 1,853 | 1,450 | 771 | 679 | 92 | 2 |
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE TemplateHaskell #-}
--------------------------------------------------------------------------------
-- |
-- Module : Life.Simulation
-- Copyright : (C) 2013 Sam Fredrickson
-- License : BSD-style (see "LICENSE" file)
-- Maintainer : Sam Fredrickson <[email protected]>
-- Stability : experimental
-- Portability : GHC
--
-- Simulate the model from Life.Model by some timestep.
--------------------------------------------------------------------------------
module Life.Simulation (initialModel, stepModel) where
import Control.Applicative
import Control.Arrow
import Control.Lens
import Control.Monad.Reader
import Control.Monad.State
import Graphics.Gloss.Interface.Pure.Simulate (ViewPort)
import Life.Model
import qualified Data.Set as Set
-- The simulation takes in the initial model and time delta as inputs.
-- Organisms use this initial model to make decisions.
type Config = (Model, Float)
-- State to keep track of while performing a step.
data SimState = SimState { _unprocessed :: Set.Set Object
, _removed :: Set.Set Object
, _processed :: Set.Set Object
}
makeLenses ''SimState
newtype Simulation a = Simulation {
runSimulation :: ReaderT Config (State SimState) a
} deriving (Functor, Applicative, Monad,
MonadReader Config, MonadState SimState)
process :: Object -> Simulation Object
process o = do
if isFood o
then return o
else do (_, d) <- ask
return $ o & (position +~ ((d,d) * (o ^. velocity)))
& (energy -~ (d * (o ^. metabolism)))
simulation :: Simulation ()
simulation = do
finished <- Set.null <$> use unprocessed
if finished
then return ()
else do (o, unprocessed') <- Set.deleteFindMin <$> use unprocessed
unprocessed .= unprocessed'
beenRemoved <- Set.member o <$> use removed
when (not beenRemoved) $ do
o' <- process o
processed' <- Set.insert o' <$> use processed
processed .= processed'
simulation
initialModel :: Model
initialModel = Set.fromList [
Food 0 (100, 100) 20 10
, Food 1 (-25, -75) 20 10
, Organism 2 (0,0) (10, 10) 10 100 10 Male
]
stepModel :: ViewPort -> Float -> Model -> Model
stepModel _ d m =
let cfg = (m,d)
st = SimState m Set.empty Set.empty
runS = runSimulation >>> runReaderT
(_, st') = runState (runS simulation cfg) st
in Set.difference (st' ^. processed) (st' ^. removed)
| kinghajj/Life | src/Life/Simulation.hs | bsd-3-clause | 2,618 | 0 | 17 | 662 | 664 | 360 | 304 | 52 | 2 |
-- | Export Module for SSTG.Core.Preprocessing
module SSTG.Core.Preprocessing
( module SSTG.Core.Preprocessing.Defunctionalization
) where
import SSTG.Core.Preprocessing.Defunctionalization
| AntonXue/SSTG | src/SSTG/Core/Preprocessing.hs | bsd-3-clause | 200 | 0 | 5 | 25 | 25 | 18 | 7 | 3 | 0 |
module Main where
import Data.Version (showVersion)
import Git.Freq
import Options.Applicative
import qualified Paths_git_freq (version)
filePaths :: Parser [FilePath]
filePaths = many (argument str (metavar "PATH..." <> help "Target paths"))
version :: Parser (a -> a)
version = infoOption (showVersion Paths_git_freq.version)
( short 'v'
<> long "version"
<> help "Print version information" )
main :: IO ()
main = execParser opts >>= freq
where
opts = info (helper <*> version <*> filePaths)
( fullDesc
<> progDesc (unlines [ "Total addition, deletion per file will be shown as a csv in following format:"
, "`file name, addition, deletion`"
])
<> header "git-freq - Show frequently changed code in a repository")
| fujimura/git-freq | src/Main.hs | bsd-3-clause | 850 | 0 | 14 | 241 | 200 | 105 | 95 | 19 | 1 |
{-# LANGUAGE Rank2Types, ViewPatterns, TypeFamilies, DeriveFunctor, GeneralizedNewtypeDeriving #-}
module Data.Graphics.Scene
( -- * Scene
Rendering(..)
, Intensive(..)
, VFX(..)
, vfx
, withVertices
, drawPrimitive
, applyMatrix
, vertices
, foggy
, embedIO
, Scene(..)
-- * Picture
, Picture(..)
, opacity
, bitmap
, toward
) where
import qualified Data.Graphics.Bitmap as B
import Linear
import qualified Data.Vector.Storable as V
import Control.Lens
import Data.Graphics.Class
import Data.Graphics.Vertex
import qualified Codec.Picture as C
bitmap :: B.Bitmap -> Picture
bitmap bmp = Picture $ Scene $ vertices bmp TriangleStrip vx
where
V2 w h = fmap fromIntegral $ B.size bmp
vx = V.fromList [V3 (-w/2) (-h/2) 0 `positionUV` V2 0 0
, V3 (w/2) (-h/2) 0 `positionUV` V2 1 0
, V3 (-w/2) (h/2) 0 `positionUV` V2 0 1
, V3 (w/2) (h/2) 0 `positionUV` V2 1 1]
toward :: Vec3 -> Picture -> Scene
toward n@((^/norm n) -> V3 x y z) (Picture (Scene s)) = Scene $ applyMatrix
(m33_to_m44 $ fromQuaternion $ axisAngle (V3 (-y) x 0) $ acos $ z / norm n)
s
newtype Rendering s = Rendering { runRendering :: forall r. Monoid r => Intensive s r -> (VFX s r -> r) -> r }
data Intensive s r = Intensive !(C.Image C.PixelRGBA8 -> Int -> s -> r) !(s -> r) !(M44 Float -> r -> r)
data VFX s r = Diffuse !(V4 Float) r
| WithVertices !PrimitiveMode !(V.Vector Vertex) (s -> r)
| Foggy !Float !(V4 Float) r
| EmbedIO (IO r)
deriving Functor
newtype Scene = Scene { unScene :: forall s. Rendering s }
vfx :: VFX s (Rendering s) -> Rendering s
vfx v = Rendering $ \i t -> t (fmap (\r -> runRendering r i t) v)
{-# INLINE vfx #-}
withVertices :: PrimitiveMode -> V.Vector Vertex -> (s -> Rendering s) -> Rendering s
withVertices m v c = vfx $ WithVertices m v c
{-# INLINE withVertices #-}
drawPrimitive :: B.Bitmap -> s -> Rendering s
drawPrimitive (B.Bitmap b _ h) = \s -> Rendering $ \(Intensive f _ _) _ -> f b h s
drawPrimitive B.Blank = \s -> Rendering $ \(Intensive _ g _) _ -> g s
{-# INLINE drawPrimitive #-}
applyMatrix :: M44 Float -> Rendering s -> Rendering s
applyMatrix m r = Rendering $ \i@(Intensive _ _ k) v -> k m (runRendering r i v)
{-# INLINE applyMatrix #-}
vertices :: B.Bitmap -> PrimitiveMode -> V.Vector Vertex -> Rendering s
vertices b m v = withVertices m v $ drawPrimitive b
{-# INLINE vertices #-}
embedIO :: IO (Rendering s) -> Rendering s
embedIO = vfx . EmbedIO
foggy :: Float -> V4 Float -> Rendering s -> Rendering s
foggy d col = vfx . Foggy d col
instance Affine (Rendering s) where
type Vec (Rendering s) = V3 Float
type Normal (Rendering s) = V3 Float
rotateOn v = applyMatrix (m33_to_m44 $ fromQuaternion $ axisAngle v (norm v))
{-# INLINE rotateOn #-}
scale (V3 x y z) = applyMatrix (scaled (V4 x y z 1))
{-# INLINE scale #-}
translate (V3 x y z) = applyMatrix $ V4 (V4 1 0 0 x) (V4 0 1 0 y) (V4 0 0 1 z) (V4 0 0 0 1)
{-# INLINE translate #-}
instance Monoid (Rendering s) where
mempty = Rendering mempty
{-# INLINE mempty #-}
mappend (Rendering a) (Rendering b) = Rendering (mappend a b)
{-# INLINE mappend #-}
instance Affine Scene where
type Vec Scene = V3 Float
type Normal Scene = V3 Float
rotateOn v (Scene s) = Scene $ rotateOn v s
scale v (Scene s) = Scene $ scale v s
translate v (Scene s) = Scene $ translate v s
{-# INLINE translate #-}
instance Figure Scene where
primitive m vs = Scene $ vertices B.Blank m $ V.fromList $ map positionOnly vs
color col (Scene s) = Scene $ vfx (Diffuse col s)
line = primitive LineStrip
polygon = primitive TriangleFan
polygonOutline = primitive LineLoop
circle v = toward v $ circle $ norm v
circleOutline v = toward v $ circleOutline $ norm v
unit_circle :: Int -> [V2 Float]
unit_circle n = map angle [0,2*pi/fromIntegral n..2*pi]
instance Monoid Scene where
mempty = Scene mempty
{-# INLINE mempty #-}
mappend (Scene x) (Scene y) = Scene (mappend x y)
{-# INLINE mappend #-}
v2ToV3 :: Num a => V2 a -> V3 a
v2ToV3 (V2 x y) = V3 x y 0
newtype Picture = Picture { unPicture :: Scene } deriving Monoid
instance Affine Picture where
type Vec Picture = V2 Float
type Normal Picture = Float
rotateOn t (Picture (Scene s)) = Picture $ Scene $ applyMatrix m s where
m = V4 (V4 (cos t) (-sin t) 0 0) (V4 (sin t) (cos t) 0 0) (V4 0 0 1 0) (V4 0 0 0 1)
translate (V2 x y) (Picture (Scene s)) = Picture $ Scene $ applyMatrix (translation .~ V3 x y 0 $ identity) s
scale (V2 x y) (Picture (Scene s)) = Picture $ Scene $ applyMatrix m s where
m = V4 (V4 x 0 0 0) (V4 0 y 0 0) (V4 0 0 1 0) (V4 0 0 0 1)
instance Figure Picture where
primitive m v = Picture $ primitive m $ map v2ToV3 v
color col (Picture s) = Picture (color col s)
line = primitive LineStrip
polygon = primitive TriangleFan
polygonOutline = primitive LineLoop
circle r = polygon $ map (^*r) $ unit_circle 33
circleOutline r = polygonOutline $ map (^*r) $ unit_circle 33
| fumieval/audiovisual | src/Data/Graphics/Scene.hs | bsd-3-clause | 4,987 | 1 | 16 | 1,125 | 2,232 | 1,150 | 1,082 | 135 | 1 |
-- | An implementation of the International Geomagnetic Reference Field, as defined at <http://www.ngdc.noaa.gov/IAGA/vmod/igrf.html>.
module IGRF
(
MagneticModel(..)
, igrf11
, igrf12
, igrf13
, fieldAtTime
, evaluateModelGradientInLocalTangentPlane
)
where
import Data.VectorSpace
import Math.SphericalHarmonics
-- | Represents a spherical harmonic model of a magnetic field.
data MagneticModel a = MagneticModel
{
fieldAtEpoch :: SphericalHarmonicModel a -- ^ Field at model epoch in nT, reference radius in km
, secularVariation :: SphericalHarmonicModel a -- ^ Secular variation in nT / yr, reference radius in km
}
-- | Gets a spherical harmonic model of a magnetic field at a specified time offset from the model epoch.
fieldAtTime :: (Fractional a, Eq a) => MagneticModel a -- ^ Magnetic field model
-> a -- ^ Time since model epoch (year)
-> SphericalHarmonicModel a -- ^ Spherical harmonic model of magnetic field at specified time. Field in nT, reference radius in km
fieldAtTime m t = (fieldAtEpoch m) ^+^ (t *^ secularVariation m)
-- | The International Geomagnetic Reference Field model, 11th edition.
-- Model epoch is January 1st, 2010.
igrf11 :: (Fractional a) => MagneticModel a
igrf11 = MagneticModel
{
fieldAtEpoch = f
, secularVariation = s
}
where
f = scaledSphericalHarmonicModel r fcs
fcs = [[(0, 0)],
[(-29496.5, 0), (-1585.9, 4945.1)],
[(-2396.6, 0), (3026.0, -2707.7), (1668.6, -575.4)],
[(1339.7, 0), (-2326.3, -160.5), (1231.7, 251.7), (634.2, -536.8)],
[(912.6, 0), (809.0, 286.5), (166.6, -211.2), (-357.1, 164.4), (89.7, -309.2)],
[(-231.1, 0), (357.2, 44.7), (200.3, 188.9), (-141.2, -118.1), (-163.1, 0.1), (-7.7, 100.9)],
[(72.8, 0), (68.6, -20.8), (76.0, 44.2), (-141.4, 61.5), (-22.9, -66.3), (13.1, 3.1), (-77.9, 54.9)],
[(80.4, 0), (-75.0, -57.8), (-4.7, -21.2), (45.3, 6.6), (14.0, 24.9), (10.4, 7.0), (1.6, -27.7), (4.9, -3.4)],
[(24.3, 0), (8.2, 10.9), (-14.5, -20.0), (-5.7, 11.9), (-19.3, -17.4), (11.6, 16.7), (10.9, 7.1), (-14.1, -10.8), (-3.7, 1.7)],
[(5.4, 0), (9.4, -20.5), (3.4, 11.6), (-5.3, 12.8), (3.1, -7.2), (-12.4, -7.4), (-0.8, 8.0), (8.4, 2.2), (-8.4, -6.1), (-10.1, 7.0)],
[(-2.0, 0), (-6.3, 2.8), (0.9, -0.1), (-1.1, 4.7), (-0.2, 4.4), (2.5, -7.2), (-0.3, -1.0), (2.2, -4.0), (3.1, -2.0), (-1.0, -2.0), (-2.8, -8.3)],
[(3.0, 0), (-1.5, 0.1), (-2.1, 1.7), (1.6, -0.6), (-0.5, -1.8), (0.5, 0.9), (-0.8, -0.4), (0.4, -2.5), (1.8, -1.3), (0.2, -2.1), (0.8, -1.9), (3.8, -1.8)],
[(-2.1, 0), (-0.2, -0.8), (0.3, 0.3), (1.0, 2.2), (-0.7, -2.5), (0.9, 0.5), (-0.1, 0.6), (0.5, 0.0), (-0.4, 0.1), (-0.4, 0.3), (0.2, -0.9), (-0.8, -0.2), (0.0, 0.8)],
[(-0.2, 0), (-0.9, -0.8), (0.3, 0.3), (0.4, 1.7), (-0.4, -0.6), (1.1, -1.2), (-0.3, -0.1), (0.8, 0.5), (-0.2, 0.1), (0.4, 0.5), (0.0, 0.4), (0.4, -0.2), (-0.3, -0.5), (-0.3, -0.8)]
]
s = scaledSphericalHarmonicModel r scs
scs = [[(0, 0)],
[(11.4, 0), (16.7, -28.8)],
[(-11.3, 0), (-3.9, -23.0), (2.7, -12.9)],
[(1.3, 0), (-3.9, 8.6), (-2.9, -2.9), (-8.1, -2.1)],
[(-1.4, 0), (2.0, 0.4), (-8.9, 3.2), (4.4, 3.6), (-2.3, -0.8)],
[(-0.5, 0), (0.5, 0.5), (-1.5, 1.5), (-0.7, 0.9), (1.3, 3.7), (1.4, -0.6)],
[(-0.3, 0), (-0.3, -0.1), (-0.3, -2.1), (1.9, -0.4), (-1.6, -0.5), (-0.2, 0.8), (1.8, 0.5)],
[(0.2, 0), (-0.1, 0.6), (-0.6, 0.3), (1.4, -0.2), (0.3, -0.1), (0.1, -0.8), (-0.8, -0.3), (0.4, 0.2)],
[(-0.1, 0), (0.1, 0.0), (-0.5, 0.2), (0.3, 0.5), (-0.3, 0.4), (0.3, 0.1), (0.2, -0.1), (-0.5, 0.4), (0.2, 0.4)]
]
r = 6371.2
-- | The International Geomagnetic Reference Field model, 12th edition.
-- Model epoch is January 1st, 2015.
igrf12 :: (Fractional a) => MagneticModel a
igrf12 = MagneticModel
{
fieldAtEpoch = f,
secularVariation = s
}
where
f = scaledSphericalHarmonicModel r fcs
fcs = [[(0, 0)],
[(-29442.0, 0), (-1501.0, 4797.1)],
[(-2445.1, 0), (3012.9, -2845.6), (1676.7, -641.9)],
[(1350.7, 0), (-2352.3, -115.3), (1225.6, 244.9), (582.0, -538.4)],
[(907.6, 0), (813.7, 283.3), (120.4, -188.7), (-334.9, 180.9), (70.4, -329.5)],
[(-232.6, 0), (360.1, 47.3), (192.4, 197.0), (-140.9, -119.3), (-157.5, 16.0), (4.1, 100.2)],
[(70.0, 0), (67.7, -20.8), (72.7, 33.2), (-129.9, 58.9), (-28.9, -66.7), (13.2, 7.3), (-70.9, 62.6)],
[(81.6, 0), (-76.1, -54.1), (-6.8, -19.5), (51.8, 5.7), (15.0, 24.4), (9.4, 3.4), (-2.8, -27.4), (6.8, -2.2)],
[(24.2, 0), (8.8, 10.1), (-16.9, -18.3), (-3.2, 13.3), (-20.6, -14.6), (13.4, 16.2), (11.7, 5.7), (-15.9, -9.1), (-2.0, 2.1)],
[(5.4, 0), (8.8, -21.6), (3.1, 10.8), (-3.3, 11.8), (0.7, -6.8), (-13.3, -6.9), (-0.1, 7.8), (8.7, 1.0), (-9.1, -4.0), (-10.5, 8.4)],
[(-1.9, 0), (-6.3, 3.2), (0.1, -0.4), (0.5, 4.6), (-0.5, 4.4), (1.8, -7.9), (-0.7, -0.6), (2.1, -4.2), (2.4, -2.8), (-1.8, -1.2), (-3.6, -8.7)],
[(3.1, 0), (-1.5, -0.1), (-2.3, 2.0), (2.0, -0.7), (-0.8, -1.1), (0.6, 0.8), (-0.7, -0.2), (0.2, -2.2), (1.7, -1.4), (-0.2, -2.5), (0.4, -2.0), (3.5, -2.4)],
[(-1.9, 0), (-0.2, -1.1), (0.4, 0.4), (1.2, 1.9), (-0.8, -2.2), (0.9, 0.3), (0.1, 0.7), (0.5, -0.1), (-0.3, 0.3), (-0.4, 0.2), (0.2, -0.9), (-0.9, -0.1), (0.0, 0.7)],
[(0.0, 0), (-0.9, -0.9), (0.4, 0.4), (0.5, 1.6), (-0.5, -0.5), (1.0, -1.2), (-0.2, -0.1), (0.8, 0.4), (-0.1, -0.1), (0.3, 0.4), (0.1, 0.5), (0.5, -0.3), (-0.4, -0.4), (-0.3, -0.8)]
]
s = scaledSphericalHarmonicModel r scs
scs = [[(0,0)],
[(10.3, 0), (18.1, -26.6)],
[(-8.7, 0), (-3.3, -27.4), (2.1, -14.1)],
[(3.4, 0), (-5.5, 8.2), (-0.7, -0.4), (-10.1, 1.8)],
[(-0.7, 0), (0.2, -1.3), (-9.1, 5.3), (4.1, 2.9), (-4.3, -5.2)],
[(-0.2, 0), (0.5, 0.6), (-1.3, 1.7), (-0.1, -1.2), (1.4, 3.4), (3.9, 0)],
[(-0.3, 0), (-0.1, 0), (-0.7, -2.1), (2.1, -0.7), (-1.2, 0.2), (0.3, 0.9), (1.6, 1)],
[(0.3, 0), (-0.2, 0.8), (-0.5, 0.4), (1.3, -0.2), (0.1, -0.3), (-0.6, -0.6), (-0.8, 0.1), (0.2, -0.2)],
[(0.2, 0), (0, -0.3), (-0.6, 0.3), (0.5, 0.1), (-0.2, 0.5), (0.4, -0.2), (0.1, -0.3), (-0.4, 0.3), (0.3, 0)]
]
r = 6371.2
-- | The International Geomagnetic Reference Field model, 13th edition.
-- Model epoch is January 1st, 2020.
igrf13 :: (Fractional a) => MagneticModel a
igrf13 = MagneticModel
{
fieldAtEpoch = f,
secularVariation = s
}
where
f = scaledSphericalHarmonicModel r fcs
fcs = [[(0.0,0.0)],
[(-29404.8,0.0),(-1450.9,4652.5)],
[(-2499.6,0.0),(2982.0,-2991.6),(1677.0,-734.6)],
[(1363.2,0.0),(-2381.2,-82.1),(1236.2,241.9),(525.7,-543.4)],
[(903.0,0.0),(809.5,281.9),(86.3,-158.4),(-309.4,199.7),(48.0,-349.7)],
[(-234.3,0.0),(363.2,47.7),(187.8,208.3),(-140.7,-121.2),(-151.2,32.3),(13.5,98.9)],
[(66.0,0.0),(65.5,-19.1),(72.9,25.1),(-121.5,52.8),(-36.2,-64.5),(13.5,8.9),(-64.7,68.1)],
[(80.6,0.0),(-76.7,-51.5),(-8.2,-16.9),(56.5,2.2),(15.8,23.5),(6.4,-2.2),(-7.2,-27.2),(9.8,-1.8)],
[(23.7,0.0),(9.7,8.4),(-17.6,-15.3),(-0.5,12.8),(-21.1,-11.7),(15.3,14.9),(13.7,3.6),(-16.5,-6.9),(-0.3,2.8)],
[(5.0,0.0),(8.4,-23.4),(2.9,11.0),(-1.5,9.8),(-1.1,-5.1),(-13.2,-6.3),(1.1,7.8),(8.8,0.4),(-9.3,-1.4),(-11.9,9.6)],
[(-1.9,0.0),(-6.2,3.4),(-0.1,-0.2),(1.7,3.6),(-0.9,4.8),(0.7,-8.6),(-0.9,-0.1),(1.9,-4.3),(1.4,-3.4),(-2.4,-0.1),(-3.8,-8.8)],
[(3.0,0.0),(-1.4,0.0),(-2.5,2.5),(2.3,-0.6),(-0.9,-0.4),(0.3,0.6),(-0.7,-0.2),(-0.1,-1.7),(1.4,-1.6),(-0.6,-3.0),(0.2,-2.0),(3.1,-2.6)],
[(-2.0,0.0),(-0.1,-1.2),(0.5,0.5),(1.3,1.4),(-1.2,-1.8),(0.7,0.1),(0.3,0.8),(0.5,-0.2),(-0.3,0.6),(-0.5,0.2),(0.1,-0.9),(-1.1,0.0),(-0.3,0.5)],
[(0.1,0.0),(-0.9,-0.9),(0.5,0.6),(0.7,1.4),(-0.3,-0.4),(0.8,-1.3),(0.0,-0.1),(0.8,0.3),(0.0,-0.1),(0.4,0.5),(0.1,0.5),(0.5,-0.4),(-0.5,-0.4),(-0.4,-0.6)]
]
s = scaledSphericalHarmonicModel r scs
scs = [[(0.0,0.0)],
[(5.7,0.0),(7.4,-25.9)],
[(-11.0,0.0),(-7.0,-30.2),(-2.1,-22.4)],
[(2.2,0.0),(-5.9,6.0),(3.1,-1.1),(-12.0,0.5)],
[(-1.2,0.0),(-1.6,-0.1),(-5.9,6.5),(5.2,3.6),(-5.1,-5.0)],
[(-0.3,0.0),(0.5,0.0),(-0.6,2.5),(0.2,-0.6),(1.3,3.0),(0.9,0.3)],
[(-0.5,0.0),(-0.3,0.0),(0.4,-1.6),(1.3,-1.3),(-1.4,0.8),(0.0,0.0),(0.9,1.0)],
[(-0.1,0.0),(-0.2,0.6),(0.0,0.6),(0.7,-0.8),(0.1,-0.2),(-0.5,-1.1),(-0.8,0.1),(0.8,0.3)],
[(0.0,0.0),(0.1,-0.2),(-0.1,0.6),(0.4,-0.2),(-0.1,0.5),(0.4,-0.3),(0.3,-0.4),(-0.1,0.5),(0.4,0.0)]
]
r = 6371.2
| dmcclean/igrf | src/IGRF.hs | bsd-3-clause | 9,299 | 0 | 10 | 2,308 | 5,422 | 3,449 | 1,973 | 107 | 1 |
{-
Kubernetes
No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
OpenAPI spec version: 2.0
Kubernetes API version: v1.9.12
Generated by Swagger Codegen (https://github.com/swagger-api/swagger-codegen.git)
-}
{-|
Module : Kubernetes.OpenAPI.API.Authentication
-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MonoLocalBinds #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# OPTIONS_GHC -fno-warn-name-shadowing -fno-warn-unused-binds -fno-warn-unused-imports #-}
module Kubernetes.OpenAPI.API.Authentication where
import Kubernetes.OpenAPI.Core
import Kubernetes.OpenAPI.MimeTypes
import Kubernetes.OpenAPI.Model as M
import qualified Data.Aeson as A
import qualified Data.ByteString as B
import qualified Data.ByteString.Lazy as BL
import qualified Data.Data as P (Typeable, TypeRep, typeOf, typeRep)
import qualified Data.Foldable as P
import qualified Data.Map as Map
import qualified Data.Maybe as P
import qualified Data.Proxy as P (Proxy(..))
import qualified Data.Set as Set
import qualified Data.String as P
import qualified Data.Text as T
import qualified Data.Text.Encoding as T
import qualified Data.Text.Lazy as TL
import qualified Data.Text.Lazy.Encoding as TL
import qualified Data.Time as TI
import qualified Network.HTTP.Client.MultipartFormData as NH
import qualified Network.HTTP.Media as ME
import qualified Network.HTTP.Types as NH
import qualified Web.FormUrlEncoded as WH
import qualified Web.HttpApiData as WH
import Data.Text (Text)
import GHC.Base ((<|>))
import Prelude ((==),(/=),($), (.),(<$>),(<*>),(>>=),Maybe(..),Bool(..),Char,Double,FilePath,Float,Int,Integer,String,fmap,undefined,mempty,maybe,pure,Monad,Applicative,Functor)
import qualified Prelude as P
-- * Operations
-- ** Authentication
-- *** getAPIGroup
-- | @GET \/apis\/authentication.k8s.io\/@
--
-- get information of a group
--
-- AuthMethod: 'AuthApiKeyBearerToken'
--
getAPIGroup
:: Accept accept -- ^ request accept ('MimeType')
-> KubernetesRequest GetAPIGroup MimeNoContent V1APIGroup accept
getAPIGroup _ =
_mkRequest "GET" ["/apis/authentication.k8s.io/"]
`_hasAuthType` (P.Proxy :: P.Proxy AuthApiKeyBearerToken)
data GetAPIGroup
-- | @application/json@
instance Consumes GetAPIGroup MimeJSON
-- | @application/yaml@
instance Consumes GetAPIGroup MimeYaml
-- | @application/vnd.kubernetes.protobuf@
instance Consumes GetAPIGroup MimeVndKubernetesProtobuf
-- | @application/json@
instance Produces GetAPIGroup MimeJSON
-- | @application/yaml@
instance Produces GetAPIGroup MimeYaml
-- | @application/vnd.kubernetes.protobuf@
instance Produces GetAPIGroup MimeVndKubernetesProtobuf
| denibertovic/haskell | kubernetes/lib/Kubernetes/OpenAPI/API/Authentication.hs | bsd-3-clause | 2,752 | 0 | 8 | 331 | 484 | 333 | 151 | -1 | -1 |
{-# LANGUAGE NoMonomorphismRestriction #-}
module Grammar
(pUnit
,pName
,runParser {- from Parser -}
,initialParserState {- from Grammar.Utils -}
) where
import Control.Applicative
import Data.Maybe
import AST
import CppToken
import Grammar.Expr
import Grammar.Parser
import Grammar.Types
import Grammar.Utils
singleton x = [x]
pUnit = Unit <$> many pImport <*> addLocation (pModule <|> pFunction) <* eof
pModule = keyword "module" *> (Decl <$> pName) <* token Semicolon <*!> (ModuleDef . concat <$> many pTopLevelDecl)
pTopLevelDecl :: MParser [LocDecl LocE]
pTopLevelDecl = singleton <$> addLocation (choice
[pExternalFunction
,pFunction
,pTypedef (\name typ -> Decl name (TypeDef typ))
]) <|>
pVarDecl (\typ name e -> Decl name (VarDef typ e))
pImport :: MParser Name
pImport = keyword "import" *> pName <* token Semicolon
pFunction = (\ret nm params code -> Decl nm (FunctionDef ret params code)) <$>
pType <*> pName <*> pFormalParamList <*!> addLocation pCompoundStatement
pExternalFunction = keyword "extern" *!> (
(\linkage ret nm params extname -> Decl nm (ExternalFunction (fmap snd linkage) ret params (fromMaybe nm extname)))
<$> optional string <*> pType <*> pName <*> pFormalParamList
<*> optional (token Assignment *!> pStringName)
<* token Semicolon)
pFormalParamList = inParens (listOf $ choice [pFormalParam, pVarargParam])
pFormalParam = FormalParam <$> pType <*> optional pSimpleName
pVarargParam = VarargParam <$ token Ellipsis
pCompoundStatement = CompoundStmt [] <$> inBraces (commit (many pStatement))
pStatement = addLocation $ choice
[token Semicolon $> EmptyStmt
,pTypedef TypDecl
,VarDecl <$> pVarDecl (\typ name e -> Decl name (VarDef typ e))
,ReturnStmt <$> (keyword "return" *> pExpression <*! token Semicolon)
,ReturnStmtVoid <$ (keyword "return" *!> token Semicolon)
,ExprStmt <$> pExpression <*! token Semicolon
,pCompoundStatement
,keyword "if" *!> (IfStmt <$> inParens pExpression <*> pStatement <*> pElse)
,keyword "while" *!> (WhileStmt <$> inParens pExpression <*> pStatement)
,BreakStmt <$ keyword "break"
,ContinueStmt <$ keyword "continue"
] <|> failParse "Out of luck in pStatement"
pVarDecl f = genVarDecl f (optional pVarInitializer)
pVarInitializer = token Assignment *> pInitializationExpression
pElse = (keyword "else" *> pStatement) <|> addLocation (pure EmptyStmt)
| olsner/m3 | Grammar.hs | bsd-3-clause | 2,402 | 0 | 19 | 404 | 769 | 395 | 374 | 53 | 1 |
{-
Totality checker
-}
module Test () where
{-@ foo :: {vv:[{v:[a]|((len v) = 1)}]|((len vv)= 1)} -> [[a]] @-}
foo [[x]] = [[x]]
| spinda/liquidhaskell | tests/gsoc15/broken/pos/grty2.hs | bsd-3-clause | 136 | 0 | 7 | 31 | 29 | 19 | 10 | 2 | 1 |
{-# LANGUAGE TupleSections #-}
-- | Extra functions for working with pairs and triples.
-- Some of these functions are available in the "Control.Arrow" module,
-- but here are available specialised to pairs. Some operations work on triples.
module Data.Tuple.Extra(
module Data.Tuple,
-- * Specialised 'Arrow' functions
first, second, (***), (&&&),
-- * More pair operations
dupe, both,
-- * Monadic versions
firstM, secondM,
-- * Operations on triple
fst3, snd3, thd3,
first3, second3, third3,
curry3, uncurry3
) where
import Data.Tuple
import qualified Control.Arrow as Arrow
infixr 3 ***, &&&
-- | Update the first component of a pair.
--
-- > first succ (1,"test") == (2,"test")
first :: (a -> a') -> (a, b) -> (a', b)
first = Arrow.first
-- | Update the second component of a pair.
--
-- > second reverse (1,"test") == (1,"tset")
second :: (b -> b') -> (a, b) -> (a, b')
second = Arrow.second
-- | Update the first component of a pair.
--
-- > firstM (\x -> [x-1, x+1]) (1,"test") == [(0,"test"),(2,"test")]
firstM :: Functor m => (a -> m a') -> (a, b) -> m (a', b)
firstM f (a,b) = (,b) <$> f a
-- | Update the second component of a pair.
--
-- > secondM (\x -> [reverse x, x]) (1,"test") == [(1,"tset"),(1,"test")]
secondM :: Functor m => (b -> m b') -> (a, b) -> m (a, b')
secondM f (a,b) = (a,) <$> f b
-- | Given two functions, apply one to the first component and one to the second.
-- A specialised version of 'Control.Arrow.***'.
--
-- > (succ *** reverse) (1,"test") == (2,"tset")
(***) :: (a -> a') -> (b -> b') -> (a, b) -> (a', b')
(***) = (Arrow.***)
-- | Given two functions, apply both to a single argument to form a pair.
-- A specialised version of 'Control.Arrow.&&&'.
--
-- > (succ &&& pred) 1 == (2,0)
(&&&) :: (a -> b) -> (a -> c) -> a -> (b, c)
(&&&) = (Arrow.&&&)
-- | Duplicate a single value into a pair.
--
-- > dupe 12 == (12, 12)
dupe :: a -> (a,a)
dupe x = (x,x)
-- | Apply a single function to both components of a pair.
--
-- > both succ (1,2) == (2,3)
both :: (a -> b) -> (a, a) -> (b, b)
both f (x,y) = (f x, f y)
-- | Extract the 'fst' of a triple.
fst3 :: (a,b,c) -> a
fst3 (a,b,c) = a
-- | Extract the 'snd' of a triple.
snd3 :: (a,b,c) -> b
snd3 (a,b,c) = b
-- | Extract the final element of a triple.
thd3 :: (a,b,c) -> c
thd3 (a,b,c) = c
-- | Converts an uncurried function to a curried function.
curry3 :: ((a, b, c) -> d) -> a -> b -> c -> d
curry3 f a b c = f (a,b,c)
-- | Converts a curried function to a function on a triple.
uncurry3 :: (a -> b -> c -> d) -> ((a, b, c) -> d)
uncurry3 f ~(a,b,c) = f a b c
-- | Update the first component of a triple.
--
-- > first3 succ (1,1,1) == (2,1,1)
first3 :: (a -> a') -> (a, b, c) -> (a', b, c)
first3 f (a,b,c) = (f a,b,c)
-- | Update the second component of a triple.
--
-- > second3 succ (1,1,1) == (1,2,1)
second3 :: (b -> b') -> (a, b, c) -> (a, b', c)
second3 f (a,b,c) = (a,f b,c)
-- | Update the third component of a triple.
--
-- > third3 succ (1,1,1) == (1,1,2)
third3 :: (c -> c') -> (a, b, c) -> (a, b, c')
third3 f (a,b,c) = (a,b,f c)
| ndmitchell/extra | src/Data/Tuple/Extra.hs | bsd-3-clause | 3,116 | 0 | 9 | 706 | 995 | 607 | 388 | 44 | 1 |
module Hint.GHC (
Message, module X
) where
import GHC as X hiding (Phase, GhcT, runGhcT)
import Control.Monad.Ghc as X (GhcT, runGhcT)
import HscTypes as X (SourceError, srcErrorMessages, GhcApiError)
import Outputable as X (PprStyle, SDoc, Outputable(ppr),
showSDoc, showSDocForUser, showSDocUnqual,
withPprStyle, defaultErrStyle)
import ErrUtils as X (mkLocMessage, pprErrMsgBagWithLoc, MsgDoc) -- we alias MsgDoc as Message below
import DriverPhases as X (Phase(Cpp), HscSource(HsSrcFile))
import StringBuffer as X (stringToStringBuffer)
import Lexer as X (P(..), ParseResult(..), mkPState)
import Parser as X (parseStmt, parseType)
import FastString as X (fsLit)
import DynFlags as X (xFlags, xopt, LogAction, FlagSpec(..))
#if __GLASGOW_HASKELL__ >= 800
import DynFlags as X (WarnReason(NoReason))
#endif
import PprTyThing as X (pprTypeForUser)
import SrcLoc as X (mkRealSrcLoc)
import ConLike as X (ConLike(RealDataCon))
import DynFlags as X (addWay', Way(..), dynamicGhc)
type Message = MsgDoc
| int-e/hint | src/Hint/GHC.hs | bsd-3-clause | 1,065 | 0 | 6 | 191 | 293 | 205 | 88 | 20 | 0 |
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE TypeSynonymInstances #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE OverloadedStrings #-}
-- | A demonstration of the precedence and environment extensions
module Text.PrettyPrint.Final.Demos.STLCDemo () where
import Control.Monad
import Control.Applicative
import Control.Monad.Identity
import Control.Monad.Reader
import Control.Monad.Writer
import Control.Monad.State
import Control.Monad.RWS
import Data.List
import Data.String (IsString(..))
import Data.Text (Text)
import qualified Data.Text as T
import Data.Map (Map)
import qualified Data.Map as Map
import Text.PrettyPrint.Final hiding (collection)
import Text.PrettyPrint.Final.Extensions.Environment
import Text.PrettyPrint.Final.Extensions.Precedence
import Text.PrettyPrint.Final.Rendering.HTML
data Ann = Class Text | Tooltip Text
deriving (Eq, Ord, Show)
-- The Language
data Ty = Int | Arr Ty Ty
data Op = Plus | Minus | Times | Div
data Exp =
Lit Int
| Bin Op Exp Exp
| Ifz Exp Exp Exp
| Var Text
| Lam Text Ty Exp
| App Exp Exp
| Raw Doc
infixl 5 /+/
infixl 5 /-/
infixl 6 /*/
infixl 6 ///
infixl 9 /@/
(/+/) :: Exp -> Exp -> Exp
(/+/) = Bin Plus
(/-/) :: Exp -> Exp -> Exp
(/-/) = Bin Minus
(/*/) :: Exp -> Exp -> Exp
(/*/) = Bin Times
(///) :: Exp -> Exp -> Exp
(///) = Bin Div
(/@/) :: Exp -> Exp -> Exp
(/@/) = App
-- The Pretty Printer
-- class shortcuts
lit :: Ann
lit = Class "lit"
var :: Ann
var = Class "var"
pun :: Ann
pun = Class "pun"
bdr :: Ann
bdr = Class "bdr"
kwd :: Ann
kwd = Class "kwd"
opr :: Ann
opr = Class "opr"
type TEnv = Map Text Text
tEnv0 :: TEnv
tEnv0 = Map.empty
newtype DocM a = DocM { unDocM :: EnvT TEnv (PrecT Ann (RWST (PEnv Int Ann ()) (POut Int Ann) (PState Int ()) Maybe)) a }
deriving
( Functor, Applicative, Monad, Alternative
, MonadReader (PEnv Int Ann ()), MonadWriter (POut Int Ann), MonadState (PState Int ())
, MonadReaderPrec Ann, MonadReaderEnv TEnv
)
instance MonadPretty Int Ann () DocM
instance MonadPrettyPrec Int Ann () DocM
instance MonadPrettyEnv TEnv Int Ann () DocM
instance Measure Int () DocM where
measure = return . runIdentity . measure
runDocM :: PEnv Int Ann () -> PrecEnv Ann -> TEnv -> PState Int () -> DocM a -> Maybe (PState Int (), POut Int Ann, a)
runDocM e pe te s d = (\(a,s',o) -> (s',o,a)) <$> runRWST (runPrecT pe (runEnvT te $ unDocM d)) e s
askTEnv :: DocM TEnv
askTEnv = askEnv
localTEnv :: (TEnv -> TEnv) -> DocM a -> DocM a
localTEnv f = localEnv f
-- Doc
env0 :: (Num w) => PEnv w ann ()
env0 = PEnv
{ maxWidth = 80
, maxRibbon = 60
, layout = Break
, failure = CantFail
, nesting = 0
, formatting = mempty
, formatAnn = const mempty
}
state0 :: PState Int ()
state0 = PState
{ curLine = []
}
type Doc = DocM ()
execDoc :: Doc -> POut Int Ann
execDoc d =
let rM = runDocM env0 precEnv0 tEnv0 state0 d
in case rM of
Nothing -> PAtom $ AChunk $ CText "<internal pretty printing error>"
Just (_, o, ()) -> o
instance IsString Doc where
fromString = text . fromString
instance Monoid Doc where
mempty = return ()
mappend = (>>)
renderAnnotation :: Ann -> Text -> Text
renderAnnotation (Class c) t = mconcat [ "<span class='" , c , "'>" , t , "</span>" ]
renderAnnotation (Tooltip p) t = mconcat [ "<span title='" , p , "'>" , t , "</span>" ]
instance Show Doc where
show = T.unpack . (render renderAnnotation) . execDoc
-- Pretty Class for this Doc
class Pretty a where
pretty :: a -> Doc
instance Pretty Doc where
pretty = id
instance Pretty Text where
pretty = text . T.pack . show
-- printing expressions
ftTy :: Ty -> Text
ftTy Int = "Int"
ftTy (Arr t1 t2) = ftTy t1 `T.append` " -> " `T.append` ftTy t2
ppOp :: Op -> Doc -> Doc -> Doc
ppOp Plus x1 x2 = infl 20 (annotate opr "+") (grouped x1) (grouped x2)
ppOp Minus x1 x2 = infl 20 (annotate opr "-") (grouped x1) (grouped x2)
ppOp Times x1 x2 = infl 30 (annotate opr "*") (grouped x1) (grouped x2)
ppOp Div x1 x2 = infl 30 (annotate opr "/") (grouped x1) (grouped x2)
ppExp :: Exp -> Doc
ppExp (Lit i) = annotate lit $ text $ T.pack $ show i
ppExp (Bin o e1 e2) = ppOp o (ppExp e1) (ppExp e2)
ppExp (Ifz e1 e2 e3) = grouped $ atLevel 10 $ hvsep
[ grouped $ nest 2 $ hvsep [ annotate kwd "ifz" , botLevel $ ppExp e1 ]
, grouped $ nest 2 $ hvsep [ annotate kwd "then" , botLevel $ ppExp e2 ]
, grouped $ nest 2 $ hvsep [ annotate kwd "else" , ppExp e3 ]
]
ppExp (Var x) = do
tEnv <- askTEnv
let tt = tEnv Map.! x
annotate (Tooltip tt) $ annotate var $ text x
ppExp (Lam x ty e) = localTEnv (Map.insert x $ ftTy ty) $ grouped $ atLevel 10 $ nest 2 $ hvsep
[ hsep [ annotate kwd "lam" , annotate (Tooltip $ ftTy ty) $ annotate bdr $ text x , annotate pun "." ]
, ppExp e
]
ppExp (App e1 e2) = app (ppExp e1) [ppExp e2]
ppExp (Raw d) = d
precDebug :: Doc
precDebug = do
lvl <- askLevel
bmp <- askBumped
text $ "p:" `T.append` T.pack (show lvl) `T.append` (if bmp then "B" else "")
instance Pretty Exp where
pretty = ppExp
e1 :: Exp
e1 = Lam "x" Int $ Var "x"
-- ifz ((1 - 2) + (3 - 4)) * (5 / 7)
-- then lam x . x
-- else (lam y . y) (ifz 1 then 2 else 3)
e2 :: Exp
e2 = Ifz ((Lit 1 /-/ Lit 2 /+/ (Lit 3 /-/ Lit 4)) /*/ (Lit 5 /// Lit 7) /+/ Lit 8)
(Lam "x" Int $ Var "x")
((Lam "y" Int $ Var "y") /@/ (Ifz (Lit 1) (Lit 2) (Lit 3)))
-- run this file to output an html file "stlc_demo.html", which links against
-- "stlc_demo.css"
main :: IO ()
main = do
let output = show $ localMaxWidth (const 15) $ pretty e2
putStrLn output
writeFile "stlc_demo.html" $ concat
[ "<html><head><link rel='stylesheet' type='text/css' href='stlc_demo.css'></head><body><p>"
, output
, "</p></body></html>"
]
| davdar/pretty-monadic-printer | Text/PrettyPrint/Final/Demos/STLCDemo.hs | mit | 5,971 | 0 | 15 | 1,307 | 2,340 | 1,244 | 1,096 | -1 | -1 |
module System.Logging.LogSink.Compat (
module Prelude
, module Control.Applicative
) where
import Control.Applicative
| sol/logsink | src/System/Logging/LogSink/Compat.hs | mit | 131 | 0 | 5 | 25 | 25 | 17 | 8 | 4 | 0 |
{-# LANGUAGE OverloadedStrings #-}
module Lamdu.Infer.Error
( Error(..)
) where
import qualified Lamdu.Calc.Term as V
import qualified Lamdu.Calc.Type as T
import Lamdu.Calc.Type.Constraints (Constraints)
import Text.PrettyPrint ((<+>), Doc)
import Text.PrettyPrint.HughesPJClass (Pretty(..))
data Error
= DuplicateField T.Tag T.Row
| AccessOpaqueNominal T.NominalId
| MissingNominal T.NominalId
| OccursCheckFail Doc Doc
| TypesDoNotUnity Doc Doc
| UnboundVariable V.Var
| SkolemsUnified Doc Doc
| SkolemNotPolymorphic Doc Doc
| UnexpectedSkolemConstraint Constraints
| SkolemEscapesScope Doc Doc Doc
instance Pretty Error where
pPrint (DuplicateField t r) =
"Field" <+> pPrint t <+> "forbidden in row" <+> pPrint r
pPrint (MissingNominal i) =
"Missing nominal:" <+> pPrint i
pPrint (AccessOpaqueNominal i) =
"Accessing opaque nominal:" <+> pPrint i
pPrint (OccursCheckFail v t) =
"Occurs check fails:" <+> v <+> "vs." <+> t
pPrint (UnboundVariable v) =
"Unbound variable:" <+> pPrint v
pPrint (TypesDoNotUnity x y) =
"Types do not unify" <+> x <+> "vs." <+> y
pPrint (SkolemsUnified x y) =
"Two skolems unified" <+> x <+> "vs." <+> y
pPrint (SkolemNotPolymorphic x y) =
"Skolem" <+> x <+> "unified with non-polymorphic type" <+> y
pPrint (UnexpectedSkolemConstraint constraints) =
"Unexpected constraint on skolem[s] " <+> pPrint constraints
pPrint (SkolemEscapesScope u v unallowedSkolems) =
"Skolem escapes scope when unifying" <+> u <+> " & " <+> v <+>
" unallowed skolems: " <+> unallowedSkolems
| Peaker/Algorithm-W-Step-By-Step | src/Lamdu/Infer/Error.hs | gpl-3.0 | 1,712 | 0 | 10 | 423 | 431 | 233 | 198 | 41 | 0 |
{-# LANGUAGE OverloadedStrings #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
-- Module : Test.AWS.EFS.Internal
-- Copyright : (c) 2013-2015 Brendan Hay
-- License : This Source Code Form is subject to the terms of
-- the Mozilla Public License, v. 2.0.
-- A copy of the MPL can be found in the LICENSE file or
-- you can obtain it at http://mozilla.org/MPL/2.0/.
-- Maintainer : Brendan Hay <[email protected]>
-- Stability : experimental
-- Portability : non-portable (GHC extensions)
module Test.AWS.EFS.Internal where
import Test.AWS.Prelude
| fmapfmapfmap/amazonka | amazonka-efs/test/Test/AWS/EFS/Internal.hs | mpl-2.0 | 613 | 0 | 4 | 140 | 25 | 21 | 4 | 4 | 0 |
module Data.Profunctor.Product.Newtype where
import qualified Data.Profunctor as P
class Newtype t where
constructor :: a -> t a
field :: t a -> a
pNewtype :: (P.Profunctor p, Newtype t) => p a b -> p (t a) (t b)
pNewtype = P.dimap field constructor
| karamaan/product-profunctors | Data/Profunctor/Product/Newtype.hs | bsd-3-clause | 263 | 0 | 9 | 58 | 109 | 58 | 51 | 7 | 1 |
module Main (main) where
import Control.Exception
import Data.Array.IArray
a :: Array Int Int
a = listArray (1,4) [1..4]
b :: Array (Int,Int) Int
b = listArray ((0,0), (3,3)) (repeat 0)
main :: IO ()
main = do print (a ! 5) `catch` \e -> print (e :: SomeException)
print (b ! (0,5)) `catch` \e -> print (e :: SomeException)
| DavidAlphaFox/ghc | libraries/array/tests/T2120.hs | bsd-3-clause | 340 | 0 | 11 | 75 | 188 | 107 | 81 | 10 | 1 |
{-# LANGUAGE TypeSynonymInstances #-}
module Text.XML.HaXml.Schema.PrimitiveTypes
( -- * Type class for parsing simpleTypes
SimpleType(..)
, module Text.Parse
, -- * Primitive XSD datatypes
XsdString(..)
, Boolean(..)
, Base64Binary(..)
, HexBinary(..)
, Float(..)
, Decimal(..)
, Double(..)
, AnyURI(..)
, QName(..)
, NOTATION(..)
, Duration(..)
, DateTime(..)
, Time(..)
, Date(..)
, GYearMonth(..)
, GYear(..)
, GMonthDay(..)
, GDay(..)
, GMonth(..)
, -- * Derived, yet builtin, datatypes
NormalizedString(..)
, Token(..)
, Language(..)
, Name(..)
, NCName(..)
, ID(..)
, IDREF(..)
, IDREFS(..)
, ENTITY(..)
, ENTITIES(..)
, NMTOKEN(..)
, NMTOKENS(..)
, Integer(..)
, NonPositiveInteger(..)
, NegativeInteger(..)
, Long(..)
, Int(..)
, Short(..)
, Byte(..)
, NonNegativeInteger(..)
, UnsignedLong(..)
, UnsignedInt(..)
, UnsignedShort(..)
, UnsignedByte(..)
, PositiveInteger(..)
) where
import Text.Parse
import Data.Char as Char
--import Data.Time.LocalTime -- for dates and times?
import Text.XML.HaXml.Types (QName(..))
import Data.Int
import Data.Word
-- | Ultimately, an XML parser will find some plain text as the content
-- of a simpleType, which will need to be parsed. We use a TextParser,
-- because values of simpleTypes can also be given elsewhere, e.g. as
-- attribute values in an XSD definition, e.g. to restrict the permissible
-- values of the simpleType. Such restrictions are therefore implemented
-- as layered parsers.
class SimpleType a where
acceptingParser :: TextParser a
simpleTypeText :: a -> String
-- * Primitive types
type Boolean = Bool
newtype XsdString = XsdString String deriving (Eq,Show)
data Base64Binary = Base64Binary String deriving (Eq,Show)
data HexBinary = HexBinary String deriving (Eq,Show)
data AnyURI = AnyURI String deriving (Eq,Show)
--data QName
data NOTATION = NOTATION String -- or re-use NOTATION from HaXml.Types?
deriving (Eq,Show)
data Decimal = Decimal Double deriving (Eq,Show)
--data Float
--data Double
data Duration = Duration Bool Int Int Int Int Int Float deriving (Eq,Show)
-- * All of the following temporal types are incompletely specified for now.
-- They should probably be mapped to something appropriate from the time
-- package?
data DateTime = DateTime String deriving (Eq,Show) -- LocalTime ?
data Time = Time String deriving (Eq,Show) -- TimeOfDay ?
data Date = Date String deriving (Eq,Show) -- Day ?
data GYearMonth = GYearMonth String deriving (Eq,Show) -- ??
data GYear = GYear String deriving (Eq,Show) -- ??
data GMonthDay = GMonthDay String deriving (Eq,Show) -- ??
data GDay = GDay String deriving (Eq,Show) -- ??
data GMonth = GMonth String deriving (Eq,Show) -- ??
isNext :: Char -> TextParser Char
isNext c = do d <- next
if c==d then return c else fail ("expected "++c:", got "++d:".")
instance SimpleType Bool where
acceptingParser = do w <- word
case w of "true" -> return True;
"false" -> return False
"0" -> return False;
"1" -> return True
_ -> fail ("Not a bool: "++w)
simpleTypeText False = "false"
simpleTypeText True = "true"
instance SimpleType XsdString where
acceptingParser = fmap XsdString (many next)
simpleTypeText (XsdString s) = s
instance SimpleType Base64Binary where
acceptingParser = fmap Base64Binary (many (satisfy isAlphaNum `onFail`
satisfy isSpace `onFail`
satisfy (`elem`"+/=")))
simpleTypeText (Base64Binary s) = s
instance SimpleType HexBinary where
acceptingParser = fmap HexBinary (many (satisfy Char.isHexDigit))
simpleTypeText (HexBinary s) = s
instance SimpleType AnyURI where
acceptingParser = fmap AnyURI (many next) -- not very satisfactory
simpleTypeText (AnyURI s) = s
instance SimpleType NOTATION where
acceptingParser = fmap NOTATION (many next) -- not very satisfactory
simpleTypeText (NOTATION s) = s
instance SimpleType Decimal where
acceptingParser = fmap Decimal parse
simpleTypeText (Decimal s) = show s -- XXX FIXME: showGFloat?
instance SimpleType Float where
acceptingParser = parse
simpleTypeText x = show x -- XXX FIXME: showGFloat?
instance SimpleType Double where
acceptingParser = parse
simpleTypeText x = show x -- XXX FIXME: showGFloat?
instance SimpleType Duration where
acceptingParser = return Duration `apply` (do isNext '-'; return False
`onFail` return True)
`discard` isNext 'P'
`apply` ((parseDec `discard` isNext 'Y')
`onFail` return 0)
`apply` ((parseDec `discard` isNext 'M')
`onFail` return 0)
`apply` ((parseDec `discard` isNext 'D')
`onFail` return 0)
`discard` (isNext 'T'`onFail`return 'T')
-- fix: T absent iff H:M:S absent also
`apply` ((parseDec `discard` isNext 'H')
`onFail` return 0)
`apply` ((parseDec `discard` isNext 'M')
`onFail` return 0)
`apply` ((parseFloat `discard` isNext 'S')
`onFail` return 0)
simpleTypeText (Duration pos y m d h n s) =
(if pos then "" else "-")++show y++"Y"++show m++"M"++show d++"D"
++"T"++show h++"H"++show n++"M"++show s++"S"
instance SimpleType DateTime where
acceptingParser = fmap DateTime (many next)
-- acceptingParser = fail "not implemented: simpletype parser for DateTime"
simpleTypeText (DateTime x) = x
instance SimpleType Time where
acceptingParser = fmap Time (many next)
-- acceptingParser = fail "not implemented: simpletype parser for Time"
simpleTypeText (Time x) = x
instance SimpleType Date where
acceptingParser = fmap Date (many next)
-- acceptingParser = fail "not implemented: simpletype parser for Date"
simpleTypeText (Date x) = x
instance SimpleType GYearMonth where
acceptingParser = fmap GYearMonth (many next)
-- acceptingParser = fail "not implemented: simpletype parser for GYearMonth"
simpleTypeText (GYearMonth x) = x
instance SimpleType GYear where
acceptingParser = fmap GYear (many next)
-- acceptingParser = fail "not implemented: simpletype parser for GYear"
simpleTypeText (GYear x) = x
instance SimpleType GMonthDay where
acceptingParser = fmap GMonthDay (many next)
-- acceptingParser = fail "not implemented: simpletype parser for GMonthDay"
simpleTypeText (GMonthDay x) = x
instance SimpleType GDay where
acceptingParser = fmap GDay (many next)
-- acceptingParser = fail "not implemented: simpletype parser for GDay"
simpleTypeText (GDay x) = x
instance SimpleType GMonth where
acceptingParser = fmap GMonth (many next)
-- acceptingParser = fail "not implemented: simpletype parser for GMonth"
simpleTypeText (GMonth x) = x
-- * Derived builtin types
newtype NormalizedString = Normalized String deriving (Eq,Show)
newtype Token = Token String deriving (Eq,Show)
newtype Language = Language String deriving (Eq,Show)
newtype Name = Name String deriving (Eq,Show)
newtype NCName = NCName String deriving (Eq,Show)
newtype ID = ID String deriving (Eq,Show)
newtype IDREF = IDREF String deriving (Eq,Show)
newtype IDREFS = IDREFS String deriving (Eq,Show)
newtype ENTITY = ENTITY String deriving (Eq,Show)
newtype ENTITIES = ENTITIES String deriving (Eq,Show)
newtype NMTOKEN = NMTOKEN String deriving (Eq,Show)
newtype NMTOKENS = NMTOKENS String deriving (Eq,Show)
instance SimpleType NormalizedString where
acceptingParser = fmap Normalized (many next)
simpleTypeText (Normalized x) = x
instance SimpleType Token where
acceptingParser = fmap Token (many next)
simpleTypeText (Token x) = x
instance SimpleType Language where
acceptingParser = fmap Language (many next)
simpleTypeText (Language x) = x
instance SimpleType Name where
acceptingParser = fmap Name (many next)
simpleTypeText (Name x) = x
instance SimpleType NCName where
acceptingParser = fmap NCName (many next)
simpleTypeText (NCName x) = x
instance SimpleType ID where
acceptingParser = fmap ID (many next)
simpleTypeText (ID x) = x
instance SimpleType IDREF where
acceptingParser = fmap IDREF (many next)
simpleTypeText (IDREF x) = x
instance SimpleType IDREFS where
acceptingParser = fmap IDREFS (many next)
simpleTypeText (IDREFS x) = x
instance SimpleType ENTITY where
acceptingParser = fmap ENTITY (many next)
simpleTypeText (ENTITY x) = x
instance SimpleType ENTITIES where
acceptingParser = fmap ENTITIES (many next)
simpleTypeText (ENTITIES x) = x
instance SimpleType NMTOKEN where
acceptingParser = fmap NMTOKEN (many next)
simpleTypeText (NMTOKEN x) = x
instance SimpleType NMTOKENS where
acceptingParser = fmap NMTOKENS (many next)
simpleTypeText (NMTOKENS x) = x
--data Integer
newtype NonPositiveInteger = NonPos Integer deriving (Eq,Show)
newtype NegativeInteger = Negative Integer deriving (Eq,Show)
newtype Long = Long Int64 deriving (Eq,Show)
--data Int
newtype Short = Short Int16 deriving (Eq,Show)
newtype Byte = Byte Int8 deriving (Eq,Show)
newtype NonNegativeInteger = NonNeg Integer deriving (Eq,Show)
newtype UnsignedLong = ULong Word64 deriving (Eq,Show)
newtype UnsignedInt = UInt Word32 deriving (Eq,Show)
newtype UnsignedShort = UShort Word16 deriving (Eq,Show)
newtype UnsignedByte = UByte Word8 deriving (Eq,Show)
newtype PositiveInteger = Positive Integer deriving (Eq,Show)
instance SimpleType Integer where
acceptingParser = parse
simpleTypeText = show
instance SimpleType NonPositiveInteger where
acceptingParser = fmap NonPos parse
simpleTypeText (NonPos x) = show x
instance SimpleType NegativeInteger where
acceptingParser = fmap Negative parse
simpleTypeText (Negative x) = show x
instance SimpleType Long where
acceptingParser = fmap (Long . fromInteger) parse
simpleTypeText (Long x) = show x
instance SimpleType Int where
acceptingParser = parse
simpleTypeText = show
instance SimpleType Short where
acceptingParser = fmap (Short . fromInteger) parse
simpleTypeText (Short x) = show x
instance SimpleType Byte where
acceptingParser = fmap (Byte . fromInteger) parse
simpleTypeText (Byte x) = show x
instance SimpleType NonNegativeInteger where
acceptingParser = fmap NonNeg parse
simpleTypeText (NonNeg x) = show x
instance SimpleType UnsignedLong where
acceptingParser = fmap (ULong . fromInteger) parse
simpleTypeText (ULong x) = show x
instance SimpleType UnsignedInt where
acceptingParser = fmap (UInt . fromInteger) parse
simpleTypeText (UInt x) = show x
instance SimpleType UnsignedShort where
acceptingParser = fmap (UShort . fromInteger) parse
simpleTypeText (UShort x) = show x
instance SimpleType UnsignedByte where
acceptingParser = fmap (UByte . fromInteger) parse
simpleTypeText (UByte x) = show x
instance SimpleType PositiveInteger where
acceptingParser = fmap Positive parse
simpleTypeText (Positive x) = show x
| Ian-Stewart-Binks/courseography | dependencies/HaXml-1.25.3/src/Text/XML/HaXml/Schema/PrimitiveTypes.hs | gpl-3.0 | 12,300 | 2 | 20 | 3,479 | 3,265 | 1,802 | 1,463 | 254 | 2 |
{-# OPTIONS_HADDOCK hide #-}
-- #hide
#if __GLASGOW_HASKELL__ >= 701
{-# LANGUAGE Safe #-}
#endif
module Text.XHtml.Strict.Attributes where
import Text.XHtml.Internals
-- * Attributes in XHTML Strict
action :: String -> HtmlAttr
align :: String -> HtmlAttr
alt :: String -> HtmlAttr
altcode :: String -> HtmlAttr
archive :: String -> HtmlAttr
base :: String -> HtmlAttr
border :: Int -> HtmlAttr
bordercolor :: String -> HtmlAttr
cellpadding :: Int -> HtmlAttr
cellspacing :: Int -> HtmlAttr
checked :: HtmlAttr
codebase :: String -> HtmlAttr
cols :: String -> HtmlAttr
colspan :: Int -> HtmlAttr
content :: String -> HtmlAttr
coords :: String -> HtmlAttr
disabled :: HtmlAttr
enctype :: String -> HtmlAttr
height :: String -> HtmlAttr
href :: String -> HtmlAttr
hreflang :: String -> HtmlAttr
httpequiv :: String -> HtmlAttr
identifier :: String -> HtmlAttr
ismap :: HtmlAttr
lang :: String -> HtmlAttr
maxlength :: Int -> HtmlAttr
method :: String -> HtmlAttr
multiple :: HtmlAttr
name :: String -> HtmlAttr
nohref :: HtmlAttr
rel :: String -> HtmlAttr
rev :: String -> HtmlAttr
rows :: String -> HtmlAttr
rowspan :: Int -> HtmlAttr
rules :: String -> HtmlAttr
selected :: HtmlAttr
shape :: String -> HtmlAttr
size :: String -> HtmlAttr
src :: String -> HtmlAttr
theclass :: String -> HtmlAttr
thefor :: String -> HtmlAttr
thestyle :: String -> HtmlAttr
thetype :: String -> HtmlAttr
title :: String -> HtmlAttr
usemap :: String -> HtmlAttr
valign :: String -> HtmlAttr
value :: String -> HtmlAttr
width :: String -> HtmlAttr
action = strAttr "action"
align = strAttr "align"
alt = strAttr "alt"
altcode = strAttr "altcode"
archive = strAttr "archive"
base = strAttr "base"
border = intAttr "border"
bordercolor = strAttr "bordercolor"
cellpadding = intAttr "cellpadding"
cellspacing = intAttr "cellspacing"
checked = emptyAttr "checked"
codebase = strAttr "codebase"
cols = strAttr "cols"
colspan = intAttr "colspan"
content = strAttr "content"
coords = strAttr "coords"
disabled = emptyAttr "disabled"
enctype = strAttr "enctype"
height = strAttr "height"
href = strAttr "href"
hreflang = strAttr "hreflang"
httpequiv = strAttr "http-equiv"
identifier = strAttr "id"
ismap = emptyAttr "ismap"
lang = strAttr "lang"
maxlength = intAttr "maxlength"
method = strAttr "method"
multiple = emptyAttr "multiple"
name = strAttr "name"
nohref = emptyAttr "nohref"
rel = strAttr "rel"
rev = strAttr "rev"
rows = strAttr "rows"
rowspan = intAttr "rowspan"
rules = strAttr "rules"
selected = emptyAttr "selected"
shape = strAttr "shape"
size = strAttr "size"
src = strAttr "src"
theclass = strAttr "class"
thefor = strAttr "for"
thestyle = strAttr "style"
thetype = strAttr "type"
title = strAttr "title"
usemap = strAttr "usemap"
valign = strAttr "valign"
value = strAttr "value"
width = strAttr "width"
| DavidAlphaFox/ghc | libraries/xhtml/Text/XHtml/Strict/Attributes.hs | bsd-3-clause | 4,187 | 0 | 5 | 1,836 | 812 | 436 | 376 | 99 | 1 |
{-# LANGUAGE TemplateHaskell #-}
module Common
( TestDependable(..)
, repoRoot
, testFile
)
where
import CommonTH
import System.FilePath ( (</>) )
import Language.Haskell.TH.Syntax (lift)
import Database.Schema.Migrations.Dependencies ( Dependable(..) )
repoRoot :: FilePath
repoRoot = $(getRepoRoot >>= lift)
testFile :: FilePath -> FilePath
testFile fp = repoRoot </> "test" </> fp
instance Dependable TestDependable where
depId = tdId
depsOf = tdDeps
data TestDependable = TD { tdId :: String
, tdDeps :: [String]
}
deriving (Show, Eq, Ord)
| creswick/dbmigrations | test/Common.hs | bsd-3-clause | 646 | 0 | 9 | 179 | 163 | 99 | 64 | 19 | 1 |
{-# LANGUAGE CPP #-}
{-# LANGUAGE OverloadedStrings #-}
-- | Some next-gen helper functions for the scaffolding's configuration system.
module Yesod.Default.Config2
( MergedValue (..)
, applyCurrentEnv
, getCurrentEnv
, applyEnvValue
, loadAppSettings
, loadAppSettingsArgs
, configSettingsYml
, getDevSettings
, develMainHelper
, makeYesodLogger
, EnvUsage
, ignoreEnv
, useEnv
, requireEnv
, useCustomEnv
, requireCustomEnv
) where
import Data.Monoid
import Data.Semigroup
import Data.List.NonEmpty (nonEmpty)
import Data.Aeson
import qualified Data.HashMap.Strict as H
import Data.Text (Text, pack)
import System.Environment (getEnvironment, getArgs)
import Control.Arrow ((***))
import Control.Applicative ((<$>))
import Control.Monad (forM)
import Control.Exception (throwIO)
import Data.Text.Encoding (encodeUtf8)
import qualified Data.Yaml as Y
import Network.Wai (Application)
import Network.Wai.Handler.Warp
import Safe (readMay)
import Data.Maybe (fromMaybe)
import Control.Concurrent (forkIO, threadDelay)
import System.Exit (exitSuccess)
import System.Directory (doesFileExist)
import Network.Wai.Logger (clockDateCacher)
import Yesod.Core.Types (Logger (Logger))
import System.Log.FastLogger (LoggerSet)
import qualified Data.Text as T
#ifndef mingw32_HOST_OS
import System.Posix.Signals (installHandler, sigINT, Handler(Catch))
#endif
newtype MergedValue = MergedValue { getMergedValue :: Value }
instance Semigroup MergedValue where
MergedValue x <> MergedValue y = MergedValue $ mergeValues x y
-- | Left biased
mergeValues :: Value -> Value -> Value
mergeValues (Object x) (Object y) = Object $ H.unionWith mergeValues x y
mergeValues x _ = x
applyEnvValue :: Bool -- ^ require an environment variable to be present?
-> H.HashMap Text Text -> Value -> Value
applyEnvValue requireEnv' env =
goV
where
goV (Object o) = Object $ goV <$> o
goV (Array a) = Array (goV <$> a)
goV (String t1) = fromMaybe (String t1) $ do
t2 <- T.stripPrefix "_env:" t1
let (name, t3) = T.break (== ':') t2
Just $ case H.lookup name env of
Just val -> parseValue val
Nothing ->
case T.stripPrefix ":" t3 of
Just val | not requireEnv' -> parseValue val
_ -> Null
goV v = v
parseValue val = fromMaybe (String val) $ Y.decode $ encodeUtf8 val
getCurrentEnv :: IO (H.HashMap Text Text)
getCurrentEnv = fmap (H.fromList . map (pack *** pack)) getEnvironment
applyCurrentEnv :: Bool -- ^ require an environment variable to be present?
-> Value -> IO Value
applyCurrentEnv requireEnv' orig = flip (applyEnvValue requireEnv') orig <$> getCurrentEnv
data EnvUsage = IgnoreEnv
| UseEnv
| RequireEnv
| UseCustomEnv (H.HashMap Text Text)
| RequireCustomEnv (H.HashMap Text Text)
ignoreEnv, useEnv, requireEnv :: EnvUsage
ignoreEnv = IgnoreEnv
useEnv = UseEnv
requireEnv = RequireEnv
useCustomEnv, requireCustomEnv :: H.HashMap Text Text -> EnvUsage
useCustomEnv = UseCustomEnv
requireCustomEnv = RequireCustomEnv
-- | Load the settings from the following three sources:
--
-- * Run time config files
--
-- * Run time environment variables
--
-- * The default compile time config file
loadAppSettings
:: FromJSON settings
=> [FilePath] -- ^ run time config files to use, earlier files have precedence
-> [Value] -- ^ any other values to use, usually from compile time config. overridden by files
-> EnvUsage
-> IO settings
loadAppSettings runTimeFiles compileValues envUsage = do
runValues <- forM runTimeFiles $ \fp -> do
eres <- Y.decodeFileEither fp
case eres of
Left e -> do
putStrLn $ "loadAppSettings: Could not parse file as YAML: " ++ fp
throwIO e
Right value -> return value
value' <-
case nonEmpty $ map MergedValue $ runValues ++ compileValues of
Nothing -> error "loadAppSettings: No configuration provided"
Just ne -> return $ getMergedValue $ sconcat ne
value <-
case envUsage of
IgnoreEnv -> return $ applyEnvValue False mempty value'
UseEnv -> applyCurrentEnv False value'
RequireEnv -> applyCurrentEnv True value'
UseCustomEnv env -> return $ applyEnvValue False env value'
RequireCustomEnv env -> return $ applyEnvValue True env value'
case fromJSON value of
Error s -> error $ "Could not convert to AppSettings: " ++ s
Success settings -> return settings
-- | Same as @loadAppSettings@, but get the list of runtime config files from
-- the command line arguments.
loadAppSettingsArgs
:: FromJSON settings
=> [Value] -- ^ any other values to use, usually from compile time config. overridden by files
-> EnvUsage -- ^ use environment variables
-> IO settings
loadAppSettingsArgs values env = do
args <- getArgs
loadAppSettings args values env
-- | Location of the default config file.
configSettingsYml :: FilePath
configSettingsYml = "config/settings.yml"
-- | Helper for getApplicationDev in the scaffolding. Looks up PORT and
-- DISPLAY_PORT and prints appropriate messages.
getDevSettings :: Settings -> IO Settings
getDevSettings settings = do
env <- getEnvironment
let p = fromMaybe (getPort settings) $ lookup "PORT" env >>= readMay
pdisplay = fromMaybe p $ lookup "DISPLAY_PORT" env >>= readMay
putStrLn $ "Devel application launched: http://localhost:" ++ show pdisplay
return $ setPort p settings
-- | Helper for develMain in the scaffolding.
develMainHelper :: IO (Settings, Application) -> IO ()
develMainHelper getSettingsApp = do
#ifndef mingw32_HOST_OS
_ <- installHandler sigINT (Catch $ return ()) Nothing
#endif
putStrLn "Starting devel application"
(settings, app) <- getSettingsApp
_ <- forkIO $ runSettings settings app
loop
where
loop :: IO ()
loop = do
threadDelay 100000
e <- doesFileExist "yesod-devel/devel-terminate"
if e then terminateDevel else loop
terminateDevel :: IO ()
terminateDevel = exitSuccess
makeYesodLogger :: LoggerSet -> IO Logger
makeYesodLogger loggerSet' = do
(getter, _) <- clockDateCacher
return $! Yesod.Core.Types.Logger loggerSet' getter
| pikajude/yesod | yesod/Yesod/Default/Config2.hs | mit | 6,524 | 0 | 20 | 1,575 | 1,572 | 828 | 744 | 147 | 8 |
{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE PolyKinds, DataKinds, TypeFamilies, TypeOperators, UndecidableInstances #-}
-----------------------------------------------------------------------------
-- |
-- Module : Data.Either
-- Copyright : (c) The University of Glasgow 2001
-- License : BSD-style (see the file libraries/base/LICENSE)
--
-- Maintainer : [email protected]
-- Stability : experimental
-- Portability : portable
--
-- The Either type, and associated operations.
--
-----------------------------------------------------------------------------
module Data.Either (
Either(..),
either,
lefts,
rights,
isLeft,
isRight,
partitionEithers,
) where
import GHC.Base
import GHC.Show
import GHC.Read
import Data.Type.Equality
-- $setup
-- Allow the use of some Prelude functions in doctests.
-- >>> import Prelude ( (+), (*), length, putStrLn )
{-
-- just for testing
import Test.QuickCheck
-}
{-|
The 'Either' type represents values with two possibilities: a value of
type @'Either' a b@ is either @'Left' a@ or @'Right' b@.
The 'Either' type is sometimes used to represent a value which is
either correct or an error; by convention, the 'Left' constructor is
used to hold an error value and the 'Right' constructor is used to
hold a correct value (mnemonic: \"right\" also means \"correct\").
==== __Examples__
The type @'Either' 'String' 'Int'@ is the type of values which can be either
a 'String' or an 'Int'. The 'Left' constructor can be used only on
'String's, and the 'Right' constructor can be used only on 'Int's:
>>> let s = Left "foo" :: Either String Int
>>> s
Left "foo"
>>> let n = Right 3 :: Either String Int
>>> n
Right 3
>>> :type s
s :: Either String Int
>>> :type n
n :: Either String Int
The 'fmap' from our 'Functor' instance will ignore 'Left' values, but
will apply the supplied function to values contained in a 'Right':
>>> let s = Left "foo" :: Either String Int
>>> let n = Right 3 :: Either String Int
>>> fmap (*2) s
Left "foo"
>>> fmap (*2) n
Right 6
The 'Monad' instance for 'Either' allows us to chain together multiple
actions which may fail, and fail overall if any of the individual
steps failed. First we'll write a function that can either parse an
'Int' from a 'Char', or fail.
>>> import Data.Char ( digitToInt, isDigit )
>>> :{
let parseEither :: Char -> Either String Int
parseEither c
| isDigit c = Right (digitToInt c)
| otherwise = Left "parse error"
>>> :}
The following should work, since both @\'1\'@ and @\'2\'@ can be
parsed as 'Int's.
>>> :{
let parseMultiple :: Either String Int
parseMultiple = do
x <- parseEither '1'
y <- parseEither '2'
return (x + y)
>>> :}
>>> parseMultiple
Right 3
But the following should fail overall, since the first operation where
we attempt to parse @\'m\'@ as an 'Int' will fail:
>>> :{
let parseMultiple :: Either String Int
parseMultiple = do
x <- parseEither 'm'
y <- parseEither '2'
return (x + y)
>>> :}
>>> parseMultiple
Left "parse error"
-}
data Either a b = Left a | Right b
deriving (Eq, Ord, Read, Show)
instance Functor (Either a) where
fmap _ (Left x) = Left x
fmap f (Right y) = Right (f y)
instance Applicative (Either e) where
pure = Right
Left e <*> _ = Left e
Right f <*> r = fmap f r
instance Monad (Either e) where
return = Right
Left l >>= _ = Left l
Right r >>= k = k r
-- | Case analysis for the 'Either' type.
-- If the value is @'Left' a@, apply the first function to @a@;
-- if it is @'Right' b@, apply the second function to @b@.
--
-- ==== __Examples__
--
-- We create two values of type @'Either' 'String' 'Int'@, one using the
-- 'Left' constructor and another using the 'Right' constructor. Then
-- we apply \"either\" the 'length' function (if we have a 'String')
-- or the \"times-two\" function (if we have an 'Int'):
--
-- >>> let s = Left "foo" :: Either String Int
-- >>> let n = Right 3 :: Either String Int
-- >>> either length (*2) s
-- 3
-- >>> either length (*2) n
-- 6
--
either :: (a -> c) -> (b -> c) -> Either a b -> c
either f _ (Left x) = f x
either _ g (Right y) = g y
-- | Extracts from a list of 'Either' all the 'Left' elements.
-- All the 'Left' elements are extracted in order.
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]
-- >>> lefts list
-- ["foo","bar","baz"]
--
lefts :: [Either a b] -> [a]
lefts x = [a | Left a <- x]
-- | Extracts from a list of 'Either' all the 'Right' elements.
-- All the 'Right' elements are extracted in order.
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]
-- >>> rights list
-- [3,7]
--
rights :: [Either a b] -> [b]
rights x = [a | Right a <- x]
-- | Partitions a list of 'Either' into two lists.
-- All the 'Left' elements are extracted, in order, to the first
-- component of the output. Similarly the 'Right' elements are extracted
-- to the second component of the output.
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]
-- >>> partitionEithers list
-- (["foo","bar","baz"],[3,7])
--
-- The pair returned by @'partitionEithers' x@ should be the same
-- pair as @('lefts' x, 'rights' x)@:
--
-- >>> let list = [ Left "foo", Right 3, Left "bar", Right 7, Left "baz" ]
-- >>> partitionEithers list == (lefts list, rights list)
-- True
--
partitionEithers :: [Either a b] -> ([a],[b])
partitionEithers = foldr (either left right) ([],[])
where
left a ~(l, r) = (a:l, r)
right a ~(l, r) = (l, a:r)
-- | Return `True` if the given value is a `Left`-value, `False` otherwise.
--
-- @since 4.7.0.0
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> isLeft (Left "foo")
-- True
-- >>> isLeft (Right 3)
-- False
--
-- Assuming a 'Left' value signifies some sort of error, we can use
-- 'isLeft' to write a very simple error-reporting function that does
-- absolutely nothing in the case of success, and outputs \"ERROR\" if
-- any error occurred.
--
-- This example shows how 'isLeft' might be used to avoid pattern
-- matching when one does not care about the value contained in the
-- constructor:
--
-- >>> import Control.Monad ( when )
-- >>> let report e = when (isLeft e) $ putStrLn "ERROR"
-- >>> report (Right 1)
-- >>> report (Left "parse error")
-- ERROR
--
isLeft :: Either a b -> Bool
isLeft (Left _) = True
isLeft (Right _) = False
-- | Return `True` if the given value is a `Right`-value, `False` otherwise.
--
-- @since 4.7.0.0
--
-- ==== __Examples__
--
-- Basic usage:
--
-- >>> isRight (Left "foo")
-- False
-- >>> isRight (Right 3)
-- True
--
-- Assuming a 'Left' value signifies some sort of error, we can use
-- 'isRight' to write a very simple reporting function that only
-- outputs \"SUCCESS\" when a computation has succeeded.
--
-- This example shows how 'isRight' might be used to avoid pattern
-- matching when one does not care about the value contained in the
-- constructor:
--
-- >>> import Control.Monad ( when )
-- >>> let report e = when (isRight e) $ putStrLn "SUCCESS"
-- >>> report (Left "parse error")
-- >>> report (Right 1)
-- SUCCESS
--
isRight :: Either a b -> Bool
isRight (Left _) = False
isRight (Right _) = True
-- instance for the == Boolean type-level equality operator
type family EqEither a b where
EqEither ('Left x) ('Left y) = x == y
EqEither ('Right x) ('Right y) = x == y
EqEither a b = 'False
type instance a == b = EqEither a b
{-
{--------------------------------------------------------------------
Testing
--------------------------------------------------------------------}
prop_partitionEithers :: [Either Int Int] -> Bool
prop_partitionEithers x =
partitionEithers x == (lefts x, rights x)
-}
| TomMD/ghc | libraries/base/Data/Either.hs | bsd-3-clause | 8,039 | 1 | 9 | 1,711 | 852 | 512 | 340 | 51 | 1 |
{-# LANGUAGE ExistentialQuantification #-}
-- Examples from Doaitse Swierstra and Brandon Moore
-- GHC users mailing list, April 07, title "Release plans"
-- This one should fail, but Hugs passes it
module ShouldFail where
data T s = forall x. T (s -> (x -> s) -> (x, s, Int))
run :: T s -> Int
run ts = case ts of
T g -> let (x,_, b) = g x id
in b
| ezyang/ghc | testsuite/tests/typecheck/should_fail/tcfail179.hs | bsd-3-clause | 390 | 0 | 12 | 115 | 109 | 61 | 48 | 7 | 1 |
module Ripple.Amount (
Amount(..),
Currency(..),
CurrencySpecifier(..)
) where
import Control.Monad
import Control.Applicative
import Data.Bits
import Data.Word
import Data.Binary (Binary(..), Get, putWord8)
import Data.Binary.Get (getLazyByteString)
import Data.Base58Address (RippleAddress)
import Control.Error (readZ)
import qualified Data.ByteString.Lazy as LZ
import qualified Data.Text as T
import Data.Aeson ((.=), (.:))
import qualified Data.Aeson as Aeson
import qualified Data.Aeson.Types as Aeson
data Currency = XRP | Currency (Char,Char,Char) RippleAddress
deriving (Eq)
instance Show Currency where
show XRP = "XRP"
show (Currency (a,b,c) adr) = [a,b,c,'/'] ++ show adr
instance Aeson.ToJSON Currency where
toJSON XRP = Aeson.object [T.pack "currency" .= "XRP"]
toJSON (Currency (a,b,c) issuer) = Aeson.object [
T.pack "currency" .= [a,b,c],
T.pack "issuer" .= show issuer
]
instance Binary Currency where
get = do
CurrencySpecifier code <- get
issuer <- get
return $ Currency code issuer
put XRP = fail "XRP does not get encoded as a currency specifier."
put (Currency code issuer) = do
put $ CurrencySpecifier code
put issuer
-- | The raw 160-bit currency specifier, no issuer
newtype CurrencySpecifier = CurrencySpecifier (Char,Char,Char)
deriving (Show, Eq)
instance Binary CurrencySpecifier where
get = do
allZero <- getLazyByteString 12
currency <- getLazyByteString 3
version <- getLazyByteString 2
reserved <- getLazyByteString 3
when (LZ.any (/=0) allZero) (fail "Bad currency format az")
when (LZ.any (/=0) version) (fail "Bad currency format ver")
when (LZ.any (/=0) reserved) (fail "Bad currency format res")
-- Spec says ASCII
let [a,b,c] = map (toEnum.fromIntegral) $ LZ.unpack currency
return $ CurrencySpecifier (a,b,c)
put (CurrencySpecifier (a,b,c)) = do
replicateM_ 12 (putWord8 0)
putWord8 $ fromIntegral $ fromEnum a
putWord8 $ fromIntegral $ fromEnum b
putWord8 $ fromIntegral $ fromEnum c
replicateM_ 2 (putWord8 0)
replicateM_ 3 (putWord8 0)
data Amount = Amount Rational Currency
deriving (Eq)
instance Show Amount where
show (Amount a c) =
show (realToFrac a :: Double) ++ "/" ++ show c
instance Aeson.ToJSON Amount where
toJSON (Amount v XRP) = Aeson.toJSON $ show (floor (v * one_drop) :: Integer)
toJSON (Amount v (Currency (a,b,c) issuer)) = Aeson.object [
T.pack "value" .= show (realToFrac v :: Double),
T.pack "currency" .= [a,b,c],
T.pack "issuer" .= show issuer
]
instance Aeson.FromJSON Amount where
parseJSON (Aeson.Object o) = do
amountVal <- o .: T.pack "value"
amount <- realToFrac <$> case amountVal of
Aeson.Number n ->
Aeson.parseJSON (Aeson.Number n) :: Aeson.Parser Double
Aeson.String s ->
readZ (T.unpack s) :: Aeson.Parser Double
_ -> fail "No valid amount"
currency <- o .: T.pack "currency"
guard (length currency == 3 && currency /= "XRP")
issuer <- readZ =<< o .: T.pack "issuer"
let [a,b,c] = currency
return $ Amount amount (Currency (a,b,c) issuer)
parseJSON (Aeson.Number n)
| floor n == ceiling n = pure $ Amount (realToFrac n / one_drop) XRP
| otherwise = pure $ Amount (realToFrac n) XRP
parseJSON (Aeson.String s) = case T.find (=='.') s of
Nothing -> (Amount . (/one_drop) . realToFrac) <$>
(readZ (T.unpack s) :: Aeson.Parser Integer) <*> pure XRP
Just _ -> (\x -> Amount (realToFrac x)) <$>
(readZ (T.unpack s) :: Aeson.Parser Double) <*> pure XRP
parseJSON _ = fail "Invalid amount"
instance Binary Amount where
get = do
value <- get :: Get Word64
if testBit value 63 then
(flip Amount <$> get <*>) $ pure $
case (clearBit (clearBit value 63) 62 `shiftR` 54, value .&. 0x003FFFFFFFFFFFFF) of
(0,0) -> 0
(e,m) ->
(if testBit value 62 then 1 else -1) *
fromIntegral m * (10 ^^ (fromIntegral e + exp_min - 1))
else
return $ (`Amount` XRP) $
(if testBit value 62 then 1 else -1) *
(fromIntegral (clearBit value 62) / one_drop)
put (Amount value XRP) =
put $ (if value >= 0 then (`setBit` 62) else id) drops
where
drops = floor $ abs $ value * one_drop :: Word64
put (Amount 0 currency) = do
put (setBit (0 :: Word64) 63)
put currency
put (Amount value currency)
| value > 0 = put (setBit encoded 62) >> put currency
| otherwise = put encoded >> put currency
where
encoded = setBit ((e8 `shiftL` 54) .|. m64) 63
e8 = fromIntegral (fromIntegral (e-exp_min+1) :: Word8) -- to get the bits
m64 = fromIntegral m :: Word64
(m,e) = until ((>= man_min_value) . fst) (\(m,e) -> (m*10,e-1)) $
until ((<= man_max_value) . fst) (\(m,e) -> (m`div`10,e+1))
(abs $ floor (value * (10 ^^ exp_max)), -exp_max)
one_drop :: Rational
one_drop = 1000000
exp_max :: Integer
exp_max = 80
exp_min :: Integer
exp_min = -96
man_max_value :: Integer
man_max_value = 9999999999999999
man_min_value :: Integer
man_min_value = 1000000000000000
| singpolyma/ripple-haskell | Ripple/Amount.hs | isc | 4,922 | 56 | 19 | 971 | 2,142 | 1,119 | 1,023 | 128 | 1 |
{-# LANGUAGE PatternSynonyms #-}
-- For HasCallStack compatibility
{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
module JSDOM.Generated.WebKitMediaKeys
(newWebKitMediaKeys, createSession, createSession_,
isTypeSupported, isTypeSupported_, getKeySystem,
WebKitMediaKeys(..), gTypeWebKitMediaKeys)
where
import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, realToFrac, fmap, Show, Read, Eq, Ord, Maybe(..))
import qualified Prelude (error)
import Data.Typeable (Typeable)
import Data.Traversable (mapM)
import Language.Javascript.JSaddle (JSM(..), JSVal(..), JSString, strictEqual, toJSVal, valToStr, valToNumber, valToBool, js, jss, jsf, jsg, function, asyncFunction, new, array, jsUndefined, (!), (!!))
import Data.Int (Int64)
import Data.Word (Word, Word64)
import JSDOM.Types
import Control.Applicative ((<$>))
import Control.Monad (void)
import Control.Lens.Operators ((^.))
import JSDOM.EventTargetClosures (EventName, unsafeEventName, unsafeEventNameAsync)
import JSDOM.Enums
-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitMediaKeys Mozilla WebKitMediaKeys documentation>
newWebKitMediaKeys ::
(MonadDOM m, ToJSString keySystem) =>
keySystem -> m WebKitMediaKeys
newWebKitMediaKeys keySystem
= liftDOM
(WebKitMediaKeys <$>
new (jsg "WebKitMediaKeys") [toJSVal keySystem])
-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitMediaKeys.createSession Mozilla WebKitMediaKeys.createSession documentation>
createSession ::
(MonadDOM m, ToJSString type', IsUint8Array initData) =>
WebKitMediaKeys -> type' -> initData -> m WebKitMediaKeySession
createSession self type' initData
= liftDOM
((self ^. jsf "createSession" [toJSVal type', toJSVal initData])
>>= fromJSValUnchecked)
-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitMediaKeys.createSession Mozilla WebKitMediaKeys.createSession documentation>
createSession_ ::
(MonadDOM m, ToJSString type', IsUint8Array initData) =>
WebKitMediaKeys -> type' -> initData -> m ()
createSession_ self type' initData
= liftDOM
(void
(self ^. jsf "createSession" [toJSVal type', toJSVal initData]))
-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitMediaKeys.isTypeSupported Mozilla WebKitMediaKeys.isTypeSupported documentation>
isTypeSupported ::
(MonadDOM m, ToJSString keySystem, ToJSString type') =>
keySystem -> Maybe type' -> m Bool
isTypeSupported keySystem type'
= liftDOM
(((jsg "WebKitMediaKeys") ^. jsf "isTypeSupported"
[toJSVal keySystem, toJSVal type'])
>>= valToBool)
-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitMediaKeys.isTypeSupported Mozilla WebKitMediaKeys.isTypeSupported documentation>
isTypeSupported_ ::
(MonadDOM m, ToJSString keySystem, ToJSString type') =>
keySystem -> Maybe type' -> m ()
isTypeSupported_ keySystem type'
= liftDOM
(void
((jsg "WebKitMediaKeys") ^. jsf "isTypeSupported"
[toJSVal keySystem, toJSVal type']))
-- | <https://developer.mozilla.org/en-US/docs/Web/API/WebKitMediaKeys.keySystem Mozilla WebKitMediaKeys.keySystem documentation>
getKeySystem ::
(MonadDOM m, FromJSString result) => WebKitMediaKeys -> m result
getKeySystem self
= liftDOM ((self ^. js "keySystem") >>= fromJSValUnchecked)
| ghcjs/jsaddle-dom | src/JSDOM/Generated/WebKitMediaKeys.hs | mit | 3,604 | 0 | 12 | 650 | 789 | 451 | 338 | 61 | 1 |
module CustomSet
( CustomSet
, empty
, null
, singleton
, union
, toList
, fromList
, member
, delete
, difference
, isSubsetOf
, isDisjointFrom
, size
, intersection
, insert
) where
-- This example is a naive unbalanced binary search tree implementation.
-- No attempt at implementing efficient hedge algorithms was made here.
-- An even more naive implementation would be to use a list.
import Prelude hiding (null)
import Data.Monoid (mempty, mappend)
import qualified Data.Foldable as F
data CustomSet a
= Tip
| Bin {-# UNPACK #-} !Int !a !(CustomSet a) !(CustomSet a)
instance (Ord a, Eq a) => Eq (CustomSet a) where
a == b = size a == size b && a `isSubsetOf` b
instance Show a => Show (CustomSet a) where
showsPrec p xs = showParen (p > 10) $
showString "fromList " . shows (toList xs)
instance F.Foldable CustomSet where
foldMap f t = case t of
Tip -> mempty
Bin _s a l r -> F.foldMap f l `mappend` f a `mappend` F.foldMap f r
null :: CustomSet a -> Bool
null Tip = True
null _ = False
size :: CustomSet a -> Int
size Tip = 0
size (Bin s _a _l _r) = s
singleton :: Ord a => a -> CustomSet a
singleton x = Bin 1 x Tip Tip
toList :: CustomSet a -> [a]
toList = F.toList
empty :: Ord a => CustomSet a
empty = Tip
fromList :: Ord a => [a] -> CustomSet a
fromList = F.foldl' (flip insert) empty
insert :: Ord a => a -> CustomSet a -> CustomSet a
insert x Tip = singleton x
insert x t@(Bin s a l r) = case x `compare` a of
LT -> let l' = insert x l in Bin (s + size l' - size l) a l' r
GT -> let r' = insert x r in Bin (s + size r' - size r) a l r'
EQ -> t
union :: Ord a => CustomSet a -> CustomSet a -> CustomSet a
union = F.foldl' (flip insert)
member :: Ord a => a -> CustomSet a -> Bool
member _ Tip = False
member x (Bin _s a l r) = case x `compare` a of
LT -> member x l
GT -> member x r
EQ -> True
delete :: Ord a => a -> CustomSet a -> CustomSet a
delete _ Tip = Tip
delete x (Bin s a l r) = case x `compare` a of
LT -> let l' = delete x l in Bin (s + size l' - size l) a l' r
GT -> let r' = delete x r in Bin (s + size r' - size r) a l r'
EQ -> l `union` r
difference :: Ord a => CustomSet a -> CustomSet a -> CustomSet a
difference = F.foldl' (flip delete)
isSubsetOf :: Ord a => CustomSet a -> CustomSet a -> Bool
isSubsetOf a b = size a <= size b && F.all (`member` b) a
intersection :: Ord a => CustomSet a -> CustomSet a -> CustomSet a
intersection a b = F.foldl' go empty b
where go acc x = if x `member` a then insert x acc else acc
isDisjointFrom :: Ord a => CustomSet a -> CustomSet a -> Bool
isDisjointFrom a b = null (intersection a b)
| pminten/xhaskell | custom-set/example.hs | mit | 2,691 | 0 | 14 | 697 | 1,225 | 613 | 612 | 80 | 3 |
{-# LANGUAGE PatternSynonyms #-}
-- For HasCallStack compatibility
{-# LANGUAGE ImplicitParams, ConstraintKinds, KindSignatures #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
module JSDOM.Generated.FontFace
(newFontFace, load, load_, setFamily, getFamily, setStyle,
getStyle, setWeight, getWeight, setStretch, getStretch,
setUnicodeRange, getUnicodeRange, setVariant, getVariant,
setFeatureSettings, getFeatureSettings, getStatus, getLoaded,
FontFace(..), gTypeFontFace)
where
import Prelude ((.), (==), (>>=), return, IO, Int, Float, Double, Bool(..), Maybe, maybe, fromIntegral, round, realToFrac, fmap, Show, Read, Eq, Ord, Maybe(..))
import qualified Prelude (error)
import Data.Typeable (Typeable)
import Data.Traversable (mapM)
import Language.Javascript.JSaddle (JSM(..), JSVal(..), JSString, strictEqual, toJSVal, valToStr, valToNumber, valToBool, js, jss, jsf, jsg, function, asyncFunction, new, array, jsUndefined, (!), (!!))
import Data.Int (Int64)
import Data.Word (Word, Word64)
import JSDOM.Types
import Control.Applicative ((<$>))
import Control.Monad (void)
import Control.Lens.Operators ((^.))
import JSDOM.EventTargetClosures (EventName, unsafeEventName, unsafeEventNameAsync)
import JSDOM.Enums
-- | <https://developer.mozilla.org/en-US/docs/Web/API/FontFace Mozilla FontFace documentation>
newFontFace ::
(MonadDOM m, ToJSString family', IsStringOrBinaryData source) =>
family' -> source -> Maybe FontFaceDescriptors -> m FontFace
newFontFace family' source descriptors
= liftDOM
(FontFace <$>
new (jsg "FontFace")
[toJSVal family', toJSVal source, toJSVal descriptors])
-- | <https://developer.mozilla.org/en-US/docs/Web/API/FontFace.load Mozilla FontFace.load documentation>
load :: (MonadDOM m) => FontFace -> m FontFace
load self
= liftDOM
(((self ^. jsf "load" ()) >>= readPromise) >>= fromJSValUnchecked)
-- | <https://developer.mozilla.org/en-US/docs/Web/API/FontFace.load Mozilla FontFace.load documentation>
load_ :: (MonadDOM m) => FontFace -> m ()
load_ self = liftDOM (void (self ^. jsf "load" ()))
-- | <https://developer.mozilla.org/en-US/docs/Web/API/FontFace.family Mozilla FontFace.family documentation>
setFamily ::
(MonadDOM m, ToJSString val) => FontFace -> val -> m ()
setFamily self val = liftDOM (self ^. jss "family" (toJSVal val))
-- | <https://developer.mozilla.org/en-US/docs/Web/API/FontFace.family Mozilla FontFace.family documentation>
getFamily ::
(MonadDOM m, FromJSString result) => FontFace -> m result
getFamily self
= liftDOM ((self ^. js "family") >>= fromJSValUnchecked)
-- | <https://developer.mozilla.org/en-US/docs/Web/API/FontFace.style Mozilla FontFace.style documentation>
setStyle :: (MonadDOM m, ToJSString val) => FontFace -> val -> m ()
setStyle self val = liftDOM (self ^. jss "style" (toJSVal val))
-- | <https://developer.mozilla.org/en-US/docs/Web/API/FontFace.style Mozilla FontFace.style documentation>
getStyle ::
(MonadDOM m, FromJSString result) => FontFace -> m result
getStyle self
= liftDOM ((self ^. js "style") >>= fromJSValUnchecked)
-- | <https://developer.mozilla.org/en-US/docs/Web/API/FontFace.weight Mozilla FontFace.weight documentation>
setWeight ::
(MonadDOM m, ToJSString val) => FontFace -> val -> m ()
setWeight self val = liftDOM (self ^. jss "weight" (toJSVal val))
-- | <https://developer.mozilla.org/en-US/docs/Web/API/FontFace.weight Mozilla FontFace.weight documentation>
getWeight ::
(MonadDOM m, FromJSString result) => FontFace -> m result
getWeight self
= liftDOM ((self ^. js "weight") >>= fromJSValUnchecked)
-- | <https://developer.mozilla.org/en-US/docs/Web/API/FontFace.stretch Mozilla FontFace.stretch documentation>
setStretch ::
(MonadDOM m, ToJSString val) => FontFace -> val -> m ()
setStretch self val = liftDOM (self ^. jss "stretch" (toJSVal val))
-- | <https://developer.mozilla.org/en-US/docs/Web/API/FontFace.stretch Mozilla FontFace.stretch documentation>
getStretch ::
(MonadDOM m, FromJSString result) => FontFace -> m result
getStretch self
= liftDOM ((self ^. js "stretch") >>= fromJSValUnchecked)
-- | <https://developer.mozilla.org/en-US/docs/Web/API/FontFace.unicodeRange Mozilla FontFace.unicodeRange documentation>
setUnicodeRange ::
(MonadDOM m, ToJSString val) => FontFace -> val -> m ()
setUnicodeRange self val
= liftDOM (self ^. jss "unicodeRange" (toJSVal val))
-- | <https://developer.mozilla.org/en-US/docs/Web/API/FontFace.unicodeRange Mozilla FontFace.unicodeRange documentation>
getUnicodeRange ::
(MonadDOM m, FromJSString result) => FontFace -> m result
getUnicodeRange self
= liftDOM ((self ^. js "unicodeRange") >>= fromJSValUnchecked)
-- | <https://developer.mozilla.org/en-US/docs/Web/API/FontFace.variant Mozilla FontFace.variant documentation>
setVariant ::
(MonadDOM m, ToJSString val) => FontFace -> val -> m ()
setVariant self val = liftDOM (self ^. jss "variant" (toJSVal val))
-- | <https://developer.mozilla.org/en-US/docs/Web/API/FontFace.variant Mozilla FontFace.variant documentation>
getVariant ::
(MonadDOM m, FromJSString result) => FontFace -> m result
getVariant self
= liftDOM ((self ^. js "variant") >>= fromJSValUnchecked)
-- | <https://developer.mozilla.org/en-US/docs/Web/API/FontFace.featureSettings Mozilla FontFace.featureSettings documentation>
setFeatureSettings ::
(MonadDOM m, ToJSString val) => FontFace -> val -> m ()
setFeatureSettings self val
= liftDOM (self ^. jss "featureSettings" (toJSVal val))
-- | <https://developer.mozilla.org/en-US/docs/Web/API/FontFace.featureSettings Mozilla FontFace.featureSettings documentation>
getFeatureSettings ::
(MonadDOM m, FromJSString result) => FontFace -> m result
getFeatureSettings self
= liftDOM ((self ^. js "featureSettings") >>= fromJSValUnchecked)
-- | <https://developer.mozilla.org/en-US/docs/Web/API/FontFace.status Mozilla FontFace.status documentation>
getStatus :: (MonadDOM m) => FontFace -> m FontFaceLoadStatus
getStatus self
= liftDOM ((self ^. js "status") >>= fromJSValUnchecked)
-- | <https://developer.mozilla.org/en-US/docs/Web/API/FontFace.loaded Mozilla FontFace.loaded documentation>
getLoaded :: (MonadDOM m) => FontFace -> m FontFace
getLoaded self
= liftDOM
(((self ^. js "loaded") >>= readPromise) >>= fromJSValUnchecked)
| ghcjs/jsaddle-dom | src/JSDOM/Generated/FontFace.hs | mit | 6,512 | 0 | 13 | 1,002 | 1,515 | 832 | 683 | 93 | 1 |
import Control.Monad.Trans.Except
import Control.Monad.Trans.Maybe
import Control.Monad.Trans.Reader
embedded :: MaybeT (ExceptT String (ReaderT () IO)) Int
embedded = return 1
maybeUnwrap = runMaybeT embedded
eitherUnwrap = runExceptT maybeUnwrap
readerUnwrap = runReaderT eitherUnwrap
-- TODO: I haven't figured this one out yet
embedded' :: MaybeT (ExceptT String (ReaderT () IO)) Int
embedded' = _ (const (Right (Just 1)))
| diminishedprime/.org | reading-list/haskell_programming_from_first_principles/26_08.hs | mit | 429 | 0 | 11 | 58 | 137 | 73 | 64 | 10 | 1 |
module Hasql.Private.Decoders.Composite where
import Hasql.Private.Prelude
import qualified PostgreSQL.Binary.Decoding as A
newtype Composite a =
Composite (ReaderT Bool A.Composite a)
deriving (Functor, Applicative, Monad, MonadFail)
{-# INLINE run #-}
run :: Composite a -> Bool -> A.Value a
run (Composite imp) env =
A.composite (runReaderT imp env)
{-# INLINE value #-}
value :: (Bool -> A.Value a) -> Composite (Maybe a)
value decoder' =
Composite $ ReaderT $ A.nullableValueComposite . decoder'
{-# INLINE nonNullValue #-}
nonNullValue :: (Bool -> A.Value a) -> Composite a
nonNullValue decoder' =
Composite $ ReaderT $ A.valueComposite . decoder'
| nikita-volkov/hasql | library/Hasql/Private/Decoders/Composite.hs | mit | 671 | 0 | 9 | 110 | 214 | 115 | 99 | 18 | 1 |
{-# LANGUAGE OverloadedStrings #-}
import qualified Crypto.Hash
import Data.ByteString (ByteString)
import Data.Text (Text)
import qualified Data.Text as Text
import Data.Text.Encoding (decodeUtf8, encodeUtf8)
import qualified Data.Text.IO as IO
main = do
input <- Text.strip <$> IO.getContents
print $ mineAdventCoins input
mineAdventCoins :: Text -> (Int, Text)
mineAdventCoins input =
head $
filter (\(i, digest) -> Text.take 5 digest == "00000") $
map (\i -> (i, hashText $ Text.append input $ Text.pack $ show i)) $
[1 ..]
hashText :: Text -> Text
hashText text = Text.pack $ show $ md5 $ encodeUtf8 text
md5 :: ByteString -> Crypto.Hash.Digest Crypto.Hash.MD5
md5 = Crypto.Hash.hash
| SamirTalwar/advent-of-code | 2015/AOC_04_1.hs | mit | 718 | 0 | 15 | 130 | 255 | 142 | 113 | 20 | 1 |
substituteChar :: Char -> Char
substituteChar c =
case c of
'e' -> '3'
'o' -> '0'
'a' -> '4'
't' -> '7'
_ -> c
translateWord word = map substituteChar word
main :: IO ()
main =
do
putStr "Please enter a word.\n"
word1 <- getLine
print (translateWord word1) | brodyberg/Notes | FindingSuccessAndFailure/leetspeak.hs | mit | 297 | 0 | 9 | 90 | 105 | 50 | 55 | 15 | 5 |
{-# LANGUAGE NoImplicitPrelude, FlexibleContexts, ImpredicativeTypes,
DeriveDataTypeable #-}
module Eyeshadow.Phase.Lexical.Types
(Action,
Classification(..),
LexerStateData(..),
LexerStateDataActionMap(..),
LexerState(..),
Lexer(..))
where
import qualified Control.Eff as Eff
import qualified Control.Eff.Reader.Strict as Eff
import qualified Control.Eff.State.Strict as Eff
import qualified Data.Conduit as Conduit
import qualified Data.HashMap.Strict as HashMap
import qualified Data.Text as Text
import Data.Char
import Data.Maybe
import Data.Typeable
import Eyeshadow.Data.Span
import Eyeshadow.Data.Token
import Eyeshadow.Diagnostic
import Eyeshadow.Prelude
type Action a =
(Eff.Member Diagnose r,
Eff.Member (Eff.Reader Lexer) r,
Eff.Member (Eff.State LexerState) r)
=> Conduit.ConduitM (Char, Span) Token (Eff.Eff r) a
data Classification
= LetterClassification
| NumberClassification
| OperatorClassification
| HorizontalWhitespaceClassification
| VerticalWhitespaceClassification
| QuoteClassification
| ApostropheClassification
| PlusClassification
| CommaClassification
| MinusClassification
| PeriodClassification
| ColonClassification
| SemicolonClassification
| AtSignClassification
| BackslashClassification
| BacktickClassification
| OpenParenthesisClassification
| CloseParenthesisClassification
| ConnectingPunctuationClassification
| UnknownClassification
deriving (Eq, Ord)
data LexerStateData
= TopLevelLexerStateData
| WordLexerStateData
| NumberLexerStateData
| OperatorLexerStateData
| PeriodLexerStateData
| PlusLexerStateData
| MinusLexerStateData
| HyphenLexerStateData
| DashLexerStateData
| StringLexerStateData
| OpenParenthesisLexerStateData
| CloseParenthesisLexerStateData
| CommaLexerStateData
| ColonLexerStateData
| SemicolonLexerStateData
| SpliceLexerStateData
| ListSpliceLexerStateData
| WhitespaceLexerStateData
deriving (Eq, Ord)
data LexerStateDataActionMap =
LexerStateDataActionMap {
lexerStateDataActionMapClassificationActionMap
:: HashMap.HashMap Classification (Action ()),
lexerStateDataActionMapEndAction
:: Maybe (Action ()),
lexerStateDataActionMapDefaultAction
:: Action ()
}
data LexerState =
LexerState {
lexerStateSpan :: Maybe Span,
lexerStateAccumulator :: Text.Text,
lexerStateValue :: Maybe Text.Text,
lexerStateOpenDelimiter :: Maybe Char,
lexerStateCloseDelimiter :: Maybe Char,
lexerStateData :: LexerStateData,
lexerStateInput :: Maybe (Char, Span, Classification),
lexerStateDone :: Bool
}
deriving (Typeable)
data Lexer =
Lexer {
lexerClassificationMap :: HashMap.HashMap Char Classification,
lexerMinorCategoryMap :: HashMap.HashMap Text.Text Classification,
lexerMajorCategoryMap :: HashMap.HashMap Text.Text Classification,
lexerQuoteMap :: HashMap.HashMap Char [Char],
lexerParenthesisMap :: HashMap.HashMap Char [Char],
lexerEscapeMap :: HashMap.HashMap Char Char,
lexerActionMap :: HashMap.HashMap LexerStateData LexerStateDataActionMap
}
deriving (Typeable)
| IreneKnapp/Eyeshadow | Haskell/Eyeshadow/Phase/Lexical/Types.hs | mit | 3,224 | 0 | 12 | 563 | 631 | 383 | 248 | 98 | 0 |
Subsets and Splits