-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Quasiquotations for a python like interpolated string formater
--   
--   Quasiquotations for a python like interpolated string formater.
@package PyF
@version 0.9.0.1

module PyF.Class

-- | The three categories of formatting in <tt>PyF</tt>
data PyFCategory

-- | Format as an integral, no fractional part, precise value
PyFIntegral :: PyFCategory

-- | Format as a fractional, approximate value with a fractional part
PyFFractional :: PyFCategory

-- | Format as a string
PyFString :: PyFCategory

-- | Classify a type to a <a>PyFCategory</a> This classification will be
--   used to decide which formatting to use when no type specifier in
--   provided.
type family PyFClassify t :: PyFCategory

-- | Convert a type to string The default implementation uses <a>Show</a>
class PyFToString t
pyfToString :: PyFToString t => t -> String
pyfToString :: (PyFToString t, Show t) => t -> String
instance PyF.Class.PyFToString GHC.Base.String
instance PyF.Class.PyFToString Data.Text.Internal.Lazy.Text
instance PyF.Class.PyFToString Data.Text.Internal.Text
instance GHC.Show.Show t => PyF.Class.PyFToString t


-- | Formatters for integral / fractional and strings.
--   
--   Is support:
--   
--   For all types:
--   
--   <ul>
--   <li>Grouping of the integral part (i.e: adding a custom char to
--   separate groups of digits)</li>
--   <li>Padding (left, right, around, and between the sign and the
--   number)</li>
--   <li>Sign handling (i.e: display the positive sign or not)</li>
--   </ul>
--   
--   For floating:
--   
--   <ul>
--   <li>Precision</li>
--   <li>Fixed <i> Exponential </i> Generic formatting</li>
--   </ul>
--   
--   For integrals:
--   
--   <ul>
--   <li>Binary <i> Hexa </i> Octal / Character representation</li>
--   </ul>
module PyF.Formatters

-- | Format a string
formatString :: Maybe (Int, AlignMode  'AlignAll, Char) -> Maybe Int -> String -> String

-- | Format an integral number
formatIntegral :: (Show i, Integral i) => Format t t'  'Integral -> SignMode -> Maybe (Int, AlignMode k, Char) -> Maybe (Int, Char) -> i -> String

-- | Format a fractional number
formatFractional :: RealFloat f => Format t t'  'Fractional -> SignMode -> Maybe (Int, AlignMode k, Char) -> Maybe (Int, Char) -> Maybe Int -> f -> String

-- | This formatter support alternate version
data AltStatus
CanAlt :: AltStatus
NoAlt :: AltStatus

-- | This formatter support Upper case version
data UpperStatus
CanUpper :: UpperStatus
NoUpper :: UpperStatus

-- | This formatter formats an integral or a fractional
data FormatType
Fractional :: FormatType
Integral :: FormatType

-- | All the Formatters
data Format (k :: AltStatus) (k' :: UpperStatus) (k'' :: FormatType)
[Decimal] :: Format  'NoAlt  'NoUpper  'Integral
[Character] :: Format  'NoAlt  'NoUpper  'Integral
[Binary] :: Format  'CanAlt  'NoUpper  'Integral
[Hexa] :: Format  'CanAlt  'CanUpper  'Integral
[Octal] :: Format  'CanAlt  'NoUpper  'Integral
[Fixed] :: Format  'CanAlt  'CanUpper  'Fractional
[Exponent] :: Format  'CanAlt  'CanUpper  'Fractional
[Generic] :: Format  'CanAlt  'CanUpper  'Fractional
[Percent] :: Format  'CanAlt  'NoUpper  'Fractional
[Alternate] :: Format  'CanAlt u f -> Format  'NoAlt u f
[Upper] :: Format alt  'CanUpper f -> Format  'NoAlt  'NoUpper f

-- | Sign handling
data SignMode

-- | Display <a>-</a> sign and <a>+</a> sign
Plus :: SignMode

-- | Only display <a>-</a> sign
Minus :: SignMode

-- | Display <a>-</a> sign and a space for positive numbers
Space :: SignMode

-- | Existential version of <a>AlignMode</a>
data AnyAlign
[AnyAlign] :: AlignMode (k :: AlignForString) -> AnyAlign

-- | Alignement
data AlignMode (k :: AlignForString)

-- | Left padding
[AlignLeft] :: AlignMode  'AlignAll

-- | Right padding
[AlignRight] :: AlignMode  'AlignAll

-- | Padding will be added between the sign and the number
[AlignInside] :: AlignMode  'AlignNumber

-- | Padding will be added around the valueber
[AlignCenter] :: AlignMode  'AlignAll
getAlignForString :: AlignMode k -> Maybe (AlignMode  'AlignAll)
data AlignForString
AlignAll :: AlignForString
AlignNumber :: AlignForString
instance GHC.Show.Show PyF.Formatters.Repr
instance GHC.Show.Show PyF.Formatters.Sign
instance GHC.Show.Show PyF.Formatters.AlignForString
instance GHC.Show.Show PyF.Formatters.SignMode
instance GHC.Show.Show (PyF.Formatters.AlignMode k)
instance GHC.Show.Show PyF.Formatters.AnyAlign
instance Language.Haskell.TH.Syntax.Lift PyF.Formatters.AnyAlign
instance Language.Haskell.TH.Syntax.Lift (PyF.Formatters.AlignMode k)
instance Language.Haskell.TH.Syntax.Lift PyF.Formatters.SignMode
instance Language.Haskell.TH.Syntax.Lift (PyF.Formatters.Format k k' k'')

module PyF.Internal.Extensions

-- | Associate a template haskell extension to an haskell-src-ext extension
thExtToMetaExt :: Extension -> Maybe Extension


-- | This module provides a parser for <a>python format string mini
--   language</a>.
module PyF.Internal.PythonSyntax

-- | Parse a string, returns a list of raw string or replacement fields
--   
--   <pre>
--   &gt;&gt;&gt; import Text.Megaparsec
--   
--   &gt;&gt;&gt; parse parsePythonFormatString "" "hello {1+1:&gt;10.2f}"
--   Right [
--          Raw "hello ",
--          Replacement "1+1"
--          (
--          Just (FormatMode
--                         (Padding 10 (Just (Nothing,AnyAlign AlignRight)))
--                         (FixedF (Precision 2) NormalForm Minus)
--                          Nothing))]
--   </pre>
parseGenericFormatString :: Parser [Item]

-- | A format string is composed of many chunks of raw string or
--   replacement
data Item

-- | A raw string
Raw :: String -> Item

-- | A replacement string, composed of an arbitrary Haskell expression
--   followed by an optional formatter
Replacement :: Exp -> Maybe FormatMode -> Item

-- | A Formatter, listing padding, format and and grouping char
data FormatMode
FormatMode :: Padding -> TypeFormat -> Maybe Char -> FormatMode

-- | Padding, containing the padding width, the padding char and the
--   alignement mode
data Padding
PaddingDefault :: Padding
Padding :: Integer -> Maybe (Maybe Char, AnyAlign) -> Padding

-- | Floating point precision
data Precision
PrecisionDefault :: Precision
Precision :: ExprOrValue Integer -> Precision

-- | All formating type
data TypeFormat

-- | Default, depends on the infered type of the expression
DefaultF :: Precision -> SignMode -> TypeFormat

-- | Binary, such as `0b0121`
BinaryF :: AlternateForm -> SignMode -> TypeFormat

-- | Character, will convert an integer to its character representation
CharacterF :: TypeFormat

-- | Decimal, base 10 integer formatting
DecimalF :: SignMode -> TypeFormat

-- | Exponential notation for floatting points
ExponentialF :: Precision -> AlternateForm -> SignMode -> TypeFormat

-- | Exponential notation with capitalised <tt>e</tt>
ExponentialCapsF :: Precision -> AlternateForm -> SignMode -> TypeFormat

-- | Fixed number of digits floating point
FixedF :: Precision -> AlternateForm -> SignMode -> TypeFormat

-- | Capitalized version of the previous
FixedCapsF :: Precision -> AlternateForm -> SignMode -> TypeFormat

-- | General formatting: <a>FixedF</a> or <a>ExponentialF</a> depending on
--   the number magnitude
GeneralF :: Precision -> AlternateForm -> SignMode -> TypeFormat

-- | Same as <a>GeneralF</a> but with upper case <tt>E</tt> and infinite /
--   NaN
GeneralCapsF :: Precision -> AlternateForm -> SignMode -> TypeFormat

-- | Octal, such as 00245
OctalF :: AlternateForm -> SignMode -> TypeFormat

-- | Simple string
StringF :: Precision -> TypeFormat

-- | Hexadecimal, such as 0xaf3e
HexF :: AlternateForm -> SignMode -> TypeFormat

-- | Hexadecimal with capitalized letters, such as 0XAF3E
HexCapsF :: AlternateForm -> SignMode -> TypeFormat

-- | Percent representation
PercentF :: Precision -> AlternateForm -> SignMode -> TypeFormat

-- | If the formatter use its alternate form
data AlternateForm
AlternateForm :: AlternateForm
NormalForm :: AlternateForm

-- | Default formating mode, no padding, default precision, no grouping, no
--   sign handling
pattern DefaultFormatMode :: FormatMode
type Parser t = ParsecT Void String (Reader ParsingContext) t
data ParsingContext
ParsingContext :: (Char, Char) -> [Extension] -> ParsingContext
[delimiters] :: ParsingContext -> (Char, Char)
[enabledExtensions] :: ParsingContext -> [Extension]

-- | Represents a value of type <tt>t</tt> or an Haskell expression
--   supposed to represents that value
data ExprOrValue t
Value :: t -> ExprOrValue t
HaskellExpr :: Exp -> ExprOrValue t
instance GHC.Show.Show PyF.Internal.PythonSyntax.Item
instance GHC.Show.Show PyF.Internal.PythonSyntax.FormatMode
instance GHC.Show.Show PyF.Internal.PythonSyntax.TypeFormat
instance GHC.Show.Show PyF.Internal.PythonSyntax.AlternateForm
instance GHC.Show.Show PyF.Internal.PythonSyntax.TypeFlag
instance GHC.Show.Show PyF.Internal.PythonSyntax.Precision
instance GHC.Show.Show t => GHC.Show.Show (PyF.Internal.PythonSyntax.ExprOrValue t)
instance GHC.Show.Show PyF.Internal.PythonSyntax.Padding
instance GHC.Show.Show PyF.Internal.PythonSyntax.ParsingContext


-- | This module uses the python mini language detailed in
--   <a>PythonSyntax</a> to build an template haskell expression
--   representing a formatted string.
module PyF.Internal.QQ

-- | Parse a string and return a formatter for it
toExp :: (Char, Char) -> String -> Q Exp
toExpPython :: String -> Q Exp
instance PyF.Internal.QQ.FormatAny2 (PyF.Class.PyFClassify t) t k => PyF.Internal.QQ.FormatAny t k
instance (GHC.Show.Show t, GHC.Real.Integral t) => PyF.Internal.QQ.FormatAny2 'PyF.Class.PyFIntegral t k
instance GHC.Float.RealFloat t => PyF.Internal.QQ.FormatAny2 'PyF.Class.PyFFractional t k
instance PyF.Class.PyFToString t => PyF.Internal.QQ.FormatAny2 'PyF.Class.PyFString t 'PyF.Formatters.AlignAll
instance (TypeError ...) => PyF.Internal.QQ.FormatAny2 'PyF.Class.PyFString t 'PyF.Formatters.AlignNumber


-- | A lot of quasiquoters to format and interpolate string expression
module PyF

-- | Generic formatter, can format an expression to any <tt>t</tt> as long
--   as <tt>t</tt> is an instance of <tt>IsString</tt>.
fmt :: QuasiQuoter
fmtWithDelimiters :: (Char, Char) -> QuasiQuoter