Syntax.hs

-- Note: this is an automatically generated file. Do not edit.

-- | A basic Datalog model

module Hydra.Datalog.Syntax where

import qualified Hydra.Core as Core
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
import qualified Data.Scientific as Sci

-- | A relation applied to a list of terms
data Atom =
  Atom {
    atomRelation :: Relation,
    atomTermList :: TermList}
  deriving (Eq, Ord, Read, Show)

_Atom = Core.Name "hydra.datalog.syntax.Atom"

_Atom_Relation = Core.Name "Relation"

_Atom_TermList = Core.Name "TermList"

-- | A nonempty, comma-separated list of atoms
data AtomList =
  AtomListSingle Atom |
  AtomListMany AtomListMultiple
  deriving (Eq, Ord, Read, Show)

_AtomList = Core.Name "hydra.datalog.syntax.AtomList"

_AtomList_single = Core.Name "single"

_AtomList_many = Core.Name "many"

-- | An atom followed by the remainder of a comma-separated atom list
data AtomListMultiple =
  AtomListMultiple {
    atomListMultipleAtom :: Atom,
    atomListMultipleAtomList :: AtomList}
  deriving (Eq, Ord, Read, Show)

_AtomListMultiple = Core.Name "hydra.datalog.syntax.AtomListMultiple"

_AtomListMultiple_Atom = Core.Name "Atom"

_AtomListMultiple_AtomList = Core.Name "AtomList"

-- | A constant term, e.g. an atomic value such as a symbol or number
newtype Constant =
  Constant {
    unConstant :: String}
  deriving (Eq, Ord, Read, Show)

_Constant = Core.Name "hydra.datalog.syntax.Constant"

-- | A nonempty, comma-separated list of constants
data ConstantList =
  ConstantListSingle Constant |
  ConstantListMany ConstantListMultiple
  deriving (Eq, Ord, Read, Show)

_ConstantList = Core.Name "hydra.datalog.syntax.ConstantList"

_ConstantList_single = Core.Name "single"

_ConstantList_many = Core.Name "many"

-- | A constant followed by the remainder of a comma-separated constant list
data ConstantListMultiple =
  ConstantListMultiple {
    constantListMultipleConstant :: Constant,
    constantListMultipleConstantList :: ConstantList}
  deriving (Eq, Ord, Read, Show)

_ConstantListMultiple = Core.Name "hydra.datalog.syntax.ConstantListMultiple"

_ConstantListMultiple_Constant = Core.Name "Constant"

_ConstantListMultiple_ConstantList = Core.Name "ConstantList"

-- | An unconditional assertion of a relation applied to a list of constants
data Fact =
  Fact {
    factRelation :: Relation,
    factConstantList :: ConstantList}
  deriving (Eq, Ord, Read, Show)

_Fact = Core.Name "hydra.datalog.syntax.Fact"

_Fact_Relation = Core.Name "Relation"

_Fact_ConstantList = Core.Name "ConstantList"

-- | A Datalog program: a list of facts and rules
newtype Program =
  Program {
    unProgram :: [ProgramElmt]}
  deriving (Eq, Ord, Read, Show)

_Program = Core.Name "hydra.datalog.syntax.Program"

-- | A single element of a Datalog program: either a fact or a rule
data ProgramElmt =
  ProgramElmtFact Fact |
  ProgramElmtRule Rule
  deriving (Eq, Ord, Read, Show)

_ProgramElmt = Core.Name "hydra.datalog.syntax.ProgramElmt"

_ProgramElmt_Fact = Core.Name "Fact"

_ProgramElmt_Rule = Core.Name "Rule"

-- | The name of a predicate (relation) used in facts, rules, and queries
newtype Relation =
  Relation {
    unRelation :: String}
  deriving (Eq, Ord, Read, Show)

_Relation = Core.Name "hydra.datalog.syntax.Relation"

-- | A conditional assertion: a head atom implied by a conjunction of body atoms
data Rule =
  Rule {
    ruleAtom :: Atom,
    ruleAtomList :: AtomList}
  deriving (Eq, Ord, Read, Show)

_Rule = Core.Name "hydra.datalog.syntax.Rule"

_Rule_Atom = Core.Name "Atom"

_Rule_AtomList = Core.Name "AtomList"

-- | An argument to an atom: either a constant or a variable
data Term =
  TermConstant Constant |
  TermVariable Variable
  deriving (Eq, Ord, Read, Show)

_Term = Core.Name "hydra.datalog.syntax.Term"

_Term_Constant = Core.Name "Constant"

_Term_Variable = Core.Name "Variable"

-- | A nonempty, comma-separated list of terms
data TermList =
  TermListSingle Term |
  TermListMany TermListMultiple
  deriving (Eq, Ord, Read, Show)

_TermList = Core.Name "hydra.datalog.syntax.TermList"

_TermList_single = Core.Name "single"

_TermList_many = Core.Name "many"

-- | A term followed by the remainder of a comma-separated term list
data TermListMultiple =
  TermListMultiple {
    termListMultipleTerm :: Term,
    termListMultipleTermList :: TermList}
  deriving (Eq, Ord, Read, Show)

_TermListMultiple = Core.Name "hydra.datalog.syntax.TermListMultiple"

_TermListMultiple_Term = Core.Name "Term"

_TermListMultiple_TermList = Core.Name "TermList"

-- | A logic variable, which may be bound to different constants across a query
newtype Variable =
  Variable {
    unVariable :: String}
  deriving (Eq, Ord, Read, Show)

_Variable = Core.Name "hydra.datalog.syntax.Variable"