Hoogle Search
Within LTS Haskell 24.28 (ghc-9.10.3)
Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.
pattern
PipeList :: Monad m => ListT m (Maybe a) -> Pipe () a u m ()conduino Data.Conduino A source is equivalent to a ListT producing a Maybe; this pattern synonym lets you treat it as such. It essentialyl wraps over toListT and fromListT.
fromListT :: forall (m :: Type -> Type) o i u . Monad m => ListT m (Maybe o) -> Pipe i o u m ()conduino Data.Conduino A source is essentially ListT producing a Maybe result. This converts a ListT to the source it encodes. See ZipSource for a wrapper over Pipe that gives the right Functor and Alternative instances.
toListT :: forall (m :: Type -> Type) o u . Applicative m => Pipe () o u m () -> ListT m (Maybe o)conduino Data.Conduino A source is essentially equivalent to ListT producing a Maybe result. This converts it to the ListT it encodes. See ZipSource for a wrapper over Pipe that gives the right Functor and Alternative instances.
sinkList :: forall i o u (m :: Type -> Type) . Pipe i o u m [i]conduino Data.Conduino.Combinators Sink every incoming item into a list. Note that this keeps the entire list in memory until it is all eventually read, and does no "lazy IO". It exhauts the whole stream before returning anything.
sourceList :: forall t a i u (m :: Type -> Type) . Foldable t => t a -> Pipe i a u m ()conduino Data.Conduino.Combinators Yield every item in a foldable container.
-
consumers Database.PostgreSQL.Consumers.Components Spawn a thread that generates signals for the dispatcher to probe the database for incoming jobs.
unsafeFindCycleFromList :: CycleFinder a -> [a] -> (Int, Int, ([a], [a]))data-findcycle Data.FindCycle Runs the CycleFinder for a given input list. This function is provided as a convenience for when you already have a list of values you'd like to find a cycle in. It's referred to as "unsafe", because it might lead to surprising results when the input doesn't satisfy the invariants that different algorithms assume. All algorithms assume that the sequence they're searching can be constructed by repeated function application from a starting value. Many sequences can't be, such as [1,2,1,3,1,4,1,5,...] (because there can only be one unique successor of 1). Algorithms also assume the input sequence to be infinite, and they will commonly consume more than <math> (or <math>) elements from it. If you provide a finite input list, cycles might not be identified correctly if the chosen algorithm runs into the end of it, even though the input does technically contain an identifiable cycle. If an assumption is violated, algorithms might wrongly identify cycles or never terminate. Try to stick to findCycle, findCycleExtract, cycleExp, or cycleExp' if possible, or only pass infinite lists generated via iterate f x (or equivalent) to unsafeFindCycleFromList. Similar to findCycleExtract, just don't evaluate the last part of the return value if you don't need it and want to avoid the cost of computing it.
fromList :: Ord k => [(Interval k, a)] -> IntervalMap k adata-interval Data.IntervalMap.Lazy Build a map from a list of key/value pairs. If the list contains more than one value for the same key, the last value for the key is retained.
fromListWith :: Ord k => (a -> a -> a) -> [(Interval k, a)] -> IntervalMap k adata-interval Data.IntervalMap.Lazy Build a map from a list of key/value pairs with a combining function.
toAscList :: IntervalMap k a -> [(Interval k, a)]data-interval Data.IntervalMap.Lazy Convert the map to a list of key/value pairs where the keys are in ascending order.