Karya, built on Mon Jul 24 11:39:07 PDT 2017 (patch 33511aca01257b76b88de7c7a2763b7a965c084e)

Safe HaskellNone

Global

Contents

Description

A local Prelude, meant to be imported unqualified.

Synopsis

Documentation

data Proxy a Source #

A value proxy for a type, used for class methods that just want a type, not a value.

Constructors

Proxy 

data Map k a :: * -> * -> * #

A Map from keys k to values a.

Instances

Functor (Map k) 

Methods

fmap :: (a -> b) -> Map k a -> Map k b #

(<$) :: a -> Map k b -> Map k a #

Foldable (Map k) 

Methods

fold :: Monoid m => Map k m -> m #

foldMap :: Monoid m => (a -> m) -> Map k a -> m #

foldr :: (a -> b -> b) -> b -> Map k a -> b #

foldr' :: (a -> b -> b) -> b -> Map k a -> b #

foldl :: (b -> a -> b) -> b -> Map k a -> b #

foldl' :: (b -> a -> b) -> b -> Map k a -> b #

foldr1 :: (a -> a -> a) -> Map k a -> a #

foldl1 :: (a -> a -> a) -> Map k a -> a #

toList :: Map k a -> [a] #

null :: Map k a -> Bool #

length :: Map k a -> Int #

elem :: Eq a => a -> Map k a -> Bool #

maximum :: Ord a => Map k a -> a #

minimum :: Ord a => Map k a -> a #

sum :: Num a => Map k a -> a #

product :: Num a => Map k a -> a #

Traversable (Map k) 

Methods

traverse :: Applicative f => (a -> f b) -> Map k a -> f (Map k b) #

sequenceA :: Applicative f => Map k (f a) -> f (Map k a) #

mapM :: Monad m => (a -> m b) -> Map k a -> m (Map k b) #

sequence :: Monad m => Map k (m a) -> m (Map k a) #

Ord k => TrieMap (Map k) 

Associated Types

type Key (Map k :: * -> *) :: * #

Methods

emptyTM :: Map k a #

lookupTM :: Key (Map k) -> Map k b -> Maybe b #

alterTM :: Key (Map k) -> XT b -> Map k b -> Map k b #

mapTM :: (a -> b) -> Map k a -> Map k b #

foldTM :: (a -> b -> b) -> Map k a -> b -> b #

(Ord k, Arbitrary k) => Arbitrary1 (Map k) 

Methods

liftArbitrary :: Gen a -> Gen (Map k a) #

liftShrink :: (a -> [a]) -> Map k a -> [Map k a] #

ToJSONKey k => ToJSON1 (Map k) 

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> Map k a -> Value #

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Map k a] -> Value #

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Map k a -> Encoding #

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Map k a] -> Encoding #

(FromJSONKey k, Ord k) => FromJSON1 (Map k) 

Methods

liftParseJSON :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser (Map k a) #

liftParseJSONList :: (Value -> Parser a) -> (Value -> Parser [a]) -> Value -> Parser [Map k a] #

Ord k => IsList (Map k v) 

Associated Types

type Item (Map k v) :: * #

Methods

fromList :: [Item (Map k v)] -> Map k v #

fromListN :: Int -> [Item (Map k v)] -> Map k v #

toList :: Map k v -> [Item (Map k v)] #

(Eq k, Eq a) => Eq (Map k a) 

Methods

(==) :: Map k a -> Map k a -> Bool #

(/=) :: Map k a -> Map k a -> Bool #

(Data k, Data a, Ord k) => Data (Map k a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Map k a -> c (Map k a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Map k a) #

toConstr :: Map k a -> Constr #

dataTypeOf :: Map k a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Map k a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Map k a)) #

gmapT :: (forall b. Data b => b -> b) -> Map k a -> Map k a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Map k a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Map k a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Map k a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Map k a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Map k a -> m (Map k a) #

(Ord k, Ord v) => Ord (Map k v) 

Methods

compare :: Map k v -> Map k v -> Ordering #

(<) :: Map k v -> Map k v -> Bool #

(<=) :: Map k v -> Map k v -> Bool #

(>) :: Map k v -> Map k v -> Bool #

(>=) :: Map k v -> Map k v -> Bool #

max :: Map k v -> Map k v -> Map k v #

min :: Map k v -> Map k v -> Map k v #

(Ord k, Read k, Read e) => Read (Map k e) 

Methods

readsPrec :: Int -> ReadS (Map k e) #

readList :: ReadS [Map k e] #

readPrec :: ReadPrec (Map k e) #

readListPrec :: ReadPrec [Map k e] #

(Show k, Show a) => Show (Map k a) 

Methods

showsPrec :: Int -> Map k a -> ShowS #

show :: Map k a -> String #

showList :: [Map k a] -> ShowS #

Ord k => Semigroup (Map k v) 

Methods

(<>) :: Map k v -> Map k v -> Map k v #

sconcat :: NonEmpty (Map k v) -> Map k v #

stimes :: Integral b => b -> Map k v -> Map k v #

Ord k => Monoid (Map k v) 

Methods

mempty :: Map k v #

mappend :: Map k v -> Map k v -> Map k v #

mconcat :: [Map k v] -> Map k v #

(NFData k, NFData a) => NFData (Map k a) 

Methods

rnf :: Map k a -> () #

(Ord k, Serialize k, Serialize e) => Serialize (Map k e) 

Methods

put :: Putter (Map k e) #

get :: Get (Map k e) #

(Binary k, Binary e) => Binary (Map k e) 

Methods

put :: Map k e -> Put #

get :: Get (Map k e) #

putList :: [Map k e] -> Put #

(Outputable key, Outputable elt) => Outputable (Map key elt) 

Methods

ppr :: Map key elt -> SDoc #

pprPrec :: Rational -> Map key elt -> SDoc #

(Ord k, Arbitrary k, Arbitrary v) => Arbitrary (Map k v) 

Methods

arbitrary :: Gen (Map k v) #

shrink :: Map k v -> [Map k v] #

(CoArbitrary k, CoArbitrary v) => CoArbitrary (Map k v) 

Methods

coarbitrary :: Map k v -> Gen b -> Gen b #

(ToJSON v, ToJSONKey k) => ToJSON (Map k v) 

Methods

toJSON :: Map k v -> Value #

toEncoding :: Map k v -> Encoding #

toJSONList :: [Map k v] -> Value #

toEncodingList :: [Map k v] -> Encoding #

(FromJSONKey k, Ord k, FromJSON v) => FromJSON (Map k v) 

Methods

parseJSON :: Value -> Parser (Map k v) #

parseJSONList :: Value -> Parser [Map k v] #

(Pretty k, Pretty v) => Pretty (Map k v) # 

Methods

pretty :: Map k v -> Text Source #

format :: Map k v -> Doc Source #

formatList :: [Map k v] -> Doc Source #

(Bytes k, Bytes a) => Bytes (Map k a) # 

Methods

bytes :: Map k a -> Size Source #

(Extract k, Extract v) => Extract (Map k v) # 

Methods

extract :: Map k v -> Value Source #

(Ord k, Serialize k, Serialize v) => Serialize (Map k v) # 

Methods

put :: Putter (Map k v) Source #

get :: Get (Map k v) Source #

type Key (Map k) 
type Key (Map k) = k
type Item (Map k v) 
type Item (Map k v) = (k, v)

data Set a :: * -> * #

A set of values a.

Instances

Foldable Set 

Methods

fold :: Monoid m => Set m -> m #

foldMap :: Monoid m => (a -> m) -> Set a -> m #

foldr :: (a -> b -> b) -> b -> Set a -> b #

foldr' :: (a -> b -> b) -> b -> Set a -> b #

foldl :: (b -> a -> b) -> b -> Set a -> b #

foldl' :: (b -> a -> b) -> b -> Set a -> b #

foldr1 :: (a -> a -> a) -> Set a -> a #

foldl1 :: (a -> a -> a) -> Set a -> a #

toList :: Set a -> [a] #

null :: Set a -> Bool #

length :: Set a -> Int #

elem :: Eq a => a -> Set a -> Bool #

maximum :: Ord a => Set a -> a #

minimum :: Ord a => Set a -> a #

sum :: Num a => Set a -> a #

product :: Num a => Set a -> a #

ToJSON1 Set 

Methods

liftToJSON :: (a -> Value) -> ([a] -> Value) -> Set a -> Value #

liftToJSONList :: (a -> Value) -> ([a] -> Value) -> [Set a] -> Value #

liftToEncoding :: (a -> Encoding) -> ([a] -> Encoding) -> Set a -> Encoding #

liftToEncodingList :: (a -> Encoding) -> ([a] -> Encoding) -> [Set a] -> Encoding #

Ord a => IsList (Set a) 

Associated Types

type Item (Set a) :: * #

Methods

fromList :: [Item (Set a)] -> Set a #

fromListN :: Int -> [Item (Set a)] -> Set a #

toList :: Set a -> [Item (Set a)] #

Eq a => Eq (Set a) 

Methods

(==) :: Set a -> Set a -> Bool #

(/=) :: Set a -> Set a -> Bool #

(Data a, Ord a) => Data (Set a) 

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Set a -> c (Set a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Set a) #

toConstr :: Set a -> Constr #

dataTypeOf :: Set a -> DataType #

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (Set a)) #

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Set a)) #

gmapT :: (forall b. Data b => b -> b) -> Set a -> Set a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Set a -> r #

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Set a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Set a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Set a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Set a -> m (Set a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Set a -> m (Set a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Set a -> m (Set a) #

Ord a => Ord (Set a) 

Methods

compare :: Set a -> Set a -> Ordering #

(<) :: Set a -> Set a -> Bool #

(<=) :: Set a -> Set a -> Bool #

(>) :: Set a -> Set a -> Bool #

(>=) :: Set a -> Set a -> Bool #

max :: Set a -> Set a -> Set a #

min :: Set a -> Set a -> Set a #

(Read a, Ord a) => Read (Set a) 
Show a => Show (Set a) 

Methods

showsPrec :: Int -> Set a -> ShowS #

show :: Set a -> String #

showList :: [Set a] -> ShowS #

Ord a => Semigroup (Set a) 

Methods

(<>) :: Set a -> Set a -> Set a #

sconcat :: NonEmpty (Set a) -> Set a #

stimes :: Integral b => b -> Set a -> Set a #

Ord a => Monoid (Set a) 

Methods

mempty :: Set a #

mappend :: Set a -> Set a -> Set a #

mconcat :: [Set a] -> Set a #

NFData a => NFData (Set a) 

Methods

rnf :: Set a -> () #

(Ord a, Serialize a) => Serialize (Set a) 

Methods

put :: Putter (Set a) #

get :: Get (Set a) #

Binary a => Binary (Set a) 

Methods

put :: Set a -> Put #

get :: Get (Set a) #

putList :: [Set a] -> Put #

Outputable a => Outputable (Set a) 

Methods

ppr :: Set a -> SDoc #

pprPrec :: Rational -> Set a -> SDoc #

(Ord a, Arbitrary a) => Arbitrary (Set a) 

Methods

arbitrary :: Gen (Set a) #

shrink :: Set a -> [Set a] #

CoArbitrary a => CoArbitrary (Set a) 

Methods

coarbitrary :: Set a -> Gen b -> Gen b #

ToJSON a => ToJSON (Set a) 

Methods

toJSON :: Set a -> Value #

toEncoding :: Set a -> Encoding #

toJSONList :: [Set a] -> Value #

toEncodingList :: [Set a] -> Encoding #

(Ord a, FromJSON a) => FromJSON (Set a) 

Methods

parseJSON :: Value -> Parser (Set a) #

parseJSONList :: Value -> Parser [Set a] #

Pretty a => Pretty (Set a) # 

Methods

pretty :: Set a -> Text Source #

format :: Set a -> Doc Source #

formatList :: [Set a] -> Doc Source #

(Ord a, Serialize a) => Serialize (Set a) # 

Methods

put :: Putter (Set a) Source #

get :: Get (Set a) Source #

type Item (Set a) 
type Item (Set a) = a

(<|>) :: Alternative f => forall a. f a -> f a -> f a #

An associative binary operation

first :: Bifunctor p => (a -> b) -> p a c -> p b c Source #

second :: Bifunctor p => (c -> d) -> p a c -> p a d Source #

(***) :: Bifunctor p => (a -> b) -> (c -> d) -> p a c -> p b d Source #

class Monoid a where #

The class of monoids (types with an associative binary operation that has an identity). Instances should satisfy the following laws:

  • mappend mempty x = x
  • mappend x mempty = x
  • mappend x (mappend y z) = mappend (mappend x y) z
  • mconcat = foldr mappend mempty

The method names refer to the monoid of lists under concatenation, but there are many other instances.

Some types can be viewed as a monoid in more than one way, e.g. both addition and multiplication on numbers. In such cases we often define newtypes and make those instances of Monoid, e.g. Sum and Product.

Minimal complete definition

mempty, mappend

Methods

mempty :: a #

Identity of mappend

mappend :: a -> a -> a #

An associative operation

mconcat :: [a] -> a #

Fold a list using the monoid. For most types, the default definition for mconcat will be used, but the function is included in the class definition so that an optimized version can be provided for specific types.

Instances

Monoid Ordering 
Monoid () 

Methods

mempty :: () #

mappend :: () -> () -> () #

mconcat :: [()] -> () #

Monoid All 

Methods

mempty :: All #

mappend :: All -> All -> All #

mconcat :: [All] -> All #

Monoid Any 

Methods

mempty :: Any #

mappend :: Any -> Any -> Any #

mconcat :: [Any] -> Any #

Monoid IntSet 
Monoid Builder 
Monoid ByteString 
Monoid ByteString 
Monoid Builder 
Monoid Progress 
Monoid Doc 

Methods

mempty :: Doc #

mappend :: Doc -> Doc -> Doc #

mconcat :: [Doc] -> Doc #

Monoid Buffer 

Methods

mempty :: Buffer #

mappend :: Buffer -> Buffer -> Buffer #

mconcat :: [Buffer] -> Buffer #

Monoid Buffer 

Methods

mempty :: Buffer #

mappend :: Buffer -> Buffer -> Buffer #

mconcat :: [Buffer] -> Buffer #

Monoid More 

Methods

mempty :: More #

mappend :: More -> More -> More #

mconcat :: [More] -> More #

Monoid ModuleOrigin 
Monoid Series 
Monoid B # 

Methods

mempty :: B #

mappend :: B -> B -> B #

mconcat :: [B] -> B #

Monoid BreakType #

Hard breaks with more newlines win over those with fewer.

Monoid Doc # 

Methods

mempty :: Doc #

mappend :: Doc -> Doc -> Doc #

mconcat :: [Doc] -> Doc #

Monoid Flags # 

Methods

mempty :: Flags #

mappend :: Flags -> Flags -> Flags #

mconcat :: [Flags] -> Flags #

Monoid Highlight #

This is so more serious highlights can override less serious ones.

Monoid Attributes # 
Monoid Html # 

Methods

mempty :: Html #

mappend :: Html -> Html -> Html #

mconcat :: [Html] -> Html #

Monoid Doc # 

Methods

mempty :: Doc #

mappend :: Doc -> Doc -> Doc #

mconcat :: [Doc] -> Doc #

Monoid Type # 

Methods

mempty :: Type #

mappend :: Type -> Type -> Type #

mconcat :: [Type] -> Type #

Monoid Emphasis # 
Monoid Stroke # 
Monoid StrokeMaps # 
Monoid Tags # 

Methods

mempty :: Tags #

mappend :: Tags -> Tags -> Tags #

mconcat :: [Tags] -> Tags #

Monoid Metadata # 
Monoid Module # 
Monoid Attributes # 
Monoid Events # 
Monoid Environ # 
Monoid PitchConfig # 
Monoid PSignal # 
Monoid Environ # 
Monoid Definitions # 
Monoid Settings # 
Monoid Allocations # 
Monoid ControlDamage # 
Monoid ScoreDamage # 
Monoid BlockDeps # 
Monoid Cache # 

Methods

mempty :: Cache #

mappend :: Cache -> Cache -> Cache #

mconcat :: [Cache] -> Cache #

Monoid Collect # 
Monoid Library # 
Monoid NoteDeriver # 
Monoid Result # 
Monoid Hooks # 

Methods

mempty :: Hooks #

mappend :: Hooks -> Hooks -> Hooks #

mconcat :: [Hooks] -> Hooks #

Monoid Fingerprint # 
Monoid Code # 

Methods

mempty :: Code #

mappend :: Code -> Code -> Code #

mconcat :: [Code] -> Code #

Monoid Parser # 
Monoid NoteTrack # 
Monoid NoteTrack # 
Monoid Outliers 

Methods

mempty :: Outliers #

mappend :: Outliers -> Outliers -> Outliers #

mconcat :: [Outliers] -> Outliers #

Monoid Key 

Methods

mempty :: Key #

mappend :: Key -> Key -> Key #

mconcat :: [Key] -> Key #

Monoid [a] 

Methods

mempty :: [a] #

mappend :: [a] -> [a] -> [a] #

mconcat :: [[a]] -> [a] #

Monoid a => Monoid (Maybe a)

Lift a semigroup into Maybe forming a Monoid according to http://en.wikipedia.org/wiki/Monoid: "Any semigroup S may be turned into a monoid simply by adjoining an element e not in S and defining e*e = e and e*s = s = s*e for all s ∈ S." Since there is no "Semigroup" typeclass providing just mappend, we use Monoid instead.

Methods

mempty :: Maybe a #

mappend :: Maybe a -> Maybe a -> Maybe a #

mconcat :: [Maybe a] -> Maybe a #

Monoid a => Monoid (IO a) 

Methods

mempty :: IO a #

mappend :: IO a -> IO a -> IO a #

mconcat :: [IO a] -> IO a #

Ord a => Monoid (Max a) 

Methods

mempty :: Max a #

mappend :: Max a -> Max a -> Max a #

mconcat :: [Max a] -> Max a #

Ord a => Monoid (Min a) 

Methods

mempty :: Min a #

mappend :: Min a -> Min a -> Min a #

mconcat :: [Min a] -> Min a #

Monoid a => Monoid (Identity a) 

Methods

mempty :: Identity a #

mappend :: Identity a -> Identity a -> Identity a #

mconcat :: [Identity a] -> Identity a #

(Ord a, Bounded a) => Monoid (Min a) 

Methods

mempty :: Min a #

mappend :: Min a -> Min a -> Min a #

mconcat :: [Min a] -> Min a #

(Ord a, Bounded a) => Monoid (Max a) 

Methods

mempty :: Max a #

mappend :: Max a -> Max a -> Max a #

mconcat :: [Max a] -> Max a #

Monoid m => Monoid (WrappedMonoid m) 
Semigroup a => Monoid (Option a) 

Methods

mempty :: Option a #

mappend :: Option a -> Option a -> Option a #

mconcat :: [Option a] -> Option a #

Monoid a => Monoid (Dual a) 

Methods

mempty :: Dual a #

mappend :: Dual a -> Dual a -> Dual a #

mconcat :: [Dual a] -> Dual a #

Monoid (Endo a) 

Methods

mempty :: Endo a #

mappend :: Endo a -> Endo a -> Endo a #

mconcat :: [Endo a] -> Endo a #

Num a => Monoid (Sum a) 

Methods

mempty :: Sum a #

mappend :: Sum a -> Sum a -> Sum a #

mconcat :: [Sum a] -> Sum a #

Num a => Monoid (Product a) 

Methods

mempty :: Product a #

mappend :: Product a -> Product a -> Product a #

mconcat :: [Product a] -> Product a #

Monoid (First a) 

Methods

mempty :: First a #

mappend :: First a -> First a -> First a #

mconcat :: [First a] -> First a #

Monoid (Last a) 

Methods

mempty :: Last a #

mappend :: Last a -> Last a -> Last a #

mconcat :: [Last a] -> Last a #

Monoid (IntMap a) 

Methods

mempty :: IntMap a #

mappend :: IntMap a -> IntMap a -> IntMap a #

mconcat :: [IntMap a] -> IntMap a #

Monoid (Seq a) 

Methods

mempty :: Seq a #

mappend :: Seq a -> Seq a -> Seq a #

mconcat :: [Seq a] -> Seq a #

Ord a => Monoid (Set a) 

Methods

mempty :: Set a #

mappend :: Set a -> Set a -> Set a #

mconcat :: [Set a] -> Set a #

Monoid (PutM ()) 

Methods

mempty :: PutM () #

mappend :: PutM () -> PutM () -> PutM () #

mconcat :: [PutM ()] -> PutM () #

Monoid (Vector a) 

Methods

mempty :: Vector a #

mappend :: Vector a -> Vector a -> Vector a #

mconcat :: [Vector a] -> Vector a #

Storable a => Monoid (Vector a) 

Methods

mempty :: Vector a #

mappend :: Vector a -> Vector a -> Vector a #

mconcat :: [Vector a] -> Vector a #

Prim a => Monoid (Vector a) 

Methods

mempty :: Vector a #

mappend :: Vector a -> Vector a -> Vector a #

mconcat :: [Vector a] -> Vector a #

Monoid (SRules m) 

Methods

mempty :: SRules m #

mappend :: SRules m -> SRules m -> SRules m #

mconcat :: [SRules m] -> SRules m #

Monoid a => Monoid (Rules a) 

Methods

mempty :: Rules a #

mappend :: Rules a -> Rules a -> Rules a #

mconcat :: [Rules a] -> Rules a #

Monoid (PutM ()) 

Methods

mempty :: PutM () #

mappend :: PutM () -> PutM () -> PutM () #

mconcat :: [PutM ()] -> PutM () #

(Semigroup a, Monoid a) => Monoid (Concurrently a)

Since: 2.1.0

Monoid (Doc a) 

Methods

mempty :: Doc a #

mappend :: Doc a -> Doc a -> Doc a #

mconcat :: [Doc a] -> Doc a #

Monoid m => Monoid (ParseResult m) 
Monoid (DList a) 

Methods

mempty :: DList a #

mappend :: DList a -> DList a -> DList a #

mconcat :: [DList a] -> DList a #

Monoid (UniqDFM a) 

Methods

mempty :: UniqDFM a #

mappend :: UniqDFM a -> UniqDFM a -> UniqDFM a #

mconcat :: [UniqDFM a] -> UniqDFM a #

Monoid (IResult a) 

Methods

mempty :: IResult a #

mappend :: IResult a -> IResult a -> IResult a #

mconcat :: [IResult a] -> IResult a #

Monoid (Result a) 

Methods

mempty :: Result a #

mappend :: Result a -> Result a -> Result a #

mconcat :: [Result a] -> Result a #

Monoid (Parser a) 

Methods

mempty :: Parser a #

mappend :: Parser a -> Parser a -> Parser a #

mconcat :: [Parser a] -> Parser a #

Monoid (Array a) 

Methods

mempty :: Array a #

mappend :: Array a -> Array a -> Array a #

mconcat :: [Array a] -> Array a #

Monoid (Builder a) # 

Methods

mempty :: Builder a #

mappend :: Builder a -> Builder a -> Builder a #

mconcat :: [Builder a] -> Builder a #

Ord n => Monoid (Ranges n) # 

Methods

mempty :: Ranges n #

mappend :: Ranges n -> Ranges n -> Ranges n #

mconcat :: [Ranges n] -> Ranges n #

(Hashable a, Eq a) => Monoid (HashSet a) 

Methods

mempty :: HashSet a #

mappend :: HashSet a -> HashSet a -> HashSet a #

mconcat :: [HashSet a] -> HashSet a #

Monoid (AppendList a) # 
Monoid (Signal y) # 

Methods

mempty :: Signal y #

mappend :: Signal y -> Signal y -> Signal y #

mconcat :: [Signal y] -> Signal y #

Monoid a => Monoid (Typed a) # 

Methods

mempty :: Typed a #

mappend :: Typed a -> Typed a -> Typed a #

mconcat :: [Typed a] -> Typed a #

Monoid (Instrument stroke) # 

Methods

mempty :: Instrument stroke #

mappend :: Instrument stroke -> Instrument stroke -> Instrument stroke #

mconcat :: [Instrument stroke] -> Instrument stroke #

Monoid (StrokeMap stroke) # 

Methods

mempty :: StrokeMap stroke #

mappend :: StrokeMap stroke -> StrokeMap stroke -> StrokeMap stroke #

mconcat :: [StrokeMap stroke] -> StrokeMap stroke #

Monoid (Patterns stroke) # 

Methods

mempty :: Patterns stroke #

mappend :: Patterns stroke -> Patterns stroke -> Patterns stroke #

mconcat :: [Patterns stroke] -> Patterns stroke #

Monoid (Stream Control) #

Signal.Control streams don't need sorted order.

Monoid (Stream PSignal) # 
Monoid (Stream Event) # 
Monoid (CallDuration a) # 
Monoid (ScopePriority call) # 
Monoid (SetupA a) # 

Methods

mempty :: SetupA a #

mappend :: SetupA a -> SetupA a -> SetupA a #

mconcat :: [SetupA a] -> SetupA a #

Monoid b => Monoid (a -> b) 

Methods

mempty :: a -> b #

mappend :: (a -> b) -> (a -> b) -> a -> b #

mconcat :: [a -> b] -> a -> b #

(Monoid a, Monoid b) => Monoid (a, b) 

Methods

mempty :: (a, b) #

mappend :: (a, b) -> (a, b) -> (a, b) #

mconcat :: [(a, b)] -> (a, b) #

Monoid (Proxy k s) 

Methods

mempty :: Proxy k s #

mappend :: Proxy k s -> Proxy k s -> Proxy k s #

mconcat :: [Proxy k s] -> Proxy k s #

Ord k => Monoid (Map k v) 

Methods

mempty :: Map k v #

mappend :: Map k v -> Map k v -> Map k v #

mconcat :: [Map k v] -> Map k v #

Monoid (Parser i a) 

Methods

mempty :: Parser i a #

mappend :: Parser i a -> Parser i a -> Parser i a #

mconcat :: [Parser i a] -> Parser i a #

(Eq k, Hashable k) => Monoid (HashMap k v) 

Methods

mempty :: HashMap k v #

mappend :: HashMap k v -> HashMap k v -> HashMap k v #

mconcat :: [HashMap k v] -> HashMap k v #

(Monoid a, Monoid b, Monoid c) => Monoid (a, b, c) 

Methods

mempty :: (a, b, c) #

mappend :: (a, b, c) -> (a, b, c) -> (a, b, c) #

mconcat :: [(a, b, c)] -> (a, b, c) #

Monoid a => Monoid (Const k a b) 

Methods

mempty :: Const k a b #

mappend :: Const k a b -> Const k a b -> Const k a b #

mconcat :: [Const k a b] -> Const k a b #

Alternative f => Monoid (Alt * f a) 

Methods

mempty :: Alt * f a #

mappend :: Alt * f a -> Alt * f a -> Alt * f a #

mconcat :: [Alt * f a] -> Alt * f a #

Monoid a => Monoid (Constant k a b) 

Methods

mempty :: Constant k a b #

mappend :: Constant k a b -> Constant k a b -> Constant k a b #

mconcat :: [Constant k a b] -> Constant k a b #

(Semigroup a, Monoid a) => Monoid (Tagged k s a) 

Methods

mempty :: Tagged k s a #

mappend :: Tagged k s a -> Tagged k s a -> Tagged k s a #

mconcat :: [Tagged k s a] -> Tagged k s a #

(Monoid a, Monoid b, Monoid c, Monoid d) => Monoid (a, b, c, d) 

Methods

mempty :: (a, b, c, d) #

mappend :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) #

mconcat :: [(a, b, c, d)] -> (a, b, c, d) #

Monad m => Monoid (ConduitM i o m ()) 

Methods

mempty :: ConduitM i o m () #

mappend :: ConduitM i o m () -> ConduitM i o m () -> ConduitM i o m () #

mconcat :: [ConduitM i o m ()] -> ConduitM i o m () #

(Monoid gen, Monoid trans, Monoid track, Monoid val) => Monoid (ScopesT gen trans track val) # 

Methods

mempty :: ScopesT gen trans track val #

mappend :: ScopesT gen trans track val -> ScopesT gen trans track val -> ScopesT gen trans track val #

mconcat :: [ScopesT gen trans track val] -> ScopesT gen trans track val #

(Monoid a, Monoid b, Monoid c, Monoid d, Monoid e) => Monoid (a, b, c, d, e) 

Methods

mempty :: (a, b, c, d, e) #

mappend :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) #

mconcat :: [(a, b, c, d, e)] -> (a, b, c, d, e) #

Monad m => Monoid (Pipe l i o u m ()) 

Methods

mempty :: Pipe l i o u m () #

mappend :: Pipe l i o u m () -> Pipe l i o u m () -> Pipe l i o u m () #

mconcat :: [Pipe l i o u m ()] -> Pipe l i o u m () #

(<>) :: Monoid m => m -> m -> m infixr 6 #

An infix synonym for mappend.

Since: 4.5.0.0

while :: Monad m => m Bool -> m a -> m [a] Source #

while_ :: Monad m => m Bool -> m a -> m () Source #

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

Like when, but where the test can be monadic.

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

Like unless, but where the test can be monadic.

whenJust :: Applicative m => Maybe a -> (a -> m ()) -> m () #

Perform some operation on Just, given the field inside the Just.

whenJust Nothing  print == return ()
whenJust (Just 1) print == print 1

whenJustM :: Monad m => m (Maybe a) -> (a -> m ()) -> m () #

Like whenJust, but where the test can be monadic.

ifM :: Monad m => m Bool -> m a -> m a -> m a #

Like if, but where the test can be monadic.

andM :: Monad m => [m Bool] -> m Bool #

A version of and lifted to a monad. Retains the short-circuiting behaviour.

andM [Just True,Just False,undefined] == Just False
andM [Just True,Just True ,undefined] == undefined
\xs -> Just (and xs) == andM (map Just xs)

orM :: Monad m => [m Bool] -> m Bool #

A version of or lifted to a monad. Retains the short-circuiting behaviour.

orM [Just False,Just True ,undefined] == Just True
orM [Just False,Just False,undefined] == undefined
\xs -> Just (or xs) == orM (map Just xs)

findM :: Monad m => (a -> m Bool) -> [a] -> m (Maybe a) #

Like find, but where the test can be monadic.

findM (Just . isUpper) "teST"             == Just (Just 'S')
findM (Just . isUpper) "test"             == Just Nothing
findM (Just . const True) ["x",undefined] == Just (Just "x")

allM :: Monad m => (a -> m Bool) -> [a] -> m Bool #

A version of all lifted to a monad. Retains the short-circuiting behaviour.

allM Just [True,False,undefined] == Just False
allM Just [True,True ,undefined] == undefined
\(f :: Int -> Maybe Bool) xs -> anyM f xs == orM (map f xs)

anyM :: Monad m => (a -> m Bool) -> [a] -> m Bool #

A version of any lifted to a monad. Retains the short-circuiting behaviour.

anyM Just [False,True ,undefined] == Just True
anyM Just [False,False,undefined] == undefined
\(f :: Int -> Maybe Bool) xs -> anyM f xs == orM (map f xs)

list

foldl' :: Foldable t => forall b a. (b -> a -> b) -> b -> t a -> b #

Left-associative fold of a structure but with strict application of the operator.

This ensures that each step of the fold is forced to weak head normal form before being applied, avoiding the collection of thunks that would otherwise occur. This is often what you want to strictly reduce a finite list to a single, monolithic result (e.g. length).

For a general Foldable structure this should be semantically identical to,

foldl f z = foldl' f z . toList

mconcatMap :: Monoid b => (a -> b) -> [a] -> b Source #

This is foldMap specialized to lists.

concatMapM :: (Monad m, Monoid b) => (a -> m b) -> [a] -> m b Source #

This is actually a mconcatMapM.

A further generalized version would be:

foldMapA :: (Applicative f, Traversable t, Monoid m) =>
   (a -> f m) -> t a -> f m
foldMapA f = fmap Foldable.fold . traverse f

mapMaybeM :: Monad m => (a -> m (Maybe b)) -> [a] -> m [b] #

A version of mapMaybe that works with a monadic predicate.

mapMaybe :: (a -> Maybe b) -> [a] -> [b] #

The mapMaybe function is a version of map which can throw out elements. In particular, the functional argument returns something of type Maybe b. If this is Nothing, no element is added on to the result list. If it is Just b, then b is included in the result list.

Examples

Using mapMaybe f x is a shortcut for catMaybes $ map f x in most cases:

>>> import Text.Read ( readMaybe )
>>> let readMaybeInt = readMaybe :: String -> Maybe Int
>>> mapMaybe readMaybeInt ["1", "Foo", "3"]
[1,3]
>>> catMaybes $ map readMaybeInt ["1", "Foo", "3"]
[1,3]

If we map the Just constructor, the entire list should be returned:

>>> mapMaybe Just [1,2,3]
[1,2,3]

fromMaybe :: a -> Maybe a -> a #

The fromMaybe function takes a default value and and Maybe value. If the Maybe is Nothing, it returns the default values; otherwise, it returns the value contained in the Maybe.

Examples

Basic usage:

>>> fromMaybe "" (Just "Hello, World!")
"Hello, World!"
>>> fromMaybe "" Nothing
""

Read an integer from a string using readMaybe. If we fail to parse an integer, we want to return 0 by default:

>>> import Text.Read ( readMaybe )
>>> fromMaybe 0 (readMaybe "5")
5
>>> fromMaybe 0 (readMaybe "")
0

error

justm :: Monad m => m (Maybe a) -> (a -> m (Maybe b)) -> m (Maybe b) Source #

Run the second action only if the first action returns Just.

This is like MaybeT, but using MaybeT itself required lots of annoying explicit lifting.

rightm :: Monad m => m (Either err a) -> (a -> m (Either err b)) -> m (Either err b) Source #

The Either equivalent of justm. EitherT solves the same problem, but requires a runEitherT and lots of hoistEithers.

firstJust :: Monad m => m (Maybe a) -> m (Maybe a) -> m (Maybe a) Source #

Return the first action to return Just.

firstJusts :: Monad m => [m (Maybe a)] -> m (Maybe a) Source #

firstJust applied to a list.

errorStack :: Stack => Text -> a Source #

Just like error, except show the caller's location.

errorIO :: Stack => MonadIO m => Text -> m a Source #

Like errorStack, except run in IO.

justErr :: err -> Maybe a -> Either err a Source #

Throw on Nothing.

tryJust :: MonadError e m => e -> Maybe a -> m a Source #

I usually call this require.

tryRight :: MonadError e m => Either e a -> m a Source #

I usually call this require_right.

pretty

class Pretty a where Source #

Format values in an eye-pleasing way. Unlike Show, this isn't intended to produce any kind of valid syntax, or even preserve information.

Minimal complete definition

pretty | format

Methods

pretty :: a -> Text Source #

Instances

Pretty Bool # 
Pretty Char # 
Pretty Double # 
Pretty Float # 
Pretty Int # 
Pretty Integer # 
Pretty Word8 # 
Pretty Word16 # 
Pretty Word32 # 
Pretty Word64 # 
Pretty () # 

Methods

pretty :: () -> Text Source #

format :: () -> Doc Source #

formatList :: [()] -> Doc Source #

Pretty Dynamic # 
Pretty ByteString # 
Pretty UTCTime # 
Pretty Day # 
Pretty Text # 
Pretty Text # 
Pretty Doc # 
Pretty Commit # 
Pretty Size # 
Pretty Rect # 
Pretty Color # 
Pretty Key # 
Pretty UnserializeError # 
Pretty Qualified # 
Pretty Control # 
Pretty Attributes # 
Pretty RulerId # 
Pretty TrackId # 
Pretty ViewId # 
Pretty BlockId # 
Pretty Namespace # 
Pretty Id # 
Pretty Doc # 
Pretty Anga # 
Pretty Tala # 
Pretty State # 
Pretty Tempo # 
Pretty TempoChange # 
Pretty Duration # 
Pretty Key # 
Pretty Transpose # 
Pretty ScaleId # 
Pretty NoteNumber # 
Pretty Input # 
Pretty Degree # 
Pretty Pitch # 
Pretty Note # 
Pretty ScoreTime # 
Pretty RealTime # 
Pretty ChannelMessage # 
Pretty Key # 
Pretty Message # 
Pretty WriteDevice # 
Pretty ReadDevice # 
Pretty ReadMessage # 
Pretty WriteMessage # 
Pretty Message # 
Pretty Control # 
Pretty Channel # 
Pretty State # 
Pretty Note # 
Pretty Frame # 
Pretty Stack # 
Pretty Msg # 
Pretty Modification # 
Pretty Tree # 
Pretty Blob # 
Pretty Skeleton # 
Pretty Zoom # 
Pretty Type # 
Pretty Warp # 
Pretty PControl # 
Pretty Control # 
Pretty Instrument # 
Pretty Key # 
Pretty Flag # 
Pretty Str # 
Pretty Symbol # 
Pretty Sollu # 
Pretty Pattern # 
Pretty Emphasis # 
Pretty Stroke # 
Pretty Valantalai # 
Pretty Thoppi # 
Pretty Stroke # 
Pretty Stroke # 
Pretty Stroke # 
Pretty Stroke # 
Pretty StrokeMaps # 
Pretty Tags # 
Pretty Metadata # 
Pretty Korvai # 
Pretty Module # 
Pretty Attributes # 
Pretty Note # 
Pretty Orientation # 
Pretty Stack # 
Pretty Event # 
Pretty Selection # 
Pretty Key # 
Pretty Events # 
Pretty Range # 
Pretty Mark # 
Pretty Marklist # 
Pretty Ruler # 
Pretty LabeledMark # 
Pretty ControlFunction # 
Pretty PControlRef # 
Pretty ControlRef # 
Pretty Quoted # 
Pretty Val # 
Pretty Environ # 
Pretty Duration # 
Pretty PitchError # 
Pretty Scale # 
Pretty PitchConfig # 
Pretty PSignal # 
Pretty Val # 
Pretty Environ # 
Pretty RelativePitch # 
Pretty Event # 
Pretty Type # 
Pretty NumValue # 
Pretty NumType # 
Pretty Type # 
Pretty Config # 
Pretty Flag # 
Pretty Patch # 
Pretty Keyswitch # 
Pretty Keymap # 
Pretty InitializePatch # 
Pretty Flag # 
Pretty Scale # 
Pretty Patch # 
Pretty Settings # 
Pretty Initialization # 
Pretty Config # 
Pretty Backend # 
Pretty Record # 
Pretty Event # 
Pretty Patch # 
Pretty Allotted # 
Pretty AllotState # 
Pretty State # 
Pretty Event # 
Pretty Time # 
Pretty Duration # 
Pretty StaffConfig # 
Pretty Config # 
Pretty Meter # 
Pretty TrackSignal # 
Pretty RenderSource # 
Pretty RenderStyle # 
Pretty RenderConfig # 
Pretty Track # 
Pretty Padding # 
Pretty View # 
Pretty TracklikeId # 
Pretty TrackFlag # 
Pretty Status # 
Pretty DisplayTrack # 
Pretty Track # 
Pretty Box # 
Pretty Config # 
Pretty NoteDestination # 
Pretty TrackDestinations # 
Pretty Block # 
Pretty Default # 
Pretty LilypondPerformance # 
Pretty MidiPerformance # 
Pretty Meta # 
Pretty Backend # 
Pretty Allocation # 
Pretty Allocations # 
Pretty Config # 
Pretty Track # 
Pretty Context # 
Pretty UiMsg # 
Pretty State # 
Pretty Track # 
Pretty View # 
Pretty CmdUpdate # 
Pretty Error # 
Pretty TrackInfo # 
Pretty Range # 
Pretty Track # 
Pretty State # 
Pretty SaveHistory # 
Pretty Sliced # 
Pretty Track # 
Pretty TrackWarp # 
Pretty Track # 
Pretty Scale # 
Pretty ControlDamage # 
Pretty ScoreDamage # 
Pretty BlockDeps # 
Pretty CacheEntry # 
Pretty Cached # 
Pretty CacheKey # 
Pretty Cache # 
Pretty ArgName # 
Pretty CallName # 
Pretty Integrated # 
Pretty ControlMod # 
Pretty Collect # 
Pretty Mode # 
Pretty CallPriority # 
Pretty Library # 
Pretty Inversion # 
Pretty Dynamic # 
Pretty Tagged # 
Pretty ErrorPlace # 
Pretty CallError # 
Pretty ErrorVal # 
Pretty Error # 
Pretty TransposeType # 
Pretty TimeType # 
Pretty Normalized # 
Pretty Performance # 
Pretty DeriveStatus # 
Pretty Msg # 
Pretty Range # 
Pretty UpDown # 
Pretty PitchDirection # 
Pretty PitchState # 
Pretty DynState # 
Pretty Stroke # 
Pretty Bol # 
Pretty Stroke # 
Pretty DegreeMap # 
Pretty Tuning # 
Pretty Key # 
Pretty Voice # 
Pretty Voices # 
Pretty Ly # 
Pretty StaffGroup # 
Pretty KotekanNote # 
Pretty Repeat # 
Pretty Atom # 
Pretty KotekanPattern # 
Pretty SavePoint # 
Pretty Backend # 
Pretty ResolvedInstrument # 
Pretty HistoryEntry # 
Pretty HistoryCollect # 
Pretty HistoryConfig # 
Pretty History # 
Pretty InstrumentCode # 
Pretty Action # 
Pretty EditMode # 
Pretty SyncConfig # 
Pretty Patch # 
Pretty Code # 
Pretty MouseOn # 
Pretty Bindable # 
Pretty KeySpec # 
Pretty Hand # 
Pretty Degree # 
Pretty Composite # 
Pretty Expr # 
Pretty CallType # 
Pretty Track # 
Pretty Pos # 
Pretty Sample # 
Pretty Patch # 
Pretty Modify # 
Pretty Edit # 
Pretty Control # 
Pretty Note # 
Pretty Result # 
Pretty a => Pretty [a] # 

Methods

pretty :: [a] -> Text Source #

format :: [a] -> Doc Source #

formatList :: [[a]] -> Doc Source #

Pretty a => Pretty (Maybe a) # 
(Integral a, Pretty a) => Pretty (Ratio a) # 
Pretty a => Pretty (NonEmpty a) # 
Pretty v => Pretty (IntMap v) # 
Pretty a => Pretty (Tree a) # 

Methods

pretty :: Tree a -> Text Source #

format :: Tree a -> Doc Source #

formatList :: [Tree a] -> Doc Source #

Pretty a => Pretty (Set a) # 

Methods

pretty :: Set a -> Text Source #

format :: Set a -> Doc Source #

formatList :: [Set a] -> Doc Source #

Pretty a => Pretty (Vector a) # 
(Storable a, Pretty a) => Pretty (Vector a) # 
(Unbox a, Pretty a) => Pretty (Vector a) # 
Pretty a => Pretty (Builder a) # 
Pretty a => Pretty (Lazy a) # 

Methods

pretty :: Lazy a -> Text Source #

format :: Lazy a -> Doc Source #

formatList :: [Lazy a] -> Doc Source #

Pretty (Value Doc) # 
Pretty (Record Doc) # 
Pretty n => Pretty (Ranges n) # 
Pretty a => Pretty (Stroke a) # 
Pretty a => Pretty (Note a) # 

Methods

pretty :: Note a -> Text Source #

format :: Note a -> Doc Source #

formatList :: [Note a] -> Doc Source #

Pretty dur => Pretty (NoteT dur) # 

Methods

pretty :: NoteT dur -> Text Source #

format :: NoteT dur -> Doc Source #

formatList :: [NoteT dur] -> Doc Source #

Pretty (Signal y) # 
Pretty a => Pretty (Typed a) # 
Pretty d => Pretty (LEvent d) # 
ShowVal val => Pretty (Term val) # 

Methods

pretty :: Term val -> Text Source #

format :: Term val -> Doc Source #

formatList :: [Term val] -> Doc Source #

ShowVal val => Pretty (Call val) # 

Methods

pretty :: Call val -> Text Source #

format :: Call val -> Doc Source #

formatList :: [Call val] -> Doc Source #

Pretty stroke => Pretty (NoteT stroke) # 

Methods

pretty :: NoteT stroke -> Text Source #

format :: NoteT stroke -> Doc Source #

formatList :: [NoteT stroke] -> Doc Source #

Pretty stroke => Pretty (Note stroke) # 

Methods

pretty :: Note stroke -> Text Source #

format :: Note stroke -> Doc Source #

formatList :: [Note stroke] -> Doc Source #

Pretty stroke => Pretty (Instrument stroke) # 

Methods

pretty :: Instrument stroke -> Text Source #

format :: Instrument stroke -> Doc Source #

formatList :: [Instrument stroke] -> Doc Source #

Pretty stroke => Pretty (StrokeMap stroke) # 

Methods

pretty :: StrokeMap stroke -> Text Source #

format :: StrokeMap stroke -> Doc Source #

formatList :: [StrokeMap stroke] -> Doc Source #

Pretty stroke => Pretty (Patterns stroke) # 

Methods

pretty :: Patterns stroke -> Text Source #

format :: Patterns stroke -> Doc Source #

formatList :: [Patterns stroke] -> Doc Source #

Pretty stroke => Pretty (Stroke stroke) # 

Methods

pretty :: Stroke stroke -> Text Source #

format :: Stroke stroke -> Doc Source #

formatList :: [Stroke stroke] -> Doc Source #

Pretty stroke => Pretty (Note stroke) # 

Methods

pretty :: Note stroke -> Text Source #

format :: Note stroke -> Doc Source #

formatList :: [Note stroke] -> Doc Source #

Pretty (RawPitch a) #

Will look like: 62.95nn,4i(*wayang)

Pretty a => Pretty (Stream a) # 
(Show pitch, Pretty pitch) => Pretty (GenericInput pitch) # 
Pretty a => Pretty (AttributeMap a) # 
Pretty code => Pretty (Common code) # 

Methods

pretty :: Common code -> Text Source #

format :: Common code -> Doc Source #

formatList :: [Common code] -> Doc Source #

Pretty code => Pretty (SynthDecl code) # 

Methods

pretty :: SynthDecl code -> Text Source #

format :: SynthDecl code -> Doc Source #

formatList :: [SynthDecl code] -> Doc Source #

Pretty code => Pretty (Synth code) # 

Methods

pretty :: Synth code -> Text Source #

format :: Synth code -> Doc Source #

formatList :: [Synth code] -> Doc Source #

Pretty code => Pretty (Db code) # 

Methods

pretty :: Db code -> Text Source #

format :: Db code -> Doc Source #

formatList :: [Db code] -> Doc Source #

Pretty code => Pretty (Inst code) # 

Methods

pretty :: Inst code -> Text Source #

format :: Inst code -> Doc Source #

formatList :: [Inst code] -> Doc Source #

Pretty t => Pretty (Block t) # 
Pretty (Call d) # 

Methods

pretty :: Call d -> Text Source #

format :: Call d -> Doc Source #

formatList :: [Call d] -> Doc Source #

Pretty val => Pretty (Context val) # 

Methods

pretty :: Context val -> Text Source #

format :: Context val -> Doc Source #

formatList :: [Context val] -> Doc Source #

Pretty val => Pretty (PassedArgs val) # 
Pretty (LookupCall call) # 
Show a => Pretty (CallDuration a) # 
Pretty (Merger a) # 
Pretty (Merge a) # 
Pretty (TrackCall d) # 
Pretty (ScopePriority call) # 
Pretty (TrackInfo d) # 
Pretty a => Pretty (GenericEvent a) # 
Pretty a => Pretty (Note a) # 

Methods

pretty :: Note a -> Text Source #

format :: Note a -> Doc Source #

formatList :: [Note a] -> Doc Source #

Pretty a => Pretty (Note a) # 

Methods

pretty :: Note a -> Text Source #

format :: Note a -> Doc Source #

formatList :: [Note a] -> Doc Source #

Pretty a => Pretty (Pasang a) # 
Pretty (a -> b) # 

Methods

pretty :: (a -> b) -> Text Source #

format :: (a -> b) -> Doc Source #

formatList :: [a -> b] -> Doc Source #

(Pretty a, Pretty b) => Pretty (Either a b) # 

Methods

pretty :: Either a b -> Text Source #

format :: Either a b -> Doc Source #

formatList :: [Either a b] -> Doc Source #

(Pretty a, Pretty b) => Pretty (a, b) # 

Methods

pretty :: (a, b) -> Text Source #

format :: (a, b) -> Doc Source #

formatList :: [(a, b)] -> Doc Source #

(Pretty k, Pretty v) => Pretty (Map k v) # 

Methods

pretty :: Map k v -> Text Source #

format :: Map k v -> Doc Source #

formatList :: [Map k v] -> Doc Source #

(Pretty a, Pretty b) => Pretty (Paired a b) # 

Methods

pretty :: Paired a b -> Text Source #

format :: Paired a b -> Doc Source #

formatList :: [Paired a b] -> Doc Source #

(Pretty t, Pretty u) => Pretty (Update t u) # 

Methods

pretty :: Update t u -> Text Source #

format :: Update t u -> Doc Source #

formatList :: [Update t u] -> Doc Source #

(Pretty a, Pretty b, Pretty c) => Pretty (a, b, c) # 

Methods

pretty :: (a, b, c) -> Text Source #

format :: (a, b, c) -> Doc Source #

formatList :: [(a, b, c)] -> Doc Source #

(Pretty note, Pretty control, Pretty pitch) => Pretty (Scope note control pitch) # 

Methods

pretty :: Scope note control pitch -> Text Source #

format :: Scope note control pitch -> Doc Source #

formatList :: [Scope note control pitch] -> Doc Source #

(Pretty a, Pretty b, Pretty c, Pretty d) => Pretty (a, b, c, d) # 

Methods

pretty :: (a, b, c, d) -> Text Source #

format :: (a, b, c, d) -> Doc Source #

formatList :: [(a, b, c, d)] -> Doc Source #

(Pretty gen, Pretty trans, Pretty track, Pretty val) => Pretty (ScopesT gen trans track val) # 

Methods

pretty :: ScopesT gen trans track val -> Text Source #

format :: ScopesT gen trans track val -> Doc Source #

formatList :: [ScopesT gen trans track val] -> Doc Source #

(Pretty a, Pretty b, Pretty c, Pretty d, Pretty e) => Pretty (a, b, c, d, e) # 

Methods

pretty :: (a, b, c, d, e) -> Text Source #

format :: (a, b, c, d, e) -> Doc Source #

formatList :: [(a, b, c, d, e)] -> Doc Source #

(Pretty a, Pretty b, Pretty c, Pretty d, Pretty e, Pretty f) => Pretty (a, b, c, d, e, f) # 

Methods

pretty :: (a, b, c, d, e, f) -> Text Source #

format :: (a, b, c, d, e, f) -> Doc Source #

formatList :: [(a, b, c, d, e, f)] -> Doc Source #

pretty :: Pretty a => a -> Text Source #

lens

type Lens a b = a :-> b Source #

(#) :: Lens a b -> Lens b c -> Lens a c infixr 9 Source #

Compose lenses.

pure

(#$) :: Lens f a -> f -> a infixr 1 Source #

Get: bval = a record

(#=) :: Lens f a -> a -> f -> f infix 1 Source #

Set: a= 42 record

(%=) :: Lens f a -> (a -> a) -> f -> f infix 1 Source #

Modify: a#b %= (+1) record

state

(<#>) :: Functor f => Lens a b -> f a -> f b infixl 4 Source #

Use like a> State.get.

lift :: MonadTrans t => forall m a. Monad m => m a -> t m a #

Lift a computation from the argument monad to the constructed monad.

liftIO :: MonadIO m => forall a. IO a -> m a #

Lift a computation from the IO monad.

nonempty

text

data Text :: * #

A space efficient, packed, unboxed Unicode text type.

Instances

Hashable Text 

Methods

hashWithSalt :: Int -> Text -> Int #

hash :: Text -> Int #

Chunk Text 
ToJSON Text 
KeyValue Pair 

Methods

(.=) :: ToJSON v => Text -> v -> Pair #

ToJSONKey Text 
FromJSON Text 
FromJSONKey Text 
Pretty Text # 
Pretty LilypondPerformance # 
Extract Text # 

Methods

extract :: Text -> Value Source #

Textlike Text # 
ApproxEq Text # 

Methods

eq :: Double -> Text -> Text -> Bool Source #

Serialize Text # 
ShowVal Text #

This should be the inverse of p_str and p_unquoted_str.

Methods

show_val :: Text -> Text Source #

ToVal Text # 

Methods

to_val :: Text -> Val Source #

RecordVal Text # 
ToLily Text # 

Methods

to_lily :: Text -> Text Source #

ToVal Text # 

Methods

to_val :: Text -> Val Source #

Typecheck Text # 
Return Text # 
ConvertibleStrings String StrictText 

Methods

convertString :: String -> StrictText

ConvertibleStrings StrictText String 

Methods

convertString :: StrictText -> String

ConvertibleStrings StrictText StrictText 

Methods

convertString :: StrictText -> StrictText

ConvertibleStrings StrictText StrictByteString 

Methods

convertString :: StrictText -> StrictByteString

ConvertibleStrings StrictText LazyText 

Methods

convertString :: StrictText -> LazyText

ConvertibleStrings StrictText LazyByteString 

Methods

convertString :: StrictText -> LazyByteString

ConvertibleStrings StrictByteString StrictText 

Methods

convertString :: StrictByteString -> StrictText

ConvertibleStrings LazyText StrictText 

Methods

convertString :: LazyText -> StrictText

ConvertibleStrings LazyByteString StrictText 

Methods

convertString :: LazyByteString -> StrictText

Monad m => Stream Text m Char 

Methods

uncons :: Text -> m (Maybe (Char, Text)) #

FromPairs Value (DList Pair) 

Methods

fromPairs :: DList Pair -> Value

ToJSON v => GKeyValue v (DList Pair) 

Methods

gPair :: String -> v -> DList Pair

type Item Text 
type Item Text = Char
type State Text 
type State Text = Buffer
type ChunkElem Text 

txt :: String -> Text Source #

Utilities to make it easier to convert things to Text. These are intentionally missing the e to make it easier to search for them.

showt :: Show a => a -> Text Source #