Hoogle Search

Within LTS Haskell 24.40 (ghc-9.10.3)

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

  1. withForeignPtr :: ForeignPtr a -> (Ptr a -> IO b) -> IO b

    base-compat Foreign.ForeignPtr.Safe.Compat

    This is a way to look at the pointer living inside a foreign object. This function takes a function which is applied to that pointer. The resulting IO action is then executed. The foreign object is kept alive at least during the whole action, even if it is not used directly inside. Note that it is not safe to return the pointer from the action and use it after the action completes. All uses of the pointer should be inside the withForeignPtr bracket. The reason for this unsafeness is the same as for unsafeForeignPtrToPtr below: the finalizer may run earlier than expected, because the compiler can only track usage of the ForeignPtr object, not a Ptr object made from it. This function is normally used for marshalling data to or from the object pointed to by the ForeignPtr, using the operations from the Storable class.

  2. unsafeForeignPtrToPtr :: ForeignPtr a -> Ptr a

    base-compat Foreign.ForeignPtr.Unsafe.Compat

    This function extracts the pointer component of a foreign pointer. This is a potentially dangerous operations, as if the argument to unsafeForeignPtrToPtr is the last usage occurrence of the given foreign pointer, then its finalizer(s) will be run, which potentially invalidates the plain pointer just obtained. Hence, touchForeignPtr must be used wherever it has to be guaranteed that the pointer lives on - i.e., has another usage occurrence. To avoid subtle coding errors, hand written marshalling code should preferably use withForeignPtr rather than combinations of unsafeForeignPtrToPtr and touchForeignPtr. However, the latter routines are occasionally preferred in tool generated marshalling code.

  3. unsafeDupablePerformIO :: IO a -> a

    base-compat System.IO.Unsafe.Compat

    This version of unsafePerformIO is more efficient because it omits the check that the IO is only being performed by a single thread. Hence, when you use unsafeDupablePerformIO, there is a possibility that the IO action may be performed multiple times (on a multiprocessor), and you should therefore ensure that it gives the same results each time. It may even happen that one of the duplicated IO actions is only run partially, and then interrupted in the middle without an exception being raised. Therefore, functions like bracket cannot be used safely within unsafeDupablePerformIO.

  4. segmentBefore :: (a -> Bool) -> [a] -> [[a]]

    utility-ht Data.List.HT

    Split the list before each occurence of a leading character. Keep these characters. There is always a list for the part before the first leading character. It may be empty. See package non-empty for more precise result type. 

    >>> segmentBefore isUpper "AbcdXyz"
["","Abcd","Xyz"]

>>> segmentBefore isUpper "kAbcdXYZ"
["k","Abcd","X","Y","Z"]

    forAllPredicates $ \p xs -> concat (segmentBefore p xs) == xs

    forAllPredicates $ \p xs -> length (filter p xs) == length (tail (segmentBefore p xs))

    forAllPredicates $ \p -> all (p . head) . tail . segmentBefore p

    forAllPredicates $ \p -> all (all (not . p) . tail) . tail . segmentBefore p

    forAllPredicates $ \p x -> flip seq True . (!!100) . concat . segmentBefore p . cycle . (x:)

  5. segmentBeforeJust :: (a -> Maybe b) -> [a] -> ([a], [(b, [a])])

    utility-ht Data.List.HT 

    >>> segmentBeforeJust (\c -> toMaybe (isLetter c) (toUpper c)) "123a5345b---"
("123",[('A',"5345"),('B',"---")])

  6. segmentBeforeMaybe :: (a -> Maybe b) -> [a] -> ([a], [(b, [a])])

    utility-ht Data.List.HT

    Deprecated: use segmentBeforeJust instead

  7. segmentBeforeRight :: [Either a b] -> ([a], [(b, [a])])

    utility-ht Data.List.HT 

    >>> segmentBeforeRight [Left 'a', Right LT, Right GT, Left 'b']
("a",[(LT,""),(GT,"b")])

    forAllMaybeFn $ \f xs -> segmentBeforeJust f xs == segmentBeforeRight (map (\x -> maybe (Left x) Right (f x)) xs)

  8. type NoInstanceFor (expr :: k) = 'Text "There is no instance for " ':<>: 'ShowType expr

    servant Servant.API.TypeErrors

    No instance exists for expr.

  9. type NoInstanceForSub (tycls :: k) (expr :: k') = 'Text "There is no instance for " ':<>: 'ShowType tycls ':<>: 'Text " (" ':<>: 'ShowType expr ':<>: 'Text " :> ...)"

    servant Servant.API.TypeErrors

    No instance exists for tycls (expr :> ...) because expr is not recognised.

  10. transformStepWithAtto :: forall a (m :: Type -> Type) . Monad m => Parser a -> StepT m ByteString -> StepT m a

    servant Servant.Types.SourceT

    No documentation available.

Page 429 of many | Previous | Next