exon 0.1.0.0 → 0.1.1.0
raw patch · 7 files changed
+87/−12 lines, 7 filesPVP: major bump suggested
API removals or changes: PVP suggests a major version bump
API changes (from Hackage documentation)
- Exon.Debug: dbg :: HasCallStack => Monad m => Text -> m ()
- Exon.Debug: dbgs :: HasCallStack => Monad m => Show a => a -> m ()
- Exon.Debug: dbgsWith :: HasCallStack => Monad m => Show a => Text -> a -> m ()
- Exon.Debug: dbgs_ :: HasCallStack => Monad m => Show a => a -> m a
- Exon.Debug: debugPrint :: SrcLoc -> Text -> IO ()
- Exon.Debug: debugPrintWithLoc :: Monad m => SrcLoc -> Text -> m ()
- Exon.Debug: srcLoc :: CallStack -> SrcLoc
- Exon.Debug: tr :: HasCallStack => Text -> a -> a
- Exon.Debug: trs :: Show a => HasCallStack => a -> a
- Exon.Debug: trs' :: Show b => HasCallStack => b -> a -> a
- Exon.Parse: before :: Parser a -> Parser () -> Parser () -> Parser ()
- Exon.Parse: expr :: Parser ()
- Exon.Parse: finishBefore :: Parser a -> Parser () -> Parser ()
- Exon.Parse: interpolation :: Parser RawSegment
- Exon.Parse: parse :: String -> Either Text [RawSegment]
- Exon.Parse: parser :: Parser [RawSegment]
- Exon.Parse: segment :: Parser RawSegment
- Exon.Parse: span :: Parser () -> Parser String
- Exon.Parse: text :: Parser RawSegment
- Exon.Parse: type Parser = Parser Text
- Exon.Parse: untilTokenEnd :: Parser ()
- Exon.Parse: whitespace :: Parser RawSegment
- Exon.Parse: ws :: Parser Char
- Exon.Prelude: (!!?) :: [a] -> Int -> Maybe a
- Exon.Prelude: ($!!) :: NFData a => (a -> b) -> a -> b
- Exon.Prelude: ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- Exon.Prelude: ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
- Exon.Prelude: ($<) :: Contravariant f => f b -> b -> f a
- Exon.Prelude: ($>) :: Functor f => f a -> b -> f b
- Exon.Prelude: (&&&) :: Arrow a => a b c -> a b c' -> a b (c, c')
- Exon.Prelude: (&&) :: Bool -> Bool -> Bool
- Exon.Prelude: (&&^) :: Monad m => m Bool -> m Bool -> m Bool
- Exon.Prelude: (&) :: a -> (a -> b) -> b
- Exon.Prelude: (*) :: Num a => a -> a -> a
- Exon.Prelude: (**) :: Floating a => a -> a -> a
- Exon.Prelude: (*>) :: Applicative f => f a -> f b -> f b
- Exon.Prelude: (+) :: Num a => a -> a -> a
- Exon.Prelude: (++) :: [a] -> [a] -> [a]
- Exon.Prelude: (-) :: Num a => a -> a -> a
- Exon.Prelude: (.) :: (b -> c) -> (a -> b) -> a -> c
- Exon.Prelude: (/) :: Fractional a => a -> a -> a
- Exon.Prelude: (/=) :: Eq a => a -> a -> Bool
- Exon.Prelude: (:|) :: a -> [a] -> NonEmpty a
- Exon.Prelude: (<$!>) :: Monad m => (a -> b) -> m a -> m b
- Exon.Prelude: (<$) :: Functor f => a -> f b -> f a
- Exon.Prelude: (<$>) :: Functor f => (a -> b) -> f a -> f b
- Exon.Prelude: (<&>) :: Functor f => f a -> (a -> b) -> f b
- Exon.Prelude: (<) :: Ord a => a -> a -> Bool
- Exon.Prelude: (<*) :: Applicative f => f a -> f b -> f a
- Exon.Prelude: (<**>) :: Applicative f => f a -> f (a -> b) -> f b
- Exon.Prelude: (<*>) :: Applicative f => f (a -> b) -> f a -> f b
- Exon.Prelude: (<<$>>) :: (Functor f, Functor g) => (a -> b) -> f (g a) -> f (g b)
- Exon.Prelude: (<<<) :: forall k cat (b :: k) (c :: k) (a :: k). Category cat => cat b c -> cat a b -> cat a c
- Exon.Prelude: (<=) :: Ord a => a -> a -> Bool
- Exon.Prelude: (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- Exon.Prelude: (<>) :: Semigroup a => a -> a -> a
- Exon.Prelude: (<|>) :: Alternative f => f a -> f a -> f a
- Exon.Prelude: (=<<) :: Monad m => (a -> m b) -> m a -> m b
- Exon.Prelude: (==) :: Eq a => a -> a -> Bool
- Exon.Prelude: (>$$<) :: Contravariant f => f b -> (a -> b) -> f a
- Exon.Prelude: (>$) :: Contravariant f => b -> f b -> f a
- Exon.Prelude: (>$<) :: Contravariant f => (a -> b) -> f b -> f a
- Exon.Prelude: (>) :: Ord a => a -> a -> Bool
- Exon.Prelude: (>=) :: Ord a => a -> a -> Bool
- Exon.Prelude: (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- Exon.Prelude: (>>) :: Monad m => m a -> m b -> m b
- Exon.Prelude: (>>=) :: Monad m => m a -> (a -> m b) -> m b
- Exon.Prelude: (>>>) :: forall k cat (a :: k) (b :: k) (c :: k). Category cat => cat a b -> cat b c -> cat a c
- Exon.Prelude: (?:) :: Maybe a -> a -> a
- Exon.Prelude: (??) :: Functor f => f (a -> b) -> a -> f b
- Exon.Prelude: (^) :: (Num a, Integral b) => a -> b -> a
- Exon.Prelude: (^^) :: (Fractional a, Integral b) => a -> b -> a
- Exon.Prelude: (||) :: Bool -> Bool -> Bool
- Exon.Prelude: (||^) :: Monad m => m Bool -> m Bool -> m Bool
- Exon.Prelude: All :: Bool -> All
- Exon.Prelude: Alt :: f a -> Alt (f :: k -> Type) (a :: k)
- Exon.Prelude: Any :: Bool -> Any
- Exon.Prelude: Ap :: f a -> Ap (f :: k -> Type) (a :: k)
- Exon.Prelude: AppendMode :: IOMode
- Exon.Prelude: BlockBuffering :: Maybe Int -> BufferMode
- Exon.Prelude: Bug :: SomeException -> CallStack -> Bug
- Exon.Prelude: Comparison :: (a -> a -> Ordering) -> Comparison a
- Exon.Prelude: Compose :: f (g a) -> Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1)
- Exon.Prelude: Const :: a -> Const a (b :: k)
- Exon.Prelude: D# :: Double# -> Double
- Exon.Prelude: Down :: a -> Down a
- Exon.Prelude: Dual :: a -> Dual a
- Exon.Prelude: EQ :: Ordering
- Exon.Prelude: Endo :: (a -> a) -> Endo a
- Exon.Prelude: Equivalence :: (a -> a -> Bool) -> Equivalence a
- Exon.Prelude: ExceptT :: m (Either e a) -> ExceptT e (m :: Type -> Type) a
- Exon.Prelude: F# :: Float# -> Float
- Exon.Prelude: False :: Bool
- Exon.Prelude: First :: Maybe a -> First a
- Exon.Prelude: GT :: Ordering
- Exon.Prelude: Identity :: a -> Identity a
- Exon.Prelude: Just :: a -> Maybe a
- Exon.Prelude: LT :: Ordering
- Exon.Prelude: Last :: Maybe a -> Last a
- Exon.Prelude: Left :: a -> Either a b
- Exon.Prelude: LineBuffering :: BufferMode
- Exon.Prelude: MaybeT :: m (Maybe a) -> MaybeT (m :: Type -> Type) a
- Exon.Prelude: NoBuffering :: BufferMode
- Exon.Prelude: Nothing :: Maybe a
- Exon.Prelude: Op :: (b -> a) -> Op a b
- Exon.Prelude: Option :: Maybe a -> Option a
- Exon.Prelude: Predicate :: (a -> Bool) -> Predicate a
- Exon.Prelude: Product :: a -> Product a
- Exon.Prelude: Proxy :: Proxy (t :: k)
- Exon.Prelude: ReadMode :: IOMode
- Exon.Prelude: ReadWriteMode :: IOMode
- Exon.Prelude: ReaderT :: (r -> m a) -> ReaderT r (m :: Type -> Type) a
- Exon.Prelude: Right :: b -> Either a b
- Exon.Prelude: SomeException :: e -> SomeException
- Exon.Prelude: SomeNat :: Proxy n -> SomeNat
- Exon.Prelude: StateT :: (s -> m (a, s)) -> StateT s (m :: Type -> Type) a
- Exon.Prelude: Sum :: a -> Sum a
- Exon.Prelude: True :: Bool
- Exon.Prelude: Undefined :: Undefined
- Exon.Prelude: WriteMode :: IOMode
- Exon.Prelude: ZipList :: [a] -> ZipList a
- Exon.Prelude: [appEndo] :: Endo a -> a -> a
- Exon.Prelude: [getAll] :: All -> Bool
- Exon.Prelude: [getAlt] :: Alt (f :: k -> Type) (a :: k) -> f a
- Exon.Prelude: [getAny] :: Any -> Bool
- Exon.Prelude: [getAp] :: Ap (f :: k -> Type) (a :: k) -> f a
- Exon.Prelude: [getComparison] :: Comparison a -> a -> a -> Ordering
- Exon.Prelude: [getCompose] :: Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1) -> f (g a)
- Exon.Prelude: [getConst] :: Const a (b :: k) -> a
- Exon.Prelude: [getDown] :: Down a -> a
- Exon.Prelude: [getDual] :: Dual a -> a
- Exon.Prelude: [getEquivalence] :: Equivalence a -> a -> a -> Bool
- Exon.Prelude: [getFirst] :: First a -> Maybe a
- Exon.Prelude: [getLast] :: Last a -> Maybe a
- Exon.Prelude: [getOp] :: Op a b -> b -> a
- Exon.Prelude: [getOption] :: Option a -> Maybe a
- Exon.Prelude: [getPredicate] :: Predicate a -> a -> Bool
- Exon.Prelude: [getProduct] :: Product a -> a
- Exon.Prelude: [getSum] :: Sum a -> a
- Exon.Prelude: [getZipList] :: ZipList a -> [a]
- Exon.Prelude: [runIdentity] :: Identity a -> a
- Exon.Prelude: [runMaybeT] :: MaybeT (m :: Type -> Type) a -> m (Maybe a)
- Exon.Prelude: [runReaderT] :: ReaderT r (m :: Type -> Type) a -> r -> m a
- Exon.Prelude: [runStateT] :: StateT s (m :: Type -> Type) a -> s -> m (a, s)
- Exon.Prelude: abs :: Num a => a -> a
- Exon.Prelude: absurd :: Void -> a
- Exon.Prelude: acos :: Floating a => a -> a
- Exon.Prelude: acosh :: Floating a => a -> a
- Exon.Prelude: all :: Foldable t => (a -> Bool) -> t a -> Bool
- Exon.Prelude: allM :: (Foldable f, Monad m) => (a -> m Bool) -> f a -> m Bool
- Exon.Prelude: and :: Foldable t => t Bool -> Bool
- Exon.Prelude: andM :: (Foldable f, Monad m) => f (m Bool) -> m Bool
- Exon.Prelude: any :: Foldable t => (a -> Bool) -> t a -> Bool
- Exon.Prelude: anyM :: (Foldable f, Monad m) => (a -> m Bool) -> f a -> m Bool
- Exon.Prelude: appendFile :: MonadIO m => FilePath -> String -> m ()
- Exon.Prelude: appendFileBS :: MonadIO m => FilePath -> ByteString -> m ()
- Exon.Prelude: appendFileLBS :: MonadIO m => FilePath -> LByteString -> m ()
- Exon.Prelude: appendFileLText :: MonadIO m => FilePath -> LText -> m ()
- Exon.Prelude: appendFileText :: MonadIO m => FilePath -> Text -> m ()
- Exon.Prelude: appliedTo :: Applicative f => f a -> f (a -> b) -> f b
- Exon.Prelude: asTypeOf :: a -> a -> a
- Exon.Prelude: asin :: Floating a => a -> a
- Exon.Prelude: asinh :: Floating a => a -> a
- Exon.Prelude: ask :: MonadReader r m => m r
- Exon.Prelude: asks :: MonadReader r m => (r -> a) -> m a
- Exon.Prelude: asum :: (Foldable t, Alternative f) => t (f a) -> f a
- Exon.Prelude: asumMap :: forall b m f a. (Foldable f, Alternative m) => (a -> m b) -> f a -> m b
- Exon.Prelude: atan :: Floating a => a -> a
- Exon.Prelude: atan2 :: RealFloat a => a -> a -> a
- Exon.Prelude: atanh :: Floating a => a -> a
- Exon.Prelude: atomicModifyIORef :: MonadIO m => IORef a -> (a -> (a, b)) -> m b
- Exon.Prelude: atomicModifyIORef' :: MonadIO m => IORef a -> (a -> (a, b)) -> m b
- Exon.Prelude: atomicModifyIORef'_ :: MonadIO m => IORef a -> (a -> a) -> m ()
- Exon.Prelude: atomicModifyIORef_ :: MonadIO m => IORef a -> (a -> a) -> m ()
- Exon.Prelude: atomicWriteIORef :: MonadIO m => IORef a -> a -> m ()
- Exon.Prelude: atomically :: MonadIO m => STM a -> m a
- Exon.Prelude: biList :: Bifoldable t => t a a -> [a]
- Exon.Prelude: biall :: Bifoldable t => (a -> Bool) -> (b -> Bool) -> t a b -> Bool
- Exon.Prelude: biand :: Bifoldable t => t Bool Bool -> Bool
- Exon.Prelude: biany :: Bifoldable t => (a -> Bool) -> (b -> Bool) -> t a b -> Bool
- Exon.Prelude: biasum :: (Bifoldable t, Alternative f) => t (f a) (f a) -> f a
- Exon.Prelude: bielem :: (Bifoldable t, Eq a) => a -> t a a -> Bool
- Exon.Prelude: bifind :: Bifoldable t => (a -> Bool) -> t a a -> Maybe a
- Exon.Prelude: bifold :: (Bifoldable p, Monoid m) => p m m -> m
- Exon.Prelude: bifoldMap :: (Bifoldable p, Monoid m) => (a -> m) -> (b -> m) -> p a b -> m
- Exon.Prelude: bifoldMapDefault :: (Bitraversable t, Monoid m) => (a -> m) -> (b -> m) -> t a b -> m
- Exon.Prelude: bifoldl :: Bifoldable p => (c -> a -> c) -> (c -> b -> c) -> c -> p a b -> c
- Exon.Prelude: bifoldl' :: Bifoldable t => (a -> b -> a) -> (a -> c -> a) -> a -> t b c -> a
- Exon.Prelude: bifoldlM :: (Bifoldable t, Monad m) => (a -> b -> m a) -> (a -> c -> m a) -> a -> t b c -> m a
- Exon.Prelude: bifoldr :: Bifoldable p => (a -> c -> c) -> (b -> c -> c) -> c -> p a b -> c
- Exon.Prelude: bifoldr' :: Bifoldable t => (a -> c -> c) -> (b -> c -> c) -> c -> t a b -> c
- Exon.Prelude: bifoldrM :: (Bifoldable t, Monad m) => (a -> c -> m c) -> (b -> c -> m c) -> c -> t a b -> m c
- Exon.Prelude: bifor :: (Bitraversable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f (t c d)
- Exon.Prelude: bifor_ :: (Bifoldable t, Applicative f) => t a b -> (a -> f c) -> (b -> f d) -> f ()
- Exon.Prelude: bilength :: Bifoldable t => t a b -> Int
- Exon.Prelude: bimap :: Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d
- Exon.Prelude: bimapDefault :: Bitraversable t => (a -> b) -> (c -> d) -> t a c -> t b d
- Exon.Prelude: binull :: Bifoldable t => t a b -> Bool
- Exon.Prelude: bior :: Bifoldable t => t Bool Bool -> Bool
- Exon.Prelude: bisequence :: (Bitraversable t, Applicative f) => t (f a) (f b) -> f (t a b)
- Exon.Prelude: bisequence_ :: (Bifoldable t, Applicative f) => t (f a) (f b) -> f ()
- Exon.Prelude: bitraverse :: (Bitraversable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f (t c d)
- Exon.Prelude: bitraverse_ :: (Bifoldable t, Applicative f) => (a -> f c) -> (b -> f d) -> t a b -> f ()
- Exon.Prelude: bool :: a -> a -> Bool -> a
- Exon.Prelude: boundedEnumFrom :: (Enum a, Bounded a) => a -> [a]
- Exon.Prelude: boundedEnumFromThen :: (Enum a, Bounded a) => a -> a -> [a]
- Exon.Prelude: break :: (a -> Bool) -> [a] -> ([a], [a])
- Exon.Prelude: bug :: (HasCallStack, Exception e) => e -> a
- Exon.Prelude: byteSwap16 :: Word16 -> Word16
- Exon.Prelude: byteSwap32 :: Word32 -> Word32
- Exon.Prelude: byteSwap64 :: Word64 -> Word64
- Exon.Prelude: callStack :: HasCallStack => CallStack
- Exon.Prelude: catMaybes :: [Maybe a] -> [a]
- Exon.Prelude: catchSTM :: Exception e => STM a -> (e -> STM a) -> STM a
- Exon.Prelude: ceiling :: (RealFrac a, Integral b) => a -> b
- Exon.Prelude: chainedTo :: Monad m => (a -> m b) -> m a -> m b
- Exon.Prelude: chr :: Int -> Char
- Exon.Prelude: class Applicative f => Alternative (f :: Type -> Type)
- Exon.Prelude: class Functor f => Applicative (f :: Type -> Type)
- Exon.Prelude: class Bifoldable (p :: Type -> Type -> Type)
- Exon.Prelude: class Bifunctor (p :: Type -> Type -> Type)
- Exon.Prelude: class (Bifunctor t, Bifoldable t) => Bitraversable (t :: Type -> Type -> Type)
- Exon.Prelude: class Bounded a
- Exon.Prelude: class a ~R# b => Coercible (a :: k) (b :: k)
- Exon.Prelude: class Contravariant (f :: Type -> Type)
- Exon.Prelude: class ConvertUtf8 a b
- Exon.Prelude: class Enum a
- Exon.Prelude: class Eq a
- Exon.Prelude: class (Typeable e, Show e) => Exception e
- Exon.Prelude: class Fractional a => Floating a
- Exon.Prelude: class Foldable (t :: Type -> Type)
- Exon.Prelude: class Num a => Fractional a
- Exon.Prelude: class Functor (f :: Type -> Type)
- Exon.Prelude: class Generic a
- Exon.Prelude: class Hashable a
- Exon.Prelude: class (Real a, Enum a) => Integral a
- Exon.Prelude: class IsLabel (x :: Symbol) a
- Exon.Prelude: class IsList l
- Exon.Prelude: class IsString a
- Exon.Prelude: class KnownNat (n :: Nat)
- Exon.Prelude: class LazyStrict l s | l -> s, s -> l
- Exon.Prelude: class Applicative m => Monad (m :: Type -> Type)
- Exon.Prelude: class Monad m => MonadFail (m :: Type -> Type)
- Exon.Prelude: class Monad m => MonadIO (m :: Type -> Type)
- Exon.Prelude: class (Alternative m, Monad m) => MonadPlus (m :: Type -> Type)
- Exon.Prelude: class Monad m => MonadReader r (m :: Type -> Type) | m -> r
- Exon.Prelude: class Monad m => MonadState s (m :: Type -> Type) | m -> s
- Exon.Prelude: class MonadTrans (t :: Type -> Type -> Type -> Type)
- Exon.Prelude: class Semigroup a => Monoid a
- Exon.Prelude: class NFData a
- Exon.Prelude: class Num a
- Exon.Prelude: class One x where {
- Exon.Prelude: class Eq a => Ord a
- Exon.Prelude: class Read a
- Exon.Prelude: class (Num a, Ord a) => Real a
- Exon.Prelude: class (RealFrac a, Floating a) => RealFloat a
- Exon.Prelude: class (Real a, Fractional a) => RealFrac a
- Exon.Prelude: class Semigroup a
- Exon.Prelude: class Show a
- Exon.Prelude: class ToLText a
- Exon.Prelude: class ToString a
- Exon.Prelude: class ToText a
- Exon.Prelude: class (Functor t, Foldable t) => Traversable (t :: Type -> Type)
- Exon.Prelude: class Typeable (a :: k)
- Exon.Prelude: coerce :: forall (k :: RuntimeRep) (a :: TYPE k) (b :: TYPE k). Coercible a b => a -> b
- Exon.Prelude: compare :: Ord a => a -> a -> Ordering
- Exon.Prelude: comparing :: Ord a => (b -> a) -> b -> b -> Ordering
- Exon.Prelude: comparisonEquivalence :: Comparison a -> Equivalence a
- Exon.Prelude: concat :: Foldable t => t [a] -> [a]
- Exon.Prelude: concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
- Exon.Prelude: const :: a -> b -> a
- Exon.Prelude: contramap :: Contravariant f => (a -> b) -> f b -> f a
- Exon.Prelude: cos :: Floating a => a -> a
- Exon.Prelude: cosh :: Floating a => a -> a
- Exon.Prelude: currentCallStack :: IO [String]
- Exon.Prelude: curry :: ((a, b) -> c) -> a -> b -> c
- Exon.Prelude: cycle :: [a] -> [a]
- Exon.Prelude: cycle1 :: Semigroup m => m -> m
- Exon.Prelude: data Bool
- Exon.Prelude: data BufferMode
- Exon.Prelude: data Bug
- Exon.Prelude: data ByteString
- Exon.Prelude: data CallStack
- Exon.Prelude: data Char
- Exon.Prelude: data Constraint
- Exon.Prelude: data Double
- Exon.Prelude: data Either a b
- Exon.Prelude: data Float
- Exon.Prelude: data Handle
- Exon.Prelude: data HashMap k v
- Exon.Prelude: data HashSet a
- Exon.Prelude: data IO a
- Exon.Prelude: data IOMode
- Exon.Prelude: data IORef a
- Exon.Prelude: data IdentityT (f :: k -> Type) (a :: k)
- Exon.Prelude: data Int
- Exon.Prelude: data Int16
- Exon.Prelude: data Int32
- Exon.Prelude: data Int64
- Exon.Prelude: data Int8
- Exon.Prelude: data IntMap a
- Exon.Prelude: data IntSet
- Exon.Prelude: data Integer
- Exon.Prelude: data MVar a
- Exon.Prelude: data Map k a
- Exon.Prelude: data Maybe a
- Exon.Prelude: data Nat
- Exon.Prelude: data Natural
- Exon.Prelude: data NonEmpty a
- Exon.Prelude: data Ordering
- Exon.Prelude: data Proxy (t :: k)
- Exon.Prelude: data Ratio a
- Exon.Prelude: data STM a
- Exon.Prelude: data Seq a
- Exon.Prelude: data Set a
- Exon.Prelude: data ShortByteString
- Exon.Prelude: data SomeException
- Exon.Prelude: data SomeNat
- Exon.Prelude: data TMVar a
- Exon.Prelude: data TVar a
- Exon.Prelude: data Text
- Exon.Prelude: data Undefined
- Exon.Prelude: data UnicodeException
- Exon.Prelude: data Void
- Exon.Prelude: data Word
- Exon.Prelude: data Word16
- Exon.Prelude: data Word32
- Exon.Prelude: data Word64
- Exon.Prelude: data Word8
- Exon.Prelude: data WrappedMonoid m
- Exon.Prelude: dbg :: HasCallStack => Monad m => Text -> m ()
- Exon.Prelude: dbgs :: HasCallStack => Monad m => Show a => a -> m ()
- Exon.Prelude: dbgs_ :: HasCallStack => Monad m => Show a => a -> m a
- Exon.Prelude: decodeFloat :: RealFloat a => a -> (Integer, Int)
- Exon.Prelude: decodeUtf8 :: ConvertUtf8 a b => b -> a
- Exon.Prelude: decodeUtf8' :: ByteString -> Either UnicodeException Text
- Exon.Prelude: decodeUtf8Strict :: ConvertUtf8 a b => b -> Either UnicodeException a
- Exon.Prelude: decodeUtf8With :: OnDecodeError -> ByteString -> Text
- Exon.Prelude: deepseq :: NFData a => a -> b -> b
- Exon.Prelude: defaultComparison :: Ord a => Comparison a
- Exon.Prelude: defaultEquivalence :: Eq a => Equivalence a
- Exon.Prelude: denominator :: Ratio a -> a
- Exon.Prelude: die :: MonadIO m => String -> m a
- Exon.Prelude: displayException :: Exception e => e -> String
- Exon.Prelude: div :: Integral a => a -> a -> a
- Exon.Prelude: divMod :: Integral a => a -> a -> (a, a)
- Exon.Prelude: drop :: Int -> [a] -> [a]
- Exon.Prelude: dropWhile :: (a -> Bool) -> [a] -> [a]
- Exon.Prelude: either :: (a -> c) -> (b -> c) -> Either a b -> c
- Exon.Prelude: elem :: (Foldable f, DisallowElem f, Eq a) => a -> f a -> Bool
- Exon.Prelude: empty :: Alternative f => f a
- Exon.Prelude: encodeFloat :: RealFloat a => Integer -> Int -> a
- Exon.Prelude: encodeUtf8 :: ConvertUtf8 a b => a -> b
- Exon.Prelude: enumFrom :: Enum a => a -> [a]
- Exon.Prelude: enumFromThen :: Enum a => a -> a -> [a]
- Exon.Prelude: enumFromThenTo :: Enum a => a -> a -> a -> [a]
- Exon.Prelude: enumFromTo :: Enum a => a -> a -> [a]
- Exon.Prelude: error :: forall (r :: RuntimeRep) (a :: TYPE r) t. (HasCallStack, IsText t) => t -> a
- Exon.Prelude: etaReaderT :: forall r (m :: Type -> Type) a. ReaderT r m a -> ReaderT r m a
- Exon.Prelude: evalState :: State s a -> s -> a
- Exon.Prelude: evalStateT :: Monad m => StateT s m a -> s -> m a
- Exon.Prelude: evaluateNF :: (NFData a, MonadIO m) => a -> m a
- Exon.Prelude: evaluateNF_ :: (NFData a, MonadIO m) => a -> m ()
- Exon.Prelude: evaluateWHNF :: MonadIO m => a -> m a
- Exon.Prelude: evaluateWHNF_ :: MonadIO m => a -> m ()
- Exon.Prelude: evaluatingState :: s -> State s a -> a
- Exon.Prelude: evaluatingStateT :: Functor f => s -> StateT s f a -> f a
- Exon.Prelude: even :: Integral a => a -> Bool
- Exon.Prelude: exceptToMaybeT :: forall (m :: Type -> Type) e a. Functor m => ExceptT e m a -> MaybeT m a
- Exon.Prelude: execState :: State s a -> s -> s
- Exon.Prelude: execStateT :: Monad m => StateT s m a -> s -> m s
- Exon.Prelude: executingState :: s -> State s a -> s
- Exon.Prelude: executingStateT :: Functor f => s -> StateT s f a -> f s
- Exon.Prelude: exitFailure :: MonadIO m => m a
- Exon.Prelude: exitSuccess :: MonadIO m => m a
- Exon.Prelude: exitWith :: MonadIO m => ExitCode -> m a
- Exon.Prelude: exp :: Floating a => a -> a
- Exon.Prelude: fail :: MonadFail m => String -> m a
- Exon.Prelude: filter :: (a -> Bool) -> [a] -> [a]
- Exon.Prelude: filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
- Exon.Prelude: find :: Foldable t => (a -> Bool) -> t a -> Maybe a
- Exon.Prelude: first :: Bifunctor p => (a -> b) -> p a c -> p b c
- Exon.Prelude: fix :: (a -> a) -> a
- Exon.Prelude: flap :: Functor f => f (a -> b) -> a -> f b
- Exon.Prelude: flip :: (a -> b -> c) -> b -> a -> c
- Exon.Prelude: flipfoldl' :: Foldable f => (a -> b -> b) -> b -> f a -> b
- Exon.Prelude: floatDigits :: RealFloat a => a -> Int
- Exon.Prelude: floatRadix :: RealFloat a => a -> Integer
- Exon.Prelude: floatRange :: RealFloat a => a -> (Int, Int)
- Exon.Prelude: floor :: (RealFrac a, Integral b) => a -> b
- Exon.Prelude: fmap :: Functor f => (a -> b) -> f a -> f b
- Exon.Prelude: fold :: (Foldable t, Monoid m) => t m -> m
- Exon.Prelude: foldMap :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
- Exon.Prelude: foldMap' :: (Foldable t, Monoid m) => (a -> m) -> t a -> m
- Exon.Prelude: foldMapA :: (Semigroup b, Monoid b, Applicative m, Foldable f) => (a -> m b) -> f a -> m b
- Exon.Prelude: foldMapM :: (Monoid b, Monad m, Foldable f) => (a -> m b) -> f a -> m b
- Exon.Prelude: foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
- Exon.Prelude: foldlM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
- Exon.Prelude: foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
- Exon.Prelude: forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)
- Exon.Prelude: forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()
- Exon.Prelude: for_ :: (Foldable t, Applicative f) => t a -> (a -> f b) -> f ()
- Exon.Prelude: force :: NFData a => a -> a
- Exon.Prelude: forever :: Applicative f => f a -> f b
- Exon.Prelude: fromEnum :: Enum a => a -> Int
- Exon.Prelude: fromException :: Exception e => SomeException -> Maybe e
- Exon.Prelude: fromInteger :: Num a => Integer -> a
- Exon.Prelude: fromIntegral :: (Integral a, Num b) => a -> b
- Exon.Prelude: fromLabel :: IsLabel x a => a
- Exon.Prelude: fromLazy :: LazyStrict l s => l -> s
- Exon.Prelude: fromLeft :: a -> Either a b -> a
- Exon.Prelude: fromList :: IsList l => [Item l] -> l
- Exon.Prelude: fromListN :: IsList l => Int -> [Item l] -> l
- Exon.Prelude: fromMaybe :: a -> Maybe a -> a
- Exon.Prelude: fromRational :: Fractional a => Rational -> a
- Exon.Prelude: fromRight :: b -> Either a b -> b
- Exon.Prelude: fromShort :: ShortByteString -> ByteString
- Exon.Prelude: fromStrict :: LazyStrict l s => s -> l
- Exon.Prelude: fromString :: IsString a => String -> a
- Exon.Prelude: fst :: (a, b) -> a
- Exon.Prelude: gcd :: Integral a => a -> a -> a
- Exon.Prelude: genericDrop :: Integral i => i -> [a] -> [a]
- Exon.Prelude: genericLength :: Num i => [a] -> i
- Exon.Prelude: genericReplicate :: Integral i => i -> a -> [a]
- Exon.Prelude: genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
- Exon.Prelude: genericTake :: Integral i => i -> [a] -> [a]
- Exon.Prelude: get :: MonadState s m => m s
- Exon.Prelude: getArgs :: MonadIO m => m [String]
- Exon.Prelude: getCallStack :: CallStack -> [([Char], SrcLoc)]
- Exon.Prelude: getLine :: MonadIO m => m Text
- Exon.Prelude: getStackTrace :: IO (Maybe [Location])
- Exon.Prelude: gets :: MonadState s m => (s -> a) -> m a
- Exon.Prelude: group :: Eq a => [a] -> [[a]]
- Exon.Prelude: guard :: Alternative f => Bool -> f ()
- Exon.Prelude: guardM :: MonadPlus m => m Bool -> m ()
- Exon.Prelude: guarded :: Alternative f => (a -> Bool) -> a -> f a
- Exon.Prelude: hFlush :: MonadIO m => Handle -> m ()
- Exon.Prelude: hGetBuffering :: MonadIO m => Handle -> m BufferMode
- Exon.Prelude: hIsEOF :: MonadIO m => Handle -> m Bool
- Exon.Prelude: hSetBuffering :: MonadIO m => Handle -> BufferMode -> m ()
- Exon.Prelude: hashNub :: (Eq a, Hashable a) => [a] -> [a]
- Exon.Prelude: hashWithSalt :: Hashable a => Int -> a -> Int
- Exon.Prelude: head :: IsNonEmpty f a a "head" => f a -> a
- Exon.Prelude: hoistEither :: forall (m :: Type -> Type) e a. Applicative m => Either e a -> ExceptT e m a
- Exon.Prelude: hoistMaybe :: forall (m :: Type -> Type) a. Applicative m => Maybe a -> MaybeT m a
- Exon.Prelude: id :: a -> a
- Exon.Prelude: identity :: a -> a
- Exon.Prelude: ifM :: Monad m => m Bool -> m a -> m a -> m a
- Exon.Prelude: infinitely :: Applicative f => f a -> f Void
- Exon.Prelude: infix 4 >=
- Exon.Prelude: infixl 0 `hashWithSalt`
- Exon.Prelude: infixl 1 <&>
- Exon.Prelude: infixl 3 <|>
- Exon.Prelude: infixl 4 <**>
- Exon.Prelude: infixl 6 `xor`
- Exon.Prelude: infixl 7 *
- Exon.Prelude: infixr 0 $!!
- Exon.Prelude: infixr 1 =<<
- Exon.Prelude: infixr 2 ||
- Exon.Prelude: infixr 3 &&
- Exon.Prelude: infixr 5 :|
- Exon.Prelude: infixr 6 <>
- Exon.Prelude: infixr 8 ^
- Exon.Prelude: infixr 9 .
- Exon.Prelude: init :: IsNonEmpty f a [a] "init" => f a -> [a]
- Exon.Prelude: inits :: [a] -> [[a]]
- Exon.Prelude: intNub :: [Int] -> [Int]
- Exon.Prelude: intNubOn :: (a -> Int) -> [a] -> [a]
- Exon.Prelude: integerToBounded :: (Integral a, Bounded a) => Integer -> Maybe a
- Exon.Prelude: integerToNatural :: Integer -> Maybe Natural
- Exon.Prelude: intercalate :: [a] -> [[a]] -> [a]
- Exon.Prelude: intersperse :: a -> [a] -> [a]
- Exon.Prelude: inverseMap :: (Bounded a, Enum a, Ord k) => (a -> k) -> k -> Maybe a
- Exon.Prelude: isDenormalized :: RealFloat a => a -> Bool
- Exon.Prelude: isEmptyTMVar :: TMVar a -> STM Bool
- Exon.Prelude: isIEEE :: RealFloat a => a -> Bool
- Exon.Prelude: isInfinite :: RealFloat a => a -> Bool
- Exon.Prelude: isJust :: Maybe a -> Bool
- Exon.Prelude: isLeft :: Either a b -> Bool
- Exon.Prelude: isNaN :: RealFloat a => a -> Bool
- Exon.Prelude: isNegativeZero :: RealFloat a => a -> Bool
- Exon.Prelude: isNothing :: Maybe a -> Bool
- Exon.Prelude: isPrefixOf :: Eq a => [a] -> [a] -> Bool
- Exon.Prelude: isRight :: Either a b -> Bool
- Exon.Prelude: iterate :: (a -> a) -> a -> [a]
- Exon.Prelude: join :: Monad m => m (m a) -> m a
- Exon.Prelude: last :: IsNonEmpty f a a "last" => f a -> a
- Exon.Prelude: lcm :: Integral a => a -> a -> a
- Exon.Prelude: leftToMaybe :: Either l r -> Maybe l
- Exon.Prelude: lefts :: [Either a b] -> [a]
- Exon.Prelude: length :: Foldable t => t a -> Int
- Exon.Prelude: lenientDecode :: OnDecodeError
- Exon.Prelude: lift :: (MonadTrans t, Monad m) => m a -> t m a
- Exon.Prelude: liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
- Exon.Prelude: liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
- Exon.Prelude: liftIO :: MonadIO m => IO a -> m a
- Exon.Prelude: lines :: IsText t "lines" => t -> [t]
- Exon.Prelude: listToMaybe :: [a] -> Maybe a
- Exon.Prelude: local :: MonadReader r m => (r -> r) -> m a -> m a
- Exon.Prelude: logBase :: Floating a => a -> a -> a
- Exon.Prelude: lookupEnv :: MonadIO m => String -> m (Maybe String)
- Exon.Prelude: many :: Alternative f => f a -> f [a]
- Exon.Prelude: map :: (a -> b) -> [a] -> [b]
- Exon.Prelude: mapAccumL :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
- Exon.Prelude: mapAccumR :: Traversable t => (a -> b -> (a, c)) -> a -> t b -> (a, t c)
- Exon.Prelude: mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
- Exon.Prelude: mapM :: (Traversable t, Monad m) => (a -> m b) -> t a -> m (t b)
- Exon.Prelude: mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()
- Exon.Prelude: mapMaybe :: (a -> Maybe b) -> [a] -> [b]
- Exon.Prelude: mapMaybeM :: Monad m => (a -> m (Maybe b)) -> [a] -> m [b]
- Exon.Prelude: mappend :: Monoid a => a -> a -> a
- Exon.Prelude: max :: Ord a => a -> a -> a
- Exon.Prelude: maxBound :: Bounded a => a
- Exon.Prelude: maxInt :: Int
- Exon.Prelude: maybe :: b -> (a -> b) -> Maybe a -> b
- Exon.Prelude: maybeAt :: Int -> [a] -> Maybe a
- Exon.Prelude: maybeToExceptT :: forall (m :: Type -> Type) e a. Functor m => e -> MaybeT m a -> ExceptT e m a
- Exon.Prelude: maybeToLeft :: r -> Maybe l -> Either l r
- Exon.Prelude: maybeToList :: Maybe a -> [a]
- Exon.Prelude: maybeToMonoid :: Monoid m => Maybe m -> m
- Exon.Prelude: maybeToRight :: l -> Maybe r -> Either l r
- Exon.Prelude: mconcat :: Monoid a => [a] -> a
- Exon.Prelude: mempty :: Monoid a => a
- Exon.Prelude: memptyIfFalse :: Monoid m => Bool -> m -> m
- Exon.Prelude: memptyIfTrue :: Monoid m => Bool -> m -> m
- Exon.Prelude: mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
- Exon.Prelude: min :: Ord a => a -> a -> a
- Exon.Prelude: minBound :: Bounded a => a
- Exon.Prelude: minInt :: Int
- Exon.Prelude: mkWeakTMVar :: TMVar a -> IO () -> IO (Weak (TMVar a))
- Exon.Prelude: mod :: Integral a => a -> a -> a
- Exon.Prelude: modify :: MonadState s m => (s -> s) -> m ()
- Exon.Prelude: modify' :: MonadState s m => (s -> s) -> m ()
- Exon.Prelude: modifyIORef :: MonadIO m => IORef a -> (a -> a) -> m ()
- Exon.Prelude: modifyIORef' :: MonadIO m => IORef a -> (a -> a) -> m ()
- Exon.Prelude: modifyTVar' :: TVar a -> (a -> a) -> STM ()
- Exon.Prelude: mplus :: MonadPlus m => m a -> m a -> m a
- Exon.Prelude: mtimesDefault :: (Integral b, Monoid a) => b -> a -> a
- Exon.Prelude: mzero :: MonadPlus m => m a
- Exon.Prelude: natVal :: forall (n :: Nat) proxy. KnownNat n => proxy n -> Natural
- Exon.Prelude: negate :: Num a => a -> a
- Exon.Prelude: newEmptyMVar :: MonadIO m => m (MVar a)
- Exon.Prelude: newEmptyTMVar :: STM (TMVar a)
- Exon.Prelude: newEmptyTMVarIO :: MonadIO m => m (TMVar a)
- Exon.Prelude: newIORef :: MonadIO m => a -> m (IORef a)
- Exon.Prelude: newMVar :: MonadIO m => a -> m (MVar a)
- Exon.Prelude: newTMVar :: a -> STM (TMVar a)
- Exon.Prelude: newTMVarIO :: MonadIO m => a -> m (TMVar a)
- Exon.Prelude: newTVar :: a -> STM (TVar a)
- Exon.Prelude: newTVarIO :: MonadIO m => a -> m (TVar a)
- Exon.Prelude: newtype All
- Exon.Prelude: newtype Alt (f :: k -> Type) (a :: k)
- Exon.Prelude: newtype Any
- Exon.Prelude: newtype Ap (f :: k -> Type) (a :: k)
- Exon.Prelude: newtype Comparison a
- Exon.Prelude: newtype Compose (f :: k -> Type) (g :: k1 -> k) (a :: k1)
- Exon.Prelude: newtype Const a (b :: k)
- Exon.Prelude: newtype Down a
- Exon.Prelude: newtype Dual a
- Exon.Prelude: newtype Endo a
- Exon.Prelude: newtype Equivalence a
- Exon.Prelude: newtype ExceptT e (m :: Type -> Type) a
- Exon.Prelude: newtype First a
- Exon.Prelude: newtype Identity a
- Exon.Prelude: newtype Last a
- Exon.Prelude: newtype MaybeT (m :: Type -> Type) a
- Exon.Prelude: newtype Op a b
- Exon.Prelude: newtype Option a
- Exon.Prelude: newtype Predicate a
- Exon.Prelude: newtype Product a
- Exon.Prelude: newtype ReaderT r (m :: Type -> Type) a
- Exon.Prelude: newtype StateT s (m :: Type -> Type) a
- Exon.Prelude: newtype Sum a
- Exon.Prelude: newtype ZipList a
- Exon.Prelude: nonEmpty :: [a] -> Maybe (NonEmpty a)
- Exon.Prelude: not :: Bool -> Bool
- Exon.Prelude: notElem :: (Foldable f, DisallowElem f, Eq a) => a -> f a -> Bool
- Exon.Prelude: null :: Foldable t => t a -> Bool
- Exon.Prelude: numerator :: Ratio a -> a
- Exon.Prelude: odd :: Integral a => a -> Bool
- Exon.Prelude: on :: (b -> b -> c) -> (a -> b) -> a -> a -> c
- Exon.Prelude: one :: One x => OneItem x -> x
- Exon.Prelude: optional :: Alternative f => f a -> f (Maybe a)
- Exon.Prelude: or :: Foldable t => t Bool -> Bool
- Exon.Prelude: orM :: (Foldable f, Monad m) => f (m Bool) -> m Bool
- Exon.Prelude: ord :: Char -> Int
- Exon.Prelude: ordNub :: Ord a => [a] -> [a]
- Exon.Prelude: ordNubOn :: Ord b => (a -> b) -> [a] -> [a]
- Exon.Prelude: otherwise :: Bool
- Exon.Prelude: partitionEithers :: [Either a b] -> ([a], [b])
- Exon.Prelude: partitionWith :: (a -> Either b c) -> [a] -> ([b], [c])
- Exon.Prelude: pass :: Applicative f => f ()
- Exon.Prelude: pattern Exc :: Exception e => e -> SomeException
- Exon.Prelude: permutations :: [a] -> [[a]]
- Exon.Prelude: phantom :: (Functor f, Contravariant f) => f a -> f b
- Exon.Prelude: pi :: Floating a => a
- Exon.Prelude: pred :: Enum a => a -> a
- Exon.Prelude: prettyCallStack :: CallStack -> String
- Exon.Prelude: prettySrcLoc :: SrcLoc -> String
- Exon.Prelude: print :: forall a m. (MonadIO m, Show a) => a -> m ()
- Exon.Prelude: product :: forall a f. (Foldable f, Num a) => f a -> a
- Exon.Prelude: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
- Exon.Prelude: pure :: Applicative f => a -> f a
- Exon.Prelude: put :: MonadState s m => s -> m ()
- Exon.Prelude: putBS :: MonadIO m => ByteString -> m ()
- Exon.Prelude: putBSLn :: MonadIO m => ByteString -> m ()
- Exon.Prelude: putLBS :: MonadIO m => LByteString -> m ()
- Exon.Prelude: putLBSLn :: MonadIO m => LByteString -> m ()
- Exon.Prelude: putLText :: MonadIO m => LText -> m ()
- Exon.Prelude: putLTextLn :: MonadIO m => LText -> m ()
- Exon.Prelude: putMVar :: MonadIO m => MVar a -> a -> m ()
- Exon.Prelude: putStr :: MonadIO m => String -> m ()
- Exon.Prelude: putStrLn :: MonadIO m => String -> m ()
- Exon.Prelude: putTMVar :: TMVar a -> a -> STM ()
- Exon.Prelude: putText :: MonadIO m => Text -> m ()
- Exon.Prelude: putTextLn :: MonadIO m => Text -> m ()
- Exon.Prelude: quot :: Integral a => a -> a -> a
- Exon.Prelude: quotRem :: Integral a => a -> a -> (a, a)
- Exon.Prelude: readEither :: Read a => String -> Either Text a
- Exon.Prelude: readFile :: MonadIO m => FilePath -> m String
- Exon.Prelude: readFileBS :: MonadIO m => FilePath -> m ByteString
- Exon.Prelude: readFileLBS :: MonadIO m => FilePath -> m LByteString
- Exon.Prelude: readFileLText :: MonadIO m => FilePath -> m LText
- Exon.Prelude: readFileText :: MonadIO m => FilePath -> m Text
- Exon.Prelude: readIORef :: MonadIO m => IORef a -> m a
- Exon.Prelude: readMVar :: MonadIO m => MVar a -> m a
- Exon.Prelude: readMaybe :: Read a => String -> Maybe a
- Exon.Prelude: readTMVar :: TMVar a -> STM a
- Exon.Prelude: readTVar :: TVar a -> STM a
- Exon.Prelude: readTVarIO :: MonadIO m => TVar a -> m a
- Exon.Prelude: reader :: MonadReader r m => (r -> a) -> m a
- Exon.Prelude: reads :: Read a => ReadS a
- Exon.Prelude: realToFrac :: (Real a, Fractional b) => a -> b
- Exon.Prelude: recip :: Fractional a => a -> a
- Exon.Prelude: rem :: Integral a => a -> a -> a
- Exon.Prelude: repeat :: a -> [a]
- Exon.Prelude: replicate :: Int -> a -> [a]
- Exon.Prelude: replicateM :: Applicative m => Int -> m a -> m [a]
- Exon.Prelude: replicateM_ :: Applicative m => Int -> m a -> m ()
- Exon.Prelude: return :: Monad m => a -> m a
- Exon.Prelude: reverse :: [a] -> [a]
- Exon.Prelude: rightToMaybe :: Either l r -> Maybe r
- Exon.Prelude: rights :: [Either a b] -> [b]
- Exon.Prelude: rnf :: NFData a => a -> ()
- Exon.Prelude: round :: (RealFrac a, Integral b) => a -> b
- Exon.Prelude: runExceptT :: ExceptT e m a -> m (Either e a)
- Exon.Prelude: runReader :: Reader r a -> r -> a
- Exon.Prelude: runState :: State s a -> s -> (a, s)
- Exon.Prelude: scanl :: (b -> a -> b) -> b -> [a] -> [b]
- Exon.Prelude: scanl' :: (b -> a -> b) -> b -> [a] -> [b]
- Exon.Prelude: scanl1 :: (a -> a -> a) -> [a] -> [a]
- Exon.Prelude: scanr :: (a -> b -> b) -> b -> [a] -> [b]
- Exon.Prelude: scanr1 :: (a -> a -> a) -> [a] -> [a]
- Exon.Prelude: sconcat :: Semigroup a => NonEmpty a -> a
- Exon.Prelude: second :: Bifunctor p => (b -> c) -> p a b -> p a c
- Exon.Prelude: seq :: forall (r :: RuntimeRep) a (b :: TYPE r). a -> b -> b
- Exon.Prelude: sequence :: (Traversable t, Monad m) => t (m a) -> m (t a)
- Exon.Prelude: sequenceA :: (Traversable t, Applicative f) => t (f a) -> f (t a)
- Exon.Prelude: sequenceA_ :: (Foldable t, Applicative f) => t (f a) -> f ()
- Exon.Prelude: sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()
- Exon.Prelude: show :: forall b a. (Show a, IsString b) => a -> b
- Exon.Prelude: showStackTrace :: IO (Maybe String)
- Exon.Prelude: signum :: Num a => a -> a
- Exon.Prelude: sin :: Floating a => a -> a
- Exon.Prelude: sinh :: Floating a => a -> a
- Exon.Prelude: snd :: (a, b) -> b
- Exon.Prelude: some :: Alternative f => f a -> f [a]
- Exon.Prelude: someNatVal :: Natural -> SomeNat
- Exon.Prelude: sort :: Ord a => [a] -> [a]
- Exon.Prelude: sortBy :: (a -> a -> Ordering) -> [a] -> [a]
- Exon.Prelude: sortNub :: Ord a => [a] -> [a]
- Exon.Prelude: sortOn :: Ord b => (a -> b) -> [a] -> [a]
- Exon.Prelude: sortWith :: Ord b => (a -> b) -> [a] -> [a]
- Exon.Prelude: span :: (a -> Bool) -> [a] -> ([a], [a])
- Exon.Prelude: splitAt :: Int -> [a] -> ([a], [a])
- Exon.Prelude: sqrt :: Floating a => a -> a
- Exon.Prelude: state :: MonadState s m => (s -> (a, s)) -> m a
- Exon.Prelude: stderr :: Handle
- Exon.Prelude: stdin :: Handle
- Exon.Prelude: stdout :: Handle
- Exon.Prelude: stimes :: (Semigroup a, Integral b) => b -> a -> a
- Exon.Prelude: stimesIdempotent :: Integral b => b -> a -> a
- Exon.Prelude: stimesIdempotentMonoid :: (Integral b, Monoid a) => b -> a -> a
- Exon.Prelude: stimesMonoid :: (Integral b, Monoid a) => b -> a -> a
- Exon.Prelude: strictDecode :: OnDecodeError
- Exon.Prelude: subsequences :: [a] -> [[a]]
- Exon.Prelude: subtract :: Num a => a -> a -> a
- Exon.Prelude: succ :: Enum a => a -> a
- Exon.Prelude: sum :: forall a f. (Foldable f, Num a) => f a -> a
- Exon.Prelude: swap :: (a, b) -> (b, a)
- Exon.Prelude: swapMVar :: MonadIO m => MVar a -> a -> m a
- Exon.Prelude: swapTMVar :: TMVar a -> a -> STM a
- Exon.Prelude: tail :: IsNonEmpty f a [a] "tail" => f a -> [a]
- Exon.Prelude: tails :: [a] -> [[a]]
- Exon.Prelude: take :: Int -> [a] -> [a]
- Exon.Prelude: takeMVar :: MonadIO m => MVar a -> m a
- Exon.Prelude: takeTMVar :: TMVar a -> STM a
- Exon.Prelude: takeWhile :: (a -> Bool) -> [a] -> [a]
- Exon.Prelude: tan :: Floating a => a -> a
- Exon.Prelude: tanh :: Floating a => a -> a
- Exon.Prelude: throwSTM :: Exception e => e -> STM a
- Exon.Prelude: toEnum :: Enum a => Int -> a
- Exon.Prelude: toException :: Exception e => e -> SomeException
- Exon.Prelude: toInteger :: Integral a => a -> Integer
- Exon.Prelude: toIntegralSized :: (Integral a, Integral b, Bits a, Bits b) => a -> Maybe b
- Exon.Prelude: toLText :: ToLText a => a -> LText
- Exon.Prelude: toLazy :: LazyStrict l s => s -> l
- Exon.Prelude: toList :: Foldable t => t a -> [a]
- Exon.Prelude: toRational :: Real a => a -> Rational
- Exon.Prelude: toShort :: ByteString -> ShortByteString
- Exon.Prelude: toStrict :: LazyStrict l s => l -> s
- Exon.Prelude: toString :: ToString a => a -> String
- Exon.Prelude: toText :: ToText a => a -> Text
- Exon.Prelude: tr :: HasCallStack => Text -> a -> a
- Exon.Prelude: trace :: String -> a -> a
- Exon.Prelude: traceId :: String -> String
- Exon.Prelude: traceM :: Applicative f => String -> f ()
- Exon.Prelude: traceShow :: Show a => a -> b -> b
- Exon.Prelude: traceShowId :: Show a => a -> a
- Exon.Prelude: traceShowM :: (Show a, Applicative f) => a -> f ()
- Exon.Prelude: traceShowWith :: Show b => (a -> b) -> a -> a
- Exon.Prelude: transpose :: [[a]] -> [[a]]
- Exon.Prelude: traverse :: (Traversable t, Applicative f) => (a -> f b) -> t a -> f (t b)
- Exon.Prelude: traverse_ :: (Foldable t, Applicative f) => (a -> f b) -> t a -> f ()
- Exon.Prelude: trs :: Show a => HasCallStack => a -> a
- Exon.Prelude: trs' :: Show b => HasCallStack => b -> a -> a
- Exon.Prelude: truncate :: (RealFrac a, Integral b) => a -> b
- Exon.Prelude: tryPutMVar :: MonadIO m => MVar a -> a -> m Bool
- Exon.Prelude: tryPutTMVar :: TMVar a -> a -> STM Bool
- Exon.Prelude: tryReadMVar :: MonadIO m => MVar a -> m (Maybe a)
- Exon.Prelude: tryReadTMVar :: TMVar a -> STM (Maybe a)
- Exon.Prelude: tryTakeMVar :: MonadIO m => MVar a -> m (Maybe a)
- Exon.Prelude: tryTakeTMVar :: TMVar a -> STM (Maybe a)
- Exon.Prelude: type FilePath = String
- Exon.Prelude: type HasCallStack = ?callStack :: CallStack
- Exon.Prelude: type LByteString = ByteString
- Exon.Prelude: type LText = Text
- Exon.Prelude: type OnDecodeError = OnError Word8 Char
- Exon.Prelude: type OnError a b = String -> Maybe a -> Maybe b
- Exon.Prelude: type Rational = Ratio Integer
- Exon.Prelude: type Reader r = ReaderT r Identity
- Exon.Prelude: type State s = StateT s Identity
- Exon.Prelude: type String = [Char]
- Exon.Prelude: type Type = Type
- Exon.Prelude: type family OneItem x
- Exon.Prelude: uncons :: [a] -> Maybe (a, [a])
- Exon.Prelude: uncurry :: (a -> b -> c) -> (a, b) -> c
- Exon.Prelude: undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a
- Exon.Prelude: unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
- Exon.Prelude: universe :: (Bounded a, Enum a) => [a]
- Exon.Prelude: universeNonEmpty :: (Bounded a, Enum a) => NonEmpty a
- Exon.Prelude: unless :: Applicative f => Bool -> f () -> f ()
- Exon.Prelude: unlessM :: Monad m => m Bool -> m () -> m ()
- Exon.Prelude: unlines :: IsText t "unlines" => [t] -> t
- Exon.Prelude: unstableNub :: (Eq a, Hashable a) => [a] -> [a]
- Exon.Prelude: unwords :: IsText t "unwords" => [t] -> t
- Exon.Prelude: unzip :: [(a, b)] -> ([a], [b])
- Exon.Prelude: unzip3 :: [(a, b, c)] -> ([a], [b], [c])
- Exon.Prelude: usingReader :: r -> Reader r a -> a
- Exon.Prelude: usingReaderT :: r -> ReaderT r m a -> m a
- Exon.Prelude: usingState :: s -> State s a -> (a, s)
- Exon.Prelude: usingStateT :: s -> StateT s m a -> m (a, s)
- Exon.Prelude: vacuous :: Functor f => f Void -> f a
- Exon.Prelude: viaNonEmpty :: (NonEmpty a -> b) -> [a] -> Maybe b
- Exon.Prelude: void :: Functor f => f a -> f ()
- Exon.Prelude: when :: Applicative f => Bool -> f () -> f ()
- Exon.Prelude: whenJust :: Applicative f => Maybe a -> (a -> f ()) -> f ()
- Exon.Prelude: whenJustM :: Monad m => m (Maybe a) -> (a -> m ()) -> m ()
- Exon.Prelude: whenLeft :: Applicative f => a -> Either l r -> (l -> f a) -> f a
- Exon.Prelude: whenLeftM :: Monad m => a -> m (Either l r) -> (l -> m a) -> m a
- Exon.Prelude: whenLeftM_ :: Monad m => m (Either l r) -> (l -> m ()) -> m ()
- Exon.Prelude: whenLeft_ :: Applicative f => Either l r -> (l -> f ()) -> f ()
- Exon.Prelude: whenM :: Monad m => m Bool -> m () -> m ()
- Exon.Prelude: whenNotNull :: Applicative f => [a] -> (NonEmpty a -> f ()) -> f ()
- Exon.Prelude: whenNotNullM :: Monad m => m [a] -> (NonEmpty a -> m ()) -> m ()
- Exon.Prelude: whenNothing :: Applicative f => Maybe a -> f a -> f a
- Exon.Prelude: whenNothingM :: Monad m => m (Maybe a) -> m a -> m a
- Exon.Prelude: whenNothingM_ :: Monad m => m (Maybe a) -> m () -> m ()
- Exon.Prelude: whenNothing_ :: Applicative f => Maybe a -> f () -> f ()
- Exon.Prelude: whenRight :: Applicative f => a -> Either l r -> (r -> f a) -> f a
- Exon.Prelude: whenRightM :: Monad m => a -> m (Either l r) -> (r -> m a) -> m a
- Exon.Prelude: whenRightM_ :: Monad m => m (Either l r) -> (r -> m ()) -> m ()
- Exon.Prelude: whenRight_ :: Applicative f => Either l r -> (r -> f ()) -> f ()
- Exon.Prelude: withFile :: FilePath -> IOMode -> (Handle -> IO r) -> IO r
- Exon.Prelude: withFrozenCallStack :: HasCallStack => (HasCallStack => a) -> a
- Exon.Prelude: withReader :: (r' -> r) -> Reader r a -> Reader r' a
- Exon.Prelude: withReaderT :: forall r' r (m :: Type -> Type) a. (r' -> r) -> ReaderT r m a -> ReaderT r' m a
- Exon.Prelude: withState :: (s -> s) -> State s a -> State s a
- Exon.Prelude: words :: IsText t "words" => t -> [t]
- Exon.Prelude: writeFile :: MonadIO m => FilePath -> String -> m ()
- Exon.Prelude: writeFileBS :: MonadIO m => FilePath -> ByteString -> m ()
- Exon.Prelude: writeFileLBS :: MonadIO m => FilePath -> LByteString -> m ()
- Exon.Prelude: writeFileLText :: MonadIO m => FilePath -> LText -> m ()
- Exon.Prelude: writeFileText :: MonadIO m => FilePath -> Text -> m ()
- Exon.Prelude: writeIORef :: MonadIO m => IORef a -> a -> m ()
- Exon.Prelude: writeTVar :: TVar a -> a -> STM ()
- Exon.Prelude: xor :: Bits a => a -> a -> a
- Exon.Prelude: zip :: [a] -> [b] -> [(a, b)]
- Exon.Prelude: zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
- Exon.Prelude: zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
- Exon.Prelude: zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
- Exon.Prelude: zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
- Exon.Prelude: }
+ Exon.Class.Exon: instance Exon.Class.Exon.Exon Exon.Class.Exon.ExonDefault (GHC.Base.String -> GHC.Base.String)
Files
- Changelog.md +0/−9
- changelog.md +3/−0
- exon.cabal +3/−2
- lib/Exon/Class/Exon.hs +25/−0
- readme.md +19/−0
- test/Exon/Test/ShowsPrecTest.hs +34/−0
- test/Main.hs +3/−1
− Changelog.md
@@ -1,9 +0,0 @@-# 0.2.1.0-* add naive stderr interpreters for `DataLog` and `Log`.--# 0.2.0.0--* `DataLog` got a second constructor, `Local`. It takes a higher-order `Sem` and a transformation function, the latter- of which is applied to all messages logged within the former.- This allows context manipulation for blocks of code.-* `interceptDataLogConc` adds support for concurrent processing of log messages to any interpretation of `DataLog`.
+ changelog.md view
@@ -0,0 +1,3 @@+# 0.1.1.0++* Add `Exon` instance for `String -> String`, used by `showsPrec`.
exon.cabal view
@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack name: exon-version: 0.1.0.0+version: 0.1.1.0 synopsis: Monoidal Quasiquote Interpolation description: See <https://hackage.haskell.org/package/exon/docs/Exon.html> category: String@@ -19,7 +19,7 @@ build-type: Simple extra-source-files: readme.md- Changelog.md+ changelog.md source-repository head type: git@@ -121,6 +121,7 @@ other-modules: Exon.Test.BasicTest Exon.Test.Quote+ Exon.Test.ShowsPrecTest Paths_exon hs-source-dirs: test
lib/Exon/Class/Exon.hs view
@@ -1,6 +1,8 @@ -- |Description: Internal module Exon.Class.Exon where +import Text.Show (showString)+ import Exon.Data.Result (Result (Empty, Result)) import qualified Exon.Data.Segment as Segment import Exon.Data.Segment (Segment)@@ -159,6 +161,29 @@ instance Exon ExonDefault LByteString where convertSegment = convertKeepWs++ concatSegments =+ concatKeepWs @ExonDefault++instance Exon ExonDefault (String -> String) where+ convertSegment = \case+ Segment.String a ->+ Result (showString a)+ Segment.Expression a | isEmpty @ExonDefault a ->+ Empty+ Segment.Expression a ->+ Result a+ Segment.Whitespace ws ->+ Result (showString ws)++ appendSegment z a =+ case (z, convertSegment @ExonDefault a) of+ (Result z', Result a') ->+ Result (z' . a')+ (z', Empty) ->+ z'+ (Empty, a') ->+ a' concatSegments = concatKeepWs @ExonDefault
readme.md view
@@ -1,4 +1,5 @@ This Haskell library provides quasiquote string interpolation with customizable concatenation for arbitrary types.+Visit [hackage] to read the full API documentation. The default case uses `Monoid` and `IsString`: @@ -27,6 +28,23 @@ The default implementation ignores whitespace when concatenating, while it is preserved for `String`, `Text` etc. +An instance for `String -> String` is provided, used by `showsPrec` for example:++```haskell++data Record =+ Record {+ number :: Int,+ maybeNumber :: Maybe Int,+ value :: Value+ }++instance Show Record where+ showsPrec d Record {..} =+ showParen (d > 10) $+ [exon|Record #{showsPrec 11 number} #{showsPrec 11 maybeNumber} #{showsPrec 11 value}|]+```+ # Customization Concatenation is performed by the class `Exon.Exon`:@@ -63,4 +81,5 @@ Inspired by the magnificent [string-interpolate]. +[hackage]: https://hackage.haskell.org/package/exon/docs/Exon.html [string-interpolate]: https://hackage.haskell.org/package/string-interpolate
+ test/Exon/Test/ShowsPrecTest.hs view
@@ -0,0 +1,34 @@+module Exon.Test.ShowsPrecTest where++import Hedgehog (TestT, (===))+import Text.Show (showParen, showsPrec)++import Exon.Quote (exon)++data Value =+ Value {+ x :: Int,+ y :: Int+ }+ deriving (Eq, Show)++data Record =+ Record {+ number :: Int,+ maybeNumber :: Maybe Int,+ value :: Value+ }+ deriving (Eq)++data Wrap =+ Wrap Int Record+ deriving (Eq, Show)++instance Show Record where+ showsPrec d Record {..} =+ showParen (d > 10) $+ [exon|Record #{showsPrec 11 number} #{showsPrec 11 maybeNumber} #{showsPrec 11 value}|]++test_showsPrec :: TestT IO ()+test_showsPrec =+ "Wrap 1 (Record 5 (Just 10) (Value {x = 3, y = 4}))" === show @Text (Wrap 1 (Record 5 (Just 10) (Value 3 4)))
test/Main.hs view
@@ -1,6 +1,7 @@ module Main where import Exon.Test.BasicTest (test_basic, test_keepWhitespace)+import Exon.Test.ShowsPrecTest (test_showsPrec) import Hedgehog (TestT, property, test, withTests) import Test.Tasty (TestName, TestTree, defaultMain, testGroup) import Test.Tasty.Hedgehog (testProperty)@@ -16,7 +17,8 @@ tests = testGroup "all" [ unitTest "basic" test_basic,- unitTest "keep whitespace" test_keepWhitespace+ unitTest "keep whitespace" test_keepWhitespace,+ unitTest "concat showsPrec fragments" test_showsPrec ] main :: IO ()