Foreign.Erlang.Term

External Term Format

data Term

Instances

Eq Term

Methods

(==) :: Term -> Term -> Bool

(/=) :: Term -> Term -> Bool

Ord Term

Methods

compare :: Term -> Term -> Ordering

(<) :: Term -> Term -> Bool

(<=) :: Term -> Term -> Bool

(>) :: Term -> Term -> Bool

(>=) :: Term -> Term -> Bool

max :: Term -> Term -> Term

min :: Term -> Term -> Term

Show Term

Methods

showsPrec :: Int -> Term -> ShowS

show :: Term -> String

showList :: [Term] -> ShowS

IsString Term

Methods

fromString :: String -> Term

Arbitrary Term

Methods

arbitrary :: Gen Term

shrink :: Term -> [Term]

Binary Term

Methods

put :: Term -> Put

get :: Get Term

putList :: [Term] -> Put

FromTerm Term

Methods

fromTerm :: Term -> Maybe Term

ToTerm Term

Methods

toTerm :: Term -> Term

putTerm :: ToTerm t => t -> Put

getTerm :: Get Term

Conversion to and from External Term Format

class ToTerm a where

Minimal complete definition

toTerm

Methods

toTerm :: a -> Term

Instances

ToTerm Integer

Methods

toTerm :: Integer -> Term

ToTerm ()

Methods

toTerm :: () -> Term

ToTerm String

Methods

toTerm :: String -> Term

ToTerm Pid

Methods

toTerm :: Pid -> Term

ToTerm Term

Methods

toTerm :: Term -> Term

ToTerm a => ToTerm (Tuple1 a)

Methods

toTerm :: Tuple1 a -> Term

KnownSymbol atom => ToTerm (SAtom atom)

Methods

toTerm :: SAtom atom -> Term

KnownNat n => ToTerm (SInteger n)

Methods

toTerm :: SInteger n -> Term

(ToTerm a, ToTerm b) => ToTerm (a, b)

Methods

toTerm :: (a, b) -> Term

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

Methods

toTerm :: (a, b, c) -> Term

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

Methods

toTerm :: (a, b, c, d) -> Term

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

Methods

toTerm :: (a, b, c, d, e) -> Term

class FromTerm a where

Minimal complete definition

fromTerm

Methods

fromTerm :: Term -> Maybe a

Instances

FromTerm Integer

Methods

fromTerm :: Term -> Maybe Integer

FromTerm ()

Methods

fromTerm :: Term -> Maybe ()

FromTerm String

Methods

fromTerm :: Term -> Maybe String

FromTerm Pid

Methods

fromTerm :: Term -> Maybe Pid

FromTerm Term

Methods

fromTerm :: Term -> Maybe Term

FromTerm a => FromTerm (Tuple1 a)

Methods

fromTerm :: Term -> Maybe (Tuple1 a)

KnownSymbol atom => FromTerm (SAtom atom)

Methods

fromTerm :: Term -> Maybe (SAtom atom)

KnownNat n => FromTerm (SInteger n)

Methods

fromTerm :: Term -> Maybe (SInteger n)

(FromTerm a, FromTerm b) => FromTerm (a, b)

Methods

fromTerm :: Term -> Maybe (a, b)

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

Methods

fromTerm :: Term -> Maybe (a, b, c)

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

Methods

fromTerm :: Term -> Maybe (a, b, c, d)

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

Methods

fromTerm :: Term -> Maybe (a, b, c, d, e)

fromTermA :: (FromTerm a, Alternative m) => Term -> m a

Constructors

integer

Arguments

:: Integer

Int

-> Term

Construct an integer

Static numbers

data SInteger n

A static/constant number.

Constructors

SInteger

Instances

KnownNat n => Show (SInteger n)

Methods

showsPrec :: Int -> SInteger n -> ShowS

show :: SInteger n -> String

showList :: [SInteger n] -> ShowS

KnownNat n => FromTerm (SInteger n)

Methods

fromTerm :: Term -> Maybe (SInteger n)

KnownNat n => ToTerm (SInteger n)

Methods

toTerm :: SInteger n -> Term

float

Arguments

:: Double

IEEE float

-> Term

Construct a float

atom

Arguments

:: ByteString

AtomName

-> Term

Construct an atom

Static atoms

data SAtom atom

A static/constant atom.

Constructors

SAtom

Instances

KnownSymbol atom => Show (SAtom atom)

Methods

showsPrec :: Int -> SAtom atom -> ShowS

show :: SAtom atom -> String

showList :: [SAtom atom] -> ShowS

KnownSymbol atom => FromTerm (SAtom atom)

Methods

fromTerm :: Term -> Maybe (SAtom atom)

KnownSymbol atom => ToTerm (SAtom atom)

Methods

toTerm :: SAtom atom -> Term

port

Arguments

:: ByteString

Node name

-> Word32

ID

-> Word8

Creation

-> Term

Construct a port

pid

Arguments

:: ByteString

Node name

-> Word32

ID

-> Word32

Serial

-> Word8

Creation

-> Pid

newtype Pid

Constructors

MkPid Term

Instances

Eq Pid

Methods

(==) :: Pid -> Pid -> Bool

(/=) :: Pid -> Pid -> Bool

Ord Pid

Methods

compare :: Pid -> Pid -> Ordering

(<) :: Pid -> Pid -> Bool

(<=) :: Pid -> Pid -> Bool

(>) :: Pid -> Pid -> Bool

(>=) :: Pid -> Pid -> Bool

max :: Pid -> Pid -> Pid

min :: Pid -> Pid -> Pid

Show Pid

Methods

showsPrec :: Int -> Pid -> ShowS

show :: Pid -> String

showList :: [Pid] -> ShowS

Arbitrary Pid

Methods

arbitrary :: Gen Pid

shrink :: Pid -> [Pid]

FromTerm Pid

Methods

fromTerm :: Term -> Maybe Pid

ToTerm Pid

Methods

toTerm :: Pid -> Term

tuple

Arguments

:: [Term]

Elements

-> Term

Construct a tuple

newtype Tuple1 a

Constructors

Tuple1 a

Instances

Eq a => Eq (Tuple1 a)

Methods

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

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

Ord a => Ord (Tuple1 a)

Methods

compare :: Tuple1 a -> Tuple1 a -> Ordering

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

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

(>) :: Tuple1 a -> Tuple1 a -> Bool

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

max :: Tuple1 a -> Tuple1 a -> Tuple1 a

min :: Tuple1 a -> Tuple1 a -> Tuple1 a

Show a => Show (Tuple1 a)

Methods

showsPrec :: Int -> Tuple1 a -> ShowS

show :: Tuple1 a -> String

showList :: [Tuple1 a] -> ShowS

FromTerm a => FromTerm (Tuple1 a)

Methods

fromTerm :: Term -> Maybe (Tuple1 a)

ToTerm a => ToTerm (Tuple1 a)

Methods

toTerm :: Tuple1 a -> Term

string

Arguments

:: ByteString

Characters

-> Term

Construct a list

list

Arguments

:: [Term]

Elements

-> Term

Construct a list

improperList

Arguments

:: [Term]

Elements

-> Term

Tail

-> Term

Construct an improper list (if Tail is not Nil)

ref

Arguments

:: ByteString

Node name

-> Word8

Creation

-> [Word32]

ID ...

-> Term

Construct a new reference

Recognizers

is_integer :: Term -> Bool

Test if term is an integer

is_float :: Term -> Bool

Test if term is a float

is_atom :: Term -> Bool

Test if term is an atom

is_reference :: Term -> Bool

Test if term is a reference

is_port :: Term -> Bool

Test if term is a port

is_pid :: Term -> Bool

Test if term is a pid

is_tuple :: Term -> Bool

Test if term is a tuple

is_map :: Term -> Bool

Test if term is a map

is_list :: Term -> Bool

Test if term is a list

is_binary :: Term -> Bool

Test if term is a binary

Accessors

node :: Term -> Term

atom_name :: Term -> ByteString

length :: Term -> Int

element :: Int -> Term -> Term

to_string :: Term -> Maybe ByteString

to_integer :: Term -> Maybe Integer

Matchers

match_atom :: Term -> ByteString -> Maybe ByteString

match_tuple :: Term -> Maybe [Term]