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

Functor FuncallExit

Defined in Data.Emacs.Module.Env.Functions

Methods

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

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

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)

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

Defined in Data.Emacs.Module.Env.Functions

Methods

lift :: FuncallExit a -> Q Exp

liftTyped :: FuncallExit a -> Q (TExp (FuncallExit a))

Eq a => Eq (FuncallExit a)

Defined in Data.Emacs.Module.Env.Functions

Methods

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

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

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)

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

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

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

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.1.1.1-C4EeyV2Os1JLHvH0AMaocA" '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

type UserPtrFinaliserType a = Ptr a -> IO ()

type UserPtrFinaliser a = FunPtr (UserPtrFinaliserType a)

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. MonadIO m => Env -> RawValue -> m GlobalRef

freeGlobalRef :: forall m. MonadIO m => Env -> GlobalRef -> m ()

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

nonLocalExitGet

Arguments

:: MonadIO m

=> Env

-> NonNullPtr RawValue

Symbol output

-> NonNullPtr RawValue

Data output

-> m EnumFuncallExit

nonLocalExitSignal

Arguments

:: MonadIO m

=> Env

-> RawValue

Error symbol

-> RawValue

Error data

-> m ()

nonLocalExitThrow

Arguments

:: MonadIO m

=> Env

-> RawValue

Tag, a symbol

-> RawValue

Value

-> m ()

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

variadicFunctionArgs :: CPtrdiff

makeFunction

Arguments

:: forall m a. MonadIO m

=> Env

-> CPtrdiff

Minimum arity

-> CPtrdiff

Maximum arity

-> RawFunction a

Implementation

-> CString

Documentation

-> Ptr a

Extra data

-> m RawValue

funcall

Arguments

:: MonadIO m

=> Env

-> RawValue

Function

-> CPtrdiff

Number of arguments

-> NonNullPtr RawValue

Actual arguments

-> m RawValue

funcallPrimitive

Arguments

:: MonadIO m

=> Env

-> RawValue

Function

-> CPtrdiff

Number of arguments

-> NonNullPtr RawValue

Actual arguments

-> m RawValue

intern :: MonadIO m => Env -> CString -> m RawValue

typeOf :: MonadIO m => Env -> RawValue -> m RawValue

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

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

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

makeInteger :: MonadIO m => Env -> CIntMax -> m RawValue

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

makeFloat :: MonadIO m => Env -> CDouble -> m RawValue

copyStringContents

Arguments

:: MonadIO m

=> Env

-> RawValue

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

0-terminated utf8-encoded string.

-> CPtrdiff

Length.

-> m RawValue

makeUserPtr :: forall m a. MonadIO m => Env -> UserPtrFinaliser a -> Ptr a -> m RawValue

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

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

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

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

vecGet :: MonadIO m => Env -> RawValue -> CPtrdiff -> m RawValue

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

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

Expose functions to Emacs

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

type RawFunctionType a = Env -> CPtrdiff -> Ptr RawValue -> Ptr a -> IO RawValue

data RawFunction a

Expose Haskell data to Emacs

freeStablePtrFinaliser :: UserPtrFinaliser a

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