Foreign.Lua.FunctionCalling

Call haskell functions from Lua, and vice versa.

Documentation

class FromLuaStack a where

A value that can be read from the Lua stack.

Minimal complete definition

peek

Methods

peek :: StackIndex -> Lua a

Check if at index n there is a convertible Lua value and if so return it. Throws a LuaException otherwise.

Instances

FromLuaStack Bool

Methods

peek :: StackIndex -> Lua Bool

FromLuaStack ()

Methods

peek :: StackIndex -> Lua ()

FromLuaStack ByteString

Methods

peek :: StackIndex -> Lua ByteString

FromLuaStack ByteString

Methods

peek :: StackIndex -> Lua ByteString

FromLuaStack Text

Methods

peek :: StackIndex -> Lua Text

FromLuaStack LuaNumber

Methods

peek :: StackIndex -> Lua LuaNumber

FromLuaStack LuaInteger

Methods

peek :: StackIndex -> Lua LuaInteger

FromLuaStack CFunction

Methods

peek :: StackIndex -> Lua CFunction

FromLuaStack LuaState

Methods

peek :: StackIndex -> Lua LuaState

FromLuaStack [Char]

Methods

peek :: StackIndex -> Lua [Char]

FromLuaStack a => FromLuaStack [a]

Methods

peek :: StackIndex -> Lua [a]

FromLuaStack (Ptr a)

Methods

peek :: StackIndex -> Lua (Ptr a)

FromLuaStack a => FromLuaStack (OrNil a)

Methods

peek :: StackIndex -> Lua (OrNil a)

FromLuaStack a => FromLuaStack (Optional a)

Methods

peek :: StackIndex -> Lua (Optional a)

(FromLuaStack a, FromLuaStack b) => FromLuaStack (a, b)

Methods

peek :: StackIndex -> Lua (a, b)

(Ord a, FromLuaStack a, FromLuaStack b) => FromLuaStack (Map a b)

Methods

peek :: StackIndex -> Lua (Map a b)

(FromLuaStack a, FromLuaStack b, FromLuaStack c) => FromLuaStack (a, b, c)

Methods

peek :: StackIndex -> Lua (a, b, c)

(FromLuaStack a, FromLuaStack b, FromLuaStack c, FromLuaStack d) => FromLuaStack (a, b, c, d)

Methods

peek :: StackIndex -> Lua (a, b, c, d)

(FromLuaStack a, FromLuaStack b, FromLuaStack c, FromLuaStack d, FromLuaStack e) => FromLuaStack (a, b, c, d, e)

Methods

peek :: StackIndex -> Lua (a, b, c, d, e)

(FromLuaStack a, FromLuaStack b, FromLuaStack c, FromLuaStack d, FromLuaStack e, FromLuaStack f) => FromLuaStack (a, b, c, d, e, f)

Methods

peek :: StackIndex -> Lua (a, b, c, d, e, f)

(FromLuaStack a, FromLuaStack b, FromLuaStack c, FromLuaStack d, FromLuaStack e, FromLuaStack f, FromLuaStack g) => FromLuaStack (a, b, c, d, e, f, g)

Methods

peek :: StackIndex -> Lua (a, b, c, d, e, f, g)

(FromLuaStack a, FromLuaStack b, FromLuaStack c, FromLuaStack d, FromLuaStack e, FromLuaStack f, FromLuaStack g, FromLuaStack h) => FromLuaStack (a, b, c, d, e, f, g, h)

Methods

peek :: StackIndex -> Lua (a, b, c, d, e, f, g, h)

class LuaCallFunc a where

Helper class used to make lua functions useable from haskell

Minimal complete definition

callFunc'

Methods

callFunc' :: String -> Lua () -> NumArgs -> a

Instances

FromLuaStack a => LuaCallFunc (Lua a)

Methods

callFunc' :: String -> Lua () -> NumArgs -> Lua a

(ToLuaStack a, LuaCallFunc b) => LuaCallFunc (a -> b)

Methods

callFunc' :: String -> Lua () -> NumArgs -> a -> b

class ToHaskellFunction a where

Operations and functions that can be pushed to the lua stack. This is a helper function not intended to be used directly. Use the toHaskellFunction wrapper instead.

Minimal complete definition

toHsFun

Methods

toHsFun :: StackIndex -> a -> Lua NumResults

Helper function, called by toHaskellFunction

Instances

ToHaskellFunction HaskellFunction

Methods

toHsFun :: StackIndex -> HaskellFunction -> Lua NumResults

ToLuaStack a => ToHaskellFunction (Lua a)

Methods

toHsFun :: StackIndex -> Lua a -> Lua NumResults

(FromLuaStack a, ToHaskellFunction b) => ToHaskellFunction (a -> b)

Methods

toHsFun :: StackIndex -> (a -> b) -> Lua NumResults

type HaskellFunction = Lua NumResults

Haskell function that can be called from Lua.

class ToLuaStack a where

A value that can be pushed to the Lua stack.

Minimal complete definition

push

Methods

push :: a -> Lua ()

Pushes a value onto Lua stack, casting it into meaningfully nearest Lua type.

Instances

ToLuaStack Bool

Methods

push :: Bool -> Lua ()

ToLuaStack ()

Methods

push :: () -> Lua ()

ToLuaStack ByteString

Methods

push :: ByteString -> Lua ()

ToLuaStack ByteString

Methods

push :: ByteString -> Lua ()

ToLuaStack Text

Methods

push :: Text -> Lua ()

ToLuaStack LuaNumber

Methods

push :: LuaNumber -> Lua ()

ToLuaStack LuaInteger

Methods

push :: LuaInteger -> Lua ()

ToLuaStack CFunction

Methods

push :: CFunction -> Lua ()

ToLuaStack [Char]

Methods

push :: [Char] -> Lua ()

ToLuaStack a => ToLuaStack [a]

Methods

push :: [a] -> Lua ()

ToLuaStack (Ptr a)

Methods

push :: Ptr a -> Lua ()

ToLuaStack a => ToLuaStack (OrNil a)

Methods

push :: OrNil a -> Lua ()

ToLuaStack a => ToLuaStack (Optional a)

Methods

push :: Optional a -> Lua ()

(ToLuaStack a, ToLuaStack b) => ToLuaStack (a, b)

Methods

push :: (a, b) -> Lua ()

(ToLuaStack a, ToLuaStack b) => ToLuaStack (Map a b)

Methods

push :: Map a b -> Lua ()

(ToLuaStack a, ToLuaStack b, ToLuaStack c) => ToLuaStack (a, b, c)

Methods

push :: (a, b, c) -> Lua ()

(ToLuaStack a, ToLuaStack b, ToLuaStack c, ToLuaStack d) => ToLuaStack (a, b, c, d)

Methods

push :: (a, b, c, d) -> Lua ()

(ToLuaStack a, ToLuaStack b, ToLuaStack c, ToLuaStack d, ToLuaStack e) => ToLuaStack (a, b, c, d, e)

Methods

push :: (a, b, c, d, e) -> Lua ()

(ToLuaStack a, ToLuaStack b, ToLuaStack c, ToLuaStack d, ToLuaStack e, ToLuaStack f) => ToLuaStack (a, b, c, d, e, f)

Methods

push :: (a, b, c, d, e, f) -> Lua ()

(ToLuaStack a, ToLuaStack b, ToLuaStack c, ToLuaStack d, ToLuaStack e, ToLuaStack f, ToLuaStack g) => ToLuaStack (a, b, c, d, e, f, g)

Methods

push :: (a, b, c, d, e, f, g) -> Lua ()

(ToLuaStack a, ToLuaStack b, ToLuaStack c, ToLuaStack d, ToLuaStack e, ToLuaStack f, ToLuaStack g, ToLuaStack h) => ToLuaStack (a, b, c, d, e, f, g, h)

Methods

push :: (a, b, c, d, e, f, g, h) -> Lua ()

type PreCFunction = LuaState -> IO NumResults

Type of raw haskell functions that can be made into CFunctions.

toHaskellFunction :: ToHaskellFunction a => a -> HaskellFunction

Convert a Haskell function to Lua function. Any Haskell function can be converted provided that:

• all arguments are instances of FromLuaStack
• return type is Lua a, where a is an instance of ToLuaStack

Any Haskell exception will be converted to a string and returned as Lua error.

callFunc :: LuaCallFunc a => String -> a

Call a Lua function. Use as:

v <- callfunc "proc" "abc" (1::Int) (5.0::Double)

freeCFunction :: CFunction -> Lua ()

Free function pointer created with newcfunction.

newCFunction :: ToHaskellFunction a => a -> Lua CFunction

Create new foreign Lua function. Function created can be called by Lua engine. Remeber to free the pointer with freecfunction.

pushHaskellFunction :: ToHaskellFunction a => a -> Lua ()

Pushes Haskell function as a callable userdata. All values created will be garbage collected. Use as:

pushHaskellFunction myfun
setglobal "myfun"

You are not allowed to use lua_error anywhere, but use an error code of (-1) to the same effect. Push error message as the sole return value.

registerHaskellFunction :: ToHaskellFunction a => String -> a -> Lua ()

Imports a Haskell function and registers it at global name.