Data.Emacs.Module.Env

Documentation

data Env

Emacs environment, right from the 'emacs-module.h'.

enum emacs_funcall_exit

data FuncallExit a

Possible Emacs function call outcomes. This is Haskell's version of

Constructors

FuncallExitReturn

Function has returned normally.

FuncallExitSignal a

Function has signaled an error using signal.

FuncallExitThrow a

Function has exit using throw.

Instances

Foldable FuncallExit

Defined in Data.Emacs.Module.Env.Functions

Methods

fold :: Monoid m => FuncallExit m -> m

foldMap :: Monoid m => (a -> m) -> FuncallExit a -> m

foldMap' :: Monoid m => (a -> m) -> FuncallExit a -> m

foldr :: (a -> b -> b) -> b -> FuncallExit a -> b

foldr' :: (a -> b -> b) -> b -> FuncallExit a -> b

foldl :: (b -> a -> b) -> b -> FuncallExit a -> b

foldl' :: (b -> a -> b) -> b -> FuncallExit a -> b

foldr1 :: (a -> a -> a) -> FuncallExit a -> a

foldl1 :: (a -> a -> a) -> FuncallExit a -> a

toList :: FuncallExit a -> [a]

null :: FuncallExit a -> Bool

length :: FuncallExit a -> Int

elem :: Eq a => a -> FuncallExit a -> Bool

maximum :: Ord a => FuncallExit a -> a

minimum :: Ord a => FuncallExit a -> a

sum :: Num a => FuncallExit a -> a

product :: Num a => FuncallExit a -> a

Traversable FuncallExit

Defined in Data.Emacs.Module.Env.Functions

Methods

traverse :: Applicative f => (a -> f b) -> FuncallExit a -> f (FuncallExit b)

sequenceA :: Applicative f => FuncallExit (f a) -> f (FuncallExit a)

mapM :: Monad m => (a -> m b) -> FuncallExit a -> m (FuncallExit b)

sequence :: Monad m => FuncallExit (m a) -> m (FuncallExit a)

Functor FuncallExit

Defined in Data.Emacs.Module.Env.Functions

Methods

fmap :: (a -> b) -> FuncallExit a -> FuncallExit b

(<$) :: a -> FuncallExit b -> FuncallExit a

Data a => Data (FuncallExit a)

Defined in Data.Emacs.Module.Env.Functions

Methods

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

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

toConstr :: FuncallExit a -> Constr

dataTypeOf :: FuncallExit a -> DataType

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

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

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

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

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

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

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

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

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

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

Generic (FuncallExit a)

Defined in Data.Emacs.Module.Env.Functions

Associated Types

type Rep (FuncallExit a) :: Type -> Type

Methods

from :: FuncallExit a -> Rep (FuncallExit a) x

to :: Rep (FuncallExit a) x -> FuncallExit a

Show a => Show (FuncallExit a)

Defined in Data.Emacs.Module.Env.Functions

Methods

showsPrec :: Int -> FuncallExit a -> ShowS

show :: FuncallExit a -> String

showList :: [FuncallExit a] -> ShowS

Eq a => Eq (FuncallExit a)

Defined in Data.Emacs.Module.Env.Functions

Methods

(==) :: FuncallExit a -> FuncallExit a -> Bool

(/=) :: FuncallExit a -> FuncallExit a -> Bool

Ord a => Ord (FuncallExit a)

Defined in Data.Emacs.Module.Env.Functions

Methods

compare :: FuncallExit a -> FuncallExit a -> Ordering

(<) :: FuncallExit a -> FuncallExit a -> Bool

(<=) :: FuncallExit a -> FuncallExit a -> Bool

(>) :: FuncallExit a -> FuncallExit a -> Bool

(>=) :: FuncallExit a -> FuncallExit a -> Bool

max :: FuncallExit a -> FuncallExit a -> FuncallExit a

min :: FuncallExit a -> FuncallExit a -> FuncallExit a

Pretty a => Pretty (FuncallExit a)

Defined in Data.Emacs.Module.Env.Functions

Methods

pretty :: FuncallExit a -> Doc ann

prettyList :: [FuncallExit a] -> Doc ann

Lift a => Lift (FuncallExit a :: Type)

Defined in Data.Emacs.Module.Env.Functions

Methods

lift :: Quote m => FuncallExit a -> m Exp

liftTyped :: forall (m :: Type -> Type). Quote m => FuncallExit a -> Code m (FuncallExit a)

type Rep (FuncallExit a)

Defined in Data.Emacs.Module.Env.Functions

type Rep (FuncallExit a) = D1 ('MetaData "FuncallExit" "Data.Emacs.Module.Env.Functions" "emacs-module-0.2.1-LqesOn6xic3Iyo1jMFpGm8" 'False) (C1 ('MetaCons "FuncallExitReturn" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "FuncallExitSignal" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)) :+: C1 ('MetaCons "FuncallExitThrow" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a))))

funcallExitToNum :: Num a => FuncallExit b -> a

funcallExitFromNum :: (Eq a, Num a) => a -> Maybe (FuncallExit ())

Wrappers around struct emacs_env fields

newtype EnumFuncallExit

Constructors

EnumFuncallExit

Fields

• unEnumFuncallExit :: CInt

Instances

Pretty EnumFuncallExit

Defined in Data.Emacs.Module.Raw.Env

Methods

pretty :: EnumFuncallExit -> Doc ann

prettyList :: [EnumFuncallExit] -> Doc ann

isValidEnv :: MonadIO m => Env -> m Bool

Check wheter passed emacs_env structure has expected size so that we will be able to access all of its fields.

makeGlobalRef :: forall m p. MonadIO m => Env -> RawValue p -> m (RawValue 'Pinned)

freeGlobalRef :: forall m. MonadIO m => Env -> RawValue 'Pinned -> m ()

nonLocalExitCheck :: MonadIO m => Env -> m EnumFuncallExit

nonLocalExitGet

Arguments

:: MonadIO m

=> Env

-> NonNullPtr (RawValue 'Regular)

Symbol output

-> NonNullPtr (RawValue 'Regular)

Data output

-> m EnumFuncallExit

nonLocalExitSignal

Arguments

:: MonadIO m

=> Env

-> RawValue p1

Error symbol

-> RawValue p2

Error data

-> m ()

nonLocalExitThrow

Arguments

:: MonadIO m

=> Env

-> RawValue p1

Tag, a symbol

-> RawValue p2

Value

-> m ()

nonLocalExitClear :: MonadIO m => Env -> m ()

variadicFunctionArgs :: CPtrdiff

makeFunction

Arguments

:: forall m o a. MonadIO m

=> Env

-> CPtrdiff

Minimum arity

-> CPtrdiff

Maximum arity

-> RawFunction o a

Implementation

-> CString

Documentation

-> Ptr a

Extra data

-> m (RawValue 'Regular)

funcall

Arguments

:: MonadIO m

=> Env

-> RawValue p1

Function

-> CPtrdiff

Number of arguments

-> NonNullPtr (RawValue p2)

Actual arguments

-> m (RawValue 'Regular)

funcallPrimitive

Arguments

:: MonadIO m

=> Env

-> RawValue p1

Function

-> CPtrdiff

Number of arguments

-> NonNullPtr (RawValue p2)

Actual arguments

-> m (RawValue 'Regular)

intern :: MonadIO m => Env -> CString -> m (RawValue 'Regular)

typeOf :: MonadIO m => Env -> RawValue p -> m (RawValue 'Regular)

isNotNil :: MonadIO m => Env -> RawValue p -> m CBoolean

eq :: MonadIO m => Env -> RawValue p1 -> RawValue p2 -> m CBoolean

extractInteger :: MonadIO m => Env -> RawValue p -> m CIntMax

makeInteger :: MonadIO m => Env -> CIntMax -> m (RawValue 'Regular)

extractFloat :: MonadIO m => Env -> RawValue p -> m CDouble

makeFloat :: MonadIO m => Env -> CDouble -> m (RawValue 'Regular)

copyStringContents

Arguments

:: MonadIO m

=> Env

-> RawValue p

Emacs value that holds a string

-> CString

Destination, may be NULL

-> NonNullPtr CPtrdiff

SIZE pointer

-> m CBoolean

Copy the content of the Lisp string VALUE to BUFFER as an utf8 null-terminated string.

SIZE must point to the total size of the buffer. If BUFFER is NULL or if SIZE is not big enough, write the required buffer size to SIZE and return true.

Note that SIZE must include the last null byte (e.g. "abc" needs a buffer of size 4).

Return true if the string was successfully copied.

makeString

Arguments

:: MonadIO m

=> Env

-> CString

Utf8-encoded string, may contain null bytes and is not required to be terminated with one.

-> CPtrdiff

Length.

-> m (RawValue 'Regular)

makeUserPtr :: forall m a. MonadIO m => Env -> FinalizerPtr a -> Ptr a -> m (RawValue 'Regular)

getUserPtr :: MonadIO m => Env -> RawValue p -> m (Ptr a)

setUserPtr :: MonadIO m => Env -> RawValue p -> Ptr a -> m ()

getUserFinaliser :: MonadIO m => Env -> RawValue p -> m (FinalizerPtr a)

setUserFinaliser :: MonadIO m => Env -> RawValue p -> FinalizerPtr a -> m ()

vecGet :: MonadIO m => Env -> RawValue p -> CPtrdiff -> m (RawValue 'Regular)

vecSet :: MonadIO m => Env -> RawValue p1 -> CPtrdiff -> RawValue p2 -> m ()

vecSize :: MonadIO m => Env -> RawValue p -> m CPtrdiff

Expose functions to Emacs

exportToEmacs :: RawFunctionType o a -> IO (RawFunction o a)

Take Haskell function and return C pointer to function (which ideally needs to be cleaned up later by freeHaskellFunPtrWrapped).

type RawFunctionType o a = Ptr Environment -> CPtrdiff -> Ptr (RawValue 'Regular) -> Ptr a -> IO (RawValue o)

data RawFunction o a

Pointer to a function that may later be called by by Emacs.

Instances

Show (RawFunction o a)

Defined in Data.Emacs.Module.Raw.Env.Internal

Methods

showsPrec :: Int -> RawFunction o a -> ShowS

show :: RawFunction o a -> String

showList :: [RawFunction o a] -> ShowS

Eq (RawFunction o a)

Defined in Data.Emacs.Module.Raw.Env.Internal

Methods

(==) :: RawFunction o a -> RawFunction o a -> Bool

(/=) :: RawFunction o a -> RawFunction o a -> Bool

Ord (RawFunction o a)

Defined in Data.Emacs.Module.Raw.Env.Internal

Methods

compare :: RawFunction o a -> RawFunction o a -> Ordering

(<) :: RawFunction o a -> RawFunction o a -> Bool

(<=) :: RawFunction o a -> RawFunction o a -> Bool

(>) :: RawFunction o a -> RawFunction o a -> Bool

(>=) :: RawFunction o a -> RawFunction o a -> Bool

max :: RawFunction o a -> RawFunction o a -> RawFunction o a

min :: RawFunction o a -> RawFunction o a -> RawFunction o a

Expose Haskell data to Emacs

freeStablePtrFinaliser :: FinalizerPtr a

Pass to makeUserPtr so that Emacs will free the Haskell's stable pointer when the corresponding elisp value goes out of scope.