HORIZON HASKELLDocslts/ghc-9.10.x248f8f02026-10-05Search names, modules, packages, or :: a typeCtrl K

GHC 9.10.3 · lts/ghc-9.10.x · 248f8f0 · 2026-10-05

Modulehslua-objectorientation-2.3.1Haskell2010

HsLua.ObjectOrientation

This module provides types and functions to use Haskell values as userdata objects in Lua. These objects wrap a Haskell value and provide methods and properties to interact with the Haskell value.

The terminology in this module refers to the userdata values as /UD objects, and to their type as UD type/.

  • 9 types
  • 15 values
typetype UDType e fn a = UDTypeWithList e fn a Void
#

A userdata type, capturing the behavior of Lua objects that wrap Haskell values. The type name must be unique; once the type has been used to push or retrieve a value, the behavior can no longer be modified through this type.

datadata UDTypeWithList e fn a itemtype
#

A userdata type, capturing the behavior of Lua objects that wrap Haskell values. The type name must be unique; once the type has been used to push or retrieve a value, the behavior can no longer be modified through this type.

This type includes methods to define how the object should behave as a read-only list of type itemtype.

Constructors

Defining types

2 declarations
valuedeftypeGeneric
  1. :: Pusher e fn

    function pusher

  2. -> Name

    type name

  3. -> [(Operation, fn)]

    operations

  4. -> [Member e fn a]

    methods

  5. -> UDType e fn a
#

Defines a new type, defining the behavior of objects in Lua. Note that the type name must be unique.

Methods

Properties

valueproperty
  1. :: LuaError e
  2. => Name

    property name

  3. -> Text

    property description

  4. -> (Pusher e b, a -> b)

    how to get the property value

  5. -> (Peeker e b, a -> b -> a)

    how to set a new property value

  6. -> Member e fn a
#

Declares a new read- and writable property.

valueproperty'
  1. :: LuaError e
  2. => Name

    property name

  3. -> TypeSpec

    property type

  4. -> Text

    property description

  5. -> (Pusher e b, a -> b)

    how to get the property value

  6. -> (Peeker e b, a -> b -> a)

    how to set a new property value

  7. -> Member e fn a
#

Declares a new read- and writable typed property.

valuereadonly
  1. :: Name

    property name

  2. -> Text

    property description

  3. -> (Pusher e b, a -> b)

    how to get the property value

  4. -> Member e fn a
#

Creates a read-only object property. Attempts to set the value will cause an error.

valuereadonly'
  1. :: Name

    property name

  2. -> TypeSpec

    property type

  3. -> Text

    property description

  4. -> (Pusher e b, a -> b)

    how to get the property value

  5. -> Member e fn a
#

Creates a read-only object property. Attempts to set the value will cause an error.

Aliases

Marshaling

3 declarations
valueinitTypeGeneric
  1. :: LuaError e
  2. => UDTypeWithList e fn a itemtype -> LuaE e ()
  3. -> UDTypeWithList e fn a itemtype
  4. -> LuaE e Name
#

Ensures that the type has been fully initialized, i.e., that all metatables have been created and stored in the registry. Returns the name of the initialized type.

The hook can be used to perform additional setup operations. The function is called as the last step after the type metatable has been initialized: the fully initialized metatable will be at the top of the stack at that point. Note that the hook will not be called if the type's metatable already existed before this function was invoked.

Type docs

2 declarations

Helper types for building

7 declarations
datadata Member e fn a
#

A type member, either a method or a variable.

datadata Operation
#

Lua metadata operation types.

Constructors

  • Add

    the addition (+) operation. If any operand for an addition is not a number (nor a string coercible to a number), Lua will try to call a metamethod. First, Lua will check the first operand (even if it is valid). If that operand does not define a metamethod for __add, then Lua will check the second operand. If Lua can find a metamethod, it calls the metamethod with the two operands as arguments, and the result of the call (adjusted to one value) is the result of the operation. Otherwise, it raises an error.

  • Sub

    the subtraction (-) operation. Behavior similar to the addition operation.

  • Mul

    the multiplication (*) operation. Behavior similar to the addition operation.

  • Div

    the division (/) operation. Behavior similar to the addition operation.

  • Mod

    the modulo (%) operation. Behavior similar to the addition operation.

  • Pow

    the exponentiation (^) operation. Behavior similar to the addition operation.

  • Unm

    the negation (unary -) operation. Behavior similar to the addition operation.

  • Idiv

    the floor division (//) operation. Behavior similar to the addition operation.

  • Band

    the bitwise AND (&) operation. Behavior similar to the addition operation, except that Lua will try a metamethod if any operand is neither an integer nor a value coercible to an integer (see §3.4.3).

  • Bor

    the bitwise OR (|) operation. Behavior similar to the bitwise AND operation.

  • Bxor

    the bitwise exclusive OR (binary ~) operation. Behavior similar to the bitwise AND operation.

  • Bnot

    the bitwise NOT (unary ~) operation. Behavior similar to the bitwise AND operation.

  • Shl

    the bitwise left shift (<<) operation. Behavior similar to the bitwise AND operation.

  • Shr

    the bitwise right shift (>>) operation. Behavior similar to the bitwise AND operation.

  • Concat

    the concatenation (..) operation. Behavior similar to the addition operation, except that Lua will try a metamethod if any operand is neither a string nor a number (which is always coercible to a string).

  • Len

    the length (#) operation. If the object is not a string, Lua will try its metamethod. If there is a metamethod, Lua calls it with the object as argument, and the result of the call (always adjusted to one value) is the result of the operation. If there is no metamethod but the object is a table, then Lua uses the table length operation (see §3.4.7). Otherwise, Lua raises an error.

  • Eq

    the equal (==) operation. Behavior similar to the addition operation, except that Lua will try a metamethod only when the values being compared are either both tables or both full userdata and they are not primitively equal. The result of the call is always converted to a boolean.

  • Lt

    the less than (<) operation. Behavior similar to the addition operation, except that Lua will try a metamethod only when the values being compared are neither both numbers nor both strings. The result of the call is always converted to a boolean.

  • Le

    the less equal (<=) operation. Unlike other operations, the less-equal operation can use two different events. First, Lua looks for the __le metamethod in both operands, like in the less than operation. If it cannot find such a metamethod, then it will try the __lt metamethod, assuming that a <= b is equivalent to not (b < a). As with the other comparison operators, the result is always a boolean. (This use of the __lt event can be removed in future versions; it is also slower than a real __le metamethod.)

  • Index

    The indexing access operation table[key]. This event happens when table is not a table or when key is not present in table. The metamethod is looked up in table.

  • Newindex

    The indexing assignment table[key] = value. Like the index event, this event happens when table is not a table or when key is not present in table. The metamethod is looked up in table.

  • Call

    The call operation func(args). This event happens when Lua tries to call a non-function value (that is, func is not a function). The metamethod is looked up in func. If present, the metamethod is called with func as its first argument, followed by the arguments of the original call (args). All results of the call are the result of the operation. (This is the only metamethod that allows multiple results.)

  • Tostring

    The operation used to create a string representation of the object.

  • Pairs

    the operation of iterating over the object's key-value pairs.

  • CustomOperation Name

    a custom operation, with the metamethod name as parameter.

Instances3Eq, Ord, Show
  • Eq OperationDefined in hslua-objectorientation-2.3.1 · HsLua.ObjectOrientation.Operation
  • Ord OperationDefined in hslua-objectorientation-2.3.1 · HsLua.ObjectOrientation.Operation
  • Show OperationDefined in hslua-objectorientation-2.3.1 · HsLua.ObjectOrientation.Operation
typetype ListSpec e a itemtype = ((Pusher e itemtype, a -> [itemtype]), (Peeker e itemtype, a -> [itemtype] -> a))
#

Pair of pairs, describing how a type can be used as a Lua list. The first pair describes how to push the list items, and how the list is extracted from the type; the second pair contains a method to retrieve list items, and defines how the list is used to create an updated value.

datadata Possible a
#

A property or method which may be available in some instances but not in others.

Constructors

typetype Alias = [AliasIndex]
#

Alias for a different property of this or of a nested object.