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, lines, map, pure, sum, unlines)
import qualified Data.Scientific as Sci
import Data.Void

-- | 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"