{-# LANGUAGE OverloadedStrings #-}

module Hydra.Sources.Tier2.CoreLanguage where

-- Standard Tier-2 imports
import           Prelude hiding ((++))
import qualified Data.List                 as L
import qualified Data.Map                  as M
import qualified Data.Set                  as S
import qualified Data.Maybe                as Y
import           Hydra.Dsl.Base            as Base
import qualified Hydra.Dsl.Core            as Core
import qualified Hydra.Dsl.Graph           as Graph
import qualified Hydra.Dsl.Lib.Equality    as Equality
import qualified Hydra.Dsl.Lib.Flows       as Flows
import qualified Hydra.Dsl.Lib.Io          as Io
import qualified Hydra.Dsl.Lib.Lists       as Lists
import qualified Hydra.Dsl.Lib.Literals    as Literals
import qualified Hydra.Dsl.Lib.Logic       as Logic
import qualified Hydra.Dsl.Lib.Maps        as Maps
import qualified Hydra.Dsl.Lib.Math        as Math
import qualified Hydra.Dsl.Lib.Optionals   as Optionals
import qualified Hydra.Dsl.Lib.Sets        as Sets
import           Hydra.Dsl.Lib.Strings     as Strings
import qualified Hydra.Dsl.Module          as Module
import qualified Hydra.Dsl.Terms           as Terms
import qualified Hydra.Dsl.Types           as Types
import           Hydra.Sources.Tier1.All

import Hydra.Sources.Tier2.Basics


hydraCoreLanguageModule :: Module
hydraCoreLanguageModule :: Module
hydraCoreLanguageModule = Namespace
-> [Element] -> [Module] -> [Module] -> Maybe String -> Module
Module Namespace
ns [Element]
elements
    [Module
hydraBasicsModule]
    [Module]
tier0Modules (Maybe String -> Module) -> Maybe String -> Module
forall a b. (a -> b) -> a -> b
$
    String -> Maybe String
forall a. a -> Maybe a
Just String
"Language constraints for Hydra Core"
  where
    ns :: Namespace
ns = String -> Namespace
Namespace String
"hydra/coreLanguage"
    elements :: [Element]
elements = [TElement Language -> Element
forall a. TElement a -> Element
el TElement Language
hydraCoreLanguageDef]

hydraCoreLanguageDef :: TElement Language
hydraCoreLanguageDef :: TElement Language
hydraCoreLanguageDef = Module -> String -> TTerm Language -> TElement Language
forall a. Module -> String -> TTerm a -> TElement a
definitionInModule Module
hydraCoreLanguageModule String
"hydraCoreLanguage" (TTerm Language -> TElement Language)
-> TTerm Language -> TElement Language
forall a b. (a -> b) -> a -> b
$
  String -> TTerm Language -> TTerm Language
forall a. String -> TTerm a -> TTerm a
doc String
"Language constraints for Java" (TTerm Language -> TTerm Language)
-> TTerm Language -> TTerm Language
forall a b. (a -> b) -> a -> b
$
  Type -> TTerm Language -> TTerm Language
forall a. Type -> TTerm a -> TTerm a
typed Type
languageT (TTerm Language -> TTerm Language)
-> TTerm Language -> TTerm Language
forall a b. (a -> b) -> a -> b
$
  Name -> [Field] -> TTerm Language
forall a. Name -> [Field] -> TTerm a
record Name
_Language [
    Name
_Language_nameName -> TTerm Any -> Field
forall a. Name -> TTerm a -> Field
>>: Name -> TTerm Any -> TTerm Any
forall a b. Name -> TTerm a -> TTerm b
wrap Name
_LanguageName TTerm Any
"hydra/core",
    Name
_Language_constraintsName -> TTerm Any -> Field
forall a. Name -> TTerm a -> Field
>>: Name -> [Field] -> TTerm Any
forall a. Name -> [Field] -> TTerm a
record Name
_LanguageConstraints [
    Name
_LanguageConstraints_eliminationVariantsName -> TTerm (Set EliminationVariant) -> Field
forall a. Name -> TTerm a -> Field
>>: TTerm ([EliminationVariant] -> Set EliminationVariant)
forall a. TTerm ([a] -> Set a)
Sets.fromList TTerm ([EliminationVariant] -> Set EliminationVariant)
-> TTerm [EliminationVariant] -> TTerm (Set EliminationVariant)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TElement [EliminationVariant] -> TTerm [EliminationVariant]
forall a. TElement a -> TTerm a
ref TElement [EliminationVariant]
eliminationVariantsDef,
    Name
_LanguageConstraints_literalVariantsName -> TTerm (Set LiteralVariant) -> Field
forall a. Name -> TTerm a -> Field
>>: TTerm ([LiteralVariant] -> Set LiteralVariant)
forall a. TTerm ([a] -> Set a)
Sets.fromList TTerm ([LiteralVariant] -> Set LiteralVariant)
-> TTerm [LiteralVariant] -> TTerm (Set LiteralVariant)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TElement [LiteralVariant] -> TTerm [LiteralVariant]
forall a. TElement a -> TTerm a
ref TElement [LiteralVariant]
literalVariantsDef,
    Name
_LanguageConstraints_floatTypesName -> TTerm (Set FloatType) -> Field
forall a. Name -> TTerm a -> Field
>>: TTerm ([FloatType] -> Set FloatType)
forall a. TTerm ([a] -> Set a)
Sets.fromList TTerm ([FloatType] -> Set FloatType)
-> TTerm [FloatType] -> TTerm (Set FloatType)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TElement [FloatType] -> TTerm [FloatType]
forall a. TElement a -> TTerm a
ref TElement [FloatType]
floatTypesDef,
    Name
_LanguageConstraints_functionVariantsName -> TTerm (Set FunctionVariant) -> Field
forall a. Name -> TTerm a -> Field
>>: TTerm ([FunctionVariant] -> Set FunctionVariant)
forall a. TTerm ([a] -> Set a)
Sets.fromList TTerm ([FunctionVariant] -> Set FunctionVariant)
-> TTerm [FunctionVariant] -> TTerm (Set FunctionVariant)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TElement [FunctionVariant] -> TTerm [FunctionVariant]
forall a. TElement a -> TTerm a
ref TElement [FunctionVariant]
functionVariantsDef,
    Name
_LanguageConstraints_integerTypesName -> TTerm (Set IntegerType) -> Field
forall a. Name -> TTerm a -> Field
>>: TTerm ([IntegerType] -> Set IntegerType)
forall a. TTerm ([a] -> Set a)
Sets.fromList TTerm ([IntegerType] -> Set IntegerType)
-> TTerm [IntegerType] -> TTerm (Set IntegerType)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TElement [IntegerType] -> TTerm [IntegerType]
forall a. TElement a -> TTerm a
ref TElement [IntegerType]
integerTypesDef,
    Name
_LanguageConstraints_termVariantsName -> TTerm (Set TermVariant) -> Field
forall a. Name -> TTerm a -> Field
>>: TTerm ([TermVariant] -> Set TermVariant)
forall a. TTerm ([a] -> Set a)
Sets.fromList TTerm ([TermVariant] -> Set TermVariant)
-> TTerm [TermVariant] -> TTerm (Set TermVariant)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TElement [TermVariant] -> TTerm [TermVariant]
forall a. TElement a -> TTerm a
ref TElement [TermVariant]
termVariantsDef,
    Name
_LanguageConstraints_typeVariantsName -> TTerm (Set TypeVariant) -> Field
forall a. Name -> TTerm a -> Field
>>: TTerm ([TypeVariant] -> Set TypeVariant)
forall a. TTerm ([a] -> Set a)
Sets.fromList TTerm ([TypeVariant] -> Set TypeVariant)
-> TTerm [TypeVariant] -> TTerm (Set TypeVariant)
forall a b. TTerm (a -> b) -> TTerm a -> TTerm b
@@ TElement [TypeVariant] -> TTerm [TypeVariant]
forall a. TElement a -> TTerm a
ref TElement [TypeVariant]
typeVariantsDef,
    Name
_LanguageConstraints_typesName -> TTerm (Any -> Bool) -> Field
forall a. Name -> TTerm a -> Field
>>: TTerm Bool -> TTerm (Any -> Bool)
forall a b. TTerm a -> TTerm (b -> a)
constant TTerm Bool
true]]