{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE MagicHash #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE Trustworthy #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeOperators #-}

#if __GLASGOW_HASKELL__ < 806
{-# LANGUAGE TypeInType #-}
#endif

{-# OPTIONS_GHC -Wno-deprecations #-}

#if __GLASGOW_HASKELL__ == 800 \
    && __GLASGOW_HASKELL_PATCHLEVEL1__ == 1
{-# OPTIONS_GHC -Wno-type-defaults #-} -- Needed due to GHC Trac #11947
#endif

{-|
Module:      Data.Proxyless
Copyright:   (C) 2016-2017 Ryan Scott
License:     BSD-style (see the file LICENSE)
Maintainer:  Ryan Scott
Stability:   Provisional
Portability: GHC

Remove the 'Proxy', 'Proxy#', and 'undefined' arguments from functions with
'proxyless', 'proxyHashless', and 'undefinedless', respectively, which produce
functions that take type information via GHC's @-XTypeApplications@ extension.

See also "Data.Proxyless.RequiredTypeArguments" for a version of this module
that leverages @-XRequiredTypeArguments@ instead of @-XTypeApplications@.

This module is only available with GHC 8.0 or later.

/Since: 0.2/
-}
module Data.Proxyless (
      -- * 'proxyless', 'proxyHashless', and 'undefinedless'
      proxyless
    , proxyHashless
    , undefinedless
      -- * Proxyless functions
      -- ** "Data.Bits"
    , theBitSize
    , theIsSigned
    , theBitSizeMaybe
    , theFiniteBitSize
      -- ** "Data.Data"
    , theDataTypeOf
      -- ** "Data.Typeable"
    , theTypeNatTypeRep
    , theTypeRep
    , theTypeRep#
    , theTypeSymbolTypeRep
      -- ** "Foreign.Storable"
    , theSizeOf
    , theAlignment
      -- ** "GHC.Generics"
    , theDatatypeName
    , theModuleName
    , theIsNewtype
    , thePackageName
    , theConName
    , theConFixity
    , theConIsRecord
    , theSelName
    , theSelSourceUnpackedness
    , theSelSourceStrictness
    , theSelDecidedStrictness
      -- ** "GHC.OverloadedLabels"
    , theFromLabel
      -- ** "GHC.TypeLits"
    , theNatVal
    , theNatVal'
    , theSameNat
    , theSameSymbol
    , theSomeNat
    , theSomeSymbol
    , theSymbolVal
    , theSymbolVal'
      -- ** "Prelude"
    , theFloatRadix
    , theFloatDigits
    , theFloatRange
      -- ** "Text.Printf"
    , theParseFormat
    ) where

import Data.Bits (Bits(..), FiniteBits(..))
import Data.Data (Data(dataTypeOf), DataType)
import Data.Proxy (Proxy(..))
import Data.Type.Equality ((:~:))
import Data.Typeable (Typeable, TypeRep, typeRep)
#if !(MIN_VERSION_base(4,10,0))
import Data.Typeable.Internal (typeRep#, typeNatTypeRep, typeSymbolTypeRep)
#endif

import Foreign.Storable (Storable(..))

import GHC.Exts (Proxy#, proxy#)
import GHC.Generics
import GHC.OverloadedLabels (IsLabel(..))
import GHC.TypeLits

import Text.Printf (PrintfArg(..), ModifierParser)

-- | Converts a constant function that takes a 'Proxy' argument to one that
-- doesn't require an argument.
--
-- /Since: 0.2/
proxyless :: forall k (a :: k) b. (Proxy a -> b) -> b
proxyless :: forall k (a :: k) b. (Proxy a -> b) -> b
proxyless Proxy a -> b
f = Proxy a -> b
f Proxy a
forall {k} (t :: k). Proxy t
Proxy

-- | Converts a constant function that takes a 'Proxy#' argument to one that
-- doesn't require an argument.
--
-- /Since: 0.2/
proxyHashless :: forall k (a :: k) b. (Proxy# a -> b) -> b
proxyHashless :: forall k (a :: k) b. (Proxy# a -> b) -> b
proxyHashless Proxy# a -> b
f = Proxy# a -> b
f Proxy# a
forall {k} (a :: k). Proxy# a
proxy#

-- | Converts a constant function that takes an 'undefined' argument to one that
-- doesn't require an argument.
--
-- /Since: 0.2/
undefinedless :: forall a b. (a -> b) -> b
undefinedless :: forall a b. (a -> b) -> b
undefinedless a -> b
f = a -> b
f a
forall a. HasCallStack => a
undefined

-------------------------------------------------------------------------------
-- Data.Bits
-------------------------------------------------------------------------------

-- | @'theBitSize' = 'undefinedless' 'bitSize'@
--
-- /Since: 0.2/
theBitSize :: forall a. Bits a => Int
theBitSize :: forall a. Bits a => Int
theBitSize = forall a b. (a -> b) -> b
undefinedless @a a -> Int
forall a. Bits a => a -> Int
bitSize

-- | @'theIsSigned' = 'undefinedless' 'isSigned'@
--
-- /Since: 0.2/
theIsSigned :: forall a. Bits a => Bool
theIsSigned :: forall a. Bits a => Bool
theIsSigned = forall a b. (a -> b) -> b
undefinedless @a a -> Bool
forall a. Bits a => a -> Bool
isSigned

-- | @'theBitSizeMaybe' = 'undefinedless' 'bitSizeMaybe'@
--
-- /Since: 0.2/
theBitSizeMaybe :: forall a. Bits a => Maybe Int
theBitSizeMaybe :: forall a. Bits a => Maybe Int
theBitSizeMaybe = forall a b. (a -> b) -> b
undefinedless @a a -> Maybe Int
forall a. Bits a => a -> Maybe Int
bitSizeMaybe

-- | @'theFiniteBitSize' = 'undefinedless' 'finiteBitSize'@
--
-- /Since: 0.2/
theFiniteBitSize :: forall a. FiniteBits a => Int
theFiniteBitSize :: forall a. FiniteBits a => Int
theFiniteBitSize = forall a b. (a -> b) -> b
undefinedless @a a -> Int
forall b. FiniteBits b => b -> Int
finiteBitSize

-------------------------------------------------------------------------------
-- Data.Data
-------------------------------------------------------------------------------

-- | @'theDataTypeOf' = 'undefinedless' 'dataTypeOf'@
--
-- /Since: 0.2/
theDataTypeOf :: forall a. Data a => DataType
theDataTypeOf :: forall a. Data a => DataType
theDataTypeOf = forall a b. (a -> b) -> b
undefinedless @a a -> DataType
forall a. Data a => a -> DataType
dataTypeOf

-------------------------------------------------------------------------------
-- Data.Typeable
-------------------------------------------------------------------------------

-- | @'theTypeNatTypeRep' = 'proxyHashless' 'typeNatTypeRep'@
--
-- Note that in @base-4.10@ and later, 'theTypeNatTypeRep' is simply a synonym
-- for 'theTypeRep', as 'typeNatTypeRep' is no longer exported.
--
-- /Since: 0.2/
theTypeNatTypeRep :: forall a. KnownNat a => TypeRep
#if MIN_VERSION_base(4,10,0)
theTypeNatTypeRep :: forall (a :: Nat). KnownNat a => TypeRep
theTypeNatTypeRep = forall k (a :: k). Typeable a => TypeRep
theTypeRep @_ @a
#else
theTypeNatTypeRep = proxyHashless @_ @a typeNatTypeRep
#endif

-- | @'theTypeRep' = 'proxyless' 'typeRep'@
--
-- /Since: 0.2/
theTypeRep :: forall k (a :: k). Typeable a => TypeRep
theTypeRep :: forall k (a :: k). Typeable a => TypeRep
theTypeRep = forall k (a :: k) b. (Proxy a -> b) -> b
proxyless @_ @a Proxy a -> TypeRep
forall {k} (proxy :: k -> *) (a :: k).
Typeable a =>
proxy a -> TypeRep
typeRep

-- | @'theTypeRep#' = 'proxyHashless' 'typeRep#'@
--
-- Note that in @base-4.10@ and later, 'theTypeRep#' is simply a synonym for
-- 'theTypeRep', as 'typeRep#' is no longer exported.
--
-- /Since: 0.2/
theTypeRep# :: forall k (a :: k). Typeable a => TypeRep
#if MIN_VERSION_base(4,10,0)
theTypeRep# :: forall k (a :: k). Typeable a => TypeRep
theTypeRep# = forall k (a :: k). Typeable a => TypeRep
theTypeRep @k @a
#else
theTypeRep# = proxyHashless @_ @a typeRep#
#endif

-- | @'theTypeSymbolTypeRep' = 'proxyHashless' 'typeSymbolTypeRep'@
--
-- Note that in @base-4.10@ and later, 'theTypeSymbolTypeRep' is simply a
-- synonym for 'theTypeRep', as 'typeSymbolTypeRep' is no longer exported.
--
-- /Since: 0.2/
theTypeSymbolTypeRep :: forall a. KnownSymbol a => TypeRep
#if MIN_VERSION_base(4,10,0)
theTypeSymbolTypeRep :: forall (a :: Symbol). KnownSymbol a => TypeRep
theTypeSymbolTypeRep = forall k (a :: k). Typeable a => TypeRep
theTypeRep @_ @a
#else
theTypeSymbolTypeRep = proxyHashless @_ @a typeSymbolTypeRep
#endif

-------------------------------------------------------------------------------
-- Foreign.Storable
-------------------------------------------------------------------------------

-- | @'theSizeOf' = 'undefinedless' 'sizeOf'@
--
-- /Since: 0.2/
theSizeOf :: forall a. Storable a => Int
theSizeOf :: forall a. Storable a => Int
theSizeOf = forall a b. (a -> b) -> b
undefinedless @a a -> Int
forall a. Storable a => a -> Int
sizeOf

-- | @'theAlignment' = 'undefinedless' 'alignment'@
--
-- /Since: 0.2/
theAlignment :: forall a. Storable a => Int
theAlignment :: forall a. Storable a => Int
theAlignment = forall a b. (a -> b) -> b
undefinedless @a a -> Int
forall a. Storable a => a -> Int
alignment

-------------------------------------------------------------------------------
-- GHC.Generics
-------------------------------------------------------------------------------

-- | @'theDatatypeName' = 'datatypeName' 'undefined'@
--
-- /Since: 0.2/
theDatatypeName :: forall k (d :: k). Datatype d => [Char]
theDatatypeName :: forall k (d :: k). Datatype d => [Char]
theDatatypeName = forall (d :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *)
       (a :: k1).
Datatype d =>
t d f a -> [Char]
forall {k} (d :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *)
       (f :: k1 -> *) (a :: k1).
Datatype d =>
t d f a -> [Char]
datatypeName @d Any d Any Any
forall a. HasCallStack => a
undefined

-- | @'theModuleName' = 'moduleName' 'undefined'@
--
-- /Since: 0.2/
theModuleName :: forall k (d :: k). Datatype d => [Char]
theModuleName :: forall k (d :: k). Datatype d => [Char]
theModuleName = forall (d :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *)
       (a :: k1).
Datatype d =>
t d f a -> [Char]
forall {k} (d :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *)
       (f :: k1 -> *) (a :: k1).
Datatype d =>
t d f a -> [Char]
moduleName @d Any d Any Any
forall a. HasCallStack => a
undefined

-- | @'theIsNewtype' = 'isNewtype' 'undefined'@
--
-- /Since: 0.2/
theIsNewtype :: forall k (d :: k). Datatype d => Bool
theIsNewtype :: forall k (d :: k). Datatype d => Bool
theIsNewtype = forall (d :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *)
       (a :: k1).
Datatype d =>
t d f a -> Bool
forall {k} (d :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *)
       (f :: k1 -> *) (a :: k1).
Datatype d =>
t d f a -> Bool
isNewtype @d Any d Any Any
forall a. HasCallStack => a
undefined

-- | @'thePackageName' = 'packageName' 'undefined'@
--
-- /Since: 0.2/
thePackageName :: forall k (d :: k). Datatype d => [Char]
thePackageName :: forall k (d :: k). Datatype d => [Char]
thePackageName = forall (d :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *)
       (a :: k1).
Datatype d =>
t d f a -> [Char]
forall {k} (d :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *)
       (f :: k1 -> *) (a :: k1).
Datatype d =>
t d f a -> [Char]
packageName @d Any d Any Any
forall a. HasCallStack => a
undefined

-- | @'theConName' = 'conName' 'undefined'@
--
-- /Since: 0.2/
theConName :: forall k (c :: k). Constructor c => [Char]
theConName :: forall k (c :: k). Constructor c => [Char]
theConName = forall (c :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *)
       (a :: k1).
Constructor c =>
t c f a -> [Char]
forall {k} (c :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *)
       (f :: k1 -> *) (a :: k1).
Constructor c =>
t c f a -> [Char]
conName @c Any c Any Any
forall a. HasCallStack => a
undefined

-- | @'theConFixity' = 'conFixity' 'undefined'@
--
-- /Since: 0.2/
theConFixity :: forall k (c :: k). Constructor c => Fixity
theConFixity :: forall k (c :: k). Constructor c => Fixity
theConFixity = forall (c :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *)
       (a :: k1).
Constructor c =>
t c f a -> Fixity
forall {k} (c :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *)
       (f :: k1 -> *) (a :: k1).
Constructor c =>
t c f a -> Fixity
conFixity @c Any c Any Any
forall a. HasCallStack => a
undefined

-- | @'theConIsRecord' = 'conIsRecord' 'undefined'@
--
-- /Since: 0.2/
theConIsRecord :: forall k (c :: k). Constructor c => Bool
theConIsRecord :: forall k (c :: k). Constructor c => Bool
theConIsRecord = forall (c :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *)
       (a :: k1).
Constructor c =>
t c f a -> Bool
forall {k} (c :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *)
       (f :: k1 -> *) (a :: k1).
Constructor c =>
t c f a -> Bool
conIsRecord @c Any c Any Any
forall a. HasCallStack => a
undefined

-- | @'theSelName' = 'selName' 'undefined'@
--
-- /Since: 0.2/
theSelName :: forall k (s :: k). Selector s => [Char]
theSelName :: forall k (s :: k). Selector s => [Char]
theSelName = forall (s :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *)
       (a :: k1).
Selector s =>
t s f a -> [Char]
forall {k} (s :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *)
       (f :: k1 -> *) (a :: k1).
Selector s =>
t s f a -> [Char]
selName @s Any s Any Any
forall a. HasCallStack => a
undefined

-- | @'theSelSourceUnpackedness' = 'selSourceUnpackedness' 'undefined'@
--
-- /Since: 0.2/
theSelSourceUnpackedness :: forall k (s :: k). Selector s => SourceUnpackedness
theSelSourceUnpackedness :: forall k (s :: k). Selector s => SourceUnpackedness
theSelSourceUnpackedness = forall (s :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *)
       (a :: k1).
Selector s =>
t s f a -> SourceUnpackedness
forall {k} (s :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *)
       (f :: k1 -> *) (a :: k1).
Selector s =>
t s f a -> SourceUnpackedness
selSourceUnpackedness @s Any s Any Any
forall a. HasCallStack => a
undefined

-- | @'theSelSourceStrictness' = 'selSourceStrictness' 'undefined'@
--
-- /Since: 0.2/
theSelSourceStrictness :: forall k (s :: k). Selector s => SourceStrictness
theSelSourceStrictness :: forall k (s :: k). Selector s => SourceStrictness
theSelSourceStrictness = forall (s :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *)
       (a :: k1).
Selector s =>
t s f a -> SourceStrictness
forall {k} (s :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *)
       (f :: k1 -> *) (a :: k1).
Selector s =>
t s f a -> SourceStrictness
selSourceStrictness @s Any s Any Any
forall a. HasCallStack => a
undefined

-- | @'theSelDecidedStrictness' = 'selDecidedStrictness' 'undefined'@
--
-- /Since: 0.2/
theSelDecidedStrictness :: forall k (s :: k). Selector s => DecidedStrictness
theSelDecidedStrictness :: forall k (s :: k). Selector s => DecidedStrictness
theSelDecidedStrictness = forall (s :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *) (f :: k1 -> *)
       (a :: k1).
Selector s =>
t s f a -> DecidedStrictness
forall {k} (s :: k) k1 (t :: k -> (k1 -> *) -> k1 -> *)
       (f :: k1 -> *) (a :: k1).
Selector s =>
t s f a -> DecidedStrictness
selDecidedStrictness @s Any s Any Any
forall a. HasCallStack => a
undefined

-------------------------------------------------------------------------------
-- GHC.OverloadedLabels
-------------------------------------------------------------------------------

-- | In @base-4.10@ and later, this is simply a synonym for 'fromLabel'.
-- In @base-4.9@, 'theFromLabel' is defined as:
--
-- @'theFromLabel' = 'proxyHashless' 'fromLabel'@
--
-- /Since: 0.2/
theFromLabel :: forall x a. IsLabel x a => a
#if MIN_VERSION_base(4,10,0)
theFromLabel :: forall (x :: Symbol) a. IsLabel x a => a
theFromLabel = forall (x :: Symbol) a. IsLabel x a => a
fromLabel @x
#else
theFromLabel = proxyHashless @_ @x fromLabel
#endif

-------------------------------------------------------------------------------
-- GHC.TypeLits
-------------------------------------------------------------------------------

-- | @'theNatVal' = 'proxyless' 'natVal'@
--
-- /Since: 0.2/
theNatVal :: forall n. KnownNat n => Integer
theNatVal :: forall (n :: Nat). KnownNat n => Integer
theNatVal = forall k (a :: k) b. (Proxy a -> b) -> b
proxyless @_ @n Proxy n -> Integer
forall (n :: Nat) (proxy :: Nat -> *).
KnownNat n =>
proxy n -> Integer
natVal

-- | @`theNatVal'` = 'proxyHashless' `natVal'`@
--
-- /Since: 0.2/
theNatVal' :: forall n. KnownNat n => Integer
theNatVal' :: forall (n :: Nat). KnownNat n => Integer
theNatVal' = forall k (a :: k) b. (Proxy# a -> b) -> b
proxyHashless @_ @n Proxy# n -> Integer
forall (n :: Nat). KnownNat n => Proxy# n -> Integer
natVal'

-- | @'theSameNat' = 'sameNat' 'Proxy' 'Proxy'@
--
-- /Since: 0.2/
theSameNat :: forall a b. (KnownNat a, KnownNat b) => Maybe (a :~: b)
theSameNat :: forall (a :: Nat) (b :: Nat).
(KnownNat a, KnownNat b) =>
Maybe (a :~: b)
theSameNat = Proxy a -> Proxy b -> Maybe (a :~: b)
forall (a :: Nat) (b :: Nat) (proxy1 :: Nat -> *)
       (proxy2 :: Nat -> *).
(KnownNat a, KnownNat b) =>
proxy1 a -> proxy2 b -> Maybe (a :~: b)
sameNat (forall (t :: Nat). Proxy t
forall {k} (t :: k). Proxy t
Proxy @a) (forall (t :: Nat). Proxy t
forall {k} (t :: k). Proxy t
Proxy @b)

-- | @'theSameSymbol' = 'sameSymbol' 'Proxy' 'Proxy'@
--
-- /Since: 0.2/
theSameSymbol :: forall a b. (KnownSymbol a, KnownSymbol b) => Maybe (a :~: b)
theSameSymbol :: forall (a :: Symbol) (b :: Symbol).
(KnownSymbol a, KnownSymbol b) =>
Maybe (a :~: b)
theSameSymbol = Proxy a -> Proxy b -> Maybe (a :~: b)
forall (a :: Symbol) (b :: Symbol) (proxy1 :: Symbol -> *)
       (proxy2 :: Symbol -> *).
(KnownSymbol a, KnownSymbol b) =>
proxy1 a -> proxy2 b -> Maybe (a :~: b)
sameSymbol (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
Proxy @a) (forall {k} (t :: k). Proxy t
forall (t :: Symbol). Proxy t
Proxy @b)

-- | @'theSomeNat' = 'proxyless' 'SomeNat'@
--
-- /Since: 0.2/
theSomeNat :: forall n. KnownNat n => SomeNat
theSomeNat :: forall (n :: Nat). KnownNat n => SomeNat
theSomeNat = forall k (a :: k) b. (Proxy a -> b) -> b
proxyless @_ @n Proxy n -> SomeNat
forall (n :: Nat). KnownNat n => Proxy n -> SomeNat
SomeNat

-- | @'theSomeSymbol' = 'proxyless' 'SomeSymbol'@
--
-- /Since: 0.2/
theSomeSymbol :: forall n. KnownSymbol n => SomeSymbol
theSomeSymbol :: forall (n :: Symbol). KnownSymbol n => SomeSymbol
theSomeSymbol = forall k (a :: k) b. (Proxy a -> b) -> b
proxyless @_ @n Proxy n -> SomeSymbol
forall (n :: Symbol). KnownSymbol n => Proxy n -> SomeSymbol
SomeSymbol

-- | @'theSymbolVal' = 'proxyless' 'symbolVal'@
--
-- /Since: 0.2/
theSymbolVal :: forall n. KnownSymbol n => String
theSymbolVal :: forall (n :: Symbol). KnownSymbol n => [Char]
theSymbolVal = forall k (a :: k) b. (Proxy a -> b) -> b
proxyless @_ @n Proxy n -> [Char]
forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> [Char]
symbolVal

-- | @`theSymbolVal'` = 'proxyHashless' `symbolVal'`@
--
-- /Since: 0.2/
theSymbolVal' :: forall n. KnownSymbol n => String
theSymbolVal' :: forall (n :: Symbol). KnownSymbol n => [Char]
theSymbolVal' = forall k (a :: k) b. (Proxy# a -> b) -> b
proxyHashless @_ @n Proxy# n -> [Char]
forall (n :: Symbol). KnownSymbol n => Proxy# n -> [Char]
symbolVal'

-------------------------------------------------------------------------------
-- Prelude
-------------------------------------------------------------------------------

-- | @'theFloatRadix' = 'undefinedless' 'floatRadix'@
--
-- /Since: 0.2/
theFloatRadix :: forall a. RealFloat a => Integer
theFloatRadix :: forall a. RealFloat a => Integer
theFloatRadix = forall a b. (a -> b) -> b
undefinedless @a a -> Integer
forall a. RealFloat a => a -> Integer
floatRadix

-- | @'theFloatDigits' = 'undefinedless' 'floatDigits'@
--
-- /Since: 0.2/
theFloatDigits :: forall a. RealFloat a => Int
theFloatDigits :: forall a. RealFloat a => Int
theFloatDigits = forall a b. (a -> b) -> b
undefinedless @a a -> Int
forall a. RealFloat a => a -> Int
floatDigits

-- | @'theFloatRange' = 'undefinedless' 'floatRange'@
--
-- /Since: 0.2/
theFloatRange :: forall a. RealFloat a => (Int, Int)
theFloatRange :: forall a. RealFloat a => (Int, Int)
theFloatRange = forall a b. (a -> b) -> b
undefinedless @a a -> (Int, Int)
forall a. RealFloat a => a -> (Int, Int)
floatRange

-------------------------------------------------------------------------------
-- Text.Printf
-------------------------------------------------------------------------------

-- | @'theParseFormat' = 'undefinedless' 'parseFormat'@
--
-- /Since: 0.2/
theParseFormat :: forall a. PrintfArg a => ModifierParser
theParseFormat :: forall a. PrintfArg a => ModifierParser
theParseFormat = forall a b. (a -> b) -> b
undefinedless @a a -> ModifierParser
forall a. PrintfArg a => a -> ModifierParser
parseFormat