packages feed

emacs-module 0.2.1.1 → 0.3

raw patch · 5 files changed

+45/−10 lines, 5 filesdep ~prettyprinter-combinatorsdep ~textPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: prettyprinter-combinators, text

API changes (from Hackage documentation)

+ Emacs.Module: extractByteString :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> m s ByteString
+ Emacs.Module.Monad.Class: extractByteString :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> m s ByteString
- Data.Emacs.Module.Args: Stop :: Stop a
+ Data.Emacs.Module.Args: Stop :: Stop (a :: k)
- Data.Emacs.Module.Args: class EmacsInvocation req opt rest
+ Data.Emacs.Module.Args: class EmacsInvocation (req :: Nat) (opt :: Nat) (rest :: Bool)
- Data.Emacs.Module.Args: data Stop a
+ Data.Emacs.Module.Args: data Stop (a :: k)
- Data.Emacs.Module.Args: type family EmacsArgs (req :: Nat) (opt :: Nat) (rest :: Bool) (a :: Type) = (r :: Type) | r -> req opt rest a
+ Data.Emacs.Module.Args: type family EmacsArgs (req :: Nat) (opt :: Nat) (rest :: Bool) a = (r :: Type) | r -> req opt rest a
- Data.Emacs.Module.Env: copyStringContents :: MonadIO m => Env -> RawValue p -> CString -> NonNullPtr CPtrdiff -> m CBoolean
+ Data.Emacs.Module.Env: copyStringContents :: forall m (p :: Pinning). MonadIO m => Env -> RawValue p -> CString -> NonNullPtr CPtrdiff -> m CBoolean
- Data.Emacs.Module.Env: data Env
+ Data.Emacs.Module.Env: data Env :: TYPE 'AddrRep
- Data.Emacs.Module.Env: data RawFunction o a
+ Data.Emacs.Module.Env: data RawFunction (o :: Pinning) a
- Data.Emacs.Module.Env: eq :: MonadIO m => Env -> RawValue p1 -> RawValue p2 -> m CBoolean
+ Data.Emacs.Module.Env: eq :: forall m (p1 :: Pinning) (p2 :: Pinning). MonadIO m => Env -> RawValue p1 -> RawValue p2 -> m CBoolean
- Data.Emacs.Module.Env: exportToEmacs :: RawFunctionType o a -> IO (RawFunction o a)
+ Data.Emacs.Module.Env: exportToEmacs :: forall (o :: Pinning) a. RawFunctionType o a -> IO (RawFunction o a)
- Data.Emacs.Module.Env: extractFloat :: MonadIO m => Env -> RawValue p -> m CDouble
+ Data.Emacs.Module.Env: extractFloat :: forall m (p :: Pinning). MonadIO m => Env -> RawValue p -> m CDouble
- Data.Emacs.Module.Env: extractInteger :: MonadIO m => Env -> RawValue p -> m CIntMax
+ Data.Emacs.Module.Env: extractInteger :: forall m (p :: Pinning). MonadIO m => Env -> RawValue p -> m CIntMax
- Data.Emacs.Module.Env: freeGlobalRef :: forall m. MonadIO m => Env -> RawValue 'Pinned -> m ()
+ Data.Emacs.Module.Env: freeGlobalRef :: MonadIO m => Env -> RawValue 'Pinned -> m ()
- Data.Emacs.Module.Env: funcall :: MonadIO m => Env -> RawValue p1 -> CPtrdiff -> NonNullPtr (RawValue p2) -> m (RawValue 'Regular)
+ Data.Emacs.Module.Env: funcall :: forall m (p1 :: Pinning) (p2 :: Pinning). MonadIO m => Env -> RawValue p1 -> CPtrdiff -> NonNullPtr (RawValue p2) -> m (RawValue 'Regular)
- Data.Emacs.Module.Env: funcallPrimitive :: MonadIO m => Env -> RawValue p1 -> CPtrdiff -> NonNullPtr (RawValue p2) -> m (RawValue 'Regular)
+ Data.Emacs.Module.Env: funcallPrimitive :: forall m (p1 :: Pinning) (p2 :: Pinning). MonadIO m => Env -> RawValue p1 -> CPtrdiff -> NonNullPtr (RawValue p2) -> m (RawValue 'Regular)
- Data.Emacs.Module.Env: getUserFinaliser :: MonadIO m => Env -> RawValue p -> m (FinalizerPtr a)
+ Data.Emacs.Module.Env: getUserFinaliser :: forall m (p :: Pinning) a. MonadIO m => Env -> RawValue p -> m (FinalizerPtr a)
- Data.Emacs.Module.Env: getUserPtr :: MonadIO m => Env -> RawValue p -> m (Ptr a)
+ Data.Emacs.Module.Env: getUserPtr :: forall m (p :: Pinning) a. MonadIO m => Env -> RawValue p -> m (Ptr a)
- Data.Emacs.Module.Env: isNotNil :: MonadIO m => Env -> RawValue p -> m CBoolean
+ Data.Emacs.Module.Env: isNotNil :: forall m (p :: Pinning). MonadIO m => Env -> RawValue p -> m CBoolean
- Data.Emacs.Module.Env: makeFunction :: forall m o a. MonadIO m => Env -> CPtrdiff -> CPtrdiff -> RawFunction o a -> CString -> Ptr a -> m (RawValue 'Regular)
+ Data.Emacs.Module.Env: makeFunction :: forall m (o :: Pinning) a. MonadIO m => Env -> CPtrdiff -> CPtrdiff -> RawFunction o a -> CString -> Ptr a -> m (RawValue 'Regular)
- Data.Emacs.Module.Env: makeGlobalRef :: forall m p. MonadIO m => Env -> RawValue p -> m (RawValue 'Pinned)
+ Data.Emacs.Module.Env: makeGlobalRef :: forall m (p :: Pinning). MonadIO m => Env -> RawValue p -> m (RawValue 'Pinned)
- Data.Emacs.Module.Env: makeUserPtr :: forall m a. MonadIO m => Env -> FinalizerPtr a -> Ptr a -> m (RawValue 'Regular)
+ Data.Emacs.Module.Env: makeUserPtr :: MonadIO m => Env -> FinalizerPtr a -> Ptr a -> m (RawValue 'Regular)
- Data.Emacs.Module.Env: nonLocalExitSignal :: MonadIO m => Env -> RawValue p1 -> RawValue p2 -> m ()
+ Data.Emacs.Module.Env: nonLocalExitSignal :: forall m (p1 :: Pinning) (p2 :: Pinning). MonadIO m => Env -> RawValue p1 -> RawValue p2 -> m ()
- Data.Emacs.Module.Env: nonLocalExitThrow :: MonadIO m => Env -> RawValue p1 -> RawValue p2 -> m ()
+ Data.Emacs.Module.Env: nonLocalExitThrow :: forall m (p1 :: Pinning) (p2 :: Pinning). MonadIO m => Env -> RawValue p1 -> RawValue p2 -> m ()
- Data.Emacs.Module.Env: setUserFinaliser :: MonadIO m => Env -> RawValue p -> FinalizerPtr a -> m ()
+ Data.Emacs.Module.Env: setUserFinaliser :: forall m (p :: Pinning) a. MonadIO m => Env -> RawValue p -> FinalizerPtr a -> m ()
- Data.Emacs.Module.Env: setUserPtr :: MonadIO m => Env -> RawValue p -> Ptr a -> m ()
+ Data.Emacs.Module.Env: setUserPtr :: forall m (p :: Pinning) a. MonadIO m => Env -> RawValue p -> Ptr a -> m ()
- Data.Emacs.Module.Env: type RawFunctionType o a = Ptr Environment -> CPtrdiff -> Ptr (RawValue 'Regular) -> Ptr a -> IO (RawValue o)
+ Data.Emacs.Module.Env: type RawFunctionType (o :: Pinning) a = Ptr Environment -> CPtrdiff -> Ptr RawValue 'Regular -> Ptr a -> IO RawValue o
- Data.Emacs.Module.Env: typeOf :: MonadIO m => Env -> RawValue p -> m (RawValue 'Regular)
+ Data.Emacs.Module.Env: typeOf :: forall m (p :: Pinning). MonadIO m => Env -> RawValue p -> m (RawValue 'Regular)
- Data.Emacs.Module.Env: vecGet :: MonadIO m => Env -> RawValue p -> CPtrdiff -> m (RawValue 'Regular)
+ Data.Emacs.Module.Env: vecGet :: forall m (p :: Pinning). MonadIO m => Env -> RawValue p -> CPtrdiff -> m (RawValue 'Regular)
- Data.Emacs.Module.Env: vecSet :: MonadIO m => Env -> RawValue p1 -> CPtrdiff -> RawValue p2 -> m ()
+ Data.Emacs.Module.Env: vecSet :: forall m (p1 :: Pinning) (p2 :: Pinning). MonadIO m => Env -> RawValue p1 -> CPtrdiff -> RawValue p2 -> m ()
- Data.Emacs.Module.Env: vecSize :: MonadIO m => Env -> RawValue p -> m CPtrdiff
+ Data.Emacs.Module.Env: vecSize :: forall m (p :: Pinning). MonadIO m => Env -> RawValue p -> m CPtrdiff
- Data.Emacs.Module.NonNullPtr: allocaBytesNonNull :: forall a b. Int -> (NonNullPtr a -> IO b) -> IO b
+ Data.Emacs.Module.NonNullPtr: allocaBytesNonNull :: Int -> (NonNullPtr a -> IO b) -> IO b
- Data.Emacs.Module.NonNullPtr: allocaNonNull :: forall a b. Storable a => (NonNullPtr a -> IO b) -> IO b
+ Data.Emacs.Module.NonNullPtr: allocaNonNull :: Storable a => (NonNullPtr a -> IO b) -> IO b
- Data.Emacs.Module.NonNullPtr: withPtrLenNonNull :: forall a b. (WithCallStack, Storable a) => BuilderCache a -> Builder a -> (Int -> NonNullPtr a -> IO b) -> IO b
+ Data.Emacs.Module.NonNullPtr: withPtrLenNonNull :: (WithCallStack, Storable a) => BuilderCache a -> Builder a -> (Int -> NonNullPtr a -> IO b) -> IO b
- Emacs.Module: Stop :: Stop a
+ Emacs.Module: Stop :: Stop (a :: k)
- Emacs.Module: assignUserPtr :: (MonadEmacs m v, WithCallStack) => v s -> Ptr a -> m s ()
+ Emacs.Module: assignUserPtr :: forall (s :: k) a. (MonadEmacs m v, WithCallStack) => v s -> Ptr a -> m s ()
- Emacs.Module: assignUserPtrFinaliser :: (MonadEmacs m v, WithCallStack) => v s -> FinalizerPtr a -> m s ()
+ Emacs.Module: assignUserPtrFinaliser :: forall (s :: k) a. (MonadEmacs m v, WithCallStack) => v s -> FinalizerPtr a -> m s ()
- Emacs.Module: class (forall s. Monad (m s), forall s. MonadInterleave (m s), forall s. Unbox (v s), forall s. PrimMonad (m s)) => MonadEmacs (m :: k -> Type -> Type) (v :: k -> Type) | m -> v
+ Emacs.Module: class (forall (s :: k). () => Monad m s, forall (s :: k). () => MonadInterleave m s, forall (s :: k). () => Unbox v s, forall (s :: k). () => PrimMonad m s) => MonadEmacs (m :: k -> Type -> Type) (v :: k -> Type) | m -> v
- Emacs.Module: data Env
+ Emacs.Module: data Env :: TYPE 'AddrRep
- Emacs.Module: data Stop a
+ Emacs.Module: data Stop (a :: k)
- Emacs.Module: eq :: (MonadEmacs m v, WithCallStack) => v s -> v s -> m s Bool
+ Emacs.Module: eq :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> v s -> m s Bool
- Emacs.Module: extractDouble :: (MonadEmacs m v, WithCallStack) => v s -> m s Double
+ Emacs.Module: extractDouble :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> m s Double
- Emacs.Module: extractShortByteString :: (MonadEmacs m v, WithCallStack) => v s -> m s ShortByteString
+ Emacs.Module: extractShortByteString :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> m s ShortByteString
- Emacs.Module: extractText :: (MonadEmacs m v, WithCallStack) => v s -> m s Text
+ Emacs.Module: extractText :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> m s Text
- Emacs.Module: extractUserPtr :: (MonadEmacs m v, WithCallStack) => v s -> m s (Ptr a)
+ Emacs.Module: extractUserPtr :: forall (s :: k) a. (MonadEmacs m v, WithCallStack) => v s -> m s (Ptr a)
- Emacs.Module: extractUserPtrFinaliser :: (MonadEmacs m v, WithCallStack) => v s -> m s (FinalizerPtr a)
+ Emacs.Module: extractUserPtrFinaliser :: forall (s :: k) a. (MonadEmacs m v, WithCallStack) => v s -> m s (FinalizerPtr a)
- Emacs.Module: extractWideInteger :: (MonadEmacs m v, WithCallStack) => v s -> m s Int64
+ Emacs.Module: extractWideInteger :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> m s Int64
- Emacs.Module: freeGlobalRef :: (MonadEmacs m v, WithCallStack) => RawValue 'Pinned -> m s ()
+ Emacs.Module: freeGlobalRef :: forall (s :: k). (MonadEmacs m v, WithCallStack) => RawValue 'Pinned -> m s ()
- Emacs.Module: funcall :: (MonadEmacs m v, WithCallStack, Foldable f) => v s -> f (v s) -> m s (v s)
+ Emacs.Module: funcall :: forall f (s :: k). (MonadEmacs m v, WithCallStack, Foldable f) => v s -> f (v s) -> m s (v s)
- Emacs.Module: funcallPrimitive :: (MonadEmacs m v, WithCallStack, Foldable f) => v s -> f (v s) -> m s (v s)
+ Emacs.Module: funcallPrimitive :: forall f (s :: k). (MonadEmacs m v, WithCallStack, Foldable f) => v s -> f (v s) -> m s (v s)
- Emacs.Module: funcallPrimitiveUnchecked :: (MonadEmacs m v, WithCallStack, Foldable f) => v s -> f (v s) -> m s (v s)
+ Emacs.Module: funcallPrimitiveUnchecked :: forall f (s :: k). (MonadEmacs m v, WithCallStack, Foldable f) => v s -> f (v s) -> m s (v s)
- Emacs.Module: intern :: (MonadEmacs m v, WithCallStack) => SymbolName -> m s (v s)
+ Emacs.Module: intern :: forall (s :: k). (MonadEmacs m v, WithCallStack) => SymbolName -> m s (v s)
- Emacs.Module: isNotNil :: (MonadEmacs m v, WithCallStack) => v s -> m s Bool
+ Emacs.Module: isNotNil :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> m s Bool
- Emacs.Module: makeBinaryString :: (MonadEmacs m v, WithCallStack) => ByteString -> m s (v s)
+ Emacs.Module: makeBinaryString :: forall (s :: k). (MonadEmacs m v, WithCallStack) => ByteString -> m s (v s)
- Emacs.Module: makeDouble :: (MonadEmacs m v, WithCallStack) => Double -> m s (v s)
+ Emacs.Module: makeDouble :: forall (s :: k). (MonadEmacs m v, WithCallStack) => Double -> m s (v s)
- Emacs.Module: makeFunction :: (MonadEmacs m v, WithCallStack, EmacsInvocation req opt rest, GetArities req opt rest) => (forall s'. EmacsFunction req opt rest m v s') -> Doc -> m s (v s)
+ Emacs.Module: makeFunction :: forall (req :: Nat) (opt :: Nat) (rest :: Bool) (s :: k). (MonadEmacs m v, WithCallStack, EmacsInvocation req opt rest, GetArities req opt rest) => (forall (s' :: k). () => EmacsFunction req opt rest m v s') -> Doc -> m s (v s)
- Emacs.Module: makeGlobalRef :: (MonadEmacs m v, WithCallStack) => v s -> m s (RawValue 'Pinned)
+ Emacs.Module: makeGlobalRef :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> m s (RawValue 'Pinned)
- Emacs.Module: makeString :: (MonadEmacs m v, WithCallStack) => ByteString -> m s (v s)
+ Emacs.Module: makeString :: forall (s :: k). (MonadEmacs m v, WithCallStack) => ByteString -> m s (v s)
- Emacs.Module: makeUserPtr :: (MonadEmacs m v, WithCallStack) => FinalizerPtr a -> Ptr a -> m s (v s)
+ Emacs.Module: makeUserPtr :: forall a (s :: k). (MonadEmacs m v, WithCallStack) => FinalizerPtr a -> Ptr a -> m s (v s)
- Emacs.Module: makeWideInteger :: (MonadEmacs m v, WithCallStack) => Int64 -> m s (v s)
+ Emacs.Module: makeWideInteger :: forall (s :: k). (MonadEmacs m v, WithCallStack) => Int64 -> m s (v s)
- Emacs.Module: nonLocalExitCheck :: (MonadEmacs m v, WithCallStack) => m s (FuncallExit ())
+ Emacs.Module: nonLocalExitCheck :: forall (s :: k). (MonadEmacs m v, WithCallStack) => m s (FuncallExit ())
- Emacs.Module: nonLocalExitClear :: (MonadEmacs m v, WithCallStack) => m s ()
+ Emacs.Module: nonLocalExitClear :: forall (s :: k). (MonadEmacs m v, WithCallStack) => m s ()
- Emacs.Module: nonLocalExitGet :: (MonadEmacs m v, WithCallStack) => m s (FuncallExit (v s, v s))
+ Emacs.Module: nonLocalExitGet :: forall (s :: k). (MonadEmacs m v, WithCallStack) => m s (FuncallExit (v s, v s))
- Emacs.Module: nonLocalExitSignal :: (MonadEmacs m v, WithCallStack, Foldable f) => v s -> f (v s) -> m s ()
+ Emacs.Module: nonLocalExitSignal :: forall f (s :: k). (MonadEmacs m v, WithCallStack, Foldable f) => v s -> f (v s) -> m s ()
- Emacs.Module: nonLocalExitThrow :: (MonadEmacs m v, WithCallStack) => v s -> v s -> m s ()
+ Emacs.Module: nonLocalExitThrow :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> v s -> m s ()
- Emacs.Module: processInput :: (MonadEmacs m v, WithCallStack) => m s Result
+ Emacs.Module: processInput :: forall (s :: k). (MonadEmacs m v, WithCallStack) => m s Result
- Emacs.Module: type EmacsFunction req opt rest (m :: k -> Type -> Type) (v :: k -> Type) (s :: k) = EmacsArgs req opt rest (v s) -> m s (v s)
+ Emacs.Module: type EmacsFunction (req :: Nat) (opt :: Nat) (rest :: Bool) (m :: k -> Type -> Type) (v :: k -> Type) (s :: k) = EmacsArgs req opt rest v s -> m s v s
- Emacs.Module: typeOf :: (MonadEmacs m v, WithCallStack) => v s -> m s (v s)
+ Emacs.Module: typeOf :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> m s (v s)
- Emacs.Module: unsafeVecGet :: (MonadEmacs m v, WithCallStack) => v s -> Int -> m s (v s)
+ Emacs.Module: unsafeVecGet :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> Int -> m s (v s)
- Emacs.Module: vecGet :: (MonadEmacs m v, WithCallStack) => v s -> Int -> m s (v s)
+ Emacs.Module: vecGet :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> Int -> m s (v s)
- Emacs.Module: vecSet :: (MonadEmacs m v, WithCallStack) => v s -> Int -> v s -> m s ()
+ Emacs.Module: vecSet :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> Int -> v s -> m s ()
- Emacs.Module: vecSize :: (MonadEmacs m v, WithCallStack) => v s -> m s Int
+ Emacs.Module: vecSize :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> m s Int
- Emacs.Module.Assert: type WithCallStack = (() :: Constraint)
+ Emacs.Module.Assert: type WithCallStack = ()
- Emacs.Module.Functions: addFaceProp :: (WithCallStack, MonadEmacs m v) => v s -> SymbolName -> m s (v s)
+ Emacs.Module.Functions: addFaceProp :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => v s -> SymbolName -> m s (v s)
- Emacs.Module.Functions: bindFunction :: (WithCallStack, MonadEmacs m v) => SymbolName -> v s -> m s ()
+ Emacs.Module.Functions: bindFunction :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => SymbolName -> v s -> m s ()
- Emacs.Module.Functions: car :: (WithCallStack, MonadEmacs m v) => v s -> m s (v s)
+ Emacs.Module.Functions: car :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => v s -> m s (v s)
- Emacs.Module.Functions: cdr :: (WithCallStack, MonadEmacs m v) => v s -> m s (v s)
+ Emacs.Module.Functions: cdr :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => v s -> m s (v s)
- Emacs.Module.Functions: concat2 :: (WithCallStack, MonadEmacs m v) => v s -> v s -> m s (v s)
+ Emacs.Module.Functions: concat2 :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => v s -> v s -> m s (v s)
- Emacs.Module.Functions: cons :: (WithCallStack, MonadEmacs m v) => v s -> v s -> m s (v s)
+ Emacs.Module.Functions: cons :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => v s -> v s -> m s (v s)
- Emacs.Module.Functions: extractBool :: (WithCallStack, MonadEmacs m v) => v s -> m s Bool
+ Emacs.Module.Functions: extractBool :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => v s -> m s Bool
- Emacs.Module.Functions: extractInt :: (WithCallStack, MonadEmacs m v) => v s -> m s Int
+ Emacs.Module.Functions: extractInt :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => v s -> m s Int
- Emacs.Module.Functions: extractList :: (WithCallStack, MonadEmacs m v) => v s -> m s [v s]
+ Emacs.Module.Functions: extractList :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => v s -> m s [v s]
- Emacs.Module.Functions: extractListWith :: (WithCallStack, MonadEmacs m v) => (v s -> m s a) -> v s -> m s [a]
+ Emacs.Module.Functions: extractListWith :: forall {k} m v (s :: k) a. (WithCallStack, MonadEmacs m v) => (v s -> m s a) -> v s -> m s [a]
- Emacs.Module.Functions: extractOsPath :: (WithCallStack, MonadEmacs m v) => v s -> m s OsPath
+ Emacs.Module.Functions: extractOsPath :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => v s -> m s OsPath
- Emacs.Module.Functions: extractStablePtrFromUserPtr :: (WithCallStack, MonadEmacs m v) => v s -> m s (StablePtr a)
+ Emacs.Module.Functions: extractStablePtrFromUserPtr :: forall {k} m v (s :: k) a. (WithCallStack, MonadEmacs m v) => v s -> m s (StablePtr a)
- Emacs.Module.Functions: extractVectorAsPrimArrayWith :: (WithCallStack, MonadEmacs m v, Prim a) => (v s -> m s a) -> v s -> m s (PrimArray a)
+ Emacs.Module.Functions: extractVectorAsPrimArrayWith :: forall {k} m v a (s :: k). (WithCallStack, MonadEmacs m v, Prim a) => (v s -> m s a) -> v s -> m s (PrimArray a)
- Emacs.Module.Functions: extractVectorMutableWith :: (WithCallStack, MonadEmacs m v, MVector w a) => (v s -> m s a) -> v s -> m s (w (PrimState (m s)) a)
+ Emacs.Module.Functions: extractVectorMutableWith :: forall {k} m v w a (s :: k). (WithCallStack, MonadEmacs m v, MVector w a) => (v s -> m s a) -> v s -> m s (w (PrimState (m s)) a)
- Emacs.Module.Functions: extractVectorWith :: (WithCallStack, MonadEmacs m v, Vector w a) => (v s -> m s a) -> v s -> m s (w a)
+ Emacs.Module.Functions: extractVectorWith :: forall {k} m v w a (s :: k). (WithCallStack, MonadEmacs m v, Vector w a) => (v s -> m s a) -> v s -> m s (w a)
- Emacs.Module.Functions: foldlEmacsListWith :: (WithCallStack, MonadEmacs m v) => (a -> v s -> m s a) -> a -> v s -> m s a
+ Emacs.Module.Functions: foldlEmacsListWith :: forall {k} m v a (s :: k). (WithCallStack, MonadEmacs m v) => (a -> v s -> m s a) -> a -> v s -> m s a
- Emacs.Module.Functions: funcallPrimitiveSym :: (WithCallStack, MonadEmacs m v, Foldable f) => SymbolName -> f (v s) -> m s (v s)
+ Emacs.Module.Functions: funcallPrimitiveSym :: forall {k} m v f (s :: k). (WithCallStack, MonadEmacs m v, Foldable f) => SymbolName -> f (v s) -> m s (v s)
- Emacs.Module.Functions: funcallPrimitiveSym_ :: (WithCallStack, MonadEmacs m v, Foldable f) => SymbolName -> f (v s) -> m s ()
+ Emacs.Module.Functions: funcallPrimitiveSym_ :: forall {k} m v f (s :: k). (WithCallStack, MonadEmacs m v, Foldable f) => SymbolName -> f (v s) -> m s ()
- Emacs.Module.Functions: funcallPrimitiveUncheckedSym :: (WithCallStack, MonadEmacs m v, Foldable f) => SymbolName -> f (v s) -> m s (v s)
+ Emacs.Module.Functions: funcallPrimitiveUncheckedSym :: forall {k} m v f (s :: k). (WithCallStack, MonadEmacs m v, Foldable f) => SymbolName -> f (v s) -> m s (v s)
- Emacs.Module.Functions: makeBool :: (WithCallStack, MonadEmacs m v) => Bool -> m s (v s)
+ Emacs.Module.Functions: makeBool :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => Bool -> m s (v s)
- Emacs.Module.Functions: makeInt :: (WithCallStack, MonadEmacs m v) => Int -> m s (v s)
+ Emacs.Module.Functions: makeInt :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => Int -> m s (v s)
- Emacs.Module.Functions: makeList :: (WithCallStack, MonadEmacs m v, Foldable f) => f (v s) -> m s (v s)
+ Emacs.Module.Functions: makeList :: forall {k} m v f (s :: k). (WithCallStack, MonadEmacs m v, Foldable f) => f (v s) -> m s (v s)
- Emacs.Module.Functions: makeShortByteString :: (WithCallStack, MonadEmacs m v) => ShortByteString -> m s (v s)
+ Emacs.Module.Functions: makeShortByteString :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => ShortByteString -> m s (v s)
- Emacs.Module.Functions: makeText :: (WithCallStack, MonadEmacs m v) => Text -> m s (v s)
+ Emacs.Module.Functions: makeText :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => Text -> m s (v s)
- Emacs.Module.Functions: makeUserPtrFromStablePtr :: (WithCallStack, MonadEmacs m v) => StablePtr a -> m s (v s)
+ Emacs.Module.Functions: makeUserPtrFromStablePtr :: forall {k} m v a (s :: k). (WithCallStack, MonadEmacs m v) => StablePtr a -> m s (v s)
- Emacs.Module.Functions: makeVector :: (WithCallStack, MonadEmacs m v, Foldable f) => f (v s) -> m s (v s)
+ Emacs.Module.Functions: makeVector :: forall {k} m v f (s :: k). (WithCallStack, MonadEmacs m v, Foldable f) => f (v s) -> m s (v s)
- Emacs.Module.Functions: nil :: (WithCallStack, MonadEmacs m v) => m s (v s)
+ Emacs.Module.Functions: nil :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => m s (v s)
- Emacs.Module.Functions: propertize :: (WithCallStack, MonadEmacs m v) => v s -> [(SymbolName, v s)] -> m s (v s)
+ Emacs.Module.Functions: propertize :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => v s -> [(SymbolName, v s)] -> m s (v s)
- Emacs.Module.Functions: provide :: (WithCallStack, MonadEmacs m v) => SymbolName -> m s ()
+ Emacs.Module.Functions: provide :: forall {k} m (v :: k -> Type) (s :: k). (WithCallStack, MonadEmacs m v) => SymbolName -> m s ()
- Emacs.Module.Functions: setcar :: (WithCallStack, MonadEmacs m v) => v s -> v s -> m s ()
+ Emacs.Module.Functions: setcar :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => v s -> v s -> m s ()
- Emacs.Module.Functions: setcdr :: (WithCallStack, MonadEmacs m v) => v s -> v s -> m s ()
+ Emacs.Module.Functions: setcdr :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => v s -> v s -> m s ()
- Emacs.Module.Functions: symbolName :: (WithCallStack, MonadEmacs m v) => v s -> m s (v s)
+ Emacs.Module.Functions: symbolName :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => v s -> m s (v s)
- Emacs.Module.Functions: unfoldEmacsListWith :: (WithCallStack, MonadEmacs m v) => (a -> m s (Maybe (v s, a))) -> a -> m s (v s)
+ Emacs.Module.Functions: unfoldEmacsListWith :: forall {k} m v a (s :: k). (WithCallStack, MonadEmacs m v) => (a -> m s (Maybe (v s, a))) -> a -> m s (v s)
- Emacs.Module.Functions: valueToText :: (WithCallStack, MonadEmacs m v) => v s -> m s Text
+ Emacs.Module.Functions: valueToText :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => v s -> m s Text
- Emacs.Module.Functions: vconcat2 :: (WithCallStack, MonadEmacs m v) => v s -> v s -> m s (v s)
+ Emacs.Module.Functions: vconcat2 :: forall {k} m v (s :: k). (WithCallStack, MonadEmacs m v) => v s -> v s -> m s (v s)
- Emacs.Module.Monad: data EmacsM (s :: k) (a :: Type)
+ Emacs.Module.Monad: data EmacsM (s :: k) a
- Emacs.Module.Monad: runEmacsM :: WithCallStack => Env -> (forall s. EmacsM s a) -> IO a
+ Emacs.Module.Monad: runEmacsM :: WithCallStack => Env -> (forall (s :: k). () => EmacsM s a) -> IO a
- Emacs.Module.Monad.Class: assignUserPtr :: (MonadEmacs m v, WithCallStack) => v s -> Ptr a -> m s ()
+ Emacs.Module.Monad.Class: assignUserPtr :: forall (s :: k) a. (MonadEmacs m v, WithCallStack) => v s -> Ptr a -> m s ()
- Emacs.Module.Monad.Class: assignUserPtrFinaliser :: (MonadEmacs m v, WithCallStack) => v s -> FinalizerPtr a -> m s ()
+ Emacs.Module.Monad.Class: assignUserPtrFinaliser :: forall (s :: k) a. (MonadEmacs m v, WithCallStack) => v s -> FinalizerPtr a -> m s ()
- Emacs.Module.Monad.Class: class (forall s. Monad (m s), forall s. MonadInterleave (m s), forall s. Unbox (v s), forall s. PrimMonad (m s)) => MonadEmacs (m :: k -> Type -> Type) (v :: k -> Type) | m -> v
+ Emacs.Module.Monad.Class: class (forall (s :: k). () => Monad m s, forall (s :: k). () => MonadInterleave m s, forall (s :: k). () => Unbox v s, forall (s :: k). () => PrimMonad m s) => MonadEmacs (m :: k -> Type -> Type) (v :: k -> Type) | m -> v
- Emacs.Module.Monad.Class: eq :: (MonadEmacs m v, WithCallStack) => v s -> v s -> m s Bool
+ Emacs.Module.Monad.Class: eq :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> v s -> m s Bool
- Emacs.Module.Monad.Class: extractDouble :: (MonadEmacs m v, WithCallStack) => v s -> m s Double
+ Emacs.Module.Monad.Class: extractDouble :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> m s Double
- Emacs.Module.Monad.Class: extractShortByteString :: (MonadEmacs m v, WithCallStack) => v s -> m s ShortByteString
+ Emacs.Module.Monad.Class: extractShortByteString :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> m s ShortByteString
- Emacs.Module.Monad.Class: extractText :: (MonadEmacs m v, WithCallStack) => v s -> m s Text
+ Emacs.Module.Monad.Class: extractText :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> m s Text
- Emacs.Module.Monad.Class: extractUserPtr :: (MonadEmacs m v, WithCallStack) => v s -> m s (Ptr a)
+ Emacs.Module.Monad.Class: extractUserPtr :: forall (s :: k) a. (MonadEmacs m v, WithCallStack) => v s -> m s (Ptr a)
- Emacs.Module.Monad.Class: extractUserPtrFinaliser :: (MonadEmacs m v, WithCallStack) => v s -> m s (FinalizerPtr a)
+ Emacs.Module.Monad.Class: extractUserPtrFinaliser :: forall (s :: k) a. (MonadEmacs m v, WithCallStack) => v s -> m s (FinalizerPtr a)
- Emacs.Module.Monad.Class: extractWideInteger :: (MonadEmacs m v, WithCallStack) => v s -> m s Int64
+ Emacs.Module.Monad.Class: extractWideInteger :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> m s Int64
- Emacs.Module.Monad.Class: freeGlobalRef :: (MonadEmacs m v, WithCallStack) => RawValue 'Pinned -> m s ()
+ Emacs.Module.Monad.Class: freeGlobalRef :: forall (s :: k). (MonadEmacs m v, WithCallStack) => RawValue 'Pinned -> m s ()
- Emacs.Module.Monad.Class: funcall :: (MonadEmacs m v, WithCallStack, Foldable f) => v s -> f (v s) -> m s (v s)
+ Emacs.Module.Monad.Class: funcall :: forall f (s :: k). (MonadEmacs m v, WithCallStack, Foldable f) => v s -> f (v s) -> m s (v s)
- Emacs.Module.Monad.Class: funcallPrimitive :: (MonadEmacs m v, WithCallStack, Foldable f) => v s -> f (v s) -> m s (v s)
+ Emacs.Module.Monad.Class: funcallPrimitive :: forall f (s :: k). (MonadEmacs m v, WithCallStack, Foldable f) => v s -> f (v s) -> m s (v s)
- Emacs.Module.Monad.Class: funcallPrimitiveUnchecked :: (MonadEmacs m v, WithCallStack, Foldable f) => v s -> f (v s) -> m s (v s)
+ Emacs.Module.Monad.Class: funcallPrimitiveUnchecked :: forall f (s :: k). (MonadEmacs m v, WithCallStack, Foldable f) => v s -> f (v s) -> m s (v s)
- Emacs.Module.Monad.Class: intern :: (MonadEmacs m v, WithCallStack) => SymbolName -> m s (v s)
+ Emacs.Module.Monad.Class: intern :: forall (s :: k). (MonadEmacs m v, WithCallStack) => SymbolName -> m s (v s)
- Emacs.Module.Monad.Class: isNotNil :: (MonadEmacs m v, WithCallStack) => v s -> m s Bool
+ Emacs.Module.Monad.Class: isNotNil :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> m s Bool
- Emacs.Module.Monad.Class: makeBinaryString :: (MonadEmacs m v, WithCallStack) => ByteString -> m s (v s)
+ Emacs.Module.Monad.Class: makeBinaryString :: forall (s :: k). (MonadEmacs m v, WithCallStack) => ByteString -> m s (v s)
- Emacs.Module.Monad.Class: makeDouble :: (MonadEmacs m v, WithCallStack) => Double -> m s (v s)
+ Emacs.Module.Monad.Class: makeDouble :: forall (s :: k). (MonadEmacs m v, WithCallStack) => Double -> m s (v s)
- Emacs.Module.Monad.Class: makeFunction :: (MonadEmacs m v, WithCallStack, EmacsInvocation req opt rest, GetArities req opt rest) => (forall s'. EmacsFunction req opt rest m v s') -> Doc -> m s (v s)
+ Emacs.Module.Monad.Class: makeFunction :: forall (req :: Nat) (opt :: Nat) (rest :: Bool) (s :: k). (MonadEmacs m v, WithCallStack, EmacsInvocation req opt rest, GetArities req opt rest) => (forall (s' :: k). () => EmacsFunction req opt rest m v s') -> Doc -> m s (v s)
- Emacs.Module.Monad.Class: makeGlobalRef :: (MonadEmacs m v, WithCallStack) => v s -> m s (RawValue 'Pinned)
+ Emacs.Module.Monad.Class: makeGlobalRef :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> m s (RawValue 'Pinned)
- Emacs.Module.Monad.Class: makeString :: (MonadEmacs m v, WithCallStack) => ByteString -> m s (v s)
+ Emacs.Module.Monad.Class: makeString :: forall (s :: k). (MonadEmacs m v, WithCallStack) => ByteString -> m s (v s)
- Emacs.Module.Monad.Class: makeUserPtr :: (MonadEmacs m v, WithCallStack) => FinalizerPtr a -> Ptr a -> m s (v s)
+ Emacs.Module.Monad.Class: makeUserPtr :: forall a (s :: k). (MonadEmacs m v, WithCallStack) => FinalizerPtr a -> Ptr a -> m s (v s)
- Emacs.Module.Monad.Class: makeWideInteger :: (MonadEmacs m v, WithCallStack) => Int64 -> m s (v s)
+ Emacs.Module.Monad.Class: makeWideInteger :: forall (s :: k). (MonadEmacs m v, WithCallStack) => Int64 -> m s (v s)
- Emacs.Module.Monad.Class: nonLocalExitCheck :: (MonadEmacs m v, WithCallStack) => m s (FuncallExit ())
+ Emacs.Module.Monad.Class: nonLocalExitCheck :: forall (s :: k). (MonadEmacs m v, WithCallStack) => m s (FuncallExit ())
- Emacs.Module.Monad.Class: nonLocalExitClear :: (MonadEmacs m v, WithCallStack) => m s ()
+ Emacs.Module.Monad.Class: nonLocalExitClear :: forall (s :: k). (MonadEmacs m v, WithCallStack) => m s ()
- Emacs.Module.Monad.Class: nonLocalExitGet :: (MonadEmacs m v, WithCallStack) => m s (FuncallExit (v s, v s))
+ Emacs.Module.Monad.Class: nonLocalExitGet :: forall (s :: k). (MonadEmacs m v, WithCallStack) => m s (FuncallExit (v s, v s))
- Emacs.Module.Monad.Class: nonLocalExitSignal :: (MonadEmacs m v, WithCallStack, Foldable f) => v s -> f (v s) -> m s ()
+ Emacs.Module.Monad.Class: nonLocalExitSignal :: forall f (s :: k). (MonadEmacs m v, WithCallStack, Foldable f) => v s -> f (v s) -> m s ()
- Emacs.Module.Monad.Class: nonLocalExitThrow :: (MonadEmacs m v, WithCallStack) => v s -> v s -> m s ()
+ Emacs.Module.Monad.Class: nonLocalExitThrow :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> v s -> m s ()
- Emacs.Module.Monad.Class: processInput :: (MonadEmacs m v, WithCallStack) => m s Result
+ Emacs.Module.Monad.Class: processInput :: forall (s :: k). (MonadEmacs m v, WithCallStack) => m s Result
- Emacs.Module.Monad.Class: type EmacsFunction req opt rest (m :: k -> Type -> Type) (v :: k -> Type) (s :: k) = EmacsArgs req opt rest (v s) -> m s (v s)
+ Emacs.Module.Monad.Class: type EmacsFunction (req :: Nat) (opt :: Nat) (rest :: Bool) (m :: k -> Type -> Type) (v :: k -> Type) (s :: k) = EmacsArgs req opt rest v s -> m s v s
- Emacs.Module.Monad.Class: typeOf :: (MonadEmacs m v, WithCallStack) => v s -> m s (v s)
+ Emacs.Module.Monad.Class: typeOf :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> m s (v s)
- Emacs.Module.Monad.Class: unsafeVecGet :: (MonadEmacs m v, WithCallStack) => v s -> Int -> m s (v s)
+ Emacs.Module.Monad.Class: unsafeVecGet :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> Int -> m s (v s)
- Emacs.Module.Monad.Class: vecGet :: (MonadEmacs m v, WithCallStack) => v s -> Int -> m s (v s)
+ Emacs.Module.Monad.Class: vecGet :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> Int -> m s (v s)
- Emacs.Module.Monad.Class: vecSet :: (MonadEmacs m v, WithCallStack) => v s -> Int -> v s -> m s ()
+ Emacs.Module.Monad.Class: vecSet :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> Int -> v s -> m s ()
- Emacs.Module.Monad.Class: vecSize :: (MonadEmacs m v, WithCallStack) => v s -> m s Int
+ Emacs.Module.Monad.Class: vecSize :: forall (s :: k). (MonadEmacs m v, WithCallStack) => v s -> m s Int

Files

Changelog.md view
@@ -1,3 +1,7 @@+# 0.3++- Add `extractByteString` function to the `EmacsMonad` class+ # 0.2.1.1  - Fix build with GHC 9.10.1
emacs-module.cabal view
@@ -3,7 +3,7 @@ name:   emacs-module version:-  0.2.1.1+  0.3 category: Foreign, Foreign binding  synopsis:@@ -29,11 +29,12 @@ maintainer:   Sergey Vinokurov <serg.foo@gmail.com> tested-with:-  , GHC == 9.2.8-  , GHC == 9.4.7-  , GHC == 9.6.3-  , GHC == 9.8.1-  , GHC == 9.10.1+  , GHC == 9.2+  , GHC == 9.4+  , GHC == 9.6+  , GHC == 9.8+  , GHC == 9.10+  , GHC == 9.12  extra-source-files:   cbits/emacs-module.h@@ -152,8 +153,8 @@     , os-string     , primitive     , prettyprinter >= 1.7-    , prettyprinter-combinators-    , text >= 2+    , prettyprinter-combinators >= 0.1.1+    , text >= 2.0.1     , template-haskell     , transformers-base     , tuples-homogenous-h98
src/Emacs/Module/Monad.hs view
@@ -331,6 +331,13 @@       $   handleResultNoThrow       =<< Common.extractShortByteString (coerceBuilderCache eArgsCache) eEnv eNonLocalState (getRawValue x) +  extractByteString :: WithCallStack => Value s -> EmacsM s BS.ByteString+  extractByteString x = EmacsM $ do+    Environment{eEnv, eNonLocalState, eArgsCache} <- ask+    liftBase+      $   handleResultNoThrow+      =<< Common.extractByteString (coerceBuilderCache eArgsCache) eEnv eNonLocalState (getRawValue x)+   makeString :: WithCallStack => BS.ByteString -> EmacsM s (Value s)   makeString x = withEnv $ \env ->     BSU.unsafeUseAsCStringLen x $ \(pStr, len) ->
src/Emacs/Module/Monad/Class.hs view
@@ -171,6 +171,9 @@   -- | Extract string contents from an Emacs value as utf8-encoded short bytestring.   extractShortByteString :: WithCallStack => v s -> m s BSS.ShortByteString +  -- | Extract string contents from an Emacs value as bytestring.+  extractByteString :: WithCallStack => v s -> m s BS.ByteString+   -- | Convert a utf8-encoded ByteString into an Emacs value.   makeString :: WithCallStack => BS.ByteString -> m s (v s)
src/Emacs/Module/Monad/Common.hs view
@@ -22,6 +22,7 @@   , nonLocalExitSignal   , extractText   , extractShortByteString+  , extractByteString   , checkNonLocalExitSignal   , checkNonLocalExitFull   , extractSignalInfo@@ -30,6 +31,8 @@  import Control.Exception import Control.Monad.Primitive+import Data.ByteString qualified as BS+import Data.ByteString.Internal qualified as BSI import Data.ByteString.Short (ShortByteString) import Data.ByteString.Short qualified as SBS import Data.Text (Text)@@ -42,12 +45,12 @@ import Foreign.Ptr import Foreign.Storable import GHC.Exts+import GHC.ForeignPtr (ForeignPtr(..), ForeignPtrContents(PlainPtr)) import GHC.IO import GHC.Stack (CallStack, callStack) import Prettyprinter  #ifdef ASSERTIONS-import Data.ByteString.Internal qualified as BSI import Data.Text.Encoding qualified as TE import Foreign.ForeignPtr qualified as Foreign #endif@@ -195,7 +198,8 @@       -- Should subtract 1 from size to avoid NULL terminator at the end.       ptr <- Foreign.newForeignPtr_ (Ptr (mutableByteArrayContents# mbarr#))       evaluate $ TE.decodeUtf8 $ BSI.BS ptr (I# (size# -# 1#))-#else+#endif+#ifndef ASSERTIONS     IO $ \s1 ->       case unsafeFreezeByteArray# mbarr# s1 of         (# s2, barr #) ->@@ -220,6 +224,22 @@           case unsafeFreezeByteArray# mbarr# s4 of             (# s5, barr #) ->               (# s5, SBS.SBS barr #)++{-# INLINE extractByteString #-}+extractByteString+  :: WithCallStack+  => BuilderCache (RawValue a)+  -> Env+  -> NonLocalState+  -> RawValue p+  -> IO (EmacsRes EmacsSignal Void BS.ByteString)+extractByteString cache env nls x =+  extractStringWith cache env nls x $ \size# mbarr# -> evaluate $ BSI.BS+    (ForeignPtr+      (mutableByteArrayContents# mbarr#)+      (PlainPtr mbarr#))+    -- Should subtract 1 from size to avoid NULL terminator at the end.+    (I# (size# -# 1#))  {-# INLINE checkNonLocalExitSignal #-} checkNonLocalExitSignal