Prelude.Spiros.Utilities

Utilities.

These identifiers are "soft" overrides, they generalize the signatures of their Prelude namesakes:

• map: () => [] to (Functor f) => f
• sequence: Monad to Applicative
• sequence_: Monad to Applicative

These symbols are "hard" overrides, they are completely different from Prelude:

• >: forward-composition
• <: backward-composition (i.e. '(.)')

Documentation

newtype Time

A number of microseconds (there are one million microseconds per second). An integral number because it's the smallest resolution for most GHC functions. Int because GHC frequently represents integrals as Ints (for efficiency).

Has smart constructors for common time units; in particular, for thread delays, and for human-scale durations.

• microseconds
• milliseconds
• seconds
• minutes
• hours

Which also act as self-documenting (psuedo-keyword-)arguments for threadDelay, via delayFor.

Constructors

Time

Fields

• toMicroseconds :: Int

map :: Functor f => (a -> b) -> f a -> f b

(generalization) = fmap

sequence :: (Traversable t, Applicative f) => t (f a) -> f (t a)

(generalization) = sequenceA

sequence_ :: (Foldable t, Applicative f) => t (f a) -> f ()

(generalization) = sequenceA_

(>) :: (a -> b) -> (b -> c) -> a -> c infixr 9

forwards composition

e.g. "f, then g, then h"

forwards x
 = x
 & f
 > g
 > h

same precedence/associativity as .

(<) :: (b -> c) -> (a -> b) -> a -> c infixr 9

backwards composition

e.g. "h, after g, after f"

backwards x
 = h
 < g
 < f
 $ x

same precedence/associativity as .

lessThan :: Ord a => a -> a -> Bool infix 4

same precedence/associativity as "Prelude.<"

greaterThan :: Ord a => a -> a -> Bool infix 4

same precedence/associativity as "Prelude.>"

(-:) :: a -> b -> (a, b) infix 1

(-:) = (,)

fake dictionary literal syntax:

 [ "a"-: 1
 , "b"-: 2
 , "c"-: 1+2
 ] :: [(String,Integer)]

todo :: a

Deprecated: use { ERROR TODO }

__BUG__ :: SomeException -> a

__ERROR__ :: String -> a

errorM :: MonadThrow m => String -> m a

throwM a userError (a safer error).

nothing :: Applicative m => m ()

= pure ()

returning :: Applicative m => (a -> b) -> a -> m b

Raise a Function Arrow into a Kleisli Arrow.

a convenience function for composing pure functions between "kleislis" in monadic sequences.

Definition:

= (pure .)

returning f ≡ f >>> return

returning f ≡ x -> return (f x)

Usage:

readFile "example.txt" >>= returning show >>= forceIO

maybe2bool :: Maybe a -> Bool

maybe2either :: e -> Maybe a -> Either e a

either2maybe :: Either e a -> Maybe a

either2bool :: Either e a -> Bool

maybe2list :: Maybe a -> [a]

list2maybe :: [a] -> Maybe a

nonempty2list :: NonEmpty a -> [a]

list :: r -> (a -> [a] -> r) -> [a] -> r

unsafeNatural :: Integral i => i -> Natural

unsafeNatural :: Int -> Natural  

ratio :: Integral a => a -> a -> Ratio a infixl 7

an alias, since (%) is prime symbolic real estate.

($>) :: Functor f => f a -> b -> f b

($>) = flip (<$)

(<&>) :: Functor f => f a -> (a -> b) -> f b infixl 5

Infix flipped fmap.

(<&>) = flip fmap

NOTE: conflicts with the lens package

ordNub :: Ord a => [a] -> [a]

Remove duplicates (from the given list).

Examples

>>> ordNub "abcab"
"abc"
>>> ordNub ""
""

Definition

ordNub = ordNubBy id

Laws

Idempotent (i.e. multiple applications are redundant)

Stable (i.e. preserves the original order)

Performance

Semantically, ordNub should be equivalent to nub.

Operationally, it's much faster for large lists:

• nub — only needs an Eq constraint, but takes O(n^2) time complexity.
• ordNub — needs an Ord constraint, but only takes O(n log n) time complexity.

Links

• http://github.com/nh2/haskell-ordnub, by Niklas Hambüchen.

ordNubBy :: Ord b => (a -> b) -> [a] -> [a]

Selects a key for each element, and takes the nub based on that key.

See ordNub.

nth :: Natural -> [a] -> Maybe a

Safely get the n-th item in the given list.

>>> nth 1 ['a'..'c']
Just 'b'
>>> nth 1 []
Nothing

snoc :: [a] -> a -> [a]

reverse cons

toInt :: Integral a => a -> Int

(NOTE truncates large integral types).

strip :: String -> String

lstrip :: String -> String

rstrip :: String -> String

shown :: forall a t. (Show a, IsString t) => a -> t

constructors :: BoundedEnum a => proxy a -> [a]

>>> pBool = Proxy :: Proxy Bool
>>> constructors pBool
[False,True]

constructors' :: forall a. BoundedEnum a => [a]

like constructors, but with an implicit type parameter.

>>> constructors' == [False,True]
True

> :set -XTypeApplications
> constructors' @Bool

False,True

identity :: Category cat => a `cat` a

compose :: Category cat => (b `cat` c) -> (a `cat` b) -> a `cat` c

typeName :: forall proxy a t. (Typeable a, IsString t) => proxy a -> t

whenM :: Monad m => m Bool -> m () -> m ()

unlessM :: Monad m => m Bool -> m () -> m ()

runReaderT' :: r -> ReaderT r m a -> m a

= flip runReaderT

runStateT' :: s -> StateT s m a -> m (a, s)

= flip runStateT

evalStateT' :: Monad m => s -> StateT s m a -> m a

= flip evalStateT

execStateT' :: Monad m => s -> StateT s m a -> m s

= flip execStateT

runReader' :: r -> Reader r a -> a

= flip runReader

runState' :: s -> State s a -> (a, s)

= flip runState

evalState' :: s -> State s a -> a

= flip evalState

execState' :: s -> State s a -> s

= flip execState

microseconds :: Int -> Time

milliseconds :: Int -> Time

seconds :: Int -> Time

minutes :: Int -> Time

hours :: Int -> Time

delayFor :: MonadIO m => Time -> m ()

delayMicroseconds :: MonadIO m => Int -> m ()

delayMilliseconds :: MonadIO m => Int -> m ()

delaySeconds :: MonadIO m => Int -> m ()

io :: MonadIO m => IO a -> m a

forkever_ :: IO () -> IO ()

forkever :: Maybe Int -> IO () -> IO ThreadId

forceIO :: NFData a => a -> IO a

= evaluate . force

forceIO_ :: NFData a => a -> IO ()

~ forceIO

firstSetEnvironmentVariable :: String -> [String] -> IO String

Return the value of the first environment variable that's been set, or a default value if all are unset.

Examples:

> firstSetEnvironmentVariable "/usr/run" [ "XDG_RUNTIME_HOME", "TMP" ]

Properties:

firstSetEnvironmentVariable x [] ≡ return x

firstNonemptyEnvironmentVariable :: String -> [String] -> IO String

Return the first nonempty value among the given environment variables, or a default value if all are either unset or set-to-empty.

Examples:

> firstNonemptyEnvironmentVariable "usrrun" [ XDG_RUNTIME_HOME, TMP ]

Properties:

firstNonemptyEnvironmentVariable x [] ≈ return x

Notes:

• on Windows, firstNonemptyEnvironmentVariable should be equivalent to firstSetEnvironmentVariable.

firstEnvironmentVariableSatisfying :: (String -> Bool) -> String -> [String] -> IO String

toLazyByteString :: StrictBytes -> LazyBytes