ATerm.Generics

Documentation

class GToATerm f where

Methods

gToATerm :: f a -> ATerm

Instances

(GToATerm f, GToATerm g) => GToATerm (:+: f g)

GToATerm a => GToATerm (D1 c a)

(Constructor c, GToATerms a) => GToATerm (C1 c a)

class GToATerms f where

Methods

gToATerms :: f a -> [ATerm] -> [ATerm]

Instances

GToATerms U1

ToATerm a => GToATerms (Rec0 a)

(GToATerms f, GToATerms g) => GToATerms (:*: f g)

GToATerms f => GToATerms (S1 i f)

class ToATerm a where

Methods

toATerm :: a -> ATerm

toATermList :: [a] -> ATerm

Instances

ToATerm Bool

ToATerm Char

ToATerm Double

ToATerm Float

ToATerm Int

ToATerm Integer

ToATerm ()

ToATerm a => ToATerm [a]

ToATerm a => ToATerm (Maybe a)

(ToATerm a, ToATerm b) => ToATerm (Either a b)

(ToATerm a, ToATerm b) => ToATerm (a, b)

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

integralToATerm :: Integral a => a -> ATerm

showToATerm :: Show a => a -> ATerm

listToATerm :: ToATerm a => [a] -> ATerm

stringToATerm :: String -> ATerm

tupleToATerm :: (ToATerm a, ToATerm b) => (a, b) -> ATerm

tripleToATerm :: (ToATerm a, ToATerm b, ToATerm c) => (a, b, c) -> ATerm

class FromATerm a where

Methods

fromATerm :: ATerm -> Maybe a

fromATermList :: ATerm -> Maybe [a]

Instances

FromATerm Bool

FromATerm Char

FromATerm Double

FromATerm Float

FromATerm Int

FromATerm Integer

FromATerm ()

FromATerm a => FromATerm [a]

FromATerm a => FromATerm (Maybe a)

(FromATerm a, FromATerm b) => FromATerm (Either a b)

(FromATerm a, FromATerm b) => FromATerm (a, b)

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

atermToIntegral :: Integral a => ATerm -> Maybe a

atermToRead :: Read a => ATerm -> Maybe a

atermToString :: ATerm -> Maybe String

atermToList :: FromATerm a => ATerm -> Maybe [a]

atermToTuple :: (FromATerm a, FromATerm b) => ATerm -> Maybe (a, b)

atermToTriple :: (FromATerm a, FromATerm b, FromATerm c) => ATerm -> Maybe (a, b, c)

class GFromATerm f where

Methods

gFromATerm :: ATerm -> Maybe (f a)

Instances

(GFromATerm f, GFromATerm g) => GFromATerm (:+: f g)

GFromATerm a => GFromATerm (D1 c a)

(Constructor c, GFromATerms a) => GFromATerm (C1 c a)

gFromATerms' :: GFromATerms f => [ATerm] -> Maybe (f a)

Convert all the ATerm elements into the requested structure

next :: FromATerm a => StateT [ATerm] Maybe a

Convert the next ATerm to the next needed field type

class GFromATerms f where

Methods

gFromATerms :: StateT [ATerm] Maybe (f a)

Instances

GFromATerms U1

FromATerm a => GFromATerms (Rec0 a)

(GFromATerms f, GFromATerms g) => GFromATerms (:*: f g)

GFromATerms f => GFromATerms (S1 i f)