-- | A Scala syntax model based on Scalameta (https://scalameta.org)

module Hydra.Langs.Scala.Meta where

import qualified Hydra.Core as Core
import Data.Int
import Data.List as L
import Data.Map as M
import Data.Set as S

newtype PredefString = 
  PredefString {
    PredefString -> String
unPredefString :: String}
  deriving (PredefString -> PredefString -> Bool
(PredefString -> PredefString -> Bool)
-> (PredefString -> PredefString -> Bool) -> Eq PredefString
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PredefString -> PredefString -> Bool
== :: PredefString -> PredefString -> Bool
$c/= :: PredefString -> PredefString -> Bool
/= :: PredefString -> PredefString -> Bool
Eq, Eq PredefString
Eq PredefString =>
(PredefString -> PredefString -> Ordering)
-> (PredefString -> PredefString -> Bool)
-> (PredefString -> PredefString -> Bool)
-> (PredefString -> PredefString -> Bool)
-> (PredefString -> PredefString -> Bool)
-> (PredefString -> PredefString -> PredefString)
-> (PredefString -> PredefString -> PredefString)
-> Ord PredefString
PredefString -> PredefString -> Bool
PredefString -> PredefString -> Ordering
PredefString -> PredefString -> PredefString
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: PredefString -> PredefString -> Ordering
compare :: PredefString -> PredefString -> Ordering
$c< :: PredefString -> PredefString -> Bool
< :: PredefString -> PredefString -> Bool
$c<= :: PredefString -> PredefString -> Bool
<= :: PredefString -> PredefString -> Bool
$c> :: PredefString -> PredefString -> Bool
> :: PredefString -> PredefString -> Bool
$c>= :: PredefString -> PredefString -> Bool
>= :: PredefString -> PredefString -> Bool
$cmax :: PredefString -> PredefString -> PredefString
max :: PredefString -> PredefString -> PredefString
$cmin :: PredefString -> PredefString -> PredefString
min :: PredefString -> PredefString -> PredefString
Ord, ReadPrec [PredefString]
ReadPrec PredefString
Int -> ReadS PredefString
ReadS [PredefString]
(Int -> ReadS PredefString)
-> ReadS [PredefString]
-> ReadPrec PredefString
-> ReadPrec [PredefString]
-> Read PredefString
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS PredefString
readsPrec :: Int -> ReadS PredefString
$creadList :: ReadS [PredefString]
readList :: ReadS [PredefString]
$creadPrec :: ReadPrec PredefString
readPrec :: ReadPrec PredefString
$creadListPrec :: ReadPrec [PredefString]
readListPrec :: ReadPrec [PredefString]
Read, Int -> PredefString -> String -> String
[PredefString] -> String -> String
PredefString -> String
(Int -> PredefString -> String -> String)
-> (PredefString -> String)
-> ([PredefString] -> String -> String)
-> Show PredefString
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> PredefString -> String -> String
showsPrec :: Int -> PredefString -> String -> String
$cshow :: PredefString -> String
show :: PredefString -> String
$cshowList :: [PredefString] -> String -> String
showList :: [PredefString] -> String -> String
Show)

_PredefString :: Name
_PredefString = (String -> Name
Core.Name String
"hydra/langs/scala/meta.PredefString")

data ScalaSymbol = 
  ScalaSymbol {
    ScalaSymbol -> String
scalaSymbolName :: String}
  deriving (ScalaSymbol -> ScalaSymbol -> Bool
(ScalaSymbol -> ScalaSymbol -> Bool)
-> (ScalaSymbol -> ScalaSymbol -> Bool) -> Eq ScalaSymbol
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ScalaSymbol -> ScalaSymbol -> Bool
== :: ScalaSymbol -> ScalaSymbol -> Bool
$c/= :: ScalaSymbol -> ScalaSymbol -> Bool
/= :: ScalaSymbol -> ScalaSymbol -> Bool
Eq, Eq ScalaSymbol
Eq ScalaSymbol =>
(ScalaSymbol -> ScalaSymbol -> Ordering)
-> (ScalaSymbol -> ScalaSymbol -> Bool)
-> (ScalaSymbol -> ScalaSymbol -> Bool)
-> (ScalaSymbol -> ScalaSymbol -> Bool)
-> (ScalaSymbol -> ScalaSymbol -> Bool)
-> (ScalaSymbol -> ScalaSymbol -> ScalaSymbol)
-> (ScalaSymbol -> ScalaSymbol -> ScalaSymbol)
-> Ord ScalaSymbol
ScalaSymbol -> ScalaSymbol -> Bool
ScalaSymbol -> ScalaSymbol -> Ordering
ScalaSymbol -> ScalaSymbol -> ScalaSymbol
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ScalaSymbol -> ScalaSymbol -> Ordering
compare :: ScalaSymbol -> ScalaSymbol -> Ordering
$c< :: ScalaSymbol -> ScalaSymbol -> Bool
< :: ScalaSymbol -> ScalaSymbol -> Bool
$c<= :: ScalaSymbol -> ScalaSymbol -> Bool
<= :: ScalaSymbol -> ScalaSymbol -> Bool
$c> :: ScalaSymbol -> ScalaSymbol -> Bool
> :: ScalaSymbol -> ScalaSymbol -> Bool
$c>= :: ScalaSymbol -> ScalaSymbol -> Bool
>= :: ScalaSymbol -> ScalaSymbol -> Bool
$cmax :: ScalaSymbol -> ScalaSymbol -> ScalaSymbol
max :: ScalaSymbol -> ScalaSymbol -> ScalaSymbol
$cmin :: ScalaSymbol -> ScalaSymbol -> ScalaSymbol
min :: ScalaSymbol -> ScalaSymbol -> ScalaSymbol
Ord, ReadPrec [ScalaSymbol]
ReadPrec ScalaSymbol
Int -> ReadS ScalaSymbol
ReadS [ScalaSymbol]
(Int -> ReadS ScalaSymbol)
-> ReadS [ScalaSymbol]
-> ReadPrec ScalaSymbol
-> ReadPrec [ScalaSymbol]
-> Read ScalaSymbol
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ScalaSymbol
readsPrec :: Int -> ReadS ScalaSymbol
$creadList :: ReadS [ScalaSymbol]
readList :: ReadS [ScalaSymbol]
$creadPrec :: ReadPrec ScalaSymbol
readPrec :: ReadPrec ScalaSymbol
$creadListPrec :: ReadPrec [ScalaSymbol]
readListPrec :: ReadPrec [ScalaSymbol]
Read, Int -> ScalaSymbol -> String -> String
[ScalaSymbol] -> String -> String
ScalaSymbol -> String
(Int -> ScalaSymbol -> String -> String)
-> (ScalaSymbol -> String)
-> ([ScalaSymbol] -> String -> String)
-> Show ScalaSymbol
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ScalaSymbol -> String -> String
showsPrec :: Int -> ScalaSymbol -> String -> String
$cshow :: ScalaSymbol -> String
show :: ScalaSymbol -> String
$cshowList :: [ScalaSymbol] -> String -> String
showList :: [ScalaSymbol] -> String -> String
Show)

_ScalaSymbol :: Name
_ScalaSymbol = (String -> Name
Core.Name String
"hydra/langs/scala/meta.ScalaSymbol")

_ScalaSymbol_name :: Name
_ScalaSymbol_name = (String -> Name
Core.Name String
"name")

data Tree = 
  TreeRef Ref |
  TreeStat Stat |
  TreeType Type |
  TreeBounds Type_Bounds |
  TreePat Pat |
  TreeMember Member |
  TreeCtor Ctor |
  TreeTemplate Template |
  TreeMod Mod |
  TreeEnumerator Enumerator |
  TreeImporter Importer |
  TreeImportee Importee |
  TreeCaseTree CaseTree |
  TreeSource Source |
  TreeQuasi Quasi
  deriving (Tree -> Tree -> Bool
(Tree -> Tree -> Bool) -> (Tree -> Tree -> Bool) -> Eq Tree
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Tree -> Tree -> Bool
== :: Tree -> Tree -> Bool
$c/= :: Tree -> Tree -> Bool
/= :: Tree -> Tree -> Bool
Eq, Eq Tree
Eq Tree =>
(Tree -> Tree -> Ordering)
-> (Tree -> Tree -> Bool)
-> (Tree -> Tree -> Bool)
-> (Tree -> Tree -> Bool)
-> (Tree -> Tree -> Bool)
-> (Tree -> Tree -> Tree)
-> (Tree -> Tree -> Tree)
-> Ord Tree
Tree -> Tree -> Bool
Tree -> Tree -> Ordering
Tree -> Tree -> Tree
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Tree -> Tree -> Ordering
compare :: Tree -> Tree -> Ordering
$c< :: Tree -> Tree -> Bool
< :: Tree -> Tree -> Bool
$c<= :: Tree -> Tree -> Bool
<= :: Tree -> Tree -> Bool
$c> :: Tree -> Tree -> Bool
> :: Tree -> Tree -> Bool
$c>= :: Tree -> Tree -> Bool
>= :: Tree -> Tree -> Bool
$cmax :: Tree -> Tree -> Tree
max :: Tree -> Tree -> Tree
$cmin :: Tree -> Tree -> Tree
min :: Tree -> Tree -> Tree
Ord, ReadPrec [Tree]
ReadPrec Tree
Int -> ReadS Tree
ReadS [Tree]
(Int -> ReadS Tree)
-> ReadS [Tree] -> ReadPrec Tree -> ReadPrec [Tree] -> Read Tree
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Tree
readsPrec :: Int -> ReadS Tree
$creadList :: ReadS [Tree]
readList :: ReadS [Tree]
$creadPrec :: ReadPrec Tree
readPrec :: ReadPrec Tree
$creadListPrec :: ReadPrec [Tree]
readListPrec :: ReadPrec [Tree]
Read, Int -> Tree -> String -> String
[Tree] -> String -> String
Tree -> String
(Int -> Tree -> String -> String)
-> (Tree -> String) -> ([Tree] -> String -> String) -> Show Tree
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Tree -> String -> String
showsPrec :: Int -> Tree -> String -> String
$cshow :: Tree -> String
show :: Tree -> String
$cshowList :: [Tree] -> String -> String
showList :: [Tree] -> String -> String
Show)

_Tree :: Name
_Tree = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Tree")

_Tree_ref :: Name
_Tree_ref = (String -> Name
Core.Name String
"ref")

_Tree_stat :: Name
_Tree_stat = (String -> Name
Core.Name String
"stat")

_Tree_type :: Name
_Tree_type = (String -> Name
Core.Name String
"type")

_Tree_bounds :: Name
_Tree_bounds = (String -> Name
Core.Name String
"bounds")

_Tree_pat :: Name
_Tree_pat = (String -> Name
Core.Name String
"pat")

_Tree_member :: Name
_Tree_member = (String -> Name
Core.Name String
"member")

_Tree_ctor :: Name
_Tree_ctor = (String -> Name
Core.Name String
"ctor")

_Tree_template :: Name
_Tree_template = (String -> Name
Core.Name String
"template")

_Tree_mod :: Name
_Tree_mod = (String -> Name
Core.Name String
"mod")

_Tree_enumerator :: Name
_Tree_enumerator = (String -> Name
Core.Name String
"enumerator")

_Tree_importer :: Name
_Tree_importer = (String -> Name
Core.Name String
"importer")

_Tree_importee :: Name
_Tree_importee = (String -> Name
Core.Name String
"importee")

_Tree_caseTree :: Name
_Tree_caseTree = (String -> Name
Core.Name String
"caseTree")

_Tree_source :: Name
_Tree_source = (String -> Name
Core.Name String
"source")

_Tree_quasi :: Name
_Tree_quasi = (String -> Name
Core.Name String
"quasi")

data Ref = 
  RefName Name |
  RefInit Init
  deriving (Ref -> Ref -> Bool
(Ref -> Ref -> Bool) -> (Ref -> Ref -> Bool) -> Eq Ref
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Ref -> Ref -> Bool
== :: Ref -> Ref -> Bool
$c/= :: Ref -> Ref -> Bool
/= :: Ref -> Ref -> Bool
Eq, Eq Ref
Eq Ref =>
(Ref -> Ref -> Ordering)
-> (Ref -> Ref -> Bool)
-> (Ref -> Ref -> Bool)
-> (Ref -> Ref -> Bool)
-> (Ref -> Ref -> Bool)
-> (Ref -> Ref -> Ref)
-> (Ref -> Ref -> Ref)
-> Ord Ref
Ref -> Ref -> Bool
Ref -> Ref -> Ordering
Ref -> Ref -> Ref
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Ref -> Ref -> Ordering
compare :: Ref -> Ref -> Ordering
$c< :: Ref -> Ref -> Bool
< :: Ref -> Ref -> Bool
$c<= :: Ref -> Ref -> Bool
<= :: Ref -> Ref -> Bool
$c> :: Ref -> Ref -> Bool
> :: Ref -> Ref -> Bool
$c>= :: Ref -> Ref -> Bool
>= :: Ref -> Ref -> Bool
$cmax :: Ref -> Ref -> Ref
max :: Ref -> Ref -> Ref
$cmin :: Ref -> Ref -> Ref
min :: Ref -> Ref -> Ref
Ord, ReadPrec [Ref]
ReadPrec Ref
Int -> ReadS Ref
ReadS [Ref]
(Int -> ReadS Ref)
-> ReadS [Ref] -> ReadPrec Ref -> ReadPrec [Ref] -> Read Ref
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Ref
readsPrec :: Int -> ReadS Ref
$creadList :: ReadS [Ref]
readList :: ReadS [Ref]
$creadPrec :: ReadPrec Ref
readPrec :: ReadPrec Ref
$creadListPrec :: ReadPrec [Ref]
readListPrec :: ReadPrec [Ref]
Read, Int -> Ref -> String -> String
[Ref] -> String -> String
Ref -> String
(Int -> Ref -> String -> String)
-> (Ref -> String) -> ([Ref] -> String -> String) -> Show Ref
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Ref -> String -> String
showsPrec :: Int -> Ref -> String -> String
$cshow :: Ref -> String
show :: Ref -> String
$cshowList :: [Ref] -> String -> String
showList :: [Ref] -> String -> String
Show)

_Ref :: Name
_Ref = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Ref")

_Ref_name :: Name
_Ref_name = (String -> Name
Core.Name String
"name")

_Ref_init :: Name
_Ref_init = (String -> Name
Core.Name String
"init")

data Stat = 
  StatTerm Data |
  StatDecl Decl |
  StatDefn Defn |
  StatImportExport ImportExportStat
  deriving (Stat -> Stat -> Bool
(Stat -> Stat -> Bool) -> (Stat -> Stat -> Bool) -> Eq Stat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Stat -> Stat -> Bool
== :: Stat -> Stat -> Bool
$c/= :: Stat -> Stat -> Bool
/= :: Stat -> Stat -> Bool
Eq, Eq Stat
Eq Stat =>
(Stat -> Stat -> Ordering)
-> (Stat -> Stat -> Bool)
-> (Stat -> Stat -> Bool)
-> (Stat -> Stat -> Bool)
-> (Stat -> Stat -> Bool)
-> (Stat -> Stat -> Stat)
-> (Stat -> Stat -> Stat)
-> Ord Stat
Stat -> Stat -> Bool
Stat -> Stat -> Ordering
Stat -> Stat -> Stat
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Stat -> Stat -> Ordering
compare :: Stat -> Stat -> Ordering
$c< :: Stat -> Stat -> Bool
< :: Stat -> Stat -> Bool
$c<= :: Stat -> Stat -> Bool
<= :: Stat -> Stat -> Bool
$c> :: Stat -> Stat -> Bool
> :: Stat -> Stat -> Bool
$c>= :: Stat -> Stat -> Bool
>= :: Stat -> Stat -> Bool
$cmax :: Stat -> Stat -> Stat
max :: Stat -> Stat -> Stat
$cmin :: Stat -> Stat -> Stat
min :: Stat -> Stat -> Stat
Ord, ReadPrec [Stat]
ReadPrec Stat
Int -> ReadS Stat
ReadS [Stat]
(Int -> ReadS Stat)
-> ReadS [Stat] -> ReadPrec Stat -> ReadPrec [Stat] -> Read Stat
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Stat
readsPrec :: Int -> ReadS Stat
$creadList :: ReadS [Stat]
readList :: ReadS [Stat]
$creadPrec :: ReadPrec Stat
readPrec :: ReadPrec Stat
$creadListPrec :: ReadPrec [Stat]
readListPrec :: ReadPrec [Stat]
Read, Int -> Stat -> String -> String
[Stat] -> String -> String
Stat -> String
(Int -> Stat -> String -> String)
-> (Stat -> String) -> ([Stat] -> String -> String) -> Show Stat
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Stat -> String -> String
showsPrec :: Int -> Stat -> String -> String
$cshow :: Stat -> String
show :: Stat -> String
$cshowList :: [Stat] -> String -> String
showList :: [Stat] -> String -> String
Show)

_Stat :: Name
_Stat = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Stat")

_Stat_term :: Name
_Stat_term = (String -> Name
Core.Name String
"term")

_Stat_decl :: Name
_Stat_decl = (String -> Name
Core.Name String
"decl")

_Stat_defn :: Name
_Stat_defn = (String -> Name
Core.Name String
"defn")

_Stat_importExport :: Name
_Stat_importExport = (String -> Name
Core.Name String
"importExport")

data Name = 
  NameValue String |
  NameAnonymous  |
  NameIndeterminate PredefString
  deriving (Name -> Name -> Bool
(Name -> Name -> Bool) -> (Name -> Name -> Bool) -> Eq Name
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Name -> Name -> Bool
== :: Name -> Name -> Bool
$c/= :: Name -> Name -> Bool
/= :: Name -> Name -> Bool
Eq, Eq Name
Eq Name =>
(Name -> Name -> Ordering)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Bool)
-> (Name -> Name -> Name)
-> (Name -> Name -> Name)
-> Ord Name
Name -> Name -> Bool
Name -> Name -> Ordering
Name -> Name -> Name
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Name -> Name -> Ordering
compare :: Name -> Name -> Ordering
$c< :: Name -> Name -> Bool
< :: Name -> Name -> Bool
$c<= :: Name -> Name -> Bool
<= :: Name -> Name -> Bool
$c> :: Name -> Name -> Bool
> :: Name -> Name -> Bool
$c>= :: Name -> Name -> Bool
>= :: Name -> Name -> Bool
$cmax :: Name -> Name -> Name
max :: Name -> Name -> Name
$cmin :: Name -> Name -> Name
min :: Name -> Name -> Name
Ord, ReadPrec [Name]
ReadPrec Name
Int -> ReadS Name
ReadS [Name]
(Int -> ReadS Name)
-> ReadS [Name] -> ReadPrec Name -> ReadPrec [Name] -> Read Name
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Name
readsPrec :: Int -> ReadS Name
$creadList :: ReadS [Name]
readList :: ReadS [Name]
$creadPrec :: ReadPrec Name
readPrec :: ReadPrec Name
$creadListPrec :: ReadPrec [Name]
readListPrec :: ReadPrec [Name]
Read, Int -> Name -> String -> String
[Name] -> String -> String
Name -> String
(Int -> Name -> String -> String)
-> (Name -> String) -> ([Name] -> String -> String) -> Show Name
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Name -> String -> String
showsPrec :: Int -> Name -> String -> String
$cshow :: Name -> String
show :: Name -> String
$cshowList :: [Name] -> String -> String
showList :: [Name] -> String -> String
Show)

_Name :: Name
_Name = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Name")

_Name_value :: Name
_Name_value = (String -> Name
Core.Name String
"value")

_Name_anonymous :: Name
_Name_anonymous = (String -> Name
Core.Name String
"anonymous")

_Name_indeterminate :: Name
_Name_indeterminate = (String -> Name
Core.Name String
"indeterminate")

data Lit = 
  LitNull  |
  LitInt Int |
  LitDouble Double |
  LitFloat Float |
  LitByte Int8 |
  LitShort Int16 |
  LitChar Int |
  LitLong Int64 |
  LitBoolean Bool |
  LitUnit  |
  LitString String |
  LitSymbol ScalaSymbol
  deriving (Lit -> Lit -> Bool
(Lit -> Lit -> Bool) -> (Lit -> Lit -> Bool) -> Eq Lit
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Lit -> Lit -> Bool
== :: Lit -> Lit -> Bool
$c/= :: Lit -> Lit -> Bool
/= :: Lit -> Lit -> Bool
Eq, Eq Lit
Eq Lit =>
(Lit -> Lit -> Ordering)
-> (Lit -> Lit -> Bool)
-> (Lit -> Lit -> Bool)
-> (Lit -> Lit -> Bool)
-> (Lit -> Lit -> Bool)
-> (Lit -> Lit -> Lit)
-> (Lit -> Lit -> Lit)
-> Ord Lit
Lit -> Lit -> Bool
Lit -> Lit -> Ordering
Lit -> Lit -> Lit
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Lit -> Lit -> Ordering
compare :: Lit -> Lit -> Ordering
$c< :: Lit -> Lit -> Bool
< :: Lit -> Lit -> Bool
$c<= :: Lit -> Lit -> Bool
<= :: Lit -> Lit -> Bool
$c> :: Lit -> Lit -> Bool
> :: Lit -> Lit -> Bool
$c>= :: Lit -> Lit -> Bool
>= :: Lit -> Lit -> Bool
$cmax :: Lit -> Lit -> Lit
max :: Lit -> Lit -> Lit
$cmin :: Lit -> Lit -> Lit
min :: Lit -> Lit -> Lit
Ord, ReadPrec [Lit]
ReadPrec Lit
Int -> ReadS Lit
ReadS [Lit]
(Int -> ReadS Lit)
-> ReadS [Lit] -> ReadPrec Lit -> ReadPrec [Lit] -> Read Lit
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Lit
readsPrec :: Int -> ReadS Lit
$creadList :: ReadS [Lit]
readList :: ReadS [Lit]
$creadPrec :: ReadPrec Lit
readPrec :: ReadPrec Lit
$creadListPrec :: ReadPrec [Lit]
readListPrec :: ReadPrec [Lit]
Read, Int -> Lit -> String -> String
[Lit] -> String -> String
Lit -> String
(Int -> Lit -> String -> String)
-> (Lit -> String) -> ([Lit] -> String -> String) -> Show Lit
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Lit -> String -> String
showsPrec :: Int -> Lit -> String -> String
$cshow :: Lit -> String
show :: Lit -> String
$cshowList :: [Lit] -> String -> String
showList :: [Lit] -> String -> String
Show)

_Lit :: Name
_Lit = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Lit")

_Lit_null :: Name
_Lit_null = (String -> Name
Core.Name String
"null")

_Lit_int :: Name
_Lit_int = (String -> Name
Core.Name String
"int")

_Lit_double :: Name
_Lit_double = (String -> Name
Core.Name String
"double")

_Lit_float :: Name
_Lit_float = (String -> Name
Core.Name String
"float")

_Lit_byte :: Name
_Lit_byte = (String -> Name
Core.Name String
"byte")

_Lit_short :: Name
_Lit_short = (String -> Name
Core.Name String
"short")

_Lit_char :: Name
_Lit_char = (String -> Name
Core.Name String
"char")

_Lit_long :: Name
_Lit_long = (String -> Name
Core.Name String
"long")

_Lit_boolean :: Name
_Lit_boolean = (String -> Name
Core.Name String
"boolean")

_Lit_unit :: Name
_Lit_unit = (String -> Name
Core.Name String
"unit")

_Lit_string :: Name
_Lit_string = (String -> Name
Core.Name String
"string")

_Lit_symbol :: Name
_Lit_symbol = (String -> Name
Core.Name String
"symbol")

data Data = 
  DataLit Lit |
  DataRef Data_Ref |
  DataInterpolate Data_Interpolate |
  DataXml Data_Xml |
  DataApply Data_Apply |
  DataApplyUsing Data_ApplyUsing |
  DataApplyType Data_ApplyType |
  DataAssign Data_Assign |
  DataReturn Data_Return |
  DataThrow Data_Throw |
  DataAscribe Data_Ascribe |
  DataAnnotate Data_Annotate |
  DataTuple Data_Tuple |
  DataBlock Data_Block |
  DataEndMarker Data_EndMarker |
  DataIf Data_If |
  DataQuotedMacroExpr Data_QuotedMacroExpr |
  DataQuotedMacroType Data_QuotedMacroType |
  DataSplicedMacroExpr Data_SplicedMacroExpr |
  DataMatch Data_Match |
  DataTry Data_Try |
  DataTryWithHandler Data_TryWithHandler |
  DataFunctionData Data_FunctionData |
  DataPolyFunction Data_PolyFunction |
  DataPartialFunction Data_PartialFunction |
  DataWhile Data_While |
  DataDo Data_Do |
  DataFor Data_For |
  DataForYield Data_ForYield |
  DataNew Data_New |
  DataNewAnonymous Data_NewAnonymous |
  DataPlaceholder Data_Placeholder |
  DataEta Data_Eta |
  DataRepeated Data_Repeated |
  DataParam Data_Param
  deriving (Data -> Data -> Bool
(Data -> Data -> Bool) -> (Data -> Data -> Bool) -> Eq Data
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data -> Data -> Bool
== :: Data -> Data -> Bool
$c/= :: Data -> Data -> Bool
/= :: Data -> Data -> Bool
Eq, Eq Data
Eq Data =>
(Data -> Data -> Ordering)
-> (Data -> Data -> Bool)
-> (Data -> Data -> Bool)
-> (Data -> Data -> Bool)
-> (Data -> Data -> Bool)
-> (Data -> Data -> Data)
-> (Data -> Data -> Data)
-> Ord Data
Data -> Data -> Bool
Data -> Data -> Ordering
Data -> Data -> Data
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data -> Data -> Ordering
compare :: Data -> Data -> Ordering
$c< :: Data -> Data -> Bool
< :: Data -> Data -> Bool
$c<= :: Data -> Data -> Bool
<= :: Data -> Data -> Bool
$c> :: Data -> Data -> Bool
> :: Data -> Data -> Bool
$c>= :: Data -> Data -> Bool
>= :: Data -> Data -> Bool
$cmax :: Data -> Data -> Data
max :: Data -> Data -> Data
$cmin :: Data -> Data -> Data
min :: Data -> Data -> Data
Ord, ReadPrec [Data]
ReadPrec Data
Int -> ReadS Data
ReadS [Data]
(Int -> ReadS Data)
-> ReadS [Data] -> ReadPrec Data -> ReadPrec [Data] -> Read Data
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data
readsPrec :: Int -> ReadS Data
$creadList :: ReadS [Data]
readList :: ReadS [Data]
$creadPrec :: ReadPrec Data
readPrec :: ReadPrec Data
$creadListPrec :: ReadPrec [Data]
readListPrec :: ReadPrec [Data]
Read, Int -> Data -> String -> String
[Data] -> String -> String
Data -> String
(Int -> Data -> String -> String)
-> (Data -> String) -> ([Data] -> String -> String) -> Show Data
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data -> String -> String
showsPrec :: Int -> Data -> String -> String
$cshow :: Data -> String
show :: Data -> String
$cshowList :: [Data] -> String -> String
showList :: [Data] -> String -> String
Show)

_Data :: Name
_Data = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data")

_Data_lit :: Name
_Data_lit = (String -> Name
Core.Name String
"lit")

_Data_ref :: Name
_Data_ref = (String -> Name
Core.Name String
"ref")

_Data_interpolate :: Name
_Data_interpolate = (String -> Name
Core.Name String
"interpolate")

_Data_xml :: Name
_Data_xml = (String -> Name
Core.Name String
"xml")

_Data_apply :: Name
_Data_apply = (String -> Name
Core.Name String
"apply")

_Data_applyUsing :: Name
_Data_applyUsing = (String -> Name
Core.Name String
"applyUsing")

_Data_applyType :: Name
_Data_applyType = (String -> Name
Core.Name String
"applyType")

_Data_assign :: Name
_Data_assign = (String -> Name
Core.Name String
"assign")

_Data_return :: Name
_Data_return = (String -> Name
Core.Name String
"return")

_Data_throw :: Name
_Data_throw = (String -> Name
Core.Name String
"throw")

_Data_ascribe :: Name
_Data_ascribe = (String -> Name
Core.Name String
"ascribe")

_Data_annotate :: Name
_Data_annotate = (String -> Name
Core.Name String
"annotate")

_Data_tuple :: Name
_Data_tuple = (String -> Name
Core.Name String
"tuple")

_Data_block :: Name
_Data_block = (String -> Name
Core.Name String
"block")

_Data_endMarker :: Name
_Data_endMarker = (String -> Name
Core.Name String
"endMarker")

_Data_if :: Name
_Data_if = (String -> Name
Core.Name String
"if")

_Data_quotedMacroExpr :: Name
_Data_quotedMacroExpr = (String -> Name
Core.Name String
"quotedMacroExpr")

_Data_quotedMacroType :: Name
_Data_quotedMacroType = (String -> Name
Core.Name String
"quotedMacroType")

_Data_splicedMacroExpr :: Name
_Data_splicedMacroExpr = (String -> Name
Core.Name String
"splicedMacroExpr")

_Data_match :: Name
_Data_match = (String -> Name
Core.Name String
"match")

_Data_try :: Name
_Data_try = (String -> Name
Core.Name String
"try")

_Data_tryWithHandler :: Name
_Data_tryWithHandler = (String -> Name
Core.Name String
"tryWithHandler")

_Data_functionData :: Name
_Data_functionData = (String -> Name
Core.Name String
"functionData")

_Data_polyFunction :: Name
_Data_polyFunction = (String -> Name
Core.Name String
"polyFunction")

_Data_partialFunction :: Name
_Data_partialFunction = (String -> Name
Core.Name String
"partialFunction")

_Data_while :: Name
_Data_while = (String -> Name
Core.Name String
"while")

_Data_do :: Name
_Data_do = (String -> Name
Core.Name String
"do")

_Data_for :: Name
_Data_for = (String -> Name
Core.Name String
"for")

_Data_forYield :: Name
_Data_forYield = (String -> Name
Core.Name String
"forYield")

_Data_new :: Name
_Data_new = (String -> Name
Core.Name String
"new")

_Data_newAnonymous :: Name
_Data_newAnonymous = (String -> Name
Core.Name String
"newAnonymous")

_Data_placeholder :: Name
_Data_placeholder = (String -> Name
Core.Name String
"placeholder")

_Data_eta :: Name
_Data_eta = (String -> Name
Core.Name String
"eta")

_Data_repeated :: Name
_Data_repeated = (String -> Name
Core.Name String
"repeated")

_Data_param :: Name
_Data_param = (String -> Name
Core.Name String
"param")

data Data_Ref = 
  Data_RefThis Data_This |
  Data_RefSuper Data_Super |
  Data_RefName Data_Name |
  Data_RefAnonymous Data_Anonymous |
  Data_RefSelect Data_Select |
  Data_RefApplyUnary Data_ApplyUnary
  deriving (Data_Ref -> Data_Ref -> Bool
(Data_Ref -> Data_Ref -> Bool)
-> (Data_Ref -> Data_Ref -> Bool) -> Eq Data_Ref
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Ref -> Data_Ref -> Bool
== :: Data_Ref -> Data_Ref -> Bool
$c/= :: Data_Ref -> Data_Ref -> Bool
/= :: Data_Ref -> Data_Ref -> Bool
Eq, Eq Data_Ref
Eq Data_Ref =>
(Data_Ref -> Data_Ref -> Ordering)
-> (Data_Ref -> Data_Ref -> Bool)
-> (Data_Ref -> Data_Ref -> Bool)
-> (Data_Ref -> Data_Ref -> Bool)
-> (Data_Ref -> Data_Ref -> Bool)
-> (Data_Ref -> Data_Ref -> Data_Ref)
-> (Data_Ref -> Data_Ref -> Data_Ref)
-> Ord Data_Ref
Data_Ref -> Data_Ref -> Bool
Data_Ref -> Data_Ref -> Ordering
Data_Ref -> Data_Ref -> Data_Ref
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Ref -> Data_Ref -> Ordering
compare :: Data_Ref -> Data_Ref -> Ordering
$c< :: Data_Ref -> Data_Ref -> Bool
< :: Data_Ref -> Data_Ref -> Bool
$c<= :: Data_Ref -> Data_Ref -> Bool
<= :: Data_Ref -> Data_Ref -> Bool
$c> :: Data_Ref -> Data_Ref -> Bool
> :: Data_Ref -> Data_Ref -> Bool
$c>= :: Data_Ref -> Data_Ref -> Bool
>= :: Data_Ref -> Data_Ref -> Bool
$cmax :: Data_Ref -> Data_Ref -> Data_Ref
max :: Data_Ref -> Data_Ref -> Data_Ref
$cmin :: Data_Ref -> Data_Ref -> Data_Ref
min :: Data_Ref -> Data_Ref -> Data_Ref
Ord, ReadPrec [Data_Ref]
ReadPrec Data_Ref
Int -> ReadS Data_Ref
ReadS [Data_Ref]
(Int -> ReadS Data_Ref)
-> ReadS [Data_Ref]
-> ReadPrec Data_Ref
-> ReadPrec [Data_Ref]
-> Read Data_Ref
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Ref
readsPrec :: Int -> ReadS Data_Ref
$creadList :: ReadS [Data_Ref]
readList :: ReadS [Data_Ref]
$creadPrec :: ReadPrec Data_Ref
readPrec :: ReadPrec Data_Ref
$creadListPrec :: ReadPrec [Data_Ref]
readListPrec :: ReadPrec [Data_Ref]
Read, Int -> Data_Ref -> String -> String
[Data_Ref] -> String -> String
Data_Ref -> String
(Int -> Data_Ref -> String -> String)
-> (Data_Ref -> String)
-> ([Data_Ref] -> String -> String)
-> Show Data_Ref
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Ref -> String -> String
showsPrec :: Int -> Data_Ref -> String -> String
$cshow :: Data_Ref -> String
show :: Data_Ref -> String
$cshowList :: [Data_Ref] -> String -> String
showList :: [Data_Ref] -> String -> String
Show)

_Data_Ref :: Name
_Data_Ref = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Ref")

_Data_Ref_this :: Name
_Data_Ref_this = (String -> Name
Core.Name String
"this")

_Data_Ref_super :: Name
_Data_Ref_super = (String -> Name
Core.Name String
"super")

_Data_Ref_name :: Name
_Data_Ref_name = (String -> Name
Core.Name String
"name")

_Data_Ref_anonymous :: Name
_Data_Ref_anonymous = (String -> Name
Core.Name String
"anonymous")

_Data_Ref_select :: Name
_Data_Ref_select = (String -> Name
Core.Name String
"select")

_Data_Ref_applyUnary :: Name
_Data_Ref_applyUnary = (String -> Name
Core.Name String
"applyUnary")

data Data_This = 
  Data_This {}
  deriving (Data_This -> Data_This -> Bool
(Data_This -> Data_This -> Bool)
-> (Data_This -> Data_This -> Bool) -> Eq Data_This
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_This -> Data_This -> Bool
== :: Data_This -> Data_This -> Bool
$c/= :: Data_This -> Data_This -> Bool
/= :: Data_This -> Data_This -> Bool
Eq, Eq Data_This
Eq Data_This =>
(Data_This -> Data_This -> Ordering)
-> (Data_This -> Data_This -> Bool)
-> (Data_This -> Data_This -> Bool)
-> (Data_This -> Data_This -> Bool)
-> (Data_This -> Data_This -> Bool)
-> (Data_This -> Data_This -> Data_This)
-> (Data_This -> Data_This -> Data_This)
-> Ord Data_This
Data_This -> Data_This -> Bool
Data_This -> Data_This -> Ordering
Data_This -> Data_This -> Data_This
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_This -> Data_This -> Ordering
compare :: Data_This -> Data_This -> Ordering
$c< :: Data_This -> Data_This -> Bool
< :: Data_This -> Data_This -> Bool
$c<= :: Data_This -> Data_This -> Bool
<= :: Data_This -> Data_This -> Bool
$c> :: Data_This -> Data_This -> Bool
> :: Data_This -> Data_This -> Bool
$c>= :: Data_This -> Data_This -> Bool
>= :: Data_This -> Data_This -> Bool
$cmax :: Data_This -> Data_This -> Data_This
max :: Data_This -> Data_This -> Data_This
$cmin :: Data_This -> Data_This -> Data_This
min :: Data_This -> Data_This -> Data_This
Ord, ReadPrec [Data_This]
ReadPrec Data_This
Int -> ReadS Data_This
ReadS [Data_This]
(Int -> ReadS Data_This)
-> ReadS [Data_This]
-> ReadPrec Data_This
-> ReadPrec [Data_This]
-> Read Data_This
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_This
readsPrec :: Int -> ReadS Data_This
$creadList :: ReadS [Data_This]
readList :: ReadS [Data_This]
$creadPrec :: ReadPrec Data_This
readPrec :: ReadPrec Data_This
$creadListPrec :: ReadPrec [Data_This]
readListPrec :: ReadPrec [Data_This]
Read, Int -> Data_This -> String -> String
[Data_This] -> String -> String
Data_This -> String
(Int -> Data_This -> String -> String)
-> (Data_This -> String)
-> ([Data_This] -> String -> String)
-> Show Data_This
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_This -> String -> String
showsPrec :: Int -> Data_This -> String -> String
$cshow :: Data_This -> String
show :: Data_This -> String
$cshowList :: [Data_This] -> String -> String
showList :: [Data_This] -> String -> String
Show)

_Data_This :: Name
_Data_This = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.This")

data Data_Super = 
  Data_Super {
    Data_Super -> Name
data_SuperThisp :: Name,
    Data_Super -> Name
data_SuperSuperp :: Name}
  deriving (Data_Super -> Data_Super -> Bool
(Data_Super -> Data_Super -> Bool)
-> (Data_Super -> Data_Super -> Bool) -> Eq Data_Super
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Super -> Data_Super -> Bool
== :: Data_Super -> Data_Super -> Bool
$c/= :: Data_Super -> Data_Super -> Bool
/= :: Data_Super -> Data_Super -> Bool
Eq, Eq Data_Super
Eq Data_Super =>
(Data_Super -> Data_Super -> Ordering)
-> (Data_Super -> Data_Super -> Bool)
-> (Data_Super -> Data_Super -> Bool)
-> (Data_Super -> Data_Super -> Bool)
-> (Data_Super -> Data_Super -> Bool)
-> (Data_Super -> Data_Super -> Data_Super)
-> (Data_Super -> Data_Super -> Data_Super)
-> Ord Data_Super
Data_Super -> Data_Super -> Bool
Data_Super -> Data_Super -> Ordering
Data_Super -> Data_Super -> Data_Super
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Super -> Data_Super -> Ordering
compare :: Data_Super -> Data_Super -> Ordering
$c< :: Data_Super -> Data_Super -> Bool
< :: Data_Super -> Data_Super -> Bool
$c<= :: Data_Super -> Data_Super -> Bool
<= :: Data_Super -> Data_Super -> Bool
$c> :: Data_Super -> Data_Super -> Bool
> :: Data_Super -> Data_Super -> Bool
$c>= :: Data_Super -> Data_Super -> Bool
>= :: Data_Super -> Data_Super -> Bool
$cmax :: Data_Super -> Data_Super -> Data_Super
max :: Data_Super -> Data_Super -> Data_Super
$cmin :: Data_Super -> Data_Super -> Data_Super
min :: Data_Super -> Data_Super -> Data_Super
Ord, ReadPrec [Data_Super]
ReadPrec Data_Super
Int -> ReadS Data_Super
ReadS [Data_Super]
(Int -> ReadS Data_Super)
-> ReadS [Data_Super]
-> ReadPrec Data_Super
-> ReadPrec [Data_Super]
-> Read Data_Super
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Super
readsPrec :: Int -> ReadS Data_Super
$creadList :: ReadS [Data_Super]
readList :: ReadS [Data_Super]
$creadPrec :: ReadPrec Data_Super
readPrec :: ReadPrec Data_Super
$creadListPrec :: ReadPrec [Data_Super]
readListPrec :: ReadPrec [Data_Super]
Read, Int -> Data_Super -> String -> String
[Data_Super] -> String -> String
Data_Super -> String
(Int -> Data_Super -> String -> String)
-> (Data_Super -> String)
-> ([Data_Super] -> String -> String)
-> Show Data_Super
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Super -> String -> String
showsPrec :: Int -> Data_Super -> String -> String
$cshow :: Data_Super -> String
show :: Data_Super -> String
$cshowList :: [Data_Super] -> String -> String
showList :: [Data_Super] -> String -> String
Show)

_Data_Super :: Name
_Data_Super = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Super")

_Data_Super_thisp :: Name
_Data_Super_thisp = (String -> Name
Core.Name String
"thisp")

_Data_Super_superp :: Name
_Data_Super_superp = (String -> Name
Core.Name String
"superp")

data Data_Name = 
  Data_Name {
    Data_Name -> PredefString
data_NameValue :: PredefString}
  deriving (Data_Name -> Data_Name -> Bool
(Data_Name -> Data_Name -> Bool)
-> (Data_Name -> Data_Name -> Bool) -> Eq Data_Name
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Name -> Data_Name -> Bool
== :: Data_Name -> Data_Name -> Bool
$c/= :: Data_Name -> Data_Name -> Bool
/= :: Data_Name -> Data_Name -> Bool
Eq, Eq Data_Name
Eq Data_Name =>
(Data_Name -> Data_Name -> Ordering)
-> (Data_Name -> Data_Name -> Bool)
-> (Data_Name -> Data_Name -> Bool)
-> (Data_Name -> Data_Name -> Bool)
-> (Data_Name -> Data_Name -> Bool)
-> (Data_Name -> Data_Name -> Data_Name)
-> (Data_Name -> Data_Name -> Data_Name)
-> Ord Data_Name
Data_Name -> Data_Name -> Bool
Data_Name -> Data_Name -> Ordering
Data_Name -> Data_Name -> Data_Name
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Name -> Data_Name -> Ordering
compare :: Data_Name -> Data_Name -> Ordering
$c< :: Data_Name -> Data_Name -> Bool
< :: Data_Name -> Data_Name -> Bool
$c<= :: Data_Name -> Data_Name -> Bool
<= :: Data_Name -> Data_Name -> Bool
$c> :: Data_Name -> Data_Name -> Bool
> :: Data_Name -> Data_Name -> Bool
$c>= :: Data_Name -> Data_Name -> Bool
>= :: Data_Name -> Data_Name -> Bool
$cmax :: Data_Name -> Data_Name -> Data_Name
max :: Data_Name -> Data_Name -> Data_Name
$cmin :: Data_Name -> Data_Name -> Data_Name
min :: Data_Name -> Data_Name -> Data_Name
Ord, ReadPrec [Data_Name]
ReadPrec Data_Name
Int -> ReadS Data_Name
ReadS [Data_Name]
(Int -> ReadS Data_Name)
-> ReadS [Data_Name]
-> ReadPrec Data_Name
-> ReadPrec [Data_Name]
-> Read Data_Name
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Name
readsPrec :: Int -> ReadS Data_Name
$creadList :: ReadS [Data_Name]
readList :: ReadS [Data_Name]
$creadPrec :: ReadPrec Data_Name
readPrec :: ReadPrec Data_Name
$creadListPrec :: ReadPrec [Data_Name]
readListPrec :: ReadPrec [Data_Name]
Read, Int -> Data_Name -> String -> String
[Data_Name] -> String -> String
Data_Name -> String
(Int -> Data_Name -> String -> String)
-> (Data_Name -> String)
-> ([Data_Name] -> String -> String)
-> Show Data_Name
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Name -> String -> String
showsPrec :: Int -> Data_Name -> String -> String
$cshow :: Data_Name -> String
show :: Data_Name -> String
$cshowList :: [Data_Name] -> String -> String
showList :: [Data_Name] -> String -> String
Show)

_Data_Name :: Name
_Data_Name = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Name")

_Data_Name_value :: Name
_Data_Name_value = (String -> Name
Core.Name String
"value")

data Data_Anonymous = 
  Data_Anonymous {}
  deriving (Data_Anonymous -> Data_Anonymous -> Bool
(Data_Anonymous -> Data_Anonymous -> Bool)
-> (Data_Anonymous -> Data_Anonymous -> Bool) -> Eq Data_Anonymous
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Anonymous -> Data_Anonymous -> Bool
== :: Data_Anonymous -> Data_Anonymous -> Bool
$c/= :: Data_Anonymous -> Data_Anonymous -> Bool
/= :: Data_Anonymous -> Data_Anonymous -> Bool
Eq, Eq Data_Anonymous
Eq Data_Anonymous =>
(Data_Anonymous -> Data_Anonymous -> Ordering)
-> (Data_Anonymous -> Data_Anonymous -> Bool)
-> (Data_Anonymous -> Data_Anonymous -> Bool)
-> (Data_Anonymous -> Data_Anonymous -> Bool)
-> (Data_Anonymous -> Data_Anonymous -> Bool)
-> (Data_Anonymous -> Data_Anonymous -> Data_Anonymous)
-> (Data_Anonymous -> Data_Anonymous -> Data_Anonymous)
-> Ord Data_Anonymous
Data_Anonymous -> Data_Anonymous -> Bool
Data_Anonymous -> Data_Anonymous -> Ordering
Data_Anonymous -> Data_Anonymous -> Data_Anonymous
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Anonymous -> Data_Anonymous -> Ordering
compare :: Data_Anonymous -> Data_Anonymous -> Ordering
$c< :: Data_Anonymous -> Data_Anonymous -> Bool
< :: Data_Anonymous -> Data_Anonymous -> Bool
$c<= :: Data_Anonymous -> Data_Anonymous -> Bool
<= :: Data_Anonymous -> Data_Anonymous -> Bool
$c> :: Data_Anonymous -> Data_Anonymous -> Bool
> :: Data_Anonymous -> Data_Anonymous -> Bool
$c>= :: Data_Anonymous -> Data_Anonymous -> Bool
>= :: Data_Anonymous -> Data_Anonymous -> Bool
$cmax :: Data_Anonymous -> Data_Anonymous -> Data_Anonymous
max :: Data_Anonymous -> Data_Anonymous -> Data_Anonymous
$cmin :: Data_Anonymous -> Data_Anonymous -> Data_Anonymous
min :: Data_Anonymous -> Data_Anonymous -> Data_Anonymous
Ord, ReadPrec [Data_Anonymous]
ReadPrec Data_Anonymous
Int -> ReadS Data_Anonymous
ReadS [Data_Anonymous]
(Int -> ReadS Data_Anonymous)
-> ReadS [Data_Anonymous]
-> ReadPrec Data_Anonymous
-> ReadPrec [Data_Anonymous]
-> Read Data_Anonymous
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Anonymous
readsPrec :: Int -> ReadS Data_Anonymous
$creadList :: ReadS [Data_Anonymous]
readList :: ReadS [Data_Anonymous]
$creadPrec :: ReadPrec Data_Anonymous
readPrec :: ReadPrec Data_Anonymous
$creadListPrec :: ReadPrec [Data_Anonymous]
readListPrec :: ReadPrec [Data_Anonymous]
Read, Int -> Data_Anonymous -> String -> String
[Data_Anonymous] -> String -> String
Data_Anonymous -> String
(Int -> Data_Anonymous -> String -> String)
-> (Data_Anonymous -> String)
-> ([Data_Anonymous] -> String -> String)
-> Show Data_Anonymous
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Anonymous -> String -> String
showsPrec :: Int -> Data_Anonymous -> String -> String
$cshow :: Data_Anonymous -> String
show :: Data_Anonymous -> String
$cshowList :: [Data_Anonymous] -> String -> String
showList :: [Data_Anonymous] -> String -> String
Show)

_Data_Anonymous :: Name
_Data_Anonymous = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Anonymous")

data Data_Select = 
  Data_Select {
    Data_Select -> Data
data_SelectQual :: Data,
    Data_Select -> Data_Name
data_SelectName :: Data_Name}
  deriving (Data_Select -> Data_Select -> Bool
(Data_Select -> Data_Select -> Bool)
-> (Data_Select -> Data_Select -> Bool) -> Eq Data_Select
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Select -> Data_Select -> Bool
== :: Data_Select -> Data_Select -> Bool
$c/= :: Data_Select -> Data_Select -> Bool
/= :: Data_Select -> Data_Select -> Bool
Eq, Eq Data_Select
Eq Data_Select =>
(Data_Select -> Data_Select -> Ordering)
-> (Data_Select -> Data_Select -> Bool)
-> (Data_Select -> Data_Select -> Bool)
-> (Data_Select -> Data_Select -> Bool)
-> (Data_Select -> Data_Select -> Bool)
-> (Data_Select -> Data_Select -> Data_Select)
-> (Data_Select -> Data_Select -> Data_Select)
-> Ord Data_Select
Data_Select -> Data_Select -> Bool
Data_Select -> Data_Select -> Ordering
Data_Select -> Data_Select -> Data_Select
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Select -> Data_Select -> Ordering
compare :: Data_Select -> Data_Select -> Ordering
$c< :: Data_Select -> Data_Select -> Bool
< :: Data_Select -> Data_Select -> Bool
$c<= :: Data_Select -> Data_Select -> Bool
<= :: Data_Select -> Data_Select -> Bool
$c> :: Data_Select -> Data_Select -> Bool
> :: Data_Select -> Data_Select -> Bool
$c>= :: Data_Select -> Data_Select -> Bool
>= :: Data_Select -> Data_Select -> Bool
$cmax :: Data_Select -> Data_Select -> Data_Select
max :: Data_Select -> Data_Select -> Data_Select
$cmin :: Data_Select -> Data_Select -> Data_Select
min :: Data_Select -> Data_Select -> Data_Select
Ord, ReadPrec [Data_Select]
ReadPrec Data_Select
Int -> ReadS Data_Select
ReadS [Data_Select]
(Int -> ReadS Data_Select)
-> ReadS [Data_Select]
-> ReadPrec Data_Select
-> ReadPrec [Data_Select]
-> Read Data_Select
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Select
readsPrec :: Int -> ReadS Data_Select
$creadList :: ReadS [Data_Select]
readList :: ReadS [Data_Select]
$creadPrec :: ReadPrec Data_Select
readPrec :: ReadPrec Data_Select
$creadListPrec :: ReadPrec [Data_Select]
readListPrec :: ReadPrec [Data_Select]
Read, Int -> Data_Select -> String -> String
[Data_Select] -> String -> String
Data_Select -> String
(Int -> Data_Select -> String -> String)
-> (Data_Select -> String)
-> ([Data_Select] -> String -> String)
-> Show Data_Select
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Select -> String -> String
showsPrec :: Int -> Data_Select -> String -> String
$cshow :: Data_Select -> String
show :: Data_Select -> String
$cshowList :: [Data_Select] -> String -> String
showList :: [Data_Select] -> String -> String
Show)

_Data_Select :: Name
_Data_Select = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Select")

_Data_Select_qual :: Name
_Data_Select_qual = (String -> Name
Core.Name String
"qual")

_Data_Select_name :: Name
_Data_Select_name = (String -> Name
Core.Name String
"name")

data Data_Interpolate = 
  Data_Interpolate {
    Data_Interpolate -> Data_Name
data_InterpolatePrefix :: Data_Name,
    Data_Interpolate -> [Lit]
data_InterpolateParts :: [Lit],
    Data_Interpolate -> [Data]
data_InterpolateArgs :: [Data]}
  deriving (Data_Interpolate -> Data_Interpolate -> Bool
(Data_Interpolate -> Data_Interpolate -> Bool)
-> (Data_Interpolate -> Data_Interpolate -> Bool)
-> Eq Data_Interpolate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Interpolate -> Data_Interpolate -> Bool
== :: Data_Interpolate -> Data_Interpolate -> Bool
$c/= :: Data_Interpolate -> Data_Interpolate -> Bool
/= :: Data_Interpolate -> Data_Interpolate -> Bool
Eq, Eq Data_Interpolate
Eq Data_Interpolate =>
(Data_Interpolate -> Data_Interpolate -> Ordering)
-> (Data_Interpolate -> Data_Interpolate -> Bool)
-> (Data_Interpolate -> Data_Interpolate -> Bool)
-> (Data_Interpolate -> Data_Interpolate -> Bool)
-> (Data_Interpolate -> Data_Interpolate -> Bool)
-> (Data_Interpolate -> Data_Interpolate -> Data_Interpolate)
-> (Data_Interpolate -> Data_Interpolate -> Data_Interpolate)
-> Ord Data_Interpolate
Data_Interpolate -> Data_Interpolate -> Bool
Data_Interpolate -> Data_Interpolate -> Ordering
Data_Interpolate -> Data_Interpolate -> Data_Interpolate
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Interpolate -> Data_Interpolate -> Ordering
compare :: Data_Interpolate -> Data_Interpolate -> Ordering
$c< :: Data_Interpolate -> Data_Interpolate -> Bool
< :: Data_Interpolate -> Data_Interpolate -> Bool
$c<= :: Data_Interpolate -> Data_Interpolate -> Bool
<= :: Data_Interpolate -> Data_Interpolate -> Bool
$c> :: Data_Interpolate -> Data_Interpolate -> Bool
> :: Data_Interpolate -> Data_Interpolate -> Bool
$c>= :: Data_Interpolate -> Data_Interpolate -> Bool
>= :: Data_Interpolate -> Data_Interpolate -> Bool
$cmax :: Data_Interpolate -> Data_Interpolate -> Data_Interpolate
max :: Data_Interpolate -> Data_Interpolate -> Data_Interpolate
$cmin :: Data_Interpolate -> Data_Interpolate -> Data_Interpolate
min :: Data_Interpolate -> Data_Interpolate -> Data_Interpolate
Ord, ReadPrec [Data_Interpolate]
ReadPrec Data_Interpolate
Int -> ReadS Data_Interpolate
ReadS [Data_Interpolate]
(Int -> ReadS Data_Interpolate)
-> ReadS [Data_Interpolate]
-> ReadPrec Data_Interpolate
-> ReadPrec [Data_Interpolate]
-> Read Data_Interpolate
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Interpolate
readsPrec :: Int -> ReadS Data_Interpolate
$creadList :: ReadS [Data_Interpolate]
readList :: ReadS [Data_Interpolate]
$creadPrec :: ReadPrec Data_Interpolate
readPrec :: ReadPrec Data_Interpolate
$creadListPrec :: ReadPrec [Data_Interpolate]
readListPrec :: ReadPrec [Data_Interpolate]
Read, Int -> Data_Interpolate -> String -> String
[Data_Interpolate] -> String -> String
Data_Interpolate -> String
(Int -> Data_Interpolate -> String -> String)
-> (Data_Interpolate -> String)
-> ([Data_Interpolate] -> String -> String)
-> Show Data_Interpolate
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Interpolate -> String -> String
showsPrec :: Int -> Data_Interpolate -> String -> String
$cshow :: Data_Interpolate -> String
show :: Data_Interpolate -> String
$cshowList :: [Data_Interpolate] -> String -> String
showList :: [Data_Interpolate] -> String -> String
Show)

_Data_Interpolate :: Name
_Data_Interpolate = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Interpolate")

_Data_Interpolate_prefix :: Name
_Data_Interpolate_prefix = (String -> Name
Core.Name String
"prefix")

_Data_Interpolate_parts :: Name
_Data_Interpolate_parts = (String -> Name
Core.Name String
"parts")

_Data_Interpolate_args :: Name
_Data_Interpolate_args = (String -> Name
Core.Name String
"args")

data Data_Xml = 
  Data_Xml {
    Data_Xml -> [Lit]
data_XmlParts :: [Lit],
    Data_Xml -> [Data]
data_XmlArgs :: [Data]}
  deriving (Data_Xml -> Data_Xml -> Bool
(Data_Xml -> Data_Xml -> Bool)
-> (Data_Xml -> Data_Xml -> Bool) -> Eq Data_Xml
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Xml -> Data_Xml -> Bool
== :: Data_Xml -> Data_Xml -> Bool
$c/= :: Data_Xml -> Data_Xml -> Bool
/= :: Data_Xml -> Data_Xml -> Bool
Eq, Eq Data_Xml
Eq Data_Xml =>
(Data_Xml -> Data_Xml -> Ordering)
-> (Data_Xml -> Data_Xml -> Bool)
-> (Data_Xml -> Data_Xml -> Bool)
-> (Data_Xml -> Data_Xml -> Bool)
-> (Data_Xml -> Data_Xml -> Bool)
-> (Data_Xml -> Data_Xml -> Data_Xml)
-> (Data_Xml -> Data_Xml -> Data_Xml)
-> Ord Data_Xml
Data_Xml -> Data_Xml -> Bool
Data_Xml -> Data_Xml -> Ordering
Data_Xml -> Data_Xml -> Data_Xml
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Xml -> Data_Xml -> Ordering
compare :: Data_Xml -> Data_Xml -> Ordering
$c< :: Data_Xml -> Data_Xml -> Bool
< :: Data_Xml -> Data_Xml -> Bool
$c<= :: Data_Xml -> Data_Xml -> Bool
<= :: Data_Xml -> Data_Xml -> Bool
$c> :: Data_Xml -> Data_Xml -> Bool
> :: Data_Xml -> Data_Xml -> Bool
$c>= :: Data_Xml -> Data_Xml -> Bool
>= :: Data_Xml -> Data_Xml -> Bool
$cmax :: Data_Xml -> Data_Xml -> Data_Xml
max :: Data_Xml -> Data_Xml -> Data_Xml
$cmin :: Data_Xml -> Data_Xml -> Data_Xml
min :: Data_Xml -> Data_Xml -> Data_Xml
Ord, ReadPrec [Data_Xml]
ReadPrec Data_Xml
Int -> ReadS Data_Xml
ReadS [Data_Xml]
(Int -> ReadS Data_Xml)
-> ReadS [Data_Xml]
-> ReadPrec Data_Xml
-> ReadPrec [Data_Xml]
-> Read Data_Xml
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Xml
readsPrec :: Int -> ReadS Data_Xml
$creadList :: ReadS [Data_Xml]
readList :: ReadS [Data_Xml]
$creadPrec :: ReadPrec Data_Xml
readPrec :: ReadPrec Data_Xml
$creadListPrec :: ReadPrec [Data_Xml]
readListPrec :: ReadPrec [Data_Xml]
Read, Int -> Data_Xml -> String -> String
[Data_Xml] -> String -> String
Data_Xml -> String
(Int -> Data_Xml -> String -> String)
-> (Data_Xml -> String)
-> ([Data_Xml] -> String -> String)
-> Show Data_Xml
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Xml -> String -> String
showsPrec :: Int -> Data_Xml -> String -> String
$cshow :: Data_Xml -> String
show :: Data_Xml -> String
$cshowList :: [Data_Xml] -> String -> String
showList :: [Data_Xml] -> String -> String
Show)

_Data_Xml :: Name
_Data_Xml = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Xml")

_Data_Xml_parts :: Name
_Data_Xml_parts = (String -> Name
Core.Name String
"parts")

_Data_Xml_args :: Name
_Data_Xml_args = (String -> Name
Core.Name String
"args")

data Data_Apply = 
  Data_Apply {
    Data_Apply -> Data
data_ApplyFun :: Data,
    Data_Apply -> [Data]
data_ApplyArgs :: [Data]}
  deriving (Data_Apply -> Data_Apply -> Bool
(Data_Apply -> Data_Apply -> Bool)
-> (Data_Apply -> Data_Apply -> Bool) -> Eq Data_Apply
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Apply -> Data_Apply -> Bool
== :: Data_Apply -> Data_Apply -> Bool
$c/= :: Data_Apply -> Data_Apply -> Bool
/= :: Data_Apply -> Data_Apply -> Bool
Eq, Eq Data_Apply
Eq Data_Apply =>
(Data_Apply -> Data_Apply -> Ordering)
-> (Data_Apply -> Data_Apply -> Bool)
-> (Data_Apply -> Data_Apply -> Bool)
-> (Data_Apply -> Data_Apply -> Bool)
-> (Data_Apply -> Data_Apply -> Bool)
-> (Data_Apply -> Data_Apply -> Data_Apply)
-> (Data_Apply -> Data_Apply -> Data_Apply)
-> Ord Data_Apply
Data_Apply -> Data_Apply -> Bool
Data_Apply -> Data_Apply -> Ordering
Data_Apply -> Data_Apply -> Data_Apply
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Apply -> Data_Apply -> Ordering
compare :: Data_Apply -> Data_Apply -> Ordering
$c< :: Data_Apply -> Data_Apply -> Bool
< :: Data_Apply -> Data_Apply -> Bool
$c<= :: Data_Apply -> Data_Apply -> Bool
<= :: Data_Apply -> Data_Apply -> Bool
$c> :: Data_Apply -> Data_Apply -> Bool
> :: Data_Apply -> Data_Apply -> Bool
$c>= :: Data_Apply -> Data_Apply -> Bool
>= :: Data_Apply -> Data_Apply -> Bool
$cmax :: Data_Apply -> Data_Apply -> Data_Apply
max :: Data_Apply -> Data_Apply -> Data_Apply
$cmin :: Data_Apply -> Data_Apply -> Data_Apply
min :: Data_Apply -> Data_Apply -> Data_Apply
Ord, ReadPrec [Data_Apply]
ReadPrec Data_Apply
Int -> ReadS Data_Apply
ReadS [Data_Apply]
(Int -> ReadS Data_Apply)
-> ReadS [Data_Apply]
-> ReadPrec Data_Apply
-> ReadPrec [Data_Apply]
-> Read Data_Apply
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Apply
readsPrec :: Int -> ReadS Data_Apply
$creadList :: ReadS [Data_Apply]
readList :: ReadS [Data_Apply]
$creadPrec :: ReadPrec Data_Apply
readPrec :: ReadPrec Data_Apply
$creadListPrec :: ReadPrec [Data_Apply]
readListPrec :: ReadPrec [Data_Apply]
Read, Int -> Data_Apply -> String -> String
[Data_Apply] -> String -> String
Data_Apply -> String
(Int -> Data_Apply -> String -> String)
-> (Data_Apply -> String)
-> ([Data_Apply] -> String -> String)
-> Show Data_Apply
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Apply -> String -> String
showsPrec :: Int -> Data_Apply -> String -> String
$cshow :: Data_Apply -> String
show :: Data_Apply -> String
$cshowList :: [Data_Apply] -> String -> String
showList :: [Data_Apply] -> String -> String
Show)

_Data_Apply :: Name
_Data_Apply = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Apply")

_Data_Apply_fun :: Name
_Data_Apply_fun = (String -> Name
Core.Name String
"fun")

_Data_Apply_args :: Name
_Data_Apply_args = (String -> Name
Core.Name String
"args")

data Data_ApplyUsing = 
  Data_ApplyUsing {
    Data_ApplyUsing -> Data
data_ApplyUsingFun :: Data,
    Data_ApplyUsing -> [Data]
data_ApplyUsingTargs :: [Data]}
  deriving (Data_ApplyUsing -> Data_ApplyUsing -> Bool
(Data_ApplyUsing -> Data_ApplyUsing -> Bool)
-> (Data_ApplyUsing -> Data_ApplyUsing -> Bool)
-> Eq Data_ApplyUsing
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_ApplyUsing -> Data_ApplyUsing -> Bool
== :: Data_ApplyUsing -> Data_ApplyUsing -> Bool
$c/= :: Data_ApplyUsing -> Data_ApplyUsing -> Bool
/= :: Data_ApplyUsing -> Data_ApplyUsing -> Bool
Eq, Eq Data_ApplyUsing
Eq Data_ApplyUsing =>
(Data_ApplyUsing -> Data_ApplyUsing -> Ordering)
-> (Data_ApplyUsing -> Data_ApplyUsing -> Bool)
-> (Data_ApplyUsing -> Data_ApplyUsing -> Bool)
-> (Data_ApplyUsing -> Data_ApplyUsing -> Bool)
-> (Data_ApplyUsing -> Data_ApplyUsing -> Bool)
-> (Data_ApplyUsing -> Data_ApplyUsing -> Data_ApplyUsing)
-> (Data_ApplyUsing -> Data_ApplyUsing -> Data_ApplyUsing)
-> Ord Data_ApplyUsing
Data_ApplyUsing -> Data_ApplyUsing -> Bool
Data_ApplyUsing -> Data_ApplyUsing -> Ordering
Data_ApplyUsing -> Data_ApplyUsing -> Data_ApplyUsing
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_ApplyUsing -> Data_ApplyUsing -> Ordering
compare :: Data_ApplyUsing -> Data_ApplyUsing -> Ordering
$c< :: Data_ApplyUsing -> Data_ApplyUsing -> Bool
< :: Data_ApplyUsing -> Data_ApplyUsing -> Bool
$c<= :: Data_ApplyUsing -> Data_ApplyUsing -> Bool
<= :: Data_ApplyUsing -> Data_ApplyUsing -> Bool
$c> :: Data_ApplyUsing -> Data_ApplyUsing -> Bool
> :: Data_ApplyUsing -> Data_ApplyUsing -> Bool
$c>= :: Data_ApplyUsing -> Data_ApplyUsing -> Bool
>= :: Data_ApplyUsing -> Data_ApplyUsing -> Bool
$cmax :: Data_ApplyUsing -> Data_ApplyUsing -> Data_ApplyUsing
max :: Data_ApplyUsing -> Data_ApplyUsing -> Data_ApplyUsing
$cmin :: Data_ApplyUsing -> Data_ApplyUsing -> Data_ApplyUsing
min :: Data_ApplyUsing -> Data_ApplyUsing -> Data_ApplyUsing
Ord, ReadPrec [Data_ApplyUsing]
ReadPrec Data_ApplyUsing
Int -> ReadS Data_ApplyUsing
ReadS [Data_ApplyUsing]
(Int -> ReadS Data_ApplyUsing)
-> ReadS [Data_ApplyUsing]
-> ReadPrec Data_ApplyUsing
-> ReadPrec [Data_ApplyUsing]
-> Read Data_ApplyUsing
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_ApplyUsing
readsPrec :: Int -> ReadS Data_ApplyUsing
$creadList :: ReadS [Data_ApplyUsing]
readList :: ReadS [Data_ApplyUsing]
$creadPrec :: ReadPrec Data_ApplyUsing
readPrec :: ReadPrec Data_ApplyUsing
$creadListPrec :: ReadPrec [Data_ApplyUsing]
readListPrec :: ReadPrec [Data_ApplyUsing]
Read, Int -> Data_ApplyUsing -> String -> String
[Data_ApplyUsing] -> String -> String
Data_ApplyUsing -> String
(Int -> Data_ApplyUsing -> String -> String)
-> (Data_ApplyUsing -> String)
-> ([Data_ApplyUsing] -> String -> String)
-> Show Data_ApplyUsing
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_ApplyUsing -> String -> String
showsPrec :: Int -> Data_ApplyUsing -> String -> String
$cshow :: Data_ApplyUsing -> String
show :: Data_ApplyUsing -> String
$cshowList :: [Data_ApplyUsing] -> String -> String
showList :: [Data_ApplyUsing] -> String -> String
Show)

_Data_ApplyUsing :: Name
_Data_ApplyUsing = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.ApplyUsing")

_Data_ApplyUsing_fun :: Name
_Data_ApplyUsing_fun = (String -> Name
Core.Name String
"fun")

_Data_ApplyUsing_targs :: Name
_Data_ApplyUsing_targs = (String -> Name
Core.Name String
"targs")

data Data_ApplyType = 
  Data_ApplyType {
    Data_ApplyType -> Data
data_ApplyTypeLhs :: Data,
    Data_ApplyType -> Data_Name
data_ApplyTypeOp :: Data_Name,
    Data_ApplyType -> [Type]
data_ApplyTypeTargs :: [Type],
    Data_ApplyType -> [Data]
data_ApplyTypeArgs :: [Data]}
  deriving (Data_ApplyType -> Data_ApplyType -> Bool
(Data_ApplyType -> Data_ApplyType -> Bool)
-> (Data_ApplyType -> Data_ApplyType -> Bool) -> Eq Data_ApplyType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_ApplyType -> Data_ApplyType -> Bool
== :: Data_ApplyType -> Data_ApplyType -> Bool
$c/= :: Data_ApplyType -> Data_ApplyType -> Bool
/= :: Data_ApplyType -> Data_ApplyType -> Bool
Eq, Eq Data_ApplyType
Eq Data_ApplyType =>
(Data_ApplyType -> Data_ApplyType -> Ordering)
-> (Data_ApplyType -> Data_ApplyType -> Bool)
-> (Data_ApplyType -> Data_ApplyType -> Bool)
-> (Data_ApplyType -> Data_ApplyType -> Bool)
-> (Data_ApplyType -> Data_ApplyType -> Bool)
-> (Data_ApplyType -> Data_ApplyType -> Data_ApplyType)
-> (Data_ApplyType -> Data_ApplyType -> Data_ApplyType)
-> Ord Data_ApplyType
Data_ApplyType -> Data_ApplyType -> Bool
Data_ApplyType -> Data_ApplyType -> Ordering
Data_ApplyType -> Data_ApplyType -> Data_ApplyType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_ApplyType -> Data_ApplyType -> Ordering
compare :: Data_ApplyType -> Data_ApplyType -> Ordering
$c< :: Data_ApplyType -> Data_ApplyType -> Bool
< :: Data_ApplyType -> Data_ApplyType -> Bool
$c<= :: Data_ApplyType -> Data_ApplyType -> Bool
<= :: Data_ApplyType -> Data_ApplyType -> Bool
$c> :: Data_ApplyType -> Data_ApplyType -> Bool
> :: Data_ApplyType -> Data_ApplyType -> Bool
$c>= :: Data_ApplyType -> Data_ApplyType -> Bool
>= :: Data_ApplyType -> Data_ApplyType -> Bool
$cmax :: Data_ApplyType -> Data_ApplyType -> Data_ApplyType
max :: Data_ApplyType -> Data_ApplyType -> Data_ApplyType
$cmin :: Data_ApplyType -> Data_ApplyType -> Data_ApplyType
min :: Data_ApplyType -> Data_ApplyType -> Data_ApplyType
Ord, ReadPrec [Data_ApplyType]
ReadPrec Data_ApplyType
Int -> ReadS Data_ApplyType
ReadS [Data_ApplyType]
(Int -> ReadS Data_ApplyType)
-> ReadS [Data_ApplyType]
-> ReadPrec Data_ApplyType
-> ReadPrec [Data_ApplyType]
-> Read Data_ApplyType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_ApplyType
readsPrec :: Int -> ReadS Data_ApplyType
$creadList :: ReadS [Data_ApplyType]
readList :: ReadS [Data_ApplyType]
$creadPrec :: ReadPrec Data_ApplyType
readPrec :: ReadPrec Data_ApplyType
$creadListPrec :: ReadPrec [Data_ApplyType]
readListPrec :: ReadPrec [Data_ApplyType]
Read, Int -> Data_ApplyType -> String -> String
[Data_ApplyType] -> String -> String
Data_ApplyType -> String
(Int -> Data_ApplyType -> String -> String)
-> (Data_ApplyType -> String)
-> ([Data_ApplyType] -> String -> String)
-> Show Data_ApplyType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_ApplyType -> String -> String
showsPrec :: Int -> Data_ApplyType -> String -> String
$cshow :: Data_ApplyType -> String
show :: Data_ApplyType -> String
$cshowList :: [Data_ApplyType] -> String -> String
showList :: [Data_ApplyType] -> String -> String
Show)

_Data_ApplyType :: Name
_Data_ApplyType = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.ApplyType")

_Data_ApplyType_lhs :: Name
_Data_ApplyType_lhs = (String -> Name
Core.Name String
"lhs")

_Data_ApplyType_op :: Name
_Data_ApplyType_op = (String -> Name
Core.Name String
"op")

_Data_ApplyType_targs :: Name
_Data_ApplyType_targs = (String -> Name
Core.Name String
"targs")

_Data_ApplyType_args :: Name
_Data_ApplyType_args = (String -> Name
Core.Name String
"args")

data Data_ApplyInfix = 
  Data_ApplyInfix {
    Data_ApplyInfix -> Data
data_ApplyInfixLhs :: Data,
    Data_ApplyInfix -> Data_Name
data_ApplyInfixOp :: Data_Name,
    Data_ApplyInfix -> [Type]
data_ApplyInfixTargs :: [Type],
    Data_ApplyInfix -> [Data]
data_ApplyInfixArgs :: [Data]}
  deriving (Data_ApplyInfix -> Data_ApplyInfix -> Bool
(Data_ApplyInfix -> Data_ApplyInfix -> Bool)
-> (Data_ApplyInfix -> Data_ApplyInfix -> Bool)
-> Eq Data_ApplyInfix
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_ApplyInfix -> Data_ApplyInfix -> Bool
== :: Data_ApplyInfix -> Data_ApplyInfix -> Bool
$c/= :: Data_ApplyInfix -> Data_ApplyInfix -> Bool
/= :: Data_ApplyInfix -> Data_ApplyInfix -> Bool
Eq, Eq Data_ApplyInfix
Eq Data_ApplyInfix =>
(Data_ApplyInfix -> Data_ApplyInfix -> Ordering)
-> (Data_ApplyInfix -> Data_ApplyInfix -> Bool)
-> (Data_ApplyInfix -> Data_ApplyInfix -> Bool)
-> (Data_ApplyInfix -> Data_ApplyInfix -> Bool)
-> (Data_ApplyInfix -> Data_ApplyInfix -> Bool)
-> (Data_ApplyInfix -> Data_ApplyInfix -> Data_ApplyInfix)
-> (Data_ApplyInfix -> Data_ApplyInfix -> Data_ApplyInfix)
-> Ord Data_ApplyInfix
Data_ApplyInfix -> Data_ApplyInfix -> Bool
Data_ApplyInfix -> Data_ApplyInfix -> Ordering
Data_ApplyInfix -> Data_ApplyInfix -> Data_ApplyInfix
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_ApplyInfix -> Data_ApplyInfix -> Ordering
compare :: Data_ApplyInfix -> Data_ApplyInfix -> Ordering
$c< :: Data_ApplyInfix -> Data_ApplyInfix -> Bool
< :: Data_ApplyInfix -> Data_ApplyInfix -> Bool
$c<= :: Data_ApplyInfix -> Data_ApplyInfix -> Bool
<= :: Data_ApplyInfix -> Data_ApplyInfix -> Bool
$c> :: Data_ApplyInfix -> Data_ApplyInfix -> Bool
> :: Data_ApplyInfix -> Data_ApplyInfix -> Bool
$c>= :: Data_ApplyInfix -> Data_ApplyInfix -> Bool
>= :: Data_ApplyInfix -> Data_ApplyInfix -> Bool
$cmax :: Data_ApplyInfix -> Data_ApplyInfix -> Data_ApplyInfix
max :: Data_ApplyInfix -> Data_ApplyInfix -> Data_ApplyInfix
$cmin :: Data_ApplyInfix -> Data_ApplyInfix -> Data_ApplyInfix
min :: Data_ApplyInfix -> Data_ApplyInfix -> Data_ApplyInfix
Ord, ReadPrec [Data_ApplyInfix]
ReadPrec Data_ApplyInfix
Int -> ReadS Data_ApplyInfix
ReadS [Data_ApplyInfix]
(Int -> ReadS Data_ApplyInfix)
-> ReadS [Data_ApplyInfix]
-> ReadPrec Data_ApplyInfix
-> ReadPrec [Data_ApplyInfix]
-> Read Data_ApplyInfix
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_ApplyInfix
readsPrec :: Int -> ReadS Data_ApplyInfix
$creadList :: ReadS [Data_ApplyInfix]
readList :: ReadS [Data_ApplyInfix]
$creadPrec :: ReadPrec Data_ApplyInfix
readPrec :: ReadPrec Data_ApplyInfix
$creadListPrec :: ReadPrec [Data_ApplyInfix]
readListPrec :: ReadPrec [Data_ApplyInfix]
Read, Int -> Data_ApplyInfix -> String -> String
[Data_ApplyInfix] -> String -> String
Data_ApplyInfix -> String
(Int -> Data_ApplyInfix -> String -> String)
-> (Data_ApplyInfix -> String)
-> ([Data_ApplyInfix] -> String -> String)
-> Show Data_ApplyInfix
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_ApplyInfix -> String -> String
showsPrec :: Int -> Data_ApplyInfix -> String -> String
$cshow :: Data_ApplyInfix -> String
show :: Data_ApplyInfix -> String
$cshowList :: [Data_ApplyInfix] -> String -> String
showList :: [Data_ApplyInfix] -> String -> String
Show)

_Data_ApplyInfix :: Name
_Data_ApplyInfix = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.ApplyInfix")

_Data_ApplyInfix_lhs :: Name
_Data_ApplyInfix_lhs = (String -> Name
Core.Name String
"lhs")

_Data_ApplyInfix_op :: Name
_Data_ApplyInfix_op = (String -> Name
Core.Name String
"op")

_Data_ApplyInfix_targs :: Name
_Data_ApplyInfix_targs = (String -> Name
Core.Name String
"targs")

_Data_ApplyInfix_args :: Name
_Data_ApplyInfix_args = (String -> Name
Core.Name String
"args")

data Data_ApplyUnary = 
  Data_ApplyUnary {
    Data_ApplyUnary -> Data_Name
data_ApplyUnaryOp :: Data_Name,
    Data_ApplyUnary -> Data
data_ApplyUnaryArg :: Data}
  deriving (Data_ApplyUnary -> Data_ApplyUnary -> Bool
(Data_ApplyUnary -> Data_ApplyUnary -> Bool)
-> (Data_ApplyUnary -> Data_ApplyUnary -> Bool)
-> Eq Data_ApplyUnary
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_ApplyUnary -> Data_ApplyUnary -> Bool
== :: Data_ApplyUnary -> Data_ApplyUnary -> Bool
$c/= :: Data_ApplyUnary -> Data_ApplyUnary -> Bool
/= :: Data_ApplyUnary -> Data_ApplyUnary -> Bool
Eq, Eq Data_ApplyUnary
Eq Data_ApplyUnary =>
(Data_ApplyUnary -> Data_ApplyUnary -> Ordering)
-> (Data_ApplyUnary -> Data_ApplyUnary -> Bool)
-> (Data_ApplyUnary -> Data_ApplyUnary -> Bool)
-> (Data_ApplyUnary -> Data_ApplyUnary -> Bool)
-> (Data_ApplyUnary -> Data_ApplyUnary -> Bool)
-> (Data_ApplyUnary -> Data_ApplyUnary -> Data_ApplyUnary)
-> (Data_ApplyUnary -> Data_ApplyUnary -> Data_ApplyUnary)
-> Ord Data_ApplyUnary
Data_ApplyUnary -> Data_ApplyUnary -> Bool
Data_ApplyUnary -> Data_ApplyUnary -> Ordering
Data_ApplyUnary -> Data_ApplyUnary -> Data_ApplyUnary
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_ApplyUnary -> Data_ApplyUnary -> Ordering
compare :: Data_ApplyUnary -> Data_ApplyUnary -> Ordering
$c< :: Data_ApplyUnary -> Data_ApplyUnary -> Bool
< :: Data_ApplyUnary -> Data_ApplyUnary -> Bool
$c<= :: Data_ApplyUnary -> Data_ApplyUnary -> Bool
<= :: Data_ApplyUnary -> Data_ApplyUnary -> Bool
$c> :: Data_ApplyUnary -> Data_ApplyUnary -> Bool
> :: Data_ApplyUnary -> Data_ApplyUnary -> Bool
$c>= :: Data_ApplyUnary -> Data_ApplyUnary -> Bool
>= :: Data_ApplyUnary -> Data_ApplyUnary -> Bool
$cmax :: Data_ApplyUnary -> Data_ApplyUnary -> Data_ApplyUnary
max :: Data_ApplyUnary -> Data_ApplyUnary -> Data_ApplyUnary
$cmin :: Data_ApplyUnary -> Data_ApplyUnary -> Data_ApplyUnary
min :: Data_ApplyUnary -> Data_ApplyUnary -> Data_ApplyUnary
Ord, ReadPrec [Data_ApplyUnary]
ReadPrec Data_ApplyUnary
Int -> ReadS Data_ApplyUnary
ReadS [Data_ApplyUnary]
(Int -> ReadS Data_ApplyUnary)
-> ReadS [Data_ApplyUnary]
-> ReadPrec Data_ApplyUnary
-> ReadPrec [Data_ApplyUnary]
-> Read Data_ApplyUnary
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_ApplyUnary
readsPrec :: Int -> ReadS Data_ApplyUnary
$creadList :: ReadS [Data_ApplyUnary]
readList :: ReadS [Data_ApplyUnary]
$creadPrec :: ReadPrec Data_ApplyUnary
readPrec :: ReadPrec Data_ApplyUnary
$creadListPrec :: ReadPrec [Data_ApplyUnary]
readListPrec :: ReadPrec [Data_ApplyUnary]
Read, Int -> Data_ApplyUnary -> String -> String
[Data_ApplyUnary] -> String -> String
Data_ApplyUnary -> String
(Int -> Data_ApplyUnary -> String -> String)
-> (Data_ApplyUnary -> String)
-> ([Data_ApplyUnary] -> String -> String)
-> Show Data_ApplyUnary
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_ApplyUnary -> String -> String
showsPrec :: Int -> Data_ApplyUnary -> String -> String
$cshow :: Data_ApplyUnary -> String
show :: Data_ApplyUnary -> String
$cshowList :: [Data_ApplyUnary] -> String -> String
showList :: [Data_ApplyUnary] -> String -> String
Show)

_Data_ApplyUnary :: Name
_Data_ApplyUnary = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.ApplyUnary")

_Data_ApplyUnary_op :: Name
_Data_ApplyUnary_op = (String -> Name
Core.Name String
"op")

_Data_ApplyUnary_arg :: Name
_Data_ApplyUnary_arg = (String -> Name
Core.Name String
"arg")

data Data_Assign = 
  Data_Assign {
    Data_Assign -> Data
data_AssignLhs :: Data,
    Data_Assign -> Data
data_AssignRhs :: Data}
  deriving (Data_Assign -> Data_Assign -> Bool
(Data_Assign -> Data_Assign -> Bool)
-> (Data_Assign -> Data_Assign -> Bool) -> Eq Data_Assign
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Assign -> Data_Assign -> Bool
== :: Data_Assign -> Data_Assign -> Bool
$c/= :: Data_Assign -> Data_Assign -> Bool
/= :: Data_Assign -> Data_Assign -> Bool
Eq, Eq Data_Assign
Eq Data_Assign =>
(Data_Assign -> Data_Assign -> Ordering)
-> (Data_Assign -> Data_Assign -> Bool)
-> (Data_Assign -> Data_Assign -> Bool)
-> (Data_Assign -> Data_Assign -> Bool)
-> (Data_Assign -> Data_Assign -> Bool)
-> (Data_Assign -> Data_Assign -> Data_Assign)
-> (Data_Assign -> Data_Assign -> Data_Assign)
-> Ord Data_Assign
Data_Assign -> Data_Assign -> Bool
Data_Assign -> Data_Assign -> Ordering
Data_Assign -> Data_Assign -> Data_Assign
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Assign -> Data_Assign -> Ordering
compare :: Data_Assign -> Data_Assign -> Ordering
$c< :: Data_Assign -> Data_Assign -> Bool
< :: Data_Assign -> Data_Assign -> Bool
$c<= :: Data_Assign -> Data_Assign -> Bool
<= :: Data_Assign -> Data_Assign -> Bool
$c> :: Data_Assign -> Data_Assign -> Bool
> :: Data_Assign -> Data_Assign -> Bool
$c>= :: Data_Assign -> Data_Assign -> Bool
>= :: Data_Assign -> Data_Assign -> Bool
$cmax :: Data_Assign -> Data_Assign -> Data_Assign
max :: Data_Assign -> Data_Assign -> Data_Assign
$cmin :: Data_Assign -> Data_Assign -> Data_Assign
min :: Data_Assign -> Data_Assign -> Data_Assign
Ord, ReadPrec [Data_Assign]
ReadPrec Data_Assign
Int -> ReadS Data_Assign
ReadS [Data_Assign]
(Int -> ReadS Data_Assign)
-> ReadS [Data_Assign]
-> ReadPrec Data_Assign
-> ReadPrec [Data_Assign]
-> Read Data_Assign
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Assign
readsPrec :: Int -> ReadS Data_Assign
$creadList :: ReadS [Data_Assign]
readList :: ReadS [Data_Assign]
$creadPrec :: ReadPrec Data_Assign
readPrec :: ReadPrec Data_Assign
$creadListPrec :: ReadPrec [Data_Assign]
readListPrec :: ReadPrec [Data_Assign]
Read, Int -> Data_Assign -> String -> String
[Data_Assign] -> String -> String
Data_Assign -> String
(Int -> Data_Assign -> String -> String)
-> (Data_Assign -> String)
-> ([Data_Assign] -> String -> String)
-> Show Data_Assign
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Assign -> String -> String
showsPrec :: Int -> Data_Assign -> String -> String
$cshow :: Data_Assign -> String
show :: Data_Assign -> String
$cshowList :: [Data_Assign] -> String -> String
showList :: [Data_Assign] -> String -> String
Show)

_Data_Assign :: Name
_Data_Assign = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Assign")

_Data_Assign_lhs :: Name
_Data_Assign_lhs = (String -> Name
Core.Name String
"lhs")

_Data_Assign_rhs :: Name
_Data_Assign_rhs = (String -> Name
Core.Name String
"rhs")

data Data_Return = 
  Data_Return {
    Data_Return -> Data
data_ReturnExpr :: Data}
  deriving (Data_Return -> Data_Return -> Bool
(Data_Return -> Data_Return -> Bool)
-> (Data_Return -> Data_Return -> Bool) -> Eq Data_Return
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Return -> Data_Return -> Bool
== :: Data_Return -> Data_Return -> Bool
$c/= :: Data_Return -> Data_Return -> Bool
/= :: Data_Return -> Data_Return -> Bool
Eq, Eq Data_Return
Eq Data_Return =>
(Data_Return -> Data_Return -> Ordering)
-> (Data_Return -> Data_Return -> Bool)
-> (Data_Return -> Data_Return -> Bool)
-> (Data_Return -> Data_Return -> Bool)
-> (Data_Return -> Data_Return -> Bool)
-> (Data_Return -> Data_Return -> Data_Return)
-> (Data_Return -> Data_Return -> Data_Return)
-> Ord Data_Return
Data_Return -> Data_Return -> Bool
Data_Return -> Data_Return -> Ordering
Data_Return -> Data_Return -> Data_Return
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Return -> Data_Return -> Ordering
compare :: Data_Return -> Data_Return -> Ordering
$c< :: Data_Return -> Data_Return -> Bool
< :: Data_Return -> Data_Return -> Bool
$c<= :: Data_Return -> Data_Return -> Bool
<= :: Data_Return -> Data_Return -> Bool
$c> :: Data_Return -> Data_Return -> Bool
> :: Data_Return -> Data_Return -> Bool
$c>= :: Data_Return -> Data_Return -> Bool
>= :: Data_Return -> Data_Return -> Bool
$cmax :: Data_Return -> Data_Return -> Data_Return
max :: Data_Return -> Data_Return -> Data_Return
$cmin :: Data_Return -> Data_Return -> Data_Return
min :: Data_Return -> Data_Return -> Data_Return
Ord, ReadPrec [Data_Return]
ReadPrec Data_Return
Int -> ReadS Data_Return
ReadS [Data_Return]
(Int -> ReadS Data_Return)
-> ReadS [Data_Return]
-> ReadPrec Data_Return
-> ReadPrec [Data_Return]
-> Read Data_Return
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Return
readsPrec :: Int -> ReadS Data_Return
$creadList :: ReadS [Data_Return]
readList :: ReadS [Data_Return]
$creadPrec :: ReadPrec Data_Return
readPrec :: ReadPrec Data_Return
$creadListPrec :: ReadPrec [Data_Return]
readListPrec :: ReadPrec [Data_Return]
Read, Int -> Data_Return -> String -> String
[Data_Return] -> String -> String
Data_Return -> String
(Int -> Data_Return -> String -> String)
-> (Data_Return -> String)
-> ([Data_Return] -> String -> String)
-> Show Data_Return
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Return -> String -> String
showsPrec :: Int -> Data_Return -> String -> String
$cshow :: Data_Return -> String
show :: Data_Return -> String
$cshowList :: [Data_Return] -> String -> String
showList :: [Data_Return] -> String -> String
Show)

_Data_Return :: Name
_Data_Return = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Return")

_Data_Return_expr :: Name
_Data_Return_expr = (String -> Name
Core.Name String
"expr")

data Data_Throw = 
  Data_Throw {
    Data_Throw -> Data
data_ThrowExpr :: Data}
  deriving (Data_Throw -> Data_Throw -> Bool
(Data_Throw -> Data_Throw -> Bool)
-> (Data_Throw -> Data_Throw -> Bool) -> Eq Data_Throw
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Throw -> Data_Throw -> Bool
== :: Data_Throw -> Data_Throw -> Bool
$c/= :: Data_Throw -> Data_Throw -> Bool
/= :: Data_Throw -> Data_Throw -> Bool
Eq, Eq Data_Throw
Eq Data_Throw =>
(Data_Throw -> Data_Throw -> Ordering)
-> (Data_Throw -> Data_Throw -> Bool)
-> (Data_Throw -> Data_Throw -> Bool)
-> (Data_Throw -> Data_Throw -> Bool)
-> (Data_Throw -> Data_Throw -> Bool)
-> (Data_Throw -> Data_Throw -> Data_Throw)
-> (Data_Throw -> Data_Throw -> Data_Throw)
-> Ord Data_Throw
Data_Throw -> Data_Throw -> Bool
Data_Throw -> Data_Throw -> Ordering
Data_Throw -> Data_Throw -> Data_Throw
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Throw -> Data_Throw -> Ordering
compare :: Data_Throw -> Data_Throw -> Ordering
$c< :: Data_Throw -> Data_Throw -> Bool
< :: Data_Throw -> Data_Throw -> Bool
$c<= :: Data_Throw -> Data_Throw -> Bool
<= :: Data_Throw -> Data_Throw -> Bool
$c> :: Data_Throw -> Data_Throw -> Bool
> :: Data_Throw -> Data_Throw -> Bool
$c>= :: Data_Throw -> Data_Throw -> Bool
>= :: Data_Throw -> Data_Throw -> Bool
$cmax :: Data_Throw -> Data_Throw -> Data_Throw
max :: Data_Throw -> Data_Throw -> Data_Throw
$cmin :: Data_Throw -> Data_Throw -> Data_Throw
min :: Data_Throw -> Data_Throw -> Data_Throw
Ord, ReadPrec [Data_Throw]
ReadPrec Data_Throw
Int -> ReadS Data_Throw
ReadS [Data_Throw]
(Int -> ReadS Data_Throw)
-> ReadS [Data_Throw]
-> ReadPrec Data_Throw
-> ReadPrec [Data_Throw]
-> Read Data_Throw
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Throw
readsPrec :: Int -> ReadS Data_Throw
$creadList :: ReadS [Data_Throw]
readList :: ReadS [Data_Throw]
$creadPrec :: ReadPrec Data_Throw
readPrec :: ReadPrec Data_Throw
$creadListPrec :: ReadPrec [Data_Throw]
readListPrec :: ReadPrec [Data_Throw]
Read, Int -> Data_Throw -> String -> String
[Data_Throw] -> String -> String
Data_Throw -> String
(Int -> Data_Throw -> String -> String)
-> (Data_Throw -> String)
-> ([Data_Throw] -> String -> String)
-> Show Data_Throw
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Throw -> String -> String
showsPrec :: Int -> Data_Throw -> String -> String
$cshow :: Data_Throw -> String
show :: Data_Throw -> String
$cshowList :: [Data_Throw] -> String -> String
showList :: [Data_Throw] -> String -> String
Show)

_Data_Throw :: Name
_Data_Throw = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Throw")

_Data_Throw_expr :: Name
_Data_Throw_expr = (String -> Name
Core.Name String
"expr")

data Data_Ascribe = 
  Data_Ascribe {
    Data_Ascribe -> Data
data_AscribeExpr :: Data,
    Data_Ascribe -> Type
data_AscribeTpe :: Type}
  deriving (Data_Ascribe -> Data_Ascribe -> Bool
(Data_Ascribe -> Data_Ascribe -> Bool)
-> (Data_Ascribe -> Data_Ascribe -> Bool) -> Eq Data_Ascribe
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Ascribe -> Data_Ascribe -> Bool
== :: Data_Ascribe -> Data_Ascribe -> Bool
$c/= :: Data_Ascribe -> Data_Ascribe -> Bool
/= :: Data_Ascribe -> Data_Ascribe -> Bool
Eq, Eq Data_Ascribe
Eq Data_Ascribe =>
(Data_Ascribe -> Data_Ascribe -> Ordering)
-> (Data_Ascribe -> Data_Ascribe -> Bool)
-> (Data_Ascribe -> Data_Ascribe -> Bool)
-> (Data_Ascribe -> Data_Ascribe -> Bool)
-> (Data_Ascribe -> Data_Ascribe -> Bool)
-> (Data_Ascribe -> Data_Ascribe -> Data_Ascribe)
-> (Data_Ascribe -> Data_Ascribe -> Data_Ascribe)
-> Ord Data_Ascribe
Data_Ascribe -> Data_Ascribe -> Bool
Data_Ascribe -> Data_Ascribe -> Ordering
Data_Ascribe -> Data_Ascribe -> Data_Ascribe
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Ascribe -> Data_Ascribe -> Ordering
compare :: Data_Ascribe -> Data_Ascribe -> Ordering
$c< :: Data_Ascribe -> Data_Ascribe -> Bool
< :: Data_Ascribe -> Data_Ascribe -> Bool
$c<= :: Data_Ascribe -> Data_Ascribe -> Bool
<= :: Data_Ascribe -> Data_Ascribe -> Bool
$c> :: Data_Ascribe -> Data_Ascribe -> Bool
> :: Data_Ascribe -> Data_Ascribe -> Bool
$c>= :: Data_Ascribe -> Data_Ascribe -> Bool
>= :: Data_Ascribe -> Data_Ascribe -> Bool
$cmax :: Data_Ascribe -> Data_Ascribe -> Data_Ascribe
max :: Data_Ascribe -> Data_Ascribe -> Data_Ascribe
$cmin :: Data_Ascribe -> Data_Ascribe -> Data_Ascribe
min :: Data_Ascribe -> Data_Ascribe -> Data_Ascribe
Ord, ReadPrec [Data_Ascribe]
ReadPrec Data_Ascribe
Int -> ReadS Data_Ascribe
ReadS [Data_Ascribe]
(Int -> ReadS Data_Ascribe)
-> ReadS [Data_Ascribe]
-> ReadPrec Data_Ascribe
-> ReadPrec [Data_Ascribe]
-> Read Data_Ascribe
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Ascribe
readsPrec :: Int -> ReadS Data_Ascribe
$creadList :: ReadS [Data_Ascribe]
readList :: ReadS [Data_Ascribe]
$creadPrec :: ReadPrec Data_Ascribe
readPrec :: ReadPrec Data_Ascribe
$creadListPrec :: ReadPrec [Data_Ascribe]
readListPrec :: ReadPrec [Data_Ascribe]
Read, Int -> Data_Ascribe -> String -> String
[Data_Ascribe] -> String -> String
Data_Ascribe -> String
(Int -> Data_Ascribe -> String -> String)
-> (Data_Ascribe -> String)
-> ([Data_Ascribe] -> String -> String)
-> Show Data_Ascribe
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Ascribe -> String -> String
showsPrec :: Int -> Data_Ascribe -> String -> String
$cshow :: Data_Ascribe -> String
show :: Data_Ascribe -> String
$cshowList :: [Data_Ascribe] -> String -> String
showList :: [Data_Ascribe] -> String -> String
Show)

_Data_Ascribe :: Name
_Data_Ascribe = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Ascribe")

_Data_Ascribe_expr :: Name
_Data_Ascribe_expr = (String -> Name
Core.Name String
"expr")

_Data_Ascribe_tpe :: Name
_Data_Ascribe_tpe = (String -> Name
Core.Name String
"tpe")

data Data_Annotate = 
  Data_Annotate {
    Data_Annotate -> Data
data_AnnotateExpr :: Data,
    Data_Annotate -> [Mod_Annot]
data_AnnotateAnnots :: [Mod_Annot]}
  deriving (Data_Annotate -> Data_Annotate -> Bool
(Data_Annotate -> Data_Annotate -> Bool)
-> (Data_Annotate -> Data_Annotate -> Bool) -> Eq Data_Annotate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Annotate -> Data_Annotate -> Bool
== :: Data_Annotate -> Data_Annotate -> Bool
$c/= :: Data_Annotate -> Data_Annotate -> Bool
/= :: Data_Annotate -> Data_Annotate -> Bool
Eq, Eq Data_Annotate
Eq Data_Annotate =>
(Data_Annotate -> Data_Annotate -> Ordering)
-> (Data_Annotate -> Data_Annotate -> Bool)
-> (Data_Annotate -> Data_Annotate -> Bool)
-> (Data_Annotate -> Data_Annotate -> Bool)
-> (Data_Annotate -> Data_Annotate -> Bool)
-> (Data_Annotate -> Data_Annotate -> Data_Annotate)
-> (Data_Annotate -> Data_Annotate -> Data_Annotate)
-> Ord Data_Annotate
Data_Annotate -> Data_Annotate -> Bool
Data_Annotate -> Data_Annotate -> Ordering
Data_Annotate -> Data_Annotate -> Data_Annotate
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Annotate -> Data_Annotate -> Ordering
compare :: Data_Annotate -> Data_Annotate -> Ordering
$c< :: Data_Annotate -> Data_Annotate -> Bool
< :: Data_Annotate -> Data_Annotate -> Bool
$c<= :: Data_Annotate -> Data_Annotate -> Bool
<= :: Data_Annotate -> Data_Annotate -> Bool
$c> :: Data_Annotate -> Data_Annotate -> Bool
> :: Data_Annotate -> Data_Annotate -> Bool
$c>= :: Data_Annotate -> Data_Annotate -> Bool
>= :: Data_Annotate -> Data_Annotate -> Bool
$cmax :: Data_Annotate -> Data_Annotate -> Data_Annotate
max :: Data_Annotate -> Data_Annotate -> Data_Annotate
$cmin :: Data_Annotate -> Data_Annotate -> Data_Annotate
min :: Data_Annotate -> Data_Annotate -> Data_Annotate
Ord, ReadPrec [Data_Annotate]
ReadPrec Data_Annotate
Int -> ReadS Data_Annotate
ReadS [Data_Annotate]
(Int -> ReadS Data_Annotate)
-> ReadS [Data_Annotate]
-> ReadPrec Data_Annotate
-> ReadPrec [Data_Annotate]
-> Read Data_Annotate
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Annotate
readsPrec :: Int -> ReadS Data_Annotate
$creadList :: ReadS [Data_Annotate]
readList :: ReadS [Data_Annotate]
$creadPrec :: ReadPrec Data_Annotate
readPrec :: ReadPrec Data_Annotate
$creadListPrec :: ReadPrec [Data_Annotate]
readListPrec :: ReadPrec [Data_Annotate]
Read, Int -> Data_Annotate -> String -> String
[Data_Annotate] -> String -> String
Data_Annotate -> String
(Int -> Data_Annotate -> String -> String)
-> (Data_Annotate -> String)
-> ([Data_Annotate] -> String -> String)
-> Show Data_Annotate
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Annotate -> String -> String
showsPrec :: Int -> Data_Annotate -> String -> String
$cshow :: Data_Annotate -> String
show :: Data_Annotate -> String
$cshowList :: [Data_Annotate] -> String -> String
showList :: [Data_Annotate] -> String -> String
Show)

_Data_Annotate :: Name
_Data_Annotate = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Annotate")

_Data_Annotate_expr :: Name
_Data_Annotate_expr = (String -> Name
Core.Name String
"expr")

_Data_Annotate_annots :: Name
_Data_Annotate_annots = (String -> Name
Core.Name String
"annots")

data Data_Tuple = 
  Data_Tuple {
    Data_Tuple -> [Data]
data_TupleArgs :: [Data]}
  deriving (Data_Tuple -> Data_Tuple -> Bool
(Data_Tuple -> Data_Tuple -> Bool)
-> (Data_Tuple -> Data_Tuple -> Bool) -> Eq Data_Tuple
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Tuple -> Data_Tuple -> Bool
== :: Data_Tuple -> Data_Tuple -> Bool
$c/= :: Data_Tuple -> Data_Tuple -> Bool
/= :: Data_Tuple -> Data_Tuple -> Bool
Eq, Eq Data_Tuple
Eq Data_Tuple =>
(Data_Tuple -> Data_Tuple -> Ordering)
-> (Data_Tuple -> Data_Tuple -> Bool)
-> (Data_Tuple -> Data_Tuple -> Bool)
-> (Data_Tuple -> Data_Tuple -> Bool)
-> (Data_Tuple -> Data_Tuple -> Bool)
-> (Data_Tuple -> Data_Tuple -> Data_Tuple)
-> (Data_Tuple -> Data_Tuple -> Data_Tuple)
-> Ord Data_Tuple
Data_Tuple -> Data_Tuple -> Bool
Data_Tuple -> Data_Tuple -> Ordering
Data_Tuple -> Data_Tuple -> Data_Tuple
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Tuple -> Data_Tuple -> Ordering
compare :: Data_Tuple -> Data_Tuple -> Ordering
$c< :: Data_Tuple -> Data_Tuple -> Bool
< :: Data_Tuple -> Data_Tuple -> Bool
$c<= :: Data_Tuple -> Data_Tuple -> Bool
<= :: Data_Tuple -> Data_Tuple -> Bool
$c> :: Data_Tuple -> Data_Tuple -> Bool
> :: Data_Tuple -> Data_Tuple -> Bool
$c>= :: Data_Tuple -> Data_Tuple -> Bool
>= :: Data_Tuple -> Data_Tuple -> Bool
$cmax :: Data_Tuple -> Data_Tuple -> Data_Tuple
max :: Data_Tuple -> Data_Tuple -> Data_Tuple
$cmin :: Data_Tuple -> Data_Tuple -> Data_Tuple
min :: Data_Tuple -> Data_Tuple -> Data_Tuple
Ord, ReadPrec [Data_Tuple]
ReadPrec Data_Tuple
Int -> ReadS Data_Tuple
ReadS [Data_Tuple]
(Int -> ReadS Data_Tuple)
-> ReadS [Data_Tuple]
-> ReadPrec Data_Tuple
-> ReadPrec [Data_Tuple]
-> Read Data_Tuple
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Tuple
readsPrec :: Int -> ReadS Data_Tuple
$creadList :: ReadS [Data_Tuple]
readList :: ReadS [Data_Tuple]
$creadPrec :: ReadPrec Data_Tuple
readPrec :: ReadPrec Data_Tuple
$creadListPrec :: ReadPrec [Data_Tuple]
readListPrec :: ReadPrec [Data_Tuple]
Read, Int -> Data_Tuple -> String -> String
[Data_Tuple] -> String -> String
Data_Tuple -> String
(Int -> Data_Tuple -> String -> String)
-> (Data_Tuple -> String)
-> ([Data_Tuple] -> String -> String)
-> Show Data_Tuple
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Tuple -> String -> String
showsPrec :: Int -> Data_Tuple -> String -> String
$cshow :: Data_Tuple -> String
show :: Data_Tuple -> String
$cshowList :: [Data_Tuple] -> String -> String
showList :: [Data_Tuple] -> String -> String
Show)

_Data_Tuple :: Name
_Data_Tuple = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Tuple")

_Data_Tuple_args :: Name
_Data_Tuple_args = (String -> Name
Core.Name String
"args")

data Data_Block = 
  Data_Block {
    Data_Block -> [Stat]
data_BlockStats :: [Stat]}
  deriving (Data_Block -> Data_Block -> Bool
(Data_Block -> Data_Block -> Bool)
-> (Data_Block -> Data_Block -> Bool) -> Eq Data_Block
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Block -> Data_Block -> Bool
== :: Data_Block -> Data_Block -> Bool
$c/= :: Data_Block -> Data_Block -> Bool
/= :: Data_Block -> Data_Block -> Bool
Eq, Eq Data_Block
Eq Data_Block =>
(Data_Block -> Data_Block -> Ordering)
-> (Data_Block -> Data_Block -> Bool)
-> (Data_Block -> Data_Block -> Bool)
-> (Data_Block -> Data_Block -> Bool)
-> (Data_Block -> Data_Block -> Bool)
-> (Data_Block -> Data_Block -> Data_Block)
-> (Data_Block -> Data_Block -> Data_Block)
-> Ord Data_Block
Data_Block -> Data_Block -> Bool
Data_Block -> Data_Block -> Ordering
Data_Block -> Data_Block -> Data_Block
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Block -> Data_Block -> Ordering
compare :: Data_Block -> Data_Block -> Ordering
$c< :: Data_Block -> Data_Block -> Bool
< :: Data_Block -> Data_Block -> Bool
$c<= :: Data_Block -> Data_Block -> Bool
<= :: Data_Block -> Data_Block -> Bool
$c> :: Data_Block -> Data_Block -> Bool
> :: Data_Block -> Data_Block -> Bool
$c>= :: Data_Block -> Data_Block -> Bool
>= :: Data_Block -> Data_Block -> Bool
$cmax :: Data_Block -> Data_Block -> Data_Block
max :: Data_Block -> Data_Block -> Data_Block
$cmin :: Data_Block -> Data_Block -> Data_Block
min :: Data_Block -> Data_Block -> Data_Block
Ord, ReadPrec [Data_Block]
ReadPrec Data_Block
Int -> ReadS Data_Block
ReadS [Data_Block]
(Int -> ReadS Data_Block)
-> ReadS [Data_Block]
-> ReadPrec Data_Block
-> ReadPrec [Data_Block]
-> Read Data_Block
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Block
readsPrec :: Int -> ReadS Data_Block
$creadList :: ReadS [Data_Block]
readList :: ReadS [Data_Block]
$creadPrec :: ReadPrec Data_Block
readPrec :: ReadPrec Data_Block
$creadListPrec :: ReadPrec [Data_Block]
readListPrec :: ReadPrec [Data_Block]
Read, Int -> Data_Block -> String -> String
[Data_Block] -> String -> String
Data_Block -> String
(Int -> Data_Block -> String -> String)
-> (Data_Block -> String)
-> ([Data_Block] -> String -> String)
-> Show Data_Block
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Block -> String -> String
showsPrec :: Int -> Data_Block -> String -> String
$cshow :: Data_Block -> String
show :: Data_Block -> String
$cshowList :: [Data_Block] -> String -> String
showList :: [Data_Block] -> String -> String
Show)

_Data_Block :: Name
_Data_Block = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Block")

_Data_Block_stats :: Name
_Data_Block_stats = (String -> Name
Core.Name String
"stats")

data Data_EndMarker = 
  Data_EndMarker {
    Data_EndMarker -> Data_Name
data_EndMarkerName :: Data_Name}
  deriving (Data_EndMarker -> Data_EndMarker -> Bool
(Data_EndMarker -> Data_EndMarker -> Bool)
-> (Data_EndMarker -> Data_EndMarker -> Bool) -> Eq Data_EndMarker
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_EndMarker -> Data_EndMarker -> Bool
== :: Data_EndMarker -> Data_EndMarker -> Bool
$c/= :: Data_EndMarker -> Data_EndMarker -> Bool
/= :: Data_EndMarker -> Data_EndMarker -> Bool
Eq, Eq Data_EndMarker
Eq Data_EndMarker =>
(Data_EndMarker -> Data_EndMarker -> Ordering)
-> (Data_EndMarker -> Data_EndMarker -> Bool)
-> (Data_EndMarker -> Data_EndMarker -> Bool)
-> (Data_EndMarker -> Data_EndMarker -> Bool)
-> (Data_EndMarker -> Data_EndMarker -> Bool)
-> (Data_EndMarker -> Data_EndMarker -> Data_EndMarker)
-> (Data_EndMarker -> Data_EndMarker -> Data_EndMarker)
-> Ord Data_EndMarker
Data_EndMarker -> Data_EndMarker -> Bool
Data_EndMarker -> Data_EndMarker -> Ordering
Data_EndMarker -> Data_EndMarker -> Data_EndMarker
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_EndMarker -> Data_EndMarker -> Ordering
compare :: Data_EndMarker -> Data_EndMarker -> Ordering
$c< :: Data_EndMarker -> Data_EndMarker -> Bool
< :: Data_EndMarker -> Data_EndMarker -> Bool
$c<= :: Data_EndMarker -> Data_EndMarker -> Bool
<= :: Data_EndMarker -> Data_EndMarker -> Bool
$c> :: Data_EndMarker -> Data_EndMarker -> Bool
> :: Data_EndMarker -> Data_EndMarker -> Bool
$c>= :: Data_EndMarker -> Data_EndMarker -> Bool
>= :: Data_EndMarker -> Data_EndMarker -> Bool
$cmax :: Data_EndMarker -> Data_EndMarker -> Data_EndMarker
max :: Data_EndMarker -> Data_EndMarker -> Data_EndMarker
$cmin :: Data_EndMarker -> Data_EndMarker -> Data_EndMarker
min :: Data_EndMarker -> Data_EndMarker -> Data_EndMarker
Ord, ReadPrec [Data_EndMarker]
ReadPrec Data_EndMarker
Int -> ReadS Data_EndMarker
ReadS [Data_EndMarker]
(Int -> ReadS Data_EndMarker)
-> ReadS [Data_EndMarker]
-> ReadPrec Data_EndMarker
-> ReadPrec [Data_EndMarker]
-> Read Data_EndMarker
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_EndMarker
readsPrec :: Int -> ReadS Data_EndMarker
$creadList :: ReadS [Data_EndMarker]
readList :: ReadS [Data_EndMarker]
$creadPrec :: ReadPrec Data_EndMarker
readPrec :: ReadPrec Data_EndMarker
$creadListPrec :: ReadPrec [Data_EndMarker]
readListPrec :: ReadPrec [Data_EndMarker]
Read, Int -> Data_EndMarker -> String -> String
[Data_EndMarker] -> String -> String
Data_EndMarker -> String
(Int -> Data_EndMarker -> String -> String)
-> (Data_EndMarker -> String)
-> ([Data_EndMarker] -> String -> String)
-> Show Data_EndMarker
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_EndMarker -> String -> String
showsPrec :: Int -> Data_EndMarker -> String -> String
$cshow :: Data_EndMarker -> String
show :: Data_EndMarker -> String
$cshowList :: [Data_EndMarker] -> String -> String
showList :: [Data_EndMarker] -> String -> String
Show)

_Data_EndMarker :: Name
_Data_EndMarker = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.EndMarker")

_Data_EndMarker_name :: Name
_Data_EndMarker_name = (String -> Name
Core.Name String
"name")

data Data_If = 
  Data_If {
    Data_If -> Data
data_IfCond :: Data,
    Data_If -> Data
data_IfThenp :: Data,
    Data_If -> Data
data_IfElsep :: Data}
  deriving (Data_If -> Data_If -> Bool
(Data_If -> Data_If -> Bool)
-> (Data_If -> Data_If -> Bool) -> Eq Data_If
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_If -> Data_If -> Bool
== :: Data_If -> Data_If -> Bool
$c/= :: Data_If -> Data_If -> Bool
/= :: Data_If -> Data_If -> Bool
Eq, Eq Data_If
Eq Data_If =>
(Data_If -> Data_If -> Ordering)
-> (Data_If -> Data_If -> Bool)
-> (Data_If -> Data_If -> Bool)
-> (Data_If -> Data_If -> Bool)
-> (Data_If -> Data_If -> Bool)
-> (Data_If -> Data_If -> Data_If)
-> (Data_If -> Data_If -> Data_If)
-> Ord Data_If
Data_If -> Data_If -> Bool
Data_If -> Data_If -> Ordering
Data_If -> Data_If -> Data_If
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_If -> Data_If -> Ordering
compare :: Data_If -> Data_If -> Ordering
$c< :: Data_If -> Data_If -> Bool
< :: Data_If -> Data_If -> Bool
$c<= :: Data_If -> Data_If -> Bool
<= :: Data_If -> Data_If -> Bool
$c> :: Data_If -> Data_If -> Bool
> :: Data_If -> Data_If -> Bool
$c>= :: Data_If -> Data_If -> Bool
>= :: Data_If -> Data_If -> Bool
$cmax :: Data_If -> Data_If -> Data_If
max :: Data_If -> Data_If -> Data_If
$cmin :: Data_If -> Data_If -> Data_If
min :: Data_If -> Data_If -> Data_If
Ord, ReadPrec [Data_If]
ReadPrec Data_If
Int -> ReadS Data_If
ReadS [Data_If]
(Int -> ReadS Data_If)
-> ReadS [Data_If]
-> ReadPrec Data_If
-> ReadPrec [Data_If]
-> Read Data_If
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_If
readsPrec :: Int -> ReadS Data_If
$creadList :: ReadS [Data_If]
readList :: ReadS [Data_If]
$creadPrec :: ReadPrec Data_If
readPrec :: ReadPrec Data_If
$creadListPrec :: ReadPrec [Data_If]
readListPrec :: ReadPrec [Data_If]
Read, Int -> Data_If -> String -> String
[Data_If] -> String -> String
Data_If -> String
(Int -> Data_If -> String -> String)
-> (Data_If -> String)
-> ([Data_If] -> String -> String)
-> Show Data_If
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_If -> String -> String
showsPrec :: Int -> Data_If -> String -> String
$cshow :: Data_If -> String
show :: Data_If -> String
$cshowList :: [Data_If] -> String -> String
showList :: [Data_If] -> String -> String
Show)

_Data_If :: Name
_Data_If = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.If")

_Data_If_cond :: Name
_Data_If_cond = (String -> Name
Core.Name String
"cond")

_Data_If_thenp :: Name
_Data_If_thenp = (String -> Name
Core.Name String
"thenp")

_Data_If_elsep :: Name
_Data_If_elsep = (String -> Name
Core.Name String
"elsep")

data Data_QuotedMacroExpr = 
  Data_QuotedMacroExpr {
    Data_QuotedMacroExpr -> Data
data_QuotedMacroExprBody :: Data}
  deriving (Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Bool
(Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Bool)
-> (Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Bool)
-> Eq Data_QuotedMacroExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Bool
== :: Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Bool
$c/= :: Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Bool
/= :: Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Bool
Eq, Eq Data_QuotedMacroExpr
Eq Data_QuotedMacroExpr =>
(Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Ordering)
-> (Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Bool)
-> (Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Bool)
-> (Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Bool)
-> (Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Bool)
-> (Data_QuotedMacroExpr
    -> Data_QuotedMacroExpr -> Data_QuotedMacroExpr)
-> (Data_QuotedMacroExpr
    -> Data_QuotedMacroExpr -> Data_QuotedMacroExpr)
-> Ord Data_QuotedMacroExpr
Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Bool
Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Ordering
Data_QuotedMacroExpr
-> Data_QuotedMacroExpr -> Data_QuotedMacroExpr
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Ordering
compare :: Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Ordering
$c< :: Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Bool
< :: Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Bool
$c<= :: Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Bool
<= :: Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Bool
$c> :: Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Bool
> :: Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Bool
$c>= :: Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Bool
>= :: Data_QuotedMacroExpr -> Data_QuotedMacroExpr -> Bool
$cmax :: Data_QuotedMacroExpr
-> Data_QuotedMacroExpr -> Data_QuotedMacroExpr
max :: Data_QuotedMacroExpr
-> Data_QuotedMacroExpr -> Data_QuotedMacroExpr
$cmin :: Data_QuotedMacroExpr
-> Data_QuotedMacroExpr -> Data_QuotedMacroExpr
min :: Data_QuotedMacroExpr
-> Data_QuotedMacroExpr -> Data_QuotedMacroExpr
Ord, ReadPrec [Data_QuotedMacroExpr]
ReadPrec Data_QuotedMacroExpr
Int -> ReadS Data_QuotedMacroExpr
ReadS [Data_QuotedMacroExpr]
(Int -> ReadS Data_QuotedMacroExpr)
-> ReadS [Data_QuotedMacroExpr]
-> ReadPrec Data_QuotedMacroExpr
-> ReadPrec [Data_QuotedMacroExpr]
-> Read Data_QuotedMacroExpr
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_QuotedMacroExpr
readsPrec :: Int -> ReadS Data_QuotedMacroExpr
$creadList :: ReadS [Data_QuotedMacroExpr]
readList :: ReadS [Data_QuotedMacroExpr]
$creadPrec :: ReadPrec Data_QuotedMacroExpr
readPrec :: ReadPrec Data_QuotedMacroExpr
$creadListPrec :: ReadPrec [Data_QuotedMacroExpr]
readListPrec :: ReadPrec [Data_QuotedMacroExpr]
Read, Int -> Data_QuotedMacroExpr -> String -> String
[Data_QuotedMacroExpr] -> String -> String
Data_QuotedMacroExpr -> String
(Int -> Data_QuotedMacroExpr -> String -> String)
-> (Data_QuotedMacroExpr -> String)
-> ([Data_QuotedMacroExpr] -> String -> String)
-> Show Data_QuotedMacroExpr
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_QuotedMacroExpr -> String -> String
showsPrec :: Int -> Data_QuotedMacroExpr -> String -> String
$cshow :: Data_QuotedMacroExpr -> String
show :: Data_QuotedMacroExpr -> String
$cshowList :: [Data_QuotedMacroExpr] -> String -> String
showList :: [Data_QuotedMacroExpr] -> String -> String
Show)

_Data_QuotedMacroExpr :: Name
_Data_QuotedMacroExpr = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.QuotedMacroExpr")

_Data_QuotedMacroExpr_body :: Name
_Data_QuotedMacroExpr_body = (String -> Name
Core.Name String
"body")

data Data_QuotedMacroType = 
  Data_QuotedMacroType {
    Data_QuotedMacroType -> Type
data_QuotedMacroTypeTpe :: Type}
  deriving (Data_QuotedMacroType -> Data_QuotedMacroType -> Bool
(Data_QuotedMacroType -> Data_QuotedMacroType -> Bool)
-> (Data_QuotedMacroType -> Data_QuotedMacroType -> Bool)
-> Eq Data_QuotedMacroType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_QuotedMacroType -> Data_QuotedMacroType -> Bool
== :: Data_QuotedMacroType -> Data_QuotedMacroType -> Bool
$c/= :: Data_QuotedMacroType -> Data_QuotedMacroType -> Bool
/= :: Data_QuotedMacroType -> Data_QuotedMacroType -> Bool
Eq, Eq Data_QuotedMacroType
Eq Data_QuotedMacroType =>
(Data_QuotedMacroType -> Data_QuotedMacroType -> Ordering)
-> (Data_QuotedMacroType -> Data_QuotedMacroType -> Bool)
-> (Data_QuotedMacroType -> Data_QuotedMacroType -> Bool)
-> (Data_QuotedMacroType -> Data_QuotedMacroType -> Bool)
-> (Data_QuotedMacroType -> Data_QuotedMacroType -> Bool)
-> (Data_QuotedMacroType
    -> Data_QuotedMacroType -> Data_QuotedMacroType)
-> (Data_QuotedMacroType
    -> Data_QuotedMacroType -> Data_QuotedMacroType)
-> Ord Data_QuotedMacroType
Data_QuotedMacroType -> Data_QuotedMacroType -> Bool
Data_QuotedMacroType -> Data_QuotedMacroType -> Ordering
Data_QuotedMacroType
-> Data_QuotedMacroType -> Data_QuotedMacroType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_QuotedMacroType -> Data_QuotedMacroType -> Ordering
compare :: Data_QuotedMacroType -> Data_QuotedMacroType -> Ordering
$c< :: Data_QuotedMacroType -> Data_QuotedMacroType -> Bool
< :: Data_QuotedMacroType -> Data_QuotedMacroType -> Bool
$c<= :: Data_QuotedMacroType -> Data_QuotedMacroType -> Bool
<= :: Data_QuotedMacroType -> Data_QuotedMacroType -> Bool
$c> :: Data_QuotedMacroType -> Data_QuotedMacroType -> Bool
> :: Data_QuotedMacroType -> Data_QuotedMacroType -> Bool
$c>= :: Data_QuotedMacroType -> Data_QuotedMacroType -> Bool
>= :: Data_QuotedMacroType -> Data_QuotedMacroType -> Bool
$cmax :: Data_QuotedMacroType
-> Data_QuotedMacroType -> Data_QuotedMacroType
max :: Data_QuotedMacroType
-> Data_QuotedMacroType -> Data_QuotedMacroType
$cmin :: Data_QuotedMacroType
-> Data_QuotedMacroType -> Data_QuotedMacroType
min :: Data_QuotedMacroType
-> Data_QuotedMacroType -> Data_QuotedMacroType
Ord, ReadPrec [Data_QuotedMacroType]
ReadPrec Data_QuotedMacroType
Int -> ReadS Data_QuotedMacroType
ReadS [Data_QuotedMacroType]
(Int -> ReadS Data_QuotedMacroType)
-> ReadS [Data_QuotedMacroType]
-> ReadPrec Data_QuotedMacroType
-> ReadPrec [Data_QuotedMacroType]
-> Read Data_QuotedMacroType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_QuotedMacroType
readsPrec :: Int -> ReadS Data_QuotedMacroType
$creadList :: ReadS [Data_QuotedMacroType]
readList :: ReadS [Data_QuotedMacroType]
$creadPrec :: ReadPrec Data_QuotedMacroType
readPrec :: ReadPrec Data_QuotedMacroType
$creadListPrec :: ReadPrec [Data_QuotedMacroType]
readListPrec :: ReadPrec [Data_QuotedMacroType]
Read, Int -> Data_QuotedMacroType -> String -> String
[Data_QuotedMacroType] -> String -> String
Data_QuotedMacroType -> String
(Int -> Data_QuotedMacroType -> String -> String)
-> (Data_QuotedMacroType -> String)
-> ([Data_QuotedMacroType] -> String -> String)
-> Show Data_QuotedMacroType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_QuotedMacroType -> String -> String
showsPrec :: Int -> Data_QuotedMacroType -> String -> String
$cshow :: Data_QuotedMacroType -> String
show :: Data_QuotedMacroType -> String
$cshowList :: [Data_QuotedMacroType] -> String -> String
showList :: [Data_QuotedMacroType] -> String -> String
Show)

_Data_QuotedMacroType :: Name
_Data_QuotedMacroType = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.QuotedMacroType")

_Data_QuotedMacroType_tpe :: Name
_Data_QuotedMacroType_tpe = (String -> Name
Core.Name String
"tpe")

data Data_SplicedMacroExpr = 
  Data_SplicedMacroExpr {
    Data_SplicedMacroExpr -> Data
data_SplicedMacroExprBody :: Data}
  deriving (Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Bool
(Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Bool)
-> (Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Bool)
-> Eq Data_SplicedMacroExpr
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Bool
== :: Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Bool
$c/= :: Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Bool
/= :: Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Bool
Eq, Eq Data_SplicedMacroExpr
Eq Data_SplicedMacroExpr =>
(Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Ordering)
-> (Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Bool)
-> (Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Bool)
-> (Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Bool)
-> (Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Bool)
-> (Data_SplicedMacroExpr
    -> Data_SplicedMacroExpr -> Data_SplicedMacroExpr)
-> (Data_SplicedMacroExpr
    -> Data_SplicedMacroExpr -> Data_SplicedMacroExpr)
-> Ord Data_SplicedMacroExpr
Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Bool
Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Ordering
Data_SplicedMacroExpr
-> Data_SplicedMacroExpr -> Data_SplicedMacroExpr
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Ordering
compare :: Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Ordering
$c< :: Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Bool
< :: Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Bool
$c<= :: Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Bool
<= :: Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Bool
$c> :: Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Bool
> :: Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Bool
$c>= :: Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Bool
>= :: Data_SplicedMacroExpr -> Data_SplicedMacroExpr -> Bool
$cmax :: Data_SplicedMacroExpr
-> Data_SplicedMacroExpr -> Data_SplicedMacroExpr
max :: Data_SplicedMacroExpr
-> Data_SplicedMacroExpr -> Data_SplicedMacroExpr
$cmin :: Data_SplicedMacroExpr
-> Data_SplicedMacroExpr -> Data_SplicedMacroExpr
min :: Data_SplicedMacroExpr
-> Data_SplicedMacroExpr -> Data_SplicedMacroExpr
Ord, ReadPrec [Data_SplicedMacroExpr]
ReadPrec Data_SplicedMacroExpr
Int -> ReadS Data_SplicedMacroExpr
ReadS [Data_SplicedMacroExpr]
(Int -> ReadS Data_SplicedMacroExpr)
-> ReadS [Data_SplicedMacroExpr]
-> ReadPrec Data_SplicedMacroExpr
-> ReadPrec [Data_SplicedMacroExpr]
-> Read Data_SplicedMacroExpr
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_SplicedMacroExpr
readsPrec :: Int -> ReadS Data_SplicedMacroExpr
$creadList :: ReadS [Data_SplicedMacroExpr]
readList :: ReadS [Data_SplicedMacroExpr]
$creadPrec :: ReadPrec Data_SplicedMacroExpr
readPrec :: ReadPrec Data_SplicedMacroExpr
$creadListPrec :: ReadPrec [Data_SplicedMacroExpr]
readListPrec :: ReadPrec [Data_SplicedMacroExpr]
Read, Int -> Data_SplicedMacroExpr -> String -> String
[Data_SplicedMacroExpr] -> String -> String
Data_SplicedMacroExpr -> String
(Int -> Data_SplicedMacroExpr -> String -> String)
-> (Data_SplicedMacroExpr -> String)
-> ([Data_SplicedMacroExpr] -> String -> String)
-> Show Data_SplicedMacroExpr
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_SplicedMacroExpr -> String -> String
showsPrec :: Int -> Data_SplicedMacroExpr -> String -> String
$cshow :: Data_SplicedMacroExpr -> String
show :: Data_SplicedMacroExpr -> String
$cshowList :: [Data_SplicedMacroExpr] -> String -> String
showList :: [Data_SplicedMacroExpr] -> String -> String
Show)

_Data_SplicedMacroExpr :: Name
_Data_SplicedMacroExpr = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.SplicedMacroExpr")

_Data_SplicedMacroExpr_body :: Name
_Data_SplicedMacroExpr_body = (String -> Name
Core.Name String
"body")

data Data_Match = 
  Data_Match {
    Data_Match -> Data
data_MatchExpr :: Data,
    Data_Match -> [Case]
data_MatchCases :: [Case]}
  deriving (Data_Match -> Data_Match -> Bool
(Data_Match -> Data_Match -> Bool)
-> (Data_Match -> Data_Match -> Bool) -> Eq Data_Match
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Match -> Data_Match -> Bool
== :: Data_Match -> Data_Match -> Bool
$c/= :: Data_Match -> Data_Match -> Bool
/= :: Data_Match -> Data_Match -> Bool
Eq, Eq Data_Match
Eq Data_Match =>
(Data_Match -> Data_Match -> Ordering)
-> (Data_Match -> Data_Match -> Bool)
-> (Data_Match -> Data_Match -> Bool)
-> (Data_Match -> Data_Match -> Bool)
-> (Data_Match -> Data_Match -> Bool)
-> (Data_Match -> Data_Match -> Data_Match)
-> (Data_Match -> Data_Match -> Data_Match)
-> Ord Data_Match
Data_Match -> Data_Match -> Bool
Data_Match -> Data_Match -> Ordering
Data_Match -> Data_Match -> Data_Match
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Match -> Data_Match -> Ordering
compare :: Data_Match -> Data_Match -> Ordering
$c< :: Data_Match -> Data_Match -> Bool
< :: Data_Match -> Data_Match -> Bool
$c<= :: Data_Match -> Data_Match -> Bool
<= :: Data_Match -> Data_Match -> Bool
$c> :: Data_Match -> Data_Match -> Bool
> :: Data_Match -> Data_Match -> Bool
$c>= :: Data_Match -> Data_Match -> Bool
>= :: Data_Match -> Data_Match -> Bool
$cmax :: Data_Match -> Data_Match -> Data_Match
max :: Data_Match -> Data_Match -> Data_Match
$cmin :: Data_Match -> Data_Match -> Data_Match
min :: Data_Match -> Data_Match -> Data_Match
Ord, ReadPrec [Data_Match]
ReadPrec Data_Match
Int -> ReadS Data_Match
ReadS [Data_Match]
(Int -> ReadS Data_Match)
-> ReadS [Data_Match]
-> ReadPrec Data_Match
-> ReadPrec [Data_Match]
-> Read Data_Match
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Match
readsPrec :: Int -> ReadS Data_Match
$creadList :: ReadS [Data_Match]
readList :: ReadS [Data_Match]
$creadPrec :: ReadPrec Data_Match
readPrec :: ReadPrec Data_Match
$creadListPrec :: ReadPrec [Data_Match]
readListPrec :: ReadPrec [Data_Match]
Read, Int -> Data_Match -> String -> String
[Data_Match] -> String -> String
Data_Match -> String
(Int -> Data_Match -> String -> String)
-> (Data_Match -> String)
-> ([Data_Match] -> String -> String)
-> Show Data_Match
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Match -> String -> String
showsPrec :: Int -> Data_Match -> String -> String
$cshow :: Data_Match -> String
show :: Data_Match -> String
$cshowList :: [Data_Match] -> String -> String
showList :: [Data_Match] -> String -> String
Show)

_Data_Match :: Name
_Data_Match = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Match")

_Data_Match_expr :: Name
_Data_Match_expr = (String -> Name
Core.Name String
"expr")

_Data_Match_cases :: Name
_Data_Match_cases = (String -> Name
Core.Name String
"cases")

data Data_Try = 
  Data_Try {
    Data_Try -> Data
data_TryExpr :: Data,
    Data_Try -> [Case]
data_TryCatchp :: [Case],
    Data_Try -> Maybe Data
data_TryFinallyp :: (Maybe Data)}
  deriving (Data_Try -> Data_Try -> Bool
(Data_Try -> Data_Try -> Bool)
-> (Data_Try -> Data_Try -> Bool) -> Eq Data_Try
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Try -> Data_Try -> Bool
== :: Data_Try -> Data_Try -> Bool
$c/= :: Data_Try -> Data_Try -> Bool
/= :: Data_Try -> Data_Try -> Bool
Eq, Eq Data_Try
Eq Data_Try =>
(Data_Try -> Data_Try -> Ordering)
-> (Data_Try -> Data_Try -> Bool)
-> (Data_Try -> Data_Try -> Bool)
-> (Data_Try -> Data_Try -> Bool)
-> (Data_Try -> Data_Try -> Bool)
-> (Data_Try -> Data_Try -> Data_Try)
-> (Data_Try -> Data_Try -> Data_Try)
-> Ord Data_Try
Data_Try -> Data_Try -> Bool
Data_Try -> Data_Try -> Ordering
Data_Try -> Data_Try -> Data_Try
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Try -> Data_Try -> Ordering
compare :: Data_Try -> Data_Try -> Ordering
$c< :: Data_Try -> Data_Try -> Bool
< :: Data_Try -> Data_Try -> Bool
$c<= :: Data_Try -> Data_Try -> Bool
<= :: Data_Try -> Data_Try -> Bool
$c> :: Data_Try -> Data_Try -> Bool
> :: Data_Try -> Data_Try -> Bool
$c>= :: Data_Try -> Data_Try -> Bool
>= :: Data_Try -> Data_Try -> Bool
$cmax :: Data_Try -> Data_Try -> Data_Try
max :: Data_Try -> Data_Try -> Data_Try
$cmin :: Data_Try -> Data_Try -> Data_Try
min :: Data_Try -> Data_Try -> Data_Try
Ord, ReadPrec [Data_Try]
ReadPrec Data_Try
Int -> ReadS Data_Try
ReadS [Data_Try]
(Int -> ReadS Data_Try)
-> ReadS [Data_Try]
-> ReadPrec Data_Try
-> ReadPrec [Data_Try]
-> Read Data_Try
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Try
readsPrec :: Int -> ReadS Data_Try
$creadList :: ReadS [Data_Try]
readList :: ReadS [Data_Try]
$creadPrec :: ReadPrec Data_Try
readPrec :: ReadPrec Data_Try
$creadListPrec :: ReadPrec [Data_Try]
readListPrec :: ReadPrec [Data_Try]
Read, Int -> Data_Try -> String -> String
[Data_Try] -> String -> String
Data_Try -> String
(Int -> Data_Try -> String -> String)
-> (Data_Try -> String)
-> ([Data_Try] -> String -> String)
-> Show Data_Try
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Try -> String -> String
showsPrec :: Int -> Data_Try -> String -> String
$cshow :: Data_Try -> String
show :: Data_Try -> String
$cshowList :: [Data_Try] -> String -> String
showList :: [Data_Try] -> String -> String
Show)

_Data_Try :: Name
_Data_Try = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Try")

_Data_Try_expr :: Name
_Data_Try_expr = (String -> Name
Core.Name String
"expr")

_Data_Try_catchp :: Name
_Data_Try_catchp = (String -> Name
Core.Name String
"catchp")

_Data_Try_finallyp :: Name
_Data_Try_finallyp = (String -> Name
Core.Name String
"finallyp")

data Data_TryWithHandler = 
  Data_TryWithHandler {
    Data_TryWithHandler -> Data
data_TryWithHandlerExpr :: Data,
    Data_TryWithHandler -> Data
data_TryWithHandlerCatchp :: Data,
    Data_TryWithHandler -> Maybe Data
data_TryWithHandlerFinallyp :: (Maybe Data)}
  deriving (Data_TryWithHandler -> Data_TryWithHandler -> Bool
(Data_TryWithHandler -> Data_TryWithHandler -> Bool)
-> (Data_TryWithHandler -> Data_TryWithHandler -> Bool)
-> Eq Data_TryWithHandler
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_TryWithHandler -> Data_TryWithHandler -> Bool
== :: Data_TryWithHandler -> Data_TryWithHandler -> Bool
$c/= :: Data_TryWithHandler -> Data_TryWithHandler -> Bool
/= :: Data_TryWithHandler -> Data_TryWithHandler -> Bool
Eq, Eq Data_TryWithHandler
Eq Data_TryWithHandler =>
(Data_TryWithHandler -> Data_TryWithHandler -> Ordering)
-> (Data_TryWithHandler -> Data_TryWithHandler -> Bool)
-> (Data_TryWithHandler -> Data_TryWithHandler -> Bool)
-> (Data_TryWithHandler -> Data_TryWithHandler -> Bool)
-> (Data_TryWithHandler -> Data_TryWithHandler -> Bool)
-> (Data_TryWithHandler
    -> Data_TryWithHandler -> Data_TryWithHandler)
-> (Data_TryWithHandler
    -> Data_TryWithHandler -> Data_TryWithHandler)
-> Ord Data_TryWithHandler
Data_TryWithHandler -> Data_TryWithHandler -> Bool
Data_TryWithHandler -> Data_TryWithHandler -> Ordering
Data_TryWithHandler -> Data_TryWithHandler -> Data_TryWithHandler
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_TryWithHandler -> Data_TryWithHandler -> Ordering
compare :: Data_TryWithHandler -> Data_TryWithHandler -> Ordering
$c< :: Data_TryWithHandler -> Data_TryWithHandler -> Bool
< :: Data_TryWithHandler -> Data_TryWithHandler -> Bool
$c<= :: Data_TryWithHandler -> Data_TryWithHandler -> Bool
<= :: Data_TryWithHandler -> Data_TryWithHandler -> Bool
$c> :: Data_TryWithHandler -> Data_TryWithHandler -> Bool
> :: Data_TryWithHandler -> Data_TryWithHandler -> Bool
$c>= :: Data_TryWithHandler -> Data_TryWithHandler -> Bool
>= :: Data_TryWithHandler -> Data_TryWithHandler -> Bool
$cmax :: Data_TryWithHandler -> Data_TryWithHandler -> Data_TryWithHandler
max :: Data_TryWithHandler -> Data_TryWithHandler -> Data_TryWithHandler
$cmin :: Data_TryWithHandler -> Data_TryWithHandler -> Data_TryWithHandler
min :: Data_TryWithHandler -> Data_TryWithHandler -> Data_TryWithHandler
Ord, ReadPrec [Data_TryWithHandler]
ReadPrec Data_TryWithHandler
Int -> ReadS Data_TryWithHandler
ReadS [Data_TryWithHandler]
(Int -> ReadS Data_TryWithHandler)
-> ReadS [Data_TryWithHandler]
-> ReadPrec Data_TryWithHandler
-> ReadPrec [Data_TryWithHandler]
-> Read Data_TryWithHandler
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_TryWithHandler
readsPrec :: Int -> ReadS Data_TryWithHandler
$creadList :: ReadS [Data_TryWithHandler]
readList :: ReadS [Data_TryWithHandler]
$creadPrec :: ReadPrec Data_TryWithHandler
readPrec :: ReadPrec Data_TryWithHandler
$creadListPrec :: ReadPrec [Data_TryWithHandler]
readListPrec :: ReadPrec [Data_TryWithHandler]
Read, Int -> Data_TryWithHandler -> String -> String
[Data_TryWithHandler] -> String -> String
Data_TryWithHandler -> String
(Int -> Data_TryWithHandler -> String -> String)
-> (Data_TryWithHandler -> String)
-> ([Data_TryWithHandler] -> String -> String)
-> Show Data_TryWithHandler
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_TryWithHandler -> String -> String
showsPrec :: Int -> Data_TryWithHandler -> String -> String
$cshow :: Data_TryWithHandler -> String
show :: Data_TryWithHandler -> String
$cshowList :: [Data_TryWithHandler] -> String -> String
showList :: [Data_TryWithHandler] -> String -> String
Show)

_Data_TryWithHandler :: Name
_Data_TryWithHandler = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.TryWithHandler")

_Data_TryWithHandler_expr :: Name
_Data_TryWithHandler_expr = (String -> Name
Core.Name String
"expr")

_Data_TryWithHandler_catchp :: Name
_Data_TryWithHandler_catchp = (String -> Name
Core.Name String
"catchp")

_Data_TryWithHandler_finallyp :: Name
_Data_TryWithHandler_finallyp = (String -> Name
Core.Name String
"finallyp")

data Data_FunctionData = 
  Data_FunctionDataContextFunction Data_ContextFunction |
  Data_FunctionDataFunction Data_Function
  deriving (Data_FunctionData -> Data_FunctionData -> Bool
(Data_FunctionData -> Data_FunctionData -> Bool)
-> (Data_FunctionData -> Data_FunctionData -> Bool)
-> Eq Data_FunctionData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_FunctionData -> Data_FunctionData -> Bool
== :: Data_FunctionData -> Data_FunctionData -> Bool
$c/= :: Data_FunctionData -> Data_FunctionData -> Bool
/= :: Data_FunctionData -> Data_FunctionData -> Bool
Eq, Eq Data_FunctionData
Eq Data_FunctionData =>
(Data_FunctionData -> Data_FunctionData -> Ordering)
-> (Data_FunctionData -> Data_FunctionData -> Bool)
-> (Data_FunctionData -> Data_FunctionData -> Bool)
-> (Data_FunctionData -> Data_FunctionData -> Bool)
-> (Data_FunctionData -> Data_FunctionData -> Bool)
-> (Data_FunctionData -> Data_FunctionData -> Data_FunctionData)
-> (Data_FunctionData -> Data_FunctionData -> Data_FunctionData)
-> Ord Data_FunctionData
Data_FunctionData -> Data_FunctionData -> Bool
Data_FunctionData -> Data_FunctionData -> Ordering
Data_FunctionData -> Data_FunctionData -> Data_FunctionData
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_FunctionData -> Data_FunctionData -> Ordering
compare :: Data_FunctionData -> Data_FunctionData -> Ordering
$c< :: Data_FunctionData -> Data_FunctionData -> Bool
< :: Data_FunctionData -> Data_FunctionData -> Bool
$c<= :: Data_FunctionData -> Data_FunctionData -> Bool
<= :: Data_FunctionData -> Data_FunctionData -> Bool
$c> :: Data_FunctionData -> Data_FunctionData -> Bool
> :: Data_FunctionData -> Data_FunctionData -> Bool
$c>= :: Data_FunctionData -> Data_FunctionData -> Bool
>= :: Data_FunctionData -> Data_FunctionData -> Bool
$cmax :: Data_FunctionData -> Data_FunctionData -> Data_FunctionData
max :: Data_FunctionData -> Data_FunctionData -> Data_FunctionData
$cmin :: Data_FunctionData -> Data_FunctionData -> Data_FunctionData
min :: Data_FunctionData -> Data_FunctionData -> Data_FunctionData
Ord, ReadPrec [Data_FunctionData]
ReadPrec Data_FunctionData
Int -> ReadS Data_FunctionData
ReadS [Data_FunctionData]
(Int -> ReadS Data_FunctionData)
-> ReadS [Data_FunctionData]
-> ReadPrec Data_FunctionData
-> ReadPrec [Data_FunctionData]
-> Read Data_FunctionData
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_FunctionData
readsPrec :: Int -> ReadS Data_FunctionData
$creadList :: ReadS [Data_FunctionData]
readList :: ReadS [Data_FunctionData]
$creadPrec :: ReadPrec Data_FunctionData
readPrec :: ReadPrec Data_FunctionData
$creadListPrec :: ReadPrec [Data_FunctionData]
readListPrec :: ReadPrec [Data_FunctionData]
Read, Int -> Data_FunctionData -> String -> String
[Data_FunctionData] -> String -> String
Data_FunctionData -> String
(Int -> Data_FunctionData -> String -> String)
-> (Data_FunctionData -> String)
-> ([Data_FunctionData] -> String -> String)
-> Show Data_FunctionData
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_FunctionData -> String -> String
showsPrec :: Int -> Data_FunctionData -> String -> String
$cshow :: Data_FunctionData -> String
show :: Data_FunctionData -> String
$cshowList :: [Data_FunctionData] -> String -> String
showList :: [Data_FunctionData] -> String -> String
Show)

_Data_FunctionData :: Name
_Data_FunctionData = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.FunctionData")

_Data_FunctionData_contextFunction :: Name
_Data_FunctionData_contextFunction = (String -> Name
Core.Name String
"contextFunction")

_Data_FunctionData_function :: Name
_Data_FunctionData_function = (String -> Name
Core.Name String
"function")

data Data_ContextFunction = 
  Data_ContextFunction {
    Data_ContextFunction -> [Data_Param]
data_ContextFunctionParams :: [Data_Param],
    Data_ContextFunction -> Data
data_ContextFunctionBody :: Data}
  deriving (Data_ContextFunction -> Data_ContextFunction -> Bool
(Data_ContextFunction -> Data_ContextFunction -> Bool)
-> (Data_ContextFunction -> Data_ContextFunction -> Bool)
-> Eq Data_ContextFunction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_ContextFunction -> Data_ContextFunction -> Bool
== :: Data_ContextFunction -> Data_ContextFunction -> Bool
$c/= :: Data_ContextFunction -> Data_ContextFunction -> Bool
/= :: Data_ContextFunction -> Data_ContextFunction -> Bool
Eq, Eq Data_ContextFunction
Eq Data_ContextFunction =>
(Data_ContextFunction -> Data_ContextFunction -> Ordering)
-> (Data_ContextFunction -> Data_ContextFunction -> Bool)
-> (Data_ContextFunction -> Data_ContextFunction -> Bool)
-> (Data_ContextFunction -> Data_ContextFunction -> Bool)
-> (Data_ContextFunction -> Data_ContextFunction -> Bool)
-> (Data_ContextFunction
    -> Data_ContextFunction -> Data_ContextFunction)
-> (Data_ContextFunction
    -> Data_ContextFunction -> Data_ContextFunction)
-> Ord Data_ContextFunction
Data_ContextFunction -> Data_ContextFunction -> Bool
Data_ContextFunction -> Data_ContextFunction -> Ordering
Data_ContextFunction
-> Data_ContextFunction -> Data_ContextFunction
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_ContextFunction -> Data_ContextFunction -> Ordering
compare :: Data_ContextFunction -> Data_ContextFunction -> Ordering
$c< :: Data_ContextFunction -> Data_ContextFunction -> Bool
< :: Data_ContextFunction -> Data_ContextFunction -> Bool
$c<= :: Data_ContextFunction -> Data_ContextFunction -> Bool
<= :: Data_ContextFunction -> Data_ContextFunction -> Bool
$c> :: Data_ContextFunction -> Data_ContextFunction -> Bool
> :: Data_ContextFunction -> Data_ContextFunction -> Bool
$c>= :: Data_ContextFunction -> Data_ContextFunction -> Bool
>= :: Data_ContextFunction -> Data_ContextFunction -> Bool
$cmax :: Data_ContextFunction
-> Data_ContextFunction -> Data_ContextFunction
max :: Data_ContextFunction
-> Data_ContextFunction -> Data_ContextFunction
$cmin :: Data_ContextFunction
-> Data_ContextFunction -> Data_ContextFunction
min :: Data_ContextFunction
-> Data_ContextFunction -> Data_ContextFunction
Ord, ReadPrec [Data_ContextFunction]
ReadPrec Data_ContextFunction
Int -> ReadS Data_ContextFunction
ReadS [Data_ContextFunction]
(Int -> ReadS Data_ContextFunction)
-> ReadS [Data_ContextFunction]
-> ReadPrec Data_ContextFunction
-> ReadPrec [Data_ContextFunction]
-> Read Data_ContextFunction
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_ContextFunction
readsPrec :: Int -> ReadS Data_ContextFunction
$creadList :: ReadS [Data_ContextFunction]
readList :: ReadS [Data_ContextFunction]
$creadPrec :: ReadPrec Data_ContextFunction
readPrec :: ReadPrec Data_ContextFunction
$creadListPrec :: ReadPrec [Data_ContextFunction]
readListPrec :: ReadPrec [Data_ContextFunction]
Read, Int -> Data_ContextFunction -> String -> String
[Data_ContextFunction] -> String -> String
Data_ContextFunction -> String
(Int -> Data_ContextFunction -> String -> String)
-> (Data_ContextFunction -> String)
-> ([Data_ContextFunction] -> String -> String)
-> Show Data_ContextFunction
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_ContextFunction -> String -> String
showsPrec :: Int -> Data_ContextFunction -> String -> String
$cshow :: Data_ContextFunction -> String
show :: Data_ContextFunction -> String
$cshowList :: [Data_ContextFunction] -> String -> String
showList :: [Data_ContextFunction] -> String -> String
Show)

_Data_ContextFunction :: Name
_Data_ContextFunction = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.ContextFunction")

_Data_ContextFunction_params :: Name
_Data_ContextFunction_params = (String -> Name
Core.Name String
"params")

_Data_ContextFunction_body :: Name
_Data_ContextFunction_body = (String -> Name
Core.Name String
"body")

data Data_Function = 
  Data_Function {
    Data_Function -> [Data_Param]
data_FunctionParams :: [Data_Param],
    Data_Function -> Data
data_FunctionBody :: Data}
  deriving (Data_Function -> Data_Function -> Bool
(Data_Function -> Data_Function -> Bool)
-> (Data_Function -> Data_Function -> Bool) -> Eq Data_Function
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Function -> Data_Function -> Bool
== :: Data_Function -> Data_Function -> Bool
$c/= :: Data_Function -> Data_Function -> Bool
/= :: Data_Function -> Data_Function -> Bool
Eq, Eq Data_Function
Eq Data_Function =>
(Data_Function -> Data_Function -> Ordering)
-> (Data_Function -> Data_Function -> Bool)
-> (Data_Function -> Data_Function -> Bool)
-> (Data_Function -> Data_Function -> Bool)
-> (Data_Function -> Data_Function -> Bool)
-> (Data_Function -> Data_Function -> Data_Function)
-> (Data_Function -> Data_Function -> Data_Function)
-> Ord Data_Function
Data_Function -> Data_Function -> Bool
Data_Function -> Data_Function -> Ordering
Data_Function -> Data_Function -> Data_Function
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Function -> Data_Function -> Ordering
compare :: Data_Function -> Data_Function -> Ordering
$c< :: Data_Function -> Data_Function -> Bool
< :: Data_Function -> Data_Function -> Bool
$c<= :: Data_Function -> Data_Function -> Bool
<= :: Data_Function -> Data_Function -> Bool
$c> :: Data_Function -> Data_Function -> Bool
> :: Data_Function -> Data_Function -> Bool
$c>= :: Data_Function -> Data_Function -> Bool
>= :: Data_Function -> Data_Function -> Bool
$cmax :: Data_Function -> Data_Function -> Data_Function
max :: Data_Function -> Data_Function -> Data_Function
$cmin :: Data_Function -> Data_Function -> Data_Function
min :: Data_Function -> Data_Function -> Data_Function
Ord, ReadPrec [Data_Function]
ReadPrec Data_Function
Int -> ReadS Data_Function
ReadS [Data_Function]
(Int -> ReadS Data_Function)
-> ReadS [Data_Function]
-> ReadPrec Data_Function
-> ReadPrec [Data_Function]
-> Read Data_Function
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Function
readsPrec :: Int -> ReadS Data_Function
$creadList :: ReadS [Data_Function]
readList :: ReadS [Data_Function]
$creadPrec :: ReadPrec Data_Function
readPrec :: ReadPrec Data_Function
$creadListPrec :: ReadPrec [Data_Function]
readListPrec :: ReadPrec [Data_Function]
Read, Int -> Data_Function -> String -> String
[Data_Function] -> String -> String
Data_Function -> String
(Int -> Data_Function -> String -> String)
-> (Data_Function -> String)
-> ([Data_Function] -> String -> String)
-> Show Data_Function
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Function -> String -> String
showsPrec :: Int -> Data_Function -> String -> String
$cshow :: Data_Function -> String
show :: Data_Function -> String
$cshowList :: [Data_Function] -> String -> String
showList :: [Data_Function] -> String -> String
Show)

_Data_Function :: Name
_Data_Function = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Function")

_Data_Function_params :: Name
_Data_Function_params = (String -> Name
Core.Name String
"params")

_Data_Function_body :: Name
_Data_Function_body = (String -> Name
Core.Name String
"body")

data Data_PolyFunction = 
  Data_PolyFunction {
    Data_PolyFunction -> [Type_Param]
data_PolyFunctionTparams :: [Type_Param],
    Data_PolyFunction -> Data
data_PolyFunctionBody :: Data}
  deriving (Data_PolyFunction -> Data_PolyFunction -> Bool
(Data_PolyFunction -> Data_PolyFunction -> Bool)
-> (Data_PolyFunction -> Data_PolyFunction -> Bool)
-> Eq Data_PolyFunction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_PolyFunction -> Data_PolyFunction -> Bool
== :: Data_PolyFunction -> Data_PolyFunction -> Bool
$c/= :: Data_PolyFunction -> Data_PolyFunction -> Bool
/= :: Data_PolyFunction -> Data_PolyFunction -> Bool
Eq, Eq Data_PolyFunction
Eq Data_PolyFunction =>
(Data_PolyFunction -> Data_PolyFunction -> Ordering)
-> (Data_PolyFunction -> Data_PolyFunction -> Bool)
-> (Data_PolyFunction -> Data_PolyFunction -> Bool)
-> (Data_PolyFunction -> Data_PolyFunction -> Bool)
-> (Data_PolyFunction -> Data_PolyFunction -> Bool)
-> (Data_PolyFunction -> Data_PolyFunction -> Data_PolyFunction)
-> (Data_PolyFunction -> Data_PolyFunction -> Data_PolyFunction)
-> Ord Data_PolyFunction
Data_PolyFunction -> Data_PolyFunction -> Bool
Data_PolyFunction -> Data_PolyFunction -> Ordering
Data_PolyFunction -> Data_PolyFunction -> Data_PolyFunction
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_PolyFunction -> Data_PolyFunction -> Ordering
compare :: Data_PolyFunction -> Data_PolyFunction -> Ordering
$c< :: Data_PolyFunction -> Data_PolyFunction -> Bool
< :: Data_PolyFunction -> Data_PolyFunction -> Bool
$c<= :: Data_PolyFunction -> Data_PolyFunction -> Bool
<= :: Data_PolyFunction -> Data_PolyFunction -> Bool
$c> :: Data_PolyFunction -> Data_PolyFunction -> Bool
> :: Data_PolyFunction -> Data_PolyFunction -> Bool
$c>= :: Data_PolyFunction -> Data_PolyFunction -> Bool
>= :: Data_PolyFunction -> Data_PolyFunction -> Bool
$cmax :: Data_PolyFunction -> Data_PolyFunction -> Data_PolyFunction
max :: Data_PolyFunction -> Data_PolyFunction -> Data_PolyFunction
$cmin :: Data_PolyFunction -> Data_PolyFunction -> Data_PolyFunction
min :: Data_PolyFunction -> Data_PolyFunction -> Data_PolyFunction
Ord, ReadPrec [Data_PolyFunction]
ReadPrec Data_PolyFunction
Int -> ReadS Data_PolyFunction
ReadS [Data_PolyFunction]
(Int -> ReadS Data_PolyFunction)
-> ReadS [Data_PolyFunction]
-> ReadPrec Data_PolyFunction
-> ReadPrec [Data_PolyFunction]
-> Read Data_PolyFunction
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_PolyFunction
readsPrec :: Int -> ReadS Data_PolyFunction
$creadList :: ReadS [Data_PolyFunction]
readList :: ReadS [Data_PolyFunction]
$creadPrec :: ReadPrec Data_PolyFunction
readPrec :: ReadPrec Data_PolyFunction
$creadListPrec :: ReadPrec [Data_PolyFunction]
readListPrec :: ReadPrec [Data_PolyFunction]
Read, Int -> Data_PolyFunction -> String -> String
[Data_PolyFunction] -> String -> String
Data_PolyFunction -> String
(Int -> Data_PolyFunction -> String -> String)
-> (Data_PolyFunction -> String)
-> ([Data_PolyFunction] -> String -> String)
-> Show Data_PolyFunction
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_PolyFunction -> String -> String
showsPrec :: Int -> Data_PolyFunction -> String -> String
$cshow :: Data_PolyFunction -> String
show :: Data_PolyFunction -> String
$cshowList :: [Data_PolyFunction] -> String -> String
showList :: [Data_PolyFunction] -> String -> String
Show)

_Data_PolyFunction :: Name
_Data_PolyFunction = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.PolyFunction")

_Data_PolyFunction_tparams :: Name
_Data_PolyFunction_tparams = (String -> Name
Core.Name String
"tparams")

_Data_PolyFunction_body :: Name
_Data_PolyFunction_body = (String -> Name
Core.Name String
"body")

data Data_PartialFunction = 
  Data_PartialFunction {
    Data_PartialFunction -> [Case]
data_PartialFunctionCases :: [Case]}
  deriving (Data_PartialFunction -> Data_PartialFunction -> Bool
(Data_PartialFunction -> Data_PartialFunction -> Bool)
-> (Data_PartialFunction -> Data_PartialFunction -> Bool)
-> Eq Data_PartialFunction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_PartialFunction -> Data_PartialFunction -> Bool
== :: Data_PartialFunction -> Data_PartialFunction -> Bool
$c/= :: Data_PartialFunction -> Data_PartialFunction -> Bool
/= :: Data_PartialFunction -> Data_PartialFunction -> Bool
Eq, Eq Data_PartialFunction
Eq Data_PartialFunction =>
(Data_PartialFunction -> Data_PartialFunction -> Ordering)
-> (Data_PartialFunction -> Data_PartialFunction -> Bool)
-> (Data_PartialFunction -> Data_PartialFunction -> Bool)
-> (Data_PartialFunction -> Data_PartialFunction -> Bool)
-> (Data_PartialFunction -> Data_PartialFunction -> Bool)
-> (Data_PartialFunction
    -> Data_PartialFunction -> Data_PartialFunction)
-> (Data_PartialFunction
    -> Data_PartialFunction -> Data_PartialFunction)
-> Ord Data_PartialFunction
Data_PartialFunction -> Data_PartialFunction -> Bool
Data_PartialFunction -> Data_PartialFunction -> Ordering
Data_PartialFunction
-> Data_PartialFunction -> Data_PartialFunction
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_PartialFunction -> Data_PartialFunction -> Ordering
compare :: Data_PartialFunction -> Data_PartialFunction -> Ordering
$c< :: Data_PartialFunction -> Data_PartialFunction -> Bool
< :: Data_PartialFunction -> Data_PartialFunction -> Bool
$c<= :: Data_PartialFunction -> Data_PartialFunction -> Bool
<= :: Data_PartialFunction -> Data_PartialFunction -> Bool
$c> :: Data_PartialFunction -> Data_PartialFunction -> Bool
> :: Data_PartialFunction -> Data_PartialFunction -> Bool
$c>= :: Data_PartialFunction -> Data_PartialFunction -> Bool
>= :: Data_PartialFunction -> Data_PartialFunction -> Bool
$cmax :: Data_PartialFunction
-> Data_PartialFunction -> Data_PartialFunction
max :: Data_PartialFunction
-> Data_PartialFunction -> Data_PartialFunction
$cmin :: Data_PartialFunction
-> Data_PartialFunction -> Data_PartialFunction
min :: Data_PartialFunction
-> Data_PartialFunction -> Data_PartialFunction
Ord, ReadPrec [Data_PartialFunction]
ReadPrec Data_PartialFunction
Int -> ReadS Data_PartialFunction
ReadS [Data_PartialFunction]
(Int -> ReadS Data_PartialFunction)
-> ReadS [Data_PartialFunction]
-> ReadPrec Data_PartialFunction
-> ReadPrec [Data_PartialFunction]
-> Read Data_PartialFunction
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_PartialFunction
readsPrec :: Int -> ReadS Data_PartialFunction
$creadList :: ReadS [Data_PartialFunction]
readList :: ReadS [Data_PartialFunction]
$creadPrec :: ReadPrec Data_PartialFunction
readPrec :: ReadPrec Data_PartialFunction
$creadListPrec :: ReadPrec [Data_PartialFunction]
readListPrec :: ReadPrec [Data_PartialFunction]
Read, Int -> Data_PartialFunction -> String -> String
[Data_PartialFunction] -> String -> String
Data_PartialFunction -> String
(Int -> Data_PartialFunction -> String -> String)
-> (Data_PartialFunction -> String)
-> ([Data_PartialFunction] -> String -> String)
-> Show Data_PartialFunction
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_PartialFunction -> String -> String
showsPrec :: Int -> Data_PartialFunction -> String -> String
$cshow :: Data_PartialFunction -> String
show :: Data_PartialFunction -> String
$cshowList :: [Data_PartialFunction] -> String -> String
showList :: [Data_PartialFunction] -> String -> String
Show)

_Data_PartialFunction :: Name
_Data_PartialFunction = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.PartialFunction")

_Data_PartialFunction_cases :: Name
_Data_PartialFunction_cases = (String -> Name
Core.Name String
"cases")

data Data_While = 
  Data_While {
    Data_While -> Data
data_WhileExpr :: Data,
    Data_While -> Data
data_WhileBody :: Data}
  deriving (Data_While -> Data_While -> Bool
(Data_While -> Data_While -> Bool)
-> (Data_While -> Data_While -> Bool) -> Eq Data_While
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_While -> Data_While -> Bool
== :: Data_While -> Data_While -> Bool
$c/= :: Data_While -> Data_While -> Bool
/= :: Data_While -> Data_While -> Bool
Eq, Eq Data_While
Eq Data_While =>
(Data_While -> Data_While -> Ordering)
-> (Data_While -> Data_While -> Bool)
-> (Data_While -> Data_While -> Bool)
-> (Data_While -> Data_While -> Bool)
-> (Data_While -> Data_While -> Bool)
-> (Data_While -> Data_While -> Data_While)
-> (Data_While -> Data_While -> Data_While)
-> Ord Data_While
Data_While -> Data_While -> Bool
Data_While -> Data_While -> Ordering
Data_While -> Data_While -> Data_While
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_While -> Data_While -> Ordering
compare :: Data_While -> Data_While -> Ordering
$c< :: Data_While -> Data_While -> Bool
< :: Data_While -> Data_While -> Bool
$c<= :: Data_While -> Data_While -> Bool
<= :: Data_While -> Data_While -> Bool
$c> :: Data_While -> Data_While -> Bool
> :: Data_While -> Data_While -> Bool
$c>= :: Data_While -> Data_While -> Bool
>= :: Data_While -> Data_While -> Bool
$cmax :: Data_While -> Data_While -> Data_While
max :: Data_While -> Data_While -> Data_While
$cmin :: Data_While -> Data_While -> Data_While
min :: Data_While -> Data_While -> Data_While
Ord, ReadPrec [Data_While]
ReadPrec Data_While
Int -> ReadS Data_While
ReadS [Data_While]
(Int -> ReadS Data_While)
-> ReadS [Data_While]
-> ReadPrec Data_While
-> ReadPrec [Data_While]
-> Read Data_While
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_While
readsPrec :: Int -> ReadS Data_While
$creadList :: ReadS [Data_While]
readList :: ReadS [Data_While]
$creadPrec :: ReadPrec Data_While
readPrec :: ReadPrec Data_While
$creadListPrec :: ReadPrec [Data_While]
readListPrec :: ReadPrec [Data_While]
Read, Int -> Data_While -> String -> String
[Data_While] -> String -> String
Data_While -> String
(Int -> Data_While -> String -> String)
-> (Data_While -> String)
-> ([Data_While] -> String -> String)
-> Show Data_While
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_While -> String -> String
showsPrec :: Int -> Data_While -> String -> String
$cshow :: Data_While -> String
show :: Data_While -> String
$cshowList :: [Data_While] -> String -> String
showList :: [Data_While] -> String -> String
Show)

_Data_While :: Name
_Data_While = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.While")

_Data_While_expr :: Name
_Data_While_expr = (String -> Name
Core.Name String
"expr")

_Data_While_body :: Name
_Data_While_body = (String -> Name
Core.Name String
"body")

data Data_Do = 
  Data_Do {
    Data_Do -> Data
data_DoBody :: Data,
    Data_Do -> Data
data_DoExpr :: Data}
  deriving (Data_Do -> Data_Do -> Bool
(Data_Do -> Data_Do -> Bool)
-> (Data_Do -> Data_Do -> Bool) -> Eq Data_Do
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Do -> Data_Do -> Bool
== :: Data_Do -> Data_Do -> Bool
$c/= :: Data_Do -> Data_Do -> Bool
/= :: Data_Do -> Data_Do -> Bool
Eq, Eq Data_Do
Eq Data_Do =>
(Data_Do -> Data_Do -> Ordering)
-> (Data_Do -> Data_Do -> Bool)
-> (Data_Do -> Data_Do -> Bool)
-> (Data_Do -> Data_Do -> Bool)
-> (Data_Do -> Data_Do -> Bool)
-> (Data_Do -> Data_Do -> Data_Do)
-> (Data_Do -> Data_Do -> Data_Do)
-> Ord Data_Do
Data_Do -> Data_Do -> Bool
Data_Do -> Data_Do -> Ordering
Data_Do -> Data_Do -> Data_Do
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Do -> Data_Do -> Ordering
compare :: Data_Do -> Data_Do -> Ordering
$c< :: Data_Do -> Data_Do -> Bool
< :: Data_Do -> Data_Do -> Bool
$c<= :: Data_Do -> Data_Do -> Bool
<= :: Data_Do -> Data_Do -> Bool
$c> :: Data_Do -> Data_Do -> Bool
> :: Data_Do -> Data_Do -> Bool
$c>= :: Data_Do -> Data_Do -> Bool
>= :: Data_Do -> Data_Do -> Bool
$cmax :: Data_Do -> Data_Do -> Data_Do
max :: Data_Do -> Data_Do -> Data_Do
$cmin :: Data_Do -> Data_Do -> Data_Do
min :: Data_Do -> Data_Do -> Data_Do
Ord, ReadPrec [Data_Do]
ReadPrec Data_Do
Int -> ReadS Data_Do
ReadS [Data_Do]
(Int -> ReadS Data_Do)
-> ReadS [Data_Do]
-> ReadPrec Data_Do
-> ReadPrec [Data_Do]
-> Read Data_Do
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Do
readsPrec :: Int -> ReadS Data_Do
$creadList :: ReadS [Data_Do]
readList :: ReadS [Data_Do]
$creadPrec :: ReadPrec Data_Do
readPrec :: ReadPrec Data_Do
$creadListPrec :: ReadPrec [Data_Do]
readListPrec :: ReadPrec [Data_Do]
Read, Int -> Data_Do -> String -> String
[Data_Do] -> String -> String
Data_Do -> String
(Int -> Data_Do -> String -> String)
-> (Data_Do -> String)
-> ([Data_Do] -> String -> String)
-> Show Data_Do
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Do -> String -> String
showsPrec :: Int -> Data_Do -> String -> String
$cshow :: Data_Do -> String
show :: Data_Do -> String
$cshowList :: [Data_Do] -> String -> String
showList :: [Data_Do] -> String -> String
Show)

_Data_Do :: Name
_Data_Do = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Do")

_Data_Do_body :: Name
_Data_Do_body = (String -> Name
Core.Name String
"body")

_Data_Do_expr :: Name
_Data_Do_expr = (String -> Name
Core.Name String
"expr")

data Data_For = 
  Data_For {
    Data_For -> [Enumerator]
data_ForEnums :: [Enumerator]}
  deriving (Data_For -> Data_For -> Bool
(Data_For -> Data_For -> Bool)
-> (Data_For -> Data_For -> Bool) -> Eq Data_For
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_For -> Data_For -> Bool
== :: Data_For -> Data_For -> Bool
$c/= :: Data_For -> Data_For -> Bool
/= :: Data_For -> Data_For -> Bool
Eq, Eq Data_For
Eq Data_For =>
(Data_For -> Data_For -> Ordering)
-> (Data_For -> Data_For -> Bool)
-> (Data_For -> Data_For -> Bool)
-> (Data_For -> Data_For -> Bool)
-> (Data_For -> Data_For -> Bool)
-> (Data_For -> Data_For -> Data_For)
-> (Data_For -> Data_For -> Data_For)
-> Ord Data_For
Data_For -> Data_For -> Bool
Data_For -> Data_For -> Ordering
Data_For -> Data_For -> Data_For
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_For -> Data_For -> Ordering
compare :: Data_For -> Data_For -> Ordering
$c< :: Data_For -> Data_For -> Bool
< :: Data_For -> Data_For -> Bool
$c<= :: Data_For -> Data_For -> Bool
<= :: Data_For -> Data_For -> Bool
$c> :: Data_For -> Data_For -> Bool
> :: Data_For -> Data_For -> Bool
$c>= :: Data_For -> Data_For -> Bool
>= :: Data_For -> Data_For -> Bool
$cmax :: Data_For -> Data_For -> Data_For
max :: Data_For -> Data_For -> Data_For
$cmin :: Data_For -> Data_For -> Data_For
min :: Data_For -> Data_For -> Data_For
Ord, ReadPrec [Data_For]
ReadPrec Data_For
Int -> ReadS Data_For
ReadS [Data_For]
(Int -> ReadS Data_For)
-> ReadS [Data_For]
-> ReadPrec Data_For
-> ReadPrec [Data_For]
-> Read Data_For
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_For
readsPrec :: Int -> ReadS Data_For
$creadList :: ReadS [Data_For]
readList :: ReadS [Data_For]
$creadPrec :: ReadPrec Data_For
readPrec :: ReadPrec Data_For
$creadListPrec :: ReadPrec [Data_For]
readListPrec :: ReadPrec [Data_For]
Read, Int -> Data_For -> String -> String
[Data_For] -> String -> String
Data_For -> String
(Int -> Data_For -> String -> String)
-> (Data_For -> String)
-> ([Data_For] -> String -> String)
-> Show Data_For
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_For -> String -> String
showsPrec :: Int -> Data_For -> String -> String
$cshow :: Data_For -> String
show :: Data_For -> String
$cshowList :: [Data_For] -> String -> String
showList :: [Data_For] -> String -> String
Show)

_Data_For :: Name
_Data_For = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.For")

_Data_For_enums :: Name
_Data_For_enums = (String -> Name
Core.Name String
"enums")

data Data_ForYield = 
  Data_ForYield {
    Data_ForYield -> [Enumerator]
data_ForYieldEnums :: [Enumerator]}
  deriving (Data_ForYield -> Data_ForYield -> Bool
(Data_ForYield -> Data_ForYield -> Bool)
-> (Data_ForYield -> Data_ForYield -> Bool) -> Eq Data_ForYield
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_ForYield -> Data_ForYield -> Bool
== :: Data_ForYield -> Data_ForYield -> Bool
$c/= :: Data_ForYield -> Data_ForYield -> Bool
/= :: Data_ForYield -> Data_ForYield -> Bool
Eq, Eq Data_ForYield
Eq Data_ForYield =>
(Data_ForYield -> Data_ForYield -> Ordering)
-> (Data_ForYield -> Data_ForYield -> Bool)
-> (Data_ForYield -> Data_ForYield -> Bool)
-> (Data_ForYield -> Data_ForYield -> Bool)
-> (Data_ForYield -> Data_ForYield -> Bool)
-> (Data_ForYield -> Data_ForYield -> Data_ForYield)
-> (Data_ForYield -> Data_ForYield -> Data_ForYield)
-> Ord Data_ForYield
Data_ForYield -> Data_ForYield -> Bool
Data_ForYield -> Data_ForYield -> Ordering
Data_ForYield -> Data_ForYield -> Data_ForYield
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_ForYield -> Data_ForYield -> Ordering
compare :: Data_ForYield -> Data_ForYield -> Ordering
$c< :: Data_ForYield -> Data_ForYield -> Bool
< :: Data_ForYield -> Data_ForYield -> Bool
$c<= :: Data_ForYield -> Data_ForYield -> Bool
<= :: Data_ForYield -> Data_ForYield -> Bool
$c> :: Data_ForYield -> Data_ForYield -> Bool
> :: Data_ForYield -> Data_ForYield -> Bool
$c>= :: Data_ForYield -> Data_ForYield -> Bool
>= :: Data_ForYield -> Data_ForYield -> Bool
$cmax :: Data_ForYield -> Data_ForYield -> Data_ForYield
max :: Data_ForYield -> Data_ForYield -> Data_ForYield
$cmin :: Data_ForYield -> Data_ForYield -> Data_ForYield
min :: Data_ForYield -> Data_ForYield -> Data_ForYield
Ord, ReadPrec [Data_ForYield]
ReadPrec Data_ForYield
Int -> ReadS Data_ForYield
ReadS [Data_ForYield]
(Int -> ReadS Data_ForYield)
-> ReadS [Data_ForYield]
-> ReadPrec Data_ForYield
-> ReadPrec [Data_ForYield]
-> Read Data_ForYield
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_ForYield
readsPrec :: Int -> ReadS Data_ForYield
$creadList :: ReadS [Data_ForYield]
readList :: ReadS [Data_ForYield]
$creadPrec :: ReadPrec Data_ForYield
readPrec :: ReadPrec Data_ForYield
$creadListPrec :: ReadPrec [Data_ForYield]
readListPrec :: ReadPrec [Data_ForYield]
Read, Int -> Data_ForYield -> String -> String
[Data_ForYield] -> String -> String
Data_ForYield -> String
(Int -> Data_ForYield -> String -> String)
-> (Data_ForYield -> String)
-> ([Data_ForYield] -> String -> String)
-> Show Data_ForYield
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_ForYield -> String -> String
showsPrec :: Int -> Data_ForYield -> String -> String
$cshow :: Data_ForYield -> String
show :: Data_ForYield -> String
$cshowList :: [Data_ForYield] -> String -> String
showList :: [Data_ForYield] -> String -> String
Show)

_Data_ForYield :: Name
_Data_ForYield = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.ForYield")

_Data_ForYield_enums :: Name
_Data_ForYield_enums = (String -> Name
Core.Name String
"enums")

data Data_New = 
  Data_New {
    Data_New -> Init
data_NewInit :: Init}
  deriving (Data_New -> Data_New -> Bool
(Data_New -> Data_New -> Bool)
-> (Data_New -> Data_New -> Bool) -> Eq Data_New
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_New -> Data_New -> Bool
== :: Data_New -> Data_New -> Bool
$c/= :: Data_New -> Data_New -> Bool
/= :: Data_New -> Data_New -> Bool
Eq, Eq Data_New
Eq Data_New =>
(Data_New -> Data_New -> Ordering)
-> (Data_New -> Data_New -> Bool)
-> (Data_New -> Data_New -> Bool)
-> (Data_New -> Data_New -> Bool)
-> (Data_New -> Data_New -> Bool)
-> (Data_New -> Data_New -> Data_New)
-> (Data_New -> Data_New -> Data_New)
-> Ord Data_New
Data_New -> Data_New -> Bool
Data_New -> Data_New -> Ordering
Data_New -> Data_New -> Data_New
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_New -> Data_New -> Ordering
compare :: Data_New -> Data_New -> Ordering
$c< :: Data_New -> Data_New -> Bool
< :: Data_New -> Data_New -> Bool
$c<= :: Data_New -> Data_New -> Bool
<= :: Data_New -> Data_New -> Bool
$c> :: Data_New -> Data_New -> Bool
> :: Data_New -> Data_New -> Bool
$c>= :: Data_New -> Data_New -> Bool
>= :: Data_New -> Data_New -> Bool
$cmax :: Data_New -> Data_New -> Data_New
max :: Data_New -> Data_New -> Data_New
$cmin :: Data_New -> Data_New -> Data_New
min :: Data_New -> Data_New -> Data_New
Ord, ReadPrec [Data_New]
ReadPrec Data_New
Int -> ReadS Data_New
ReadS [Data_New]
(Int -> ReadS Data_New)
-> ReadS [Data_New]
-> ReadPrec Data_New
-> ReadPrec [Data_New]
-> Read Data_New
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_New
readsPrec :: Int -> ReadS Data_New
$creadList :: ReadS [Data_New]
readList :: ReadS [Data_New]
$creadPrec :: ReadPrec Data_New
readPrec :: ReadPrec Data_New
$creadListPrec :: ReadPrec [Data_New]
readListPrec :: ReadPrec [Data_New]
Read, Int -> Data_New -> String -> String
[Data_New] -> String -> String
Data_New -> String
(Int -> Data_New -> String -> String)
-> (Data_New -> String)
-> ([Data_New] -> String -> String)
-> Show Data_New
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_New -> String -> String
showsPrec :: Int -> Data_New -> String -> String
$cshow :: Data_New -> String
show :: Data_New -> String
$cshowList :: [Data_New] -> String -> String
showList :: [Data_New] -> String -> String
Show)

_Data_New :: Name
_Data_New = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.New")

_Data_New_init :: Name
_Data_New_init = (String -> Name
Core.Name String
"init")

data Data_NewAnonymous = 
  Data_NewAnonymous {
    Data_NewAnonymous -> Template
data_NewAnonymousTempl :: Template}
  deriving (Data_NewAnonymous -> Data_NewAnonymous -> Bool
(Data_NewAnonymous -> Data_NewAnonymous -> Bool)
-> (Data_NewAnonymous -> Data_NewAnonymous -> Bool)
-> Eq Data_NewAnonymous
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_NewAnonymous -> Data_NewAnonymous -> Bool
== :: Data_NewAnonymous -> Data_NewAnonymous -> Bool
$c/= :: Data_NewAnonymous -> Data_NewAnonymous -> Bool
/= :: Data_NewAnonymous -> Data_NewAnonymous -> Bool
Eq, Eq Data_NewAnonymous
Eq Data_NewAnonymous =>
(Data_NewAnonymous -> Data_NewAnonymous -> Ordering)
-> (Data_NewAnonymous -> Data_NewAnonymous -> Bool)
-> (Data_NewAnonymous -> Data_NewAnonymous -> Bool)
-> (Data_NewAnonymous -> Data_NewAnonymous -> Bool)
-> (Data_NewAnonymous -> Data_NewAnonymous -> Bool)
-> (Data_NewAnonymous -> Data_NewAnonymous -> Data_NewAnonymous)
-> (Data_NewAnonymous -> Data_NewAnonymous -> Data_NewAnonymous)
-> Ord Data_NewAnonymous
Data_NewAnonymous -> Data_NewAnonymous -> Bool
Data_NewAnonymous -> Data_NewAnonymous -> Ordering
Data_NewAnonymous -> Data_NewAnonymous -> Data_NewAnonymous
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_NewAnonymous -> Data_NewAnonymous -> Ordering
compare :: Data_NewAnonymous -> Data_NewAnonymous -> Ordering
$c< :: Data_NewAnonymous -> Data_NewAnonymous -> Bool
< :: Data_NewAnonymous -> Data_NewAnonymous -> Bool
$c<= :: Data_NewAnonymous -> Data_NewAnonymous -> Bool
<= :: Data_NewAnonymous -> Data_NewAnonymous -> Bool
$c> :: Data_NewAnonymous -> Data_NewAnonymous -> Bool
> :: Data_NewAnonymous -> Data_NewAnonymous -> Bool
$c>= :: Data_NewAnonymous -> Data_NewAnonymous -> Bool
>= :: Data_NewAnonymous -> Data_NewAnonymous -> Bool
$cmax :: Data_NewAnonymous -> Data_NewAnonymous -> Data_NewAnonymous
max :: Data_NewAnonymous -> Data_NewAnonymous -> Data_NewAnonymous
$cmin :: Data_NewAnonymous -> Data_NewAnonymous -> Data_NewAnonymous
min :: Data_NewAnonymous -> Data_NewAnonymous -> Data_NewAnonymous
Ord, ReadPrec [Data_NewAnonymous]
ReadPrec Data_NewAnonymous
Int -> ReadS Data_NewAnonymous
ReadS [Data_NewAnonymous]
(Int -> ReadS Data_NewAnonymous)
-> ReadS [Data_NewAnonymous]
-> ReadPrec Data_NewAnonymous
-> ReadPrec [Data_NewAnonymous]
-> Read Data_NewAnonymous
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_NewAnonymous
readsPrec :: Int -> ReadS Data_NewAnonymous
$creadList :: ReadS [Data_NewAnonymous]
readList :: ReadS [Data_NewAnonymous]
$creadPrec :: ReadPrec Data_NewAnonymous
readPrec :: ReadPrec Data_NewAnonymous
$creadListPrec :: ReadPrec [Data_NewAnonymous]
readListPrec :: ReadPrec [Data_NewAnonymous]
Read, Int -> Data_NewAnonymous -> String -> String
[Data_NewAnonymous] -> String -> String
Data_NewAnonymous -> String
(Int -> Data_NewAnonymous -> String -> String)
-> (Data_NewAnonymous -> String)
-> ([Data_NewAnonymous] -> String -> String)
-> Show Data_NewAnonymous
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_NewAnonymous -> String -> String
showsPrec :: Int -> Data_NewAnonymous -> String -> String
$cshow :: Data_NewAnonymous -> String
show :: Data_NewAnonymous -> String
$cshowList :: [Data_NewAnonymous] -> String -> String
showList :: [Data_NewAnonymous] -> String -> String
Show)

_Data_NewAnonymous :: Name
_Data_NewAnonymous = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.NewAnonymous")

_Data_NewAnonymous_templ :: Name
_Data_NewAnonymous_templ = (String -> Name
Core.Name String
"templ")

data Data_Placeholder = 
  Data_Placeholder {}
  deriving (Data_Placeholder -> Data_Placeholder -> Bool
(Data_Placeholder -> Data_Placeholder -> Bool)
-> (Data_Placeholder -> Data_Placeholder -> Bool)
-> Eq Data_Placeholder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Placeholder -> Data_Placeholder -> Bool
== :: Data_Placeholder -> Data_Placeholder -> Bool
$c/= :: Data_Placeholder -> Data_Placeholder -> Bool
/= :: Data_Placeholder -> Data_Placeholder -> Bool
Eq, Eq Data_Placeholder
Eq Data_Placeholder =>
(Data_Placeholder -> Data_Placeholder -> Ordering)
-> (Data_Placeholder -> Data_Placeholder -> Bool)
-> (Data_Placeholder -> Data_Placeholder -> Bool)
-> (Data_Placeholder -> Data_Placeholder -> Bool)
-> (Data_Placeholder -> Data_Placeholder -> Bool)
-> (Data_Placeholder -> Data_Placeholder -> Data_Placeholder)
-> (Data_Placeholder -> Data_Placeholder -> Data_Placeholder)
-> Ord Data_Placeholder
Data_Placeholder -> Data_Placeholder -> Bool
Data_Placeholder -> Data_Placeholder -> Ordering
Data_Placeholder -> Data_Placeholder -> Data_Placeholder
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Placeholder -> Data_Placeholder -> Ordering
compare :: Data_Placeholder -> Data_Placeholder -> Ordering
$c< :: Data_Placeholder -> Data_Placeholder -> Bool
< :: Data_Placeholder -> Data_Placeholder -> Bool
$c<= :: Data_Placeholder -> Data_Placeholder -> Bool
<= :: Data_Placeholder -> Data_Placeholder -> Bool
$c> :: Data_Placeholder -> Data_Placeholder -> Bool
> :: Data_Placeholder -> Data_Placeholder -> Bool
$c>= :: Data_Placeholder -> Data_Placeholder -> Bool
>= :: Data_Placeholder -> Data_Placeholder -> Bool
$cmax :: Data_Placeholder -> Data_Placeholder -> Data_Placeholder
max :: Data_Placeholder -> Data_Placeholder -> Data_Placeholder
$cmin :: Data_Placeholder -> Data_Placeholder -> Data_Placeholder
min :: Data_Placeholder -> Data_Placeholder -> Data_Placeholder
Ord, ReadPrec [Data_Placeholder]
ReadPrec Data_Placeholder
Int -> ReadS Data_Placeholder
ReadS [Data_Placeholder]
(Int -> ReadS Data_Placeholder)
-> ReadS [Data_Placeholder]
-> ReadPrec Data_Placeholder
-> ReadPrec [Data_Placeholder]
-> Read Data_Placeholder
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Placeholder
readsPrec :: Int -> ReadS Data_Placeholder
$creadList :: ReadS [Data_Placeholder]
readList :: ReadS [Data_Placeholder]
$creadPrec :: ReadPrec Data_Placeholder
readPrec :: ReadPrec Data_Placeholder
$creadListPrec :: ReadPrec [Data_Placeholder]
readListPrec :: ReadPrec [Data_Placeholder]
Read, Int -> Data_Placeholder -> String -> String
[Data_Placeholder] -> String -> String
Data_Placeholder -> String
(Int -> Data_Placeholder -> String -> String)
-> (Data_Placeholder -> String)
-> ([Data_Placeholder] -> String -> String)
-> Show Data_Placeholder
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Placeholder -> String -> String
showsPrec :: Int -> Data_Placeholder -> String -> String
$cshow :: Data_Placeholder -> String
show :: Data_Placeholder -> String
$cshowList :: [Data_Placeholder] -> String -> String
showList :: [Data_Placeholder] -> String -> String
Show)

_Data_Placeholder :: Name
_Data_Placeholder = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Placeholder")

data Data_Eta = 
  Data_Eta {
    Data_Eta -> Data
data_EtaExpr :: Data}
  deriving (Data_Eta -> Data_Eta -> Bool
(Data_Eta -> Data_Eta -> Bool)
-> (Data_Eta -> Data_Eta -> Bool) -> Eq Data_Eta
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Eta -> Data_Eta -> Bool
== :: Data_Eta -> Data_Eta -> Bool
$c/= :: Data_Eta -> Data_Eta -> Bool
/= :: Data_Eta -> Data_Eta -> Bool
Eq, Eq Data_Eta
Eq Data_Eta =>
(Data_Eta -> Data_Eta -> Ordering)
-> (Data_Eta -> Data_Eta -> Bool)
-> (Data_Eta -> Data_Eta -> Bool)
-> (Data_Eta -> Data_Eta -> Bool)
-> (Data_Eta -> Data_Eta -> Bool)
-> (Data_Eta -> Data_Eta -> Data_Eta)
-> (Data_Eta -> Data_Eta -> Data_Eta)
-> Ord Data_Eta
Data_Eta -> Data_Eta -> Bool
Data_Eta -> Data_Eta -> Ordering
Data_Eta -> Data_Eta -> Data_Eta
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Eta -> Data_Eta -> Ordering
compare :: Data_Eta -> Data_Eta -> Ordering
$c< :: Data_Eta -> Data_Eta -> Bool
< :: Data_Eta -> Data_Eta -> Bool
$c<= :: Data_Eta -> Data_Eta -> Bool
<= :: Data_Eta -> Data_Eta -> Bool
$c> :: Data_Eta -> Data_Eta -> Bool
> :: Data_Eta -> Data_Eta -> Bool
$c>= :: Data_Eta -> Data_Eta -> Bool
>= :: Data_Eta -> Data_Eta -> Bool
$cmax :: Data_Eta -> Data_Eta -> Data_Eta
max :: Data_Eta -> Data_Eta -> Data_Eta
$cmin :: Data_Eta -> Data_Eta -> Data_Eta
min :: Data_Eta -> Data_Eta -> Data_Eta
Ord, ReadPrec [Data_Eta]
ReadPrec Data_Eta
Int -> ReadS Data_Eta
ReadS [Data_Eta]
(Int -> ReadS Data_Eta)
-> ReadS [Data_Eta]
-> ReadPrec Data_Eta
-> ReadPrec [Data_Eta]
-> Read Data_Eta
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Eta
readsPrec :: Int -> ReadS Data_Eta
$creadList :: ReadS [Data_Eta]
readList :: ReadS [Data_Eta]
$creadPrec :: ReadPrec Data_Eta
readPrec :: ReadPrec Data_Eta
$creadListPrec :: ReadPrec [Data_Eta]
readListPrec :: ReadPrec [Data_Eta]
Read, Int -> Data_Eta -> String -> String
[Data_Eta] -> String -> String
Data_Eta -> String
(Int -> Data_Eta -> String -> String)
-> (Data_Eta -> String)
-> ([Data_Eta] -> String -> String)
-> Show Data_Eta
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Eta -> String -> String
showsPrec :: Int -> Data_Eta -> String -> String
$cshow :: Data_Eta -> String
show :: Data_Eta -> String
$cshowList :: [Data_Eta] -> String -> String
showList :: [Data_Eta] -> String -> String
Show)

_Data_Eta :: Name
_Data_Eta = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Eta")

_Data_Eta_expr :: Name
_Data_Eta_expr = (String -> Name
Core.Name String
"expr")

data Data_Repeated = 
  Data_Repeated {
    Data_Repeated -> Data
data_RepeatedExpr :: Data}
  deriving (Data_Repeated -> Data_Repeated -> Bool
(Data_Repeated -> Data_Repeated -> Bool)
-> (Data_Repeated -> Data_Repeated -> Bool) -> Eq Data_Repeated
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Repeated -> Data_Repeated -> Bool
== :: Data_Repeated -> Data_Repeated -> Bool
$c/= :: Data_Repeated -> Data_Repeated -> Bool
/= :: Data_Repeated -> Data_Repeated -> Bool
Eq, Eq Data_Repeated
Eq Data_Repeated =>
(Data_Repeated -> Data_Repeated -> Ordering)
-> (Data_Repeated -> Data_Repeated -> Bool)
-> (Data_Repeated -> Data_Repeated -> Bool)
-> (Data_Repeated -> Data_Repeated -> Bool)
-> (Data_Repeated -> Data_Repeated -> Bool)
-> (Data_Repeated -> Data_Repeated -> Data_Repeated)
-> (Data_Repeated -> Data_Repeated -> Data_Repeated)
-> Ord Data_Repeated
Data_Repeated -> Data_Repeated -> Bool
Data_Repeated -> Data_Repeated -> Ordering
Data_Repeated -> Data_Repeated -> Data_Repeated
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Repeated -> Data_Repeated -> Ordering
compare :: Data_Repeated -> Data_Repeated -> Ordering
$c< :: Data_Repeated -> Data_Repeated -> Bool
< :: Data_Repeated -> Data_Repeated -> Bool
$c<= :: Data_Repeated -> Data_Repeated -> Bool
<= :: Data_Repeated -> Data_Repeated -> Bool
$c> :: Data_Repeated -> Data_Repeated -> Bool
> :: Data_Repeated -> Data_Repeated -> Bool
$c>= :: Data_Repeated -> Data_Repeated -> Bool
>= :: Data_Repeated -> Data_Repeated -> Bool
$cmax :: Data_Repeated -> Data_Repeated -> Data_Repeated
max :: Data_Repeated -> Data_Repeated -> Data_Repeated
$cmin :: Data_Repeated -> Data_Repeated -> Data_Repeated
min :: Data_Repeated -> Data_Repeated -> Data_Repeated
Ord, ReadPrec [Data_Repeated]
ReadPrec Data_Repeated
Int -> ReadS Data_Repeated
ReadS [Data_Repeated]
(Int -> ReadS Data_Repeated)
-> ReadS [Data_Repeated]
-> ReadPrec Data_Repeated
-> ReadPrec [Data_Repeated]
-> Read Data_Repeated
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Repeated
readsPrec :: Int -> ReadS Data_Repeated
$creadList :: ReadS [Data_Repeated]
readList :: ReadS [Data_Repeated]
$creadPrec :: ReadPrec Data_Repeated
readPrec :: ReadPrec Data_Repeated
$creadListPrec :: ReadPrec [Data_Repeated]
readListPrec :: ReadPrec [Data_Repeated]
Read, Int -> Data_Repeated -> String -> String
[Data_Repeated] -> String -> String
Data_Repeated -> String
(Int -> Data_Repeated -> String -> String)
-> (Data_Repeated -> String)
-> ([Data_Repeated] -> String -> String)
-> Show Data_Repeated
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Repeated -> String -> String
showsPrec :: Int -> Data_Repeated -> String -> String
$cshow :: Data_Repeated -> String
show :: Data_Repeated -> String
$cshowList :: [Data_Repeated] -> String -> String
showList :: [Data_Repeated] -> String -> String
Show)

_Data_Repeated :: Name
_Data_Repeated = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Repeated")

_Data_Repeated_expr :: Name
_Data_Repeated_expr = (String -> Name
Core.Name String
"expr")

data Data_Param = 
  Data_Param {
    Data_Param -> [Mod]
data_ParamMods :: [Mod],
    Data_Param -> Name
data_ParamName :: Name,
    Data_Param -> Maybe Type
data_ParamDecltpe :: (Maybe Type),
    Data_Param -> Maybe Data
data_ParamDefault :: (Maybe Data)}
  deriving (Data_Param -> Data_Param -> Bool
(Data_Param -> Data_Param -> Bool)
-> (Data_Param -> Data_Param -> Bool) -> Eq Data_Param
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Data_Param -> Data_Param -> Bool
== :: Data_Param -> Data_Param -> Bool
$c/= :: Data_Param -> Data_Param -> Bool
/= :: Data_Param -> Data_Param -> Bool
Eq, Eq Data_Param
Eq Data_Param =>
(Data_Param -> Data_Param -> Ordering)
-> (Data_Param -> Data_Param -> Bool)
-> (Data_Param -> Data_Param -> Bool)
-> (Data_Param -> Data_Param -> Bool)
-> (Data_Param -> Data_Param -> Bool)
-> (Data_Param -> Data_Param -> Data_Param)
-> (Data_Param -> Data_Param -> Data_Param)
-> Ord Data_Param
Data_Param -> Data_Param -> Bool
Data_Param -> Data_Param -> Ordering
Data_Param -> Data_Param -> Data_Param
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Data_Param -> Data_Param -> Ordering
compare :: Data_Param -> Data_Param -> Ordering
$c< :: Data_Param -> Data_Param -> Bool
< :: Data_Param -> Data_Param -> Bool
$c<= :: Data_Param -> Data_Param -> Bool
<= :: Data_Param -> Data_Param -> Bool
$c> :: Data_Param -> Data_Param -> Bool
> :: Data_Param -> Data_Param -> Bool
$c>= :: Data_Param -> Data_Param -> Bool
>= :: Data_Param -> Data_Param -> Bool
$cmax :: Data_Param -> Data_Param -> Data_Param
max :: Data_Param -> Data_Param -> Data_Param
$cmin :: Data_Param -> Data_Param -> Data_Param
min :: Data_Param -> Data_Param -> Data_Param
Ord, ReadPrec [Data_Param]
ReadPrec Data_Param
Int -> ReadS Data_Param
ReadS [Data_Param]
(Int -> ReadS Data_Param)
-> ReadS [Data_Param]
-> ReadPrec Data_Param
-> ReadPrec [Data_Param]
-> Read Data_Param
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Data_Param
readsPrec :: Int -> ReadS Data_Param
$creadList :: ReadS [Data_Param]
readList :: ReadS [Data_Param]
$creadPrec :: ReadPrec Data_Param
readPrec :: ReadPrec Data_Param
$creadListPrec :: ReadPrec [Data_Param]
readListPrec :: ReadPrec [Data_Param]
Read, Int -> Data_Param -> String -> String
[Data_Param] -> String -> String
Data_Param -> String
(Int -> Data_Param -> String -> String)
-> (Data_Param -> String)
-> ([Data_Param] -> String -> String)
-> Show Data_Param
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Data_Param -> String -> String
showsPrec :: Int -> Data_Param -> String -> String
$cshow :: Data_Param -> String
show :: Data_Param -> String
$cshowList :: [Data_Param] -> String -> String
showList :: [Data_Param] -> String -> String
Show)

_Data_Param :: Name
_Data_Param = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Data.Param")

_Data_Param_mods :: Name
_Data_Param_mods = (String -> Name
Core.Name String
"mods")

_Data_Param_name :: Name
_Data_Param_name = (String -> Name
Core.Name String
"name")

_Data_Param_decltpe :: Name
_Data_Param_decltpe = (String -> Name
Core.Name String
"decltpe")

_Data_Param_default :: Name
_Data_Param_default = (String -> Name
Core.Name String
"default")

data Type = 
  TypeRef Type_Ref |
  TypeAnonymousName Type_AnonymousName |
  TypeApply Type_Apply |
  TypeApplyInfix Type_ApplyInfix |
  TypeFunctionType Type_FunctionType |
  TypePolyFunction Type_PolyFunction |
  TypeImplicitFunction Type_ImplicitFunction |
  TypeTuple Type_Tuple |
  TypeWith Type_With |
  TypeAnd Type_And |
  TypeOr Type_Or |
  TypeRefine Type_Refine |
  TypeExistential Type_Existential |
  TypeAnnotate Type_Annotate |
  TypeLambda Type_Lambda |
  TypeMacro Type_Macro |
  TypeMethod Type_Method |
  TypePlaceholder Type_Placeholder |
  TypeByName Type_ByName |
  TypeRepeated Type_Repeated |
  TypeVar Type_Var |
  TypeTypedParam Type_TypedParam |
  TypeMatch Type_Match
  deriving (Type -> Type -> Bool
(Type -> Type -> Bool) -> (Type -> Type -> Bool) -> Eq Type
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type -> Type -> Bool
== :: Type -> Type -> Bool
$c/= :: Type -> Type -> Bool
/= :: Type -> Type -> Bool
Eq, Eq Type
Eq Type =>
(Type -> Type -> Ordering)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Bool)
-> (Type -> Type -> Type)
-> (Type -> Type -> Type)
-> Ord Type
Type -> Type -> Bool
Type -> Type -> Ordering
Type -> Type -> Type
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type -> Type -> Ordering
compare :: Type -> Type -> Ordering
$c< :: Type -> Type -> Bool
< :: Type -> Type -> Bool
$c<= :: Type -> Type -> Bool
<= :: Type -> Type -> Bool
$c> :: Type -> Type -> Bool
> :: Type -> Type -> Bool
$c>= :: Type -> Type -> Bool
>= :: Type -> Type -> Bool
$cmax :: Type -> Type -> Type
max :: Type -> Type -> Type
$cmin :: Type -> Type -> Type
min :: Type -> Type -> Type
Ord, ReadPrec [Type]
ReadPrec Type
Int -> ReadS Type
ReadS [Type]
(Int -> ReadS Type)
-> ReadS [Type] -> ReadPrec Type -> ReadPrec [Type] -> Read Type
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type
readsPrec :: Int -> ReadS Type
$creadList :: ReadS [Type]
readList :: ReadS [Type]
$creadPrec :: ReadPrec Type
readPrec :: ReadPrec Type
$creadListPrec :: ReadPrec [Type]
readListPrec :: ReadPrec [Type]
Read, Int -> Type -> String -> String
[Type] -> String -> String
Type -> String
(Int -> Type -> String -> String)
-> (Type -> String) -> ([Type] -> String -> String) -> Show Type
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type -> String -> String
showsPrec :: Int -> Type -> String -> String
$cshow :: Type -> String
show :: Type -> String
$cshowList :: [Type] -> String -> String
showList :: [Type] -> String -> String
Show)

_Type :: Name
_Type = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type")

_Type_ref :: Name
_Type_ref = (String -> Name
Core.Name String
"ref")

_Type_anonymousName :: Name
_Type_anonymousName = (String -> Name
Core.Name String
"anonymousName")

_Type_apply :: Name
_Type_apply = (String -> Name
Core.Name String
"apply")

_Type_applyInfix :: Name
_Type_applyInfix = (String -> Name
Core.Name String
"applyInfix")

_Type_functionType :: Name
_Type_functionType = (String -> Name
Core.Name String
"functionType")

_Type_polyFunction :: Name
_Type_polyFunction = (String -> Name
Core.Name String
"polyFunction")

_Type_implicitFunction :: Name
_Type_implicitFunction = (String -> Name
Core.Name String
"implicitFunction")

_Type_tuple :: Name
_Type_tuple = (String -> Name
Core.Name String
"tuple")

_Type_with :: Name
_Type_with = (String -> Name
Core.Name String
"with")

_Type_and :: Name
_Type_and = (String -> Name
Core.Name String
"and")

_Type_or :: Name
_Type_or = (String -> Name
Core.Name String
"or")

_Type_refine :: Name
_Type_refine = (String -> Name
Core.Name String
"refine")

_Type_existential :: Name
_Type_existential = (String -> Name
Core.Name String
"existential")

_Type_annotate :: Name
_Type_annotate = (String -> Name
Core.Name String
"annotate")

_Type_lambda :: Name
_Type_lambda = (String -> Name
Core.Name String
"lambda")

_Type_macro :: Name
_Type_macro = (String -> Name
Core.Name String
"macro")

_Type_method :: Name
_Type_method = (String -> Name
Core.Name String
"method")

_Type_placeholder :: Name
_Type_placeholder = (String -> Name
Core.Name String
"placeholder")

_Type_byName :: Name
_Type_byName = (String -> Name
Core.Name String
"byName")

_Type_repeated :: Name
_Type_repeated = (String -> Name
Core.Name String
"repeated")

_Type_var :: Name
_Type_var = (String -> Name
Core.Name String
"var")

_Type_typedParam :: Name
_Type_typedParam = (String -> Name
Core.Name String
"typedParam")

_Type_match :: Name
_Type_match = (String -> Name
Core.Name String
"match")

data Type_Ref = 
  Type_RefName Type_Name |
  Type_RefSelect Type_Select |
  Type_RefProject Type_Project |
  Type_RefSingleton Type_Singleton
  deriving (Type_Ref -> Type_Ref -> Bool
(Type_Ref -> Type_Ref -> Bool)
-> (Type_Ref -> Type_Ref -> Bool) -> Eq Type_Ref
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Ref -> Type_Ref -> Bool
== :: Type_Ref -> Type_Ref -> Bool
$c/= :: Type_Ref -> Type_Ref -> Bool
/= :: Type_Ref -> Type_Ref -> Bool
Eq, Eq Type_Ref
Eq Type_Ref =>
(Type_Ref -> Type_Ref -> Ordering)
-> (Type_Ref -> Type_Ref -> Bool)
-> (Type_Ref -> Type_Ref -> Bool)
-> (Type_Ref -> Type_Ref -> Bool)
-> (Type_Ref -> Type_Ref -> Bool)
-> (Type_Ref -> Type_Ref -> Type_Ref)
-> (Type_Ref -> Type_Ref -> Type_Ref)
-> Ord Type_Ref
Type_Ref -> Type_Ref -> Bool
Type_Ref -> Type_Ref -> Ordering
Type_Ref -> Type_Ref -> Type_Ref
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Ref -> Type_Ref -> Ordering
compare :: Type_Ref -> Type_Ref -> Ordering
$c< :: Type_Ref -> Type_Ref -> Bool
< :: Type_Ref -> Type_Ref -> Bool
$c<= :: Type_Ref -> Type_Ref -> Bool
<= :: Type_Ref -> Type_Ref -> Bool
$c> :: Type_Ref -> Type_Ref -> Bool
> :: Type_Ref -> Type_Ref -> Bool
$c>= :: Type_Ref -> Type_Ref -> Bool
>= :: Type_Ref -> Type_Ref -> Bool
$cmax :: Type_Ref -> Type_Ref -> Type_Ref
max :: Type_Ref -> Type_Ref -> Type_Ref
$cmin :: Type_Ref -> Type_Ref -> Type_Ref
min :: Type_Ref -> Type_Ref -> Type_Ref
Ord, ReadPrec [Type_Ref]
ReadPrec Type_Ref
Int -> ReadS Type_Ref
ReadS [Type_Ref]
(Int -> ReadS Type_Ref)
-> ReadS [Type_Ref]
-> ReadPrec Type_Ref
-> ReadPrec [Type_Ref]
-> Read Type_Ref
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Ref
readsPrec :: Int -> ReadS Type_Ref
$creadList :: ReadS [Type_Ref]
readList :: ReadS [Type_Ref]
$creadPrec :: ReadPrec Type_Ref
readPrec :: ReadPrec Type_Ref
$creadListPrec :: ReadPrec [Type_Ref]
readListPrec :: ReadPrec [Type_Ref]
Read, Int -> Type_Ref -> String -> String
[Type_Ref] -> String -> String
Type_Ref -> String
(Int -> Type_Ref -> String -> String)
-> (Type_Ref -> String)
-> ([Type_Ref] -> String -> String)
-> Show Type_Ref
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Ref -> String -> String
showsPrec :: Int -> Type_Ref -> String -> String
$cshow :: Type_Ref -> String
show :: Type_Ref -> String
$cshowList :: [Type_Ref] -> String -> String
showList :: [Type_Ref] -> String -> String
Show)

_Type_Ref :: Name
_Type_Ref = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Ref")

_Type_Ref_name :: Name
_Type_Ref_name = (String -> Name
Core.Name String
"name")

_Type_Ref_select :: Name
_Type_Ref_select = (String -> Name
Core.Name String
"select")

_Type_Ref_project :: Name
_Type_Ref_project = (String -> Name
Core.Name String
"project")

_Type_Ref_singleton :: Name
_Type_Ref_singleton = (String -> Name
Core.Name String
"singleton")

data Type_Name = 
  Type_Name {
    Type_Name -> String
type_NameValue :: String}
  deriving (Type_Name -> Type_Name -> Bool
(Type_Name -> Type_Name -> Bool)
-> (Type_Name -> Type_Name -> Bool) -> Eq Type_Name
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Name -> Type_Name -> Bool
== :: Type_Name -> Type_Name -> Bool
$c/= :: Type_Name -> Type_Name -> Bool
/= :: Type_Name -> Type_Name -> Bool
Eq, Eq Type_Name
Eq Type_Name =>
(Type_Name -> Type_Name -> Ordering)
-> (Type_Name -> Type_Name -> Bool)
-> (Type_Name -> Type_Name -> Bool)
-> (Type_Name -> Type_Name -> Bool)
-> (Type_Name -> Type_Name -> Bool)
-> (Type_Name -> Type_Name -> Type_Name)
-> (Type_Name -> Type_Name -> Type_Name)
-> Ord Type_Name
Type_Name -> Type_Name -> Bool
Type_Name -> Type_Name -> Ordering
Type_Name -> Type_Name -> Type_Name
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Name -> Type_Name -> Ordering
compare :: Type_Name -> Type_Name -> Ordering
$c< :: Type_Name -> Type_Name -> Bool
< :: Type_Name -> Type_Name -> Bool
$c<= :: Type_Name -> Type_Name -> Bool
<= :: Type_Name -> Type_Name -> Bool
$c> :: Type_Name -> Type_Name -> Bool
> :: Type_Name -> Type_Name -> Bool
$c>= :: Type_Name -> Type_Name -> Bool
>= :: Type_Name -> Type_Name -> Bool
$cmax :: Type_Name -> Type_Name -> Type_Name
max :: Type_Name -> Type_Name -> Type_Name
$cmin :: Type_Name -> Type_Name -> Type_Name
min :: Type_Name -> Type_Name -> Type_Name
Ord, ReadPrec [Type_Name]
ReadPrec Type_Name
Int -> ReadS Type_Name
ReadS [Type_Name]
(Int -> ReadS Type_Name)
-> ReadS [Type_Name]
-> ReadPrec Type_Name
-> ReadPrec [Type_Name]
-> Read Type_Name
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Name
readsPrec :: Int -> ReadS Type_Name
$creadList :: ReadS [Type_Name]
readList :: ReadS [Type_Name]
$creadPrec :: ReadPrec Type_Name
readPrec :: ReadPrec Type_Name
$creadListPrec :: ReadPrec [Type_Name]
readListPrec :: ReadPrec [Type_Name]
Read, Int -> Type_Name -> String -> String
[Type_Name] -> String -> String
Type_Name -> String
(Int -> Type_Name -> String -> String)
-> (Type_Name -> String)
-> ([Type_Name] -> String -> String)
-> Show Type_Name
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Name -> String -> String
showsPrec :: Int -> Type_Name -> String -> String
$cshow :: Type_Name -> String
show :: Type_Name -> String
$cshowList :: [Type_Name] -> String -> String
showList :: [Type_Name] -> String -> String
Show)

_Type_Name :: Name
_Type_Name = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Name")

_Type_Name_value :: Name
_Type_Name_value = (String -> Name
Core.Name String
"value")

data Type_AnonymousName = 
  Type_AnonymousName {}
  deriving (Type_AnonymousName -> Type_AnonymousName -> Bool
(Type_AnonymousName -> Type_AnonymousName -> Bool)
-> (Type_AnonymousName -> Type_AnonymousName -> Bool)
-> Eq Type_AnonymousName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_AnonymousName -> Type_AnonymousName -> Bool
== :: Type_AnonymousName -> Type_AnonymousName -> Bool
$c/= :: Type_AnonymousName -> Type_AnonymousName -> Bool
/= :: Type_AnonymousName -> Type_AnonymousName -> Bool
Eq, Eq Type_AnonymousName
Eq Type_AnonymousName =>
(Type_AnonymousName -> Type_AnonymousName -> Ordering)
-> (Type_AnonymousName -> Type_AnonymousName -> Bool)
-> (Type_AnonymousName -> Type_AnonymousName -> Bool)
-> (Type_AnonymousName -> Type_AnonymousName -> Bool)
-> (Type_AnonymousName -> Type_AnonymousName -> Bool)
-> (Type_AnonymousName -> Type_AnonymousName -> Type_AnonymousName)
-> (Type_AnonymousName -> Type_AnonymousName -> Type_AnonymousName)
-> Ord Type_AnonymousName
Type_AnonymousName -> Type_AnonymousName -> Bool
Type_AnonymousName -> Type_AnonymousName -> Ordering
Type_AnonymousName -> Type_AnonymousName -> Type_AnonymousName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_AnonymousName -> Type_AnonymousName -> Ordering
compare :: Type_AnonymousName -> Type_AnonymousName -> Ordering
$c< :: Type_AnonymousName -> Type_AnonymousName -> Bool
< :: Type_AnonymousName -> Type_AnonymousName -> Bool
$c<= :: Type_AnonymousName -> Type_AnonymousName -> Bool
<= :: Type_AnonymousName -> Type_AnonymousName -> Bool
$c> :: Type_AnonymousName -> Type_AnonymousName -> Bool
> :: Type_AnonymousName -> Type_AnonymousName -> Bool
$c>= :: Type_AnonymousName -> Type_AnonymousName -> Bool
>= :: Type_AnonymousName -> Type_AnonymousName -> Bool
$cmax :: Type_AnonymousName -> Type_AnonymousName -> Type_AnonymousName
max :: Type_AnonymousName -> Type_AnonymousName -> Type_AnonymousName
$cmin :: Type_AnonymousName -> Type_AnonymousName -> Type_AnonymousName
min :: Type_AnonymousName -> Type_AnonymousName -> Type_AnonymousName
Ord, ReadPrec [Type_AnonymousName]
ReadPrec Type_AnonymousName
Int -> ReadS Type_AnonymousName
ReadS [Type_AnonymousName]
(Int -> ReadS Type_AnonymousName)
-> ReadS [Type_AnonymousName]
-> ReadPrec Type_AnonymousName
-> ReadPrec [Type_AnonymousName]
-> Read Type_AnonymousName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_AnonymousName
readsPrec :: Int -> ReadS Type_AnonymousName
$creadList :: ReadS [Type_AnonymousName]
readList :: ReadS [Type_AnonymousName]
$creadPrec :: ReadPrec Type_AnonymousName
readPrec :: ReadPrec Type_AnonymousName
$creadListPrec :: ReadPrec [Type_AnonymousName]
readListPrec :: ReadPrec [Type_AnonymousName]
Read, Int -> Type_AnonymousName -> String -> String
[Type_AnonymousName] -> String -> String
Type_AnonymousName -> String
(Int -> Type_AnonymousName -> String -> String)
-> (Type_AnonymousName -> String)
-> ([Type_AnonymousName] -> String -> String)
-> Show Type_AnonymousName
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_AnonymousName -> String -> String
showsPrec :: Int -> Type_AnonymousName -> String -> String
$cshow :: Type_AnonymousName -> String
show :: Type_AnonymousName -> String
$cshowList :: [Type_AnonymousName] -> String -> String
showList :: [Type_AnonymousName] -> String -> String
Show)

_Type_AnonymousName :: Name
_Type_AnonymousName = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.AnonymousName")

data Type_Select = 
  Type_Select {
    Type_Select -> Data_Ref
type_SelectQual :: Data_Ref,
    Type_Select -> Type_Name
type_SelectName :: Type_Name}
  deriving (Type_Select -> Type_Select -> Bool
(Type_Select -> Type_Select -> Bool)
-> (Type_Select -> Type_Select -> Bool) -> Eq Type_Select
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Select -> Type_Select -> Bool
== :: Type_Select -> Type_Select -> Bool
$c/= :: Type_Select -> Type_Select -> Bool
/= :: Type_Select -> Type_Select -> Bool
Eq, Eq Type_Select
Eq Type_Select =>
(Type_Select -> Type_Select -> Ordering)
-> (Type_Select -> Type_Select -> Bool)
-> (Type_Select -> Type_Select -> Bool)
-> (Type_Select -> Type_Select -> Bool)
-> (Type_Select -> Type_Select -> Bool)
-> (Type_Select -> Type_Select -> Type_Select)
-> (Type_Select -> Type_Select -> Type_Select)
-> Ord Type_Select
Type_Select -> Type_Select -> Bool
Type_Select -> Type_Select -> Ordering
Type_Select -> Type_Select -> Type_Select
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Select -> Type_Select -> Ordering
compare :: Type_Select -> Type_Select -> Ordering
$c< :: Type_Select -> Type_Select -> Bool
< :: Type_Select -> Type_Select -> Bool
$c<= :: Type_Select -> Type_Select -> Bool
<= :: Type_Select -> Type_Select -> Bool
$c> :: Type_Select -> Type_Select -> Bool
> :: Type_Select -> Type_Select -> Bool
$c>= :: Type_Select -> Type_Select -> Bool
>= :: Type_Select -> Type_Select -> Bool
$cmax :: Type_Select -> Type_Select -> Type_Select
max :: Type_Select -> Type_Select -> Type_Select
$cmin :: Type_Select -> Type_Select -> Type_Select
min :: Type_Select -> Type_Select -> Type_Select
Ord, ReadPrec [Type_Select]
ReadPrec Type_Select
Int -> ReadS Type_Select
ReadS [Type_Select]
(Int -> ReadS Type_Select)
-> ReadS [Type_Select]
-> ReadPrec Type_Select
-> ReadPrec [Type_Select]
-> Read Type_Select
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Select
readsPrec :: Int -> ReadS Type_Select
$creadList :: ReadS [Type_Select]
readList :: ReadS [Type_Select]
$creadPrec :: ReadPrec Type_Select
readPrec :: ReadPrec Type_Select
$creadListPrec :: ReadPrec [Type_Select]
readListPrec :: ReadPrec [Type_Select]
Read, Int -> Type_Select -> String -> String
[Type_Select] -> String -> String
Type_Select -> String
(Int -> Type_Select -> String -> String)
-> (Type_Select -> String)
-> ([Type_Select] -> String -> String)
-> Show Type_Select
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Select -> String -> String
showsPrec :: Int -> Type_Select -> String -> String
$cshow :: Type_Select -> String
show :: Type_Select -> String
$cshowList :: [Type_Select] -> String -> String
showList :: [Type_Select] -> String -> String
Show)

_Type_Select :: Name
_Type_Select = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Select")

_Type_Select_qual :: Name
_Type_Select_qual = (String -> Name
Core.Name String
"qual")

_Type_Select_name :: Name
_Type_Select_name = (String -> Name
Core.Name String
"name")

data Type_Project = 
  Type_Project {
    Type_Project -> Type
type_ProjectQual :: Type,
    Type_Project -> Type_Name
type_ProjectName :: Type_Name}
  deriving (Type_Project -> Type_Project -> Bool
(Type_Project -> Type_Project -> Bool)
-> (Type_Project -> Type_Project -> Bool) -> Eq Type_Project
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Project -> Type_Project -> Bool
== :: Type_Project -> Type_Project -> Bool
$c/= :: Type_Project -> Type_Project -> Bool
/= :: Type_Project -> Type_Project -> Bool
Eq, Eq Type_Project
Eq Type_Project =>
(Type_Project -> Type_Project -> Ordering)
-> (Type_Project -> Type_Project -> Bool)
-> (Type_Project -> Type_Project -> Bool)
-> (Type_Project -> Type_Project -> Bool)
-> (Type_Project -> Type_Project -> Bool)
-> (Type_Project -> Type_Project -> Type_Project)
-> (Type_Project -> Type_Project -> Type_Project)
-> Ord Type_Project
Type_Project -> Type_Project -> Bool
Type_Project -> Type_Project -> Ordering
Type_Project -> Type_Project -> Type_Project
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Project -> Type_Project -> Ordering
compare :: Type_Project -> Type_Project -> Ordering
$c< :: Type_Project -> Type_Project -> Bool
< :: Type_Project -> Type_Project -> Bool
$c<= :: Type_Project -> Type_Project -> Bool
<= :: Type_Project -> Type_Project -> Bool
$c> :: Type_Project -> Type_Project -> Bool
> :: Type_Project -> Type_Project -> Bool
$c>= :: Type_Project -> Type_Project -> Bool
>= :: Type_Project -> Type_Project -> Bool
$cmax :: Type_Project -> Type_Project -> Type_Project
max :: Type_Project -> Type_Project -> Type_Project
$cmin :: Type_Project -> Type_Project -> Type_Project
min :: Type_Project -> Type_Project -> Type_Project
Ord, ReadPrec [Type_Project]
ReadPrec Type_Project
Int -> ReadS Type_Project
ReadS [Type_Project]
(Int -> ReadS Type_Project)
-> ReadS [Type_Project]
-> ReadPrec Type_Project
-> ReadPrec [Type_Project]
-> Read Type_Project
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Project
readsPrec :: Int -> ReadS Type_Project
$creadList :: ReadS [Type_Project]
readList :: ReadS [Type_Project]
$creadPrec :: ReadPrec Type_Project
readPrec :: ReadPrec Type_Project
$creadListPrec :: ReadPrec [Type_Project]
readListPrec :: ReadPrec [Type_Project]
Read, Int -> Type_Project -> String -> String
[Type_Project] -> String -> String
Type_Project -> String
(Int -> Type_Project -> String -> String)
-> (Type_Project -> String)
-> ([Type_Project] -> String -> String)
-> Show Type_Project
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Project -> String -> String
showsPrec :: Int -> Type_Project -> String -> String
$cshow :: Type_Project -> String
show :: Type_Project -> String
$cshowList :: [Type_Project] -> String -> String
showList :: [Type_Project] -> String -> String
Show)

_Type_Project :: Name
_Type_Project = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Project")

_Type_Project_qual :: Name
_Type_Project_qual = (String -> Name
Core.Name String
"qual")

_Type_Project_name :: Name
_Type_Project_name = (String -> Name
Core.Name String
"name")

data Type_Singleton = 
  Type_Singleton {
    Type_Singleton -> Data_Ref
type_SingletonRef :: Data_Ref}
  deriving (Type_Singleton -> Type_Singleton -> Bool
(Type_Singleton -> Type_Singleton -> Bool)
-> (Type_Singleton -> Type_Singleton -> Bool) -> Eq Type_Singleton
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Singleton -> Type_Singleton -> Bool
== :: Type_Singleton -> Type_Singleton -> Bool
$c/= :: Type_Singleton -> Type_Singleton -> Bool
/= :: Type_Singleton -> Type_Singleton -> Bool
Eq, Eq Type_Singleton
Eq Type_Singleton =>
(Type_Singleton -> Type_Singleton -> Ordering)
-> (Type_Singleton -> Type_Singleton -> Bool)
-> (Type_Singleton -> Type_Singleton -> Bool)
-> (Type_Singleton -> Type_Singleton -> Bool)
-> (Type_Singleton -> Type_Singleton -> Bool)
-> (Type_Singleton -> Type_Singleton -> Type_Singleton)
-> (Type_Singleton -> Type_Singleton -> Type_Singleton)
-> Ord Type_Singleton
Type_Singleton -> Type_Singleton -> Bool
Type_Singleton -> Type_Singleton -> Ordering
Type_Singleton -> Type_Singleton -> Type_Singleton
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Singleton -> Type_Singleton -> Ordering
compare :: Type_Singleton -> Type_Singleton -> Ordering
$c< :: Type_Singleton -> Type_Singleton -> Bool
< :: Type_Singleton -> Type_Singleton -> Bool
$c<= :: Type_Singleton -> Type_Singleton -> Bool
<= :: Type_Singleton -> Type_Singleton -> Bool
$c> :: Type_Singleton -> Type_Singleton -> Bool
> :: Type_Singleton -> Type_Singleton -> Bool
$c>= :: Type_Singleton -> Type_Singleton -> Bool
>= :: Type_Singleton -> Type_Singleton -> Bool
$cmax :: Type_Singleton -> Type_Singleton -> Type_Singleton
max :: Type_Singleton -> Type_Singleton -> Type_Singleton
$cmin :: Type_Singleton -> Type_Singleton -> Type_Singleton
min :: Type_Singleton -> Type_Singleton -> Type_Singleton
Ord, ReadPrec [Type_Singleton]
ReadPrec Type_Singleton
Int -> ReadS Type_Singleton
ReadS [Type_Singleton]
(Int -> ReadS Type_Singleton)
-> ReadS [Type_Singleton]
-> ReadPrec Type_Singleton
-> ReadPrec [Type_Singleton]
-> Read Type_Singleton
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Singleton
readsPrec :: Int -> ReadS Type_Singleton
$creadList :: ReadS [Type_Singleton]
readList :: ReadS [Type_Singleton]
$creadPrec :: ReadPrec Type_Singleton
readPrec :: ReadPrec Type_Singleton
$creadListPrec :: ReadPrec [Type_Singleton]
readListPrec :: ReadPrec [Type_Singleton]
Read, Int -> Type_Singleton -> String -> String
[Type_Singleton] -> String -> String
Type_Singleton -> String
(Int -> Type_Singleton -> String -> String)
-> (Type_Singleton -> String)
-> ([Type_Singleton] -> String -> String)
-> Show Type_Singleton
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Singleton -> String -> String
showsPrec :: Int -> Type_Singleton -> String -> String
$cshow :: Type_Singleton -> String
show :: Type_Singleton -> String
$cshowList :: [Type_Singleton] -> String -> String
showList :: [Type_Singleton] -> String -> String
Show)

_Type_Singleton :: Name
_Type_Singleton = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Singleton")

_Type_Singleton_ref :: Name
_Type_Singleton_ref = (String -> Name
Core.Name String
"ref")

data Type_Apply = 
  Type_Apply {
    Type_Apply -> Type
type_ApplyTpe :: Type,
    Type_Apply -> [Type]
type_ApplyArgs :: [Type]}
  deriving (Type_Apply -> Type_Apply -> Bool
(Type_Apply -> Type_Apply -> Bool)
-> (Type_Apply -> Type_Apply -> Bool) -> Eq Type_Apply
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Apply -> Type_Apply -> Bool
== :: Type_Apply -> Type_Apply -> Bool
$c/= :: Type_Apply -> Type_Apply -> Bool
/= :: Type_Apply -> Type_Apply -> Bool
Eq, Eq Type_Apply
Eq Type_Apply =>
(Type_Apply -> Type_Apply -> Ordering)
-> (Type_Apply -> Type_Apply -> Bool)
-> (Type_Apply -> Type_Apply -> Bool)
-> (Type_Apply -> Type_Apply -> Bool)
-> (Type_Apply -> Type_Apply -> Bool)
-> (Type_Apply -> Type_Apply -> Type_Apply)
-> (Type_Apply -> Type_Apply -> Type_Apply)
-> Ord Type_Apply
Type_Apply -> Type_Apply -> Bool
Type_Apply -> Type_Apply -> Ordering
Type_Apply -> Type_Apply -> Type_Apply
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Apply -> Type_Apply -> Ordering
compare :: Type_Apply -> Type_Apply -> Ordering
$c< :: Type_Apply -> Type_Apply -> Bool
< :: Type_Apply -> Type_Apply -> Bool
$c<= :: Type_Apply -> Type_Apply -> Bool
<= :: Type_Apply -> Type_Apply -> Bool
$c> :: Type_Apply -> Type_Apply -> Bool
> :: Type_Apply -> Type_Apply -> Bool
$c>= :: Type_Apply -> Type_Apply -> Bool
>= :: Type_Apply -> Type_Apply -> Bool
$cmax :: Type_Apply -> Type_Apply -> Type_Apply
max :: Type_Apply -> Type_Apply -> Type_Apply
$cmin :: Type_Apply -> Type_Apply -> Type_Apply
min :: Type_Apply -> Type_Apply -> Type_Apply
Ord, ReadPrec [Type_Apply]
ReadPrec Type_Apply
Int -> ReadS Type_Apply
ReadS [Type_Apply]
(Int -> ReadS Type_Apply)
-> ReadS [Type_Apply]
-> ReadPrec Type_Apply
-> ReadPrec [Type_Apply]
-> Read Type_Apply
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Apply
readsPrec :: Int -> ReadS Type_Apply
$creadList :: ReadS [Type_Apply]
readList :: ReadS [Type_Apply]
$creadPrec :: ReadPrec Type_Apply
readPrec :: ReadPrec Type_Apply
$creadListPrec :: ReadPrec [Type_Apply]
readListPrec :: ReadPrec [Type_Apply]
Read, Int -> Type_Apply -> String -> String
[Type_Apply] -> String -> String
Type_Apply -> String
(Int -> Type_Apply -> String -> String)
-> (Type_Apply -> String)
-> ([Type_Apply] -> String -> String)
-> Show Type_Apply
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Apply -> String -> String
showsPrec :: Int -> Type_Apply -> String -> String
$cshow :: Type_Apply -> String
show :: Type_Apply -> String
$cshowList :: [Type_Apply] -> String -> String
showList :: [Type_Apply] -> String -> String
Show)

_Type_Apply :: Name
_Type_Apply = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Apply")

_Type_Apply_tpe :: Name
_Type_Apply_tpe = (String -> Name
Core.Name String
"tpe")

_Type_Apply_args :: Name
_Type_Apply_args = (String -> Name
Core.Name String
"args")

data Type_ApplyInfix = 
  Type_ApplyInfix {
    Type_ApplyInfix -> Type
type_ApplyInfixLhs :: Type,
    Type_ApplyInfix -> Type_Name
type_ApplyInfixOp :: Type_Name,
    Type_ApplyInfix -> Type
type_ApplyInfixRhs :: Type}
  deriving (Type_ApplyInfix -> Type_ApplyInfix -> Bool
(Type_ApplyInfix -> Type_ApplyInfix -> Bool)
-> (Type_ApplyInfix -> Type_ApplyInfix -> Bool)
-> Eq Type_ApplyInfix
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_ApplyInfix -> Type_ApplyInfix -> Bool
== :: Type_ApplyInfix -> Type_ApplyInfix -> Bool
$c/= :: Type_ApplyInfix -> Type_ApplyInfix -> Bool
/= :: Type_ApplyInfix -> Type_ApplyInfix -> Bool
Eq, Eq Type_ApplyInfix
Eq Type_ApplyInfix =>
(Type_ApplyInfix -> Type_ApplyInfix -> Ordering)
-> (Type_ApplyInfix -> Type_ApplyInfix -> Bool)
-> (Type_ApplyInfix -> Type_ApplyInfix -> Bool)
-> (Type_ApplyInfix -> Type_ApplyInfix -> Bool)
-> (Type_ApplyInfix -> Type_ApplyInfix -> Bool)
-> (Type_ApplyInfix -> Type_ApplyInfix -> Type_ApplyInfix)
-> (Type_ApplyInfix -> Type_ApplyInfix -> Type_ApplyInfix)
-> Ord Type_ApplyInfix
Type_ApplyInfix -> Type_ApplyInfix -> Bool
Type_ApplyInfix -> Type_ApplyInfix -> Ordering
Type_ApplyInfix -> Type_ApplyInfix -> Type_ApplyInfix
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_ApplyInfix -> Type_ApplyInfix -> Ordering
compare :: Type_ApplyInfix -> Type_ApplyInfix -> Ordering
$c< :: Type_ApplyInfix -> Type_ApplyInfix -> Bool
< :: Type_ApplyInfix -> Type_ApplyInfix -> Bool
$c<= :: Type_ApplyInfix -> Type_ApplyInfix -> Bool
<= :: Type_ApplyInfix -> Type_ApplyInfix -> Bool
$c> :: Type_ApplyInfix -> Type_ApplyInfix -> Bool
> :: Type_ApplyInfix -> Type_ApplyInfix -> Bool
$c>= :: Type_ApplyInfix -> Type_ApplyInfix -> Bool
>= :: Type_ApplyInfix -> Type_ApplyInfix -> Bool
$cmax :: Type_ApplyInfix -> Type_ApplyInfix -> Type_ApplyInfix
max :: Type_ApplyInfix -> Type_ApplyInfix -> Type_ApplyInfix
$cmin :: Type_ApplyInfix -> Type_ApplyInfix -> Type_ApplyInfix
min :: Type_ApplyInfix -> Type_ApplyInfix -> Type_ApplyInfix
Ord, ReadPrec [Type_ApplyInfix]
ReadPrec Type_ApplyInfix
Int -> ReadS Type_ApplyInfix
ReadS [Type_ApplyInfix]
(Int -> ReadS Type_ApplyInfix)
-> ReadS [Type_ApplyInfix]
-> ReadPrec Type_ApplyInfix
-> ReadPrec [Type_ApplyInfix]
-> Read Type_ApplyInfix
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_ApplyInfix
readsPrec :: Int -> ReadS Type_ApplyInfix
$creadList :: ReadS [Type_ApplyInfix]
readList :: ReadS [Type_ApplyInfix]
$creadPrec :: ReadPrec Type_ApplyInfix
readPrec :: ReadPrec Type_ApplyInfix
$creadListPrec :: ReadPrec [Type_ApplyInfix]
readListPrec :: ReadPrec [Type_ApplyInfix]
Read, Int -> Type_ApplyInfix -> String -> String
[Type_ApplyInfix] -> String -> String
Type_ApplyInfix -> String
(Int -> Type_ApplyInfix -> String -> String)
-> (Type_ApplyInfix -> String)
-> ([Type_ApplyInfix] -> String -> String)
-> Show Type_ApplyInfix
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_ApplyInfix -> String -> String
showsPrec :: Int -> Type_ApplyInfix -> String -> String
$cshow :: Type_ApplyInfix -> String
show :: Type_ApplyInfix -> String
$cshowList :: [Type_ApplyInfix] -> String -> String
showList :: [Type_ApplyInfix] -> String -> String
Show)

_Type_ApplyInfix :: Name
_Type_ApplyInfix = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.ApplyInfix")

_Type_ApplyInfix_lhs :: Name
_Type_ApplyInfix_lhs = (String -> Name
Core.Name String
"lhs")

_Type_ApplyInfix_op :: Name
_Type_ApplyInfix_op = (String -> Name
Core.Name String
"op")

_Type_ApplyInfix_rhs :: Name
_Type_ApplyInfix_rhs = (String -> Name
Core.Name String
"rhs")

data Type_FunctionType = 
  Type_FunctionTypeFunction Type_Function |
  Type_FunctionTypeContextFunction Type_ContextFunction
  deriving (Type_FunctionType -> Type_FunctionType -> Bool
(Type_FunctionType -> Type_FunctionType -> Bool)
-> (Type_FunctionType -> Type_FunctionType -> Bool)
-> Eq Type_FunctionType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_FunctionType -> Type_FunctionType -> Bool
== :: Type_FunctionType -> Type_FunctionType -> Bool
$c/= :: Type_FunctionType -> Type_FunctionType -> Bool
/= :: Type_FunctionType -> Type_FunctionType -> Bool
Eq, Eq Type_FunctionType
Eq Type_FunctionType =>
(Type_FunctionType -> Type_FunctionType -> Ordering)
-> (Type_FunctionType -> Type_FunctionType -> Bool)
-> (Type_FunctionType -> Type_FunctionType -> Bool)
-> (Type_FunctionType -> Type_FunctionType -> Bool)
-> (Type_FunctionType -> Type_FunctionType -> Bool)
-> (Type_FunctionType -> Type_FunctionType -> Type_FunctionType)
-> (Type_FunctionType -> Type_FunctionType -> Type_FunctionType)
-> Ord Type_FunctionType
Type_FunctionType -> Type_FunctionType -> Bool
Type_FunctionType -> Type_FunctionType -> Ordering
Type_FunctionType -> Type_FunctionType -> Type_FunctionType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_FunctionType -> Type_FunctionType -> Ordering
compare :: Type_FunctionType -> Type_FunctionType -> Ordering
$c< :: Type_FunctionType -> Type_FunctionType -> Bool
< :: Type_FunctionType -> Type_FunctionType -> Bool
$c<= :: Type_FunctionType -> Type_FunctionType -> Bool
<= :: Type_FunctionType -> Type_FunctionType -> Bool
$c> :: Type_FunctionType -> Type_FunctionType -> Bool
> :: Type_FunctionType -> Type_FunctionType -> Bool
$c>= :: Type_FunctionType -> Type_FunctionType -> Bool
>= :: Type_FunctionType -> Type_FunctionType -> Bool
$cmax :: Type_FunctionType -> Type_FunctionType -> Type_FunctionType
max :: Type_FunctionType -> Type_FunctionType -> Type_FunctionType
$cmin :: Type_FunctionType -> Type_FunctionType -> Type_FunctionType
min :: Type_FunctionType -> Type_FunctionType -> Type_FunctionType
Ord, ReadPrec [Type_FunctionType]
ReadPrec Type_FunctionType
Int -> ReadS Type_FunctionType
ReadS [Type_FunctionType]
(Int -> ReadS Type_FunctionType)
-> ReadS [Type_FunctionType]
-> ReadPrec Type_FunctionType
-> ReadPrec [Type_FunctionType]
-> Read Type_FunctionType
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_FunctionType
readsPrec :: Int -> ReadS Type_FunctionType
$creadList :: ReadS [Type_FunctionType]
readList :: ReadS [Type_FunctionType]
$creadPrec :: ReadPrec Type_FunctionType
readPrec :: ReadPrec Type_FunctionType
$creadListPrec :: ReadPrec [Type_FunctionType]
readListPrec :: ReadPrec [Type_FunctionType]
Read, Int -> Type_FunctionType -> String -> String
[Type_FunctionType] -> String -> String
Type_FunctionType -> String
(Int -> Type_FunctionType -> String -> String)
-> (Type_FunctionType -> String)
-> ([Type_FunctionType] -> String -> String)
-> Show Type_FunctionType
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_FunctionType -> String -> String
showsPrec :: Int -> Type_FunctionType -> String -> String
$cshow :: Type_FunctionType -> String
show :: Type_FunctionType -> String
$cshowList :: [Type_FunctionType] -> String -> String
showList :: [Type_FunctionType] -> String -> String
Show)

_Type_FunctionType :: Name
_Type_FunctionType = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.FunctionType")

_Type_FunctionType_function :: Name
_Type_FunctionType_function = (String -> Name
Core.Name String
"function")

_Type_FunctionType_contextFunction :: Name
_Type_FunctionType_contextFunction = (String -> Name
Core.Name String
"contextFunction")

data Type_Function = 
  Type_Function {
    Type_Function -> [Type]
type_FunctionParams :: [Type],
    Type_Function -> Type
type_FunctionRes :: Type}
  deriving (Type_Function -> Type_Function -> Bool
(Type_Function -> Type_Function -> Bool)
-> (Type_Function -> Type_Function -> Bool) -> Eq Type_Function
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Function -> Type_Function -> Bool
== :: Type_Function -> Type_Function -> Bool
$c/= :: Type_Function -> Type_Function -> Bool
/= :: Type_Function -> Type_Function -> Bool
Eq, Eq Type_Function
Eq Type_Function =>
(Type_Function -> Type_Function -> Ordering)
-> (Type_Function -> Type_Function -> Bool)
-> (Type_Function -> Type_Function -> Bool)
-> (Type_Function -> Type_Function -> Bool)
-> (Type_Function -> Type_Function -> Bool)
-> (Type_Function -> Type_Function -> Type_Function)
-> (Type_Function -> Type_Function -> Type_Function)
-> Ord Type_Function
Type_Function -> Type_Function -> Bool
Type_Function -> Type_Function -> Ordering
Type_Function -> Type_Function -> Type_Function
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Function -> Type_Function -> Ordering
compare :: Type_Function -> Type_Function -> Ordering
$c< :: Type_Function -> Type_Function -> Bool
< :: Type_Function -> Type_Function -> Bool
$c<= :: Type_Function -> Type_Function -> Bool
<= :: Type_Function -> Type_Function -> Bool
$c> :: Type_Function -> Type_Function -> Bool
> :: Type_Function -> Type_Function -> Bool
$c>= :: Type_Function -> Type_Function -> Bool
>= :: Type_Function -> Type_Function -> Bool
$cmax :: Type_Function -> Type_Function -> Type_Function
max :: Type_Function -> Type_Function -> Type_Function
$cmin :: Type_Function -> Type_Function -> Type_Function
min :: Type_Function -> Type_Function -> Type_Function
Ord, ReadPrec [Type_Function]
ReadPrec Type_Function
Int -> ReadS Type_Function
ReadS [Type_Function]
(Int -> ReadS Type_Function)
-> ReadS [Type_Function]
-> ReadPrec Type_Function
-> ReadPrec [Type_Function]
-> Read Type_Function
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Function
readsPrec :: Int -> ReadS Type_Function
$creadList :: ReadS [Type_Function]
readList :: ReadS [Type_Function]
$creadPrec :: ReadPrec Type_Function
readPrec :: ReadPrec Type_Function
$creadListPrec :: ReadPrec [Type_Function]
readListPrec :: ReadPrec [Type_Function]
Read, Int -> Type_Function -> String -> String
[Type_Function] -> String -> String
Type_Function -> String
(Int -> Type_Function -> String -> String)
-> (Type_Function -> String)
-> ([Type_Function] -> String -> String)
-> Show Type_Function
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Function -> String -> String
showsPrec :: Int -> Type_Function -> String -> String
$cshow :: Type_Function -> String
show :: Type_Function -> String
$cshowList :: [Type_Function] -> String -> String
showList :: [Type_Function] -> String -> String
Show)

_Type_Function :: Name
_Type_Function = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Function")

_Type_Function_params :: Name
_Type_Function_params = (String -> Name
Core.Name String
"params")

_Type_Function_res :: Name
_Type_Function_res = (String -> Name
Core.Name String
"res")

data Type_PolyFunction = 
  Type_PolyFunction {
    Type_PolyFunction -> [Type_Param]
type_PolyFunctionTparams :: [Type_Param],
    Type_PolyFunction -> Type
type_PolyFunctionTpe :: Type}
  deriving (Type_PolyFunction -> Type_PolyFunction -> Bool
(Type_PolyFunction -> Type_PolyFunction -> Bool)
-> (Type_PolyFunction -> Type_PolyFunction -> Bool)
-> Eq Type_PolyFunction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_PolyFunction -> Type_PolyFunction -> Bool
== :: Type_PolyFunction -> Type_PolyFunction -> Bool
$c/= :: Type_PolyFunction -> Type_PolyFunction -> Bool
/= :: Type_PolyFunction -> Type_PolyFunction -> Bool
Eq, Eq Type_PolyFunction
Eq Type_PolyFunction =>
(Type_PolyFunction -> Type_PolyFunction -> Ordering)
-> (Type_PolyFunction -> Type_PolyFunction -> Bool)
-> (Type_PolyFunction -> Type_PolyFunction -> Bool)
-> (Type_PolyFunction -> Type_PolyFunction -> Bool)
-> (Type_PolyFunction -> Type_PolyFunction -> Bool)
-> (Type_PolyFunction -> Type_PolyFunction -> Type_PolyFunction)
-> (Type_PolyFunction -> Type_PolyFunction -> Type_PolyFunction)
-> Ord Type_PolyFunction
Type_PolyFunction -> Type_PolyFunction -> Bool
Type_PolyFunction -> Type_PolyFunction -> Ordering
Type_PolyFunction -> Type_PolyFunction -> Type_PolyFunction
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_PolyFunction -> Type_PolyFunction -> Ordering
compare :: Type_PolyFunction -> Type_PolyFunction -> Ordering
$c< :: Type_PolyFunction -> Type_PolyFunction -> Bool
< :: Type_PolyFunction -> Type_PolyFunction -> Bool
$c<= :: Type_PolyFunction -> Type_PolyFunction -> Bool
<= :: Type_PolyFunction -> Type_PolyFunction -> Bool
$c> :: Type_PolyFunction -> Type_PolyFunction -> Bool
> :: Type_PolyFunction -> Type_PolyFunction -> Bool
$c>= :: Type_PolyFunction -> Type_PolyFunction -> Bool
>= :: Type_PolyFunction -> Type_PolyFunction -> Bool
$cmax :: Type_PolyFunction -> Type_PolyFunction -> Type_PolyFunction
max :: Type_PolyFunction -> Type_PolyFunction -> Type_PolyFunction
$cmin :: Type_PolyFunction -> Type_PolyFunction -> Type_PolyFunction
min :: Type_PolyFunction -> Type_PolyFunction -> Type_PolyFunction
Ord, ReadPrec [Type_PolyFunction]
ReadPrec Type_PolyFunction
Int -> ReadS Type_PolyFunction
ReadS [Type_PolyFunction]
(Int -> ReadS Type_PolyFunction)
-> ReadS [Type_PolyFunction]
-> ReadPrec Type_PolyFunction
-> ReadPrec [Type_PolyFunction]
-> Read Type_PolyFunction
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_PolyFunction
readsPrec :: Int -> ReadS Type_PolyFunction
$creadList :: ReadS [Type_PolyFunction]
readList :: ReadS [Type_PolyFunction]
$creadPrec :: ReadPrec Type_PolyFunction
readPrec :: ReadPrec Type_PolyFunction
$creadListPrec :: ReadPrec [Type_PolyFunction]
readListPrec :: ReadPrec [Type_PolyFunction]
Read, Int -> Type_PolyFunction -> String -> String
[Type_PolyFunction] -> String -> String
Type_PolyFunction -> String
(Int -> Type_PolyFunction -> String -> String)
-> (Type_PolyFunction -> String)
-> ([Type_PolyFunction] -> String -> String)
-> Show Type_PolyFunction
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_PolyFunction -> String -> String
showsPrec :: Int -> Type_PolyFunction -> String -> String
$cshow :: Type_PolyFunction -> String
show :: Type_PolyFunction -> String
$cshowList :: [Type_PolyFunction] -> String -> String
showList :: [Type_PolyFunction] -> String -> String
Show)

_Type_PolyFunction :: Name
_Type_PolyFunction = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.PolyFunction")

_Type_PolyFunction_tparams :: Name
_Type_PolyFunction_tparams = (String -> Name
Core.Name String
"tparams")

_Type_PolyFunction_tpe :: Name
_Type_PolyFunction_tpe = (String -> Name
Core.Name String
"tpe")

data Type_ContextFunction = 
  Type_ContextFunction {
    Type_ContextFunction -> [Type]
type_ContextFunctionParams :: [Type],
    Type_ContextFunction -> Type
type_ContextFunctionRes :: Type}
  deriving (Type_ContextFunction -> Type_ContextFunction -> Bool
(Type_ContextFunction -> Type_ContextFunction -> Bool)
-> (Type_ContextFunction -> Type_ContextFunction -> Bool)
-> Eq Type_ContextFunction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_ContextFunction -> Type_ContextFunction -> Bool
== :: Type_ContextFunction -> Type_ContextFunction -> Bool
$c/= :: Type_ContextFunction -> Type_ContextFunction -> Bool
/= :: Type_ContextFunction -> Type_ContextFunction -> Bool
Eq, Eq Type_ContextFunction
Eq Type_ContextFunction =>
(Type_ContextFunction -> Type_ContextFunction -> Ordering)
-> (Type_ContextFunction -> Type_ContextFunction -> Bool)
-> (Type_ContextFunction -> Type_ContextFunction -> Bool)
-> (Type_ContextFunction -> Type_ContextFunction -> Bool)
-> (Type_ContextFunction -> Type_ContextFunction -> Bool)
-> (Type_ContextFunction
    -> Type_ContextFunction -> Type_ContextFunction)
-> (Type_ContextFunction
    -> Type_ContextFunction -> Type_ContextFunction)
-> Ord Type_ContextFunction
Type_ContextFunction -> Type_ContextFunction -> Bool
Type_ContextFunction -> Type_ContextFunction -> Ordering
Type_ContextFunction
-> Type_ContextFunction -> Type_ContextFunction
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_ContextFunction -> Type_ContextFunction -> Ordering
compare :: Type_ContextFunction -> Type_ContextFunction -> Ordering
$c< :: Type_ContextFunction -> Type_ContextFunction -> Bool
< :: Type_ContextFunction -> Type_ContextFunction -> Bool
$c<= :: Type_ContextFunction -> Type_ContextFunction -> Bool
<= :: Type_ContextFunction -> Type_ContextFunction -> Bool
$c> :: Type_ContextFunction -> Type_ContextFunction -> Bool
> :: Type_ContextFunction -> Type_ContextFunction -> Bool
$c>= :: Type_ContextFunction -> Type_ContextFunction -> Bool
>= :: Type_ContextFunction -> Type_ContextFunction -> Bool
$cmax :: Type_ContextFunction
-> Type_ContextFunction -> Type_ContextFunction
max :: Type_ContextFunction
-> Type_ContextFunction -> Type_ContextFunction
$cmin :: Type_ContextFunction
-> Type_ContextFunction -> Type_ContextFunction
min :: Type_ContextFunction
-> Type_ContextFunction -> Type_ContextFunction
Ord, ReadPrec [Type_ContextFunction]
ReadPrec Type_ContextFunction
Int -> ReadS Type_ContextFunction
ReadS [Type_ContextFunction]
(Int -> ReadS Type_ContextFunction)
-> ReadS [Type_ContextFunction]
-> ReadPrec Type_ContextFunction
-> ReadPrec [Type_ContextFunction]
-> Read Type_ContextFunction
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_ContextFunction
readsPrec :: Int -> ReadS Type_ContextFunction
$creadList :: ReadS [Type_ContextFunction]
readList :: ReadS [Type_ContextFunction]
$creadPrec :: ReadPrec Type_ContextFunction
readPrec :: ReadPrec Type_ContextFunction
$creadListPrec :: ReadPrec [Type_ContextFunction]
readListPrec :: ReadPrec [Type_ContextFunction]
Read, Int -> Type_ContextFunction -> String -> String
[Type_ContextFunction] -> String -> String
Type_ContextFunction -> String
(Int -> Type_ContextFunction -> String -> String)
-> (Type_ContextFunction -> String)
-> ([Type_ContextFunction] -> String -> String)
-> Show Type_ContextFunction
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_ContextFunction -> String -> String
showsPrec :: Int -> Type_ContextFunction -> String -> String
$cshow :: Type_ContextFunction -> String
show :: Type_ContextFunction -> String
$cshowList :: [Type_ContextFunction] -> String -> String
showList :: [Type_ContextFunction] -> String -> String
Show)

_Type_ContextFunction :: Name
_Type_ContextFunction = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.ContextFunction")

_Type_ContextFunction_params :: Name
_Type_ContextFunction_params = (String -> Name
Core.Name String
"params")

_Type_ContextFunction_res :: Name
_Type_ContextFunction_res = (String -> Name
Core.Name String
"res")

data Type_ImplicitFunction = 
  Type_ImplicitFunction {
    Type_ImplicitFunction -> [Type]
type_ImplicitFunctionParams :: [Type],
    Type_ImplicitFunction -> Type
type_ImplicitFunctionRes :: Type}
  deriving (Type_ImplicitFunction -> Type_ImplicitFunction -> Bool
(Type_ImplicitFunction -> Type_ImplicitFunction -> Bool)
-> (Type_ImplicitFunction -> Type_ImplicitFunction -> Bool)
-> Eq Type_ImplicitFunction
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_ImplicitFunction -> Type_ImplicitFunction -> Bool
== :: Type_ImplicitFunction -> Type_ImplicitFunction -> Bool
$c/= :: Type_ImplicitFunction -> Type_ImplicitFunction -> Bool
/= :: Type_ImplicitFunction -> Type_ImplicitFunction -> Bool
Eq, Eq Type_ImplicitFunction
Eq Type_ImplicitFunction =>
(Type_ImplicitFunction -> Type_ImplicitFunction -> Ordering)
-> (Type_ImplicitFunction -> Type_ImplicitFunction -> Bool)
-> (Type_ImplicitFunction -> Type_ImplicitFunction -> Bool)
-> (Type_ImplicitFunction -> Type_ImplicitFunction -> Bool)
-> (Type_ImplicitFunction -> Type_ImplicitFunction -> Bool)
-> (Type_ImplicitFunction
    -> Type_ImplicitFunction -> Type_ImplicitFunction)
-> (Type_ImplicitFunction
    -> Type_ImplicitFunction -> Type_ImplicitFunction)
-> Ord Type_ImplicitFunction
Type_ImplicitFunction -> Type_ImplicitFunction -> Bool
Type_ImplicitFunction -> Type_ImplicitFunction -> Ordering
Type_ImplicitFunction
-> Type_ImplicitFunction -> Type_ImplicitFunction
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_ImplicitFunction -> Type_ImplicitFunction -> Ordering
compare :: Type_ImplicitFunction -> Type_ImplicitFunction -> Ordering
$c< :: Type_ImplicitFunction -> Type_ImplicitFunction -> Bool
< :: Type_ImplicitFunction -> Type_ImplicitFunction -> Bool
$c<= :: Type_ImplicitFunction -> Type_ImplicitFunction -> Bool
<= :: Type_ImplicitFunction -> Type_ImplicitFunction -> Bool
$c> :: Type_ImplicitFunction -> Type_ImplicitFunction -> Bool
> :: Type_ImplicitFunction -> Type_ImplicitFunction -> Bool
$c>= :: Type_ImplicitFunction -> Type_ImplicitFunction -> Bool
>= :: Type_ImplicitFunction -> Type_ImplicitFunction -> Bool
$cmax :: Type_ImplicitFunction
-> Type_ImplicitFunction -> Type_ImplicitFunction
max :: Type_ImplicitFunction
-> Type_ImplicitFunction -> Type_ImplicitFunction
$cmin :: Type_ImplicitFunction
-> Type_ImplicitFunction -> Type_ImplicitFunction
min :: Type_ImplicitFunction
-> Type_ImplicitFunction -> Type_ImplicitFunction
Ord, ReadPrec [Type_ImplicitFunction]
ReadPrec Type_ImplicitFunction
Int -> ReadS Type_ImplicitFunction
ReadS [Type_ImplicitFunction]
(Int -> ReadS Type_ImplicitFunction)
-> ReadS [Type_ImplicitFunction]
-> ReadPrec Type_ImplicitFunction
-> ReadPrec [Type_ImplicitFunction]
-> Read Type_ImplicitFunction
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_ImplicitFunction
readsPrec :: Int -> ReadS Type_ImplicitFunction
$creadList :: ReadS [Type_ImplicitFunction]
readList :: ReadS [Type_ImplicitFunction]
$creadPrec :: ReadPrec Type_ImplicitFunction
readPrec :: ReadPrec Type_ImplicitFunction
$creadListPrec :: ReadPrec [Type_ImplicitFunction]
readListPrec :: ReadPrec [Type_ImplicitFunction]
Read, Int -> Type_ImplicitFunction -> String -> String
[Type_ImplicitFunction] -> String -> String
Type_ImplicitFunction -> String
(Int -> Type_ImplicitFunction -> String -> String)
-> (Type_ImplicitFunction -> String)
-> ([Type_ImplicitFunction] -> String -> String)
-> Show Type_ImplicitFunction
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_ImplicitFunction -> String -> String
showsPrec :: Int -> Type_ImplicitFunction -> String -> String
$cshow :: Type_ImplicitFunction -> String
show :: Type_ImplicitFunction -> String
$cshowList :: [Type_ImplicitFunction] -> String -> String
showList :: [Type_ImplicitFunction] -> String -> String
Show)

_Type_ImplicitFunction :: Name
_Type_ImplicitFunction = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.ImplicitFunction")

_Type_ImplicitFunction_params :: Name
_Type_ImplicitFunction_params = (String -> Name
Core.Name String
"params")

_Type_ImplicitFunction_res :: Name
_Type_ImplicitFunction_res = (String -> Name
Core.Name String
"res")

data Type_Tuple = 
  Type_Tuple {
    Type_Tuple -> [Type]
type_TupleArgs :: [Type]}
  deriving (Type_Tuple -> Type_Tuple -> Bool
(Type_Tuple -> Type_Tuple -> Bool)
-> (Type_Tuple -> Type_Tuple -> Bool) -> Eq Type_Tuple
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Tuple -> Type_Tuple -> Bool
== :: Type_Tuple -> Type_Tuple -> Bool
$c/= :: Type_Tuple -> Type_Tuple -> Bool
/= :: Type_Tuple -> Type_Tuple -> Bool
Eq, Eq Type_Tuple
Eq Type_Tuple =>
(Type_Tuple -> Type_Tuple -> Ordering)
-> (Type_Tuple -> Type_Tuple -> Bool)
-> (Type_Tuple -> Type_Tuple -> Bool)
-> (Type_Tuple -> Type_Tuple -> Bool)
-> (Type_Tuple -> Type_Tuple -> Bool)
-> (Type_Tuple -> Type_Tuple -> Type_Tuple)
-> (Type_Tuple -> Type_Tuple -> Type_Tuple)
-> Ord Type_Tuple
Type_Tuple -> Type_Tuple -> Bool
Type_Tuple -> Type_Tuple -> Ordering
Type_Tuple -> Type_Tuple -> Type_Tuple
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Tuple -> Type_Tuple -> Ordering
compare :: Type_Tuple -> Type_Tuple -> Ordering
$c< :: Type_Tuple -> Type_Tuple -> Bool
< :: Type_Tuple -> Type_Tuple -> Bool
$c<= :: Type_Tuple -> Type_Tuple -> Bool
<= :: Type_Tuple -> Type_Tuple -> Bool
$c> :: Type_Tuple -> Type_Tuple -> Bool
> :: Type_Tuple -> Type_Tuple -> Bool
$c>= :: Type_Tuple -> Type_Tuple -> Bool
>= :: Type_Tuple -> Type_Tuple -> Bool
$cmax :: Type_Tuple -> Type_Tuple -> Type_Tuple
max :: Type_Tuple -> Type_Tuple -> Type_Tuple
$cmin :: Type_Tuple -> Type_Tuple -> Type_Tuple
min :: Type_Tuple -> Type_Tuple -> Type_Tuple
Ord, ReadPrec [Type_Tuple]
ReadPrec Type_Tuple
Int -> ReadS Type_Tuple
ReadS [Type_Tuple]
(Int -> ReadS Type_Tuple)
-> ReadS [Type_Tuple]
-> ReadPrec Type_Tuple
-> ReadPrec [Type_Tuple]
-> Read Type_Tuple
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Tuple
readsPrec :: Int -> ReadS Type_Tuple
$creadList :: ReadS [Type_Tuple]
readList :: ReadS [Type_Tuple]
$creadPrec :: ReadPrec Type_Tuple
readPrec :: ReadPrec Type_Tuple
$creadListPrec :: ReadPrec [Type_Tuple]
readListPrec :: ReadPrec [Type_Tuple]
Read, Int -> Type_Tuple -> String -> String
[Type_Tuple] -> String -> String
Type_Tuple -> String
(Int -> Type_Tuple -> String -> String)
-> (Type_Tuple -> String)
-> ([Type_Tuple] -> String -> String)
-> Show Type_Tuple
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Tuple -> String -> String
showsPrec :: Int -> Type_Tuple -> String -> String
$cshow :: Type_Tuple -> String
show :: Type_Tuple -> String
$cshowList :: [Type_Tuple] -> String -> String
showList :: [Type_Tuple] -> String -> String
Show)

_Type_Tuple :: Name
_Type_Tuple = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Tuple")

_Type_Tuple_args :: Name
_Type_Tuple_args = (String -> Name
Core.Name String
"args")

data Type_With = 
  Type_With {
    Type_With -> Type
type_WithLhs :: Type,
    Type_With -> Type
type_WithRhs :: Type}
  deriving (Type_With -> Type_With -> Bool
(Type_With -> Type_With -> Bool)
-> (Type_With -> Type_With -> Bool) -> Eq Type_With
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_With -> Type_With -> Bool
== :: Type_With -> Type_With -> Bool
$c/= :: Type_With -> Type_With -> Bool
/= :: Type_With -> Type_With -> Bool
Eq, Eq Type_With
Eq Type_With =>
(Type_With -> Type_With -> Ordering)
-> (Type_With -> Type_With -> Bool)
-> (Type_With -> Type_With -> Bool)
-> (Type_With -> Type_With -> Bool)
-> (Type_With -> Type_With -> Bool)
-> (Type_With -> Type_With -> Type_With)
-> (Type_With -> Type_With -> Type_With)
-> Ord Type_With
Type_With -> Type_With -> Bool
Type_With -> Type_With -> Ordering
Type_With -> Type_With -> Type_With
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_With -> Type_With -> Ordering
compare :: Type_With -> Type_With -> Ordering
$c< :: Type_With -> Type_With -> Bool
< :: Type_With -> Type_With -> Bool
$c<= :: Type_With -> Type_With -> Bool
<= :: Type_With -> Type_With -> Bool
$c> :: Type_With -> Type_With -> Bool
> :: Type_With -> Type_With -> Bool
$c>= :: Type_With -> Type_With -> Bool
>= :: Type_With -> Type_With -> Bool
$cmax :: Type_With -> Type_With -> Type_With
max :: Type_With -> Type_With -> Type_With
$cmin :: Type_With -> Type_With -> Type_With
min :: Type_With -> Type_With -> Type_With
Ord, ReadPrec [Type_With]
ReadPrec Type_With
Int -> ReadS Type_With
ReadS [Type_With]
(Int -> ReadS Type_With)
-> ReadS [Type_With]
-> ReadPrec Type_With
-> ReadPrec [Type_With]
-> Read Type_With
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_With
readsPrec :: Int -> ReadS Type_With
$creadList :: ReadS [Type_With]
readList :: ReadS [Type_With]
$creadPrec :: ReadPrec Type_With
readPrec :: ReadPrec Type_With
$creadListPrec :: ReadPrec [Type_With]
readListPrec :: ReadPrec [Type_With]
Read, Int -> Type_With -> String -> String
[Type_With] -> String -> String
Type_With -> String
(Int -> Type_With -> String -> String)
-> (Type_With -> String)
-> ([Type_With] -> String -> String)
-> Show Type_With
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_With -> String -> String
showsPrec :: Int -> Type_With -> String -> String
$cshow :: Type_With -> String
show :: Type_With -> String
$cshowList :: [Type_With] -> String -> String
showList :: [Type_With] -> String -> String
Show)

_Type_With :: Name
_Type_With = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.With")

_Type_With_lhs :: Name
_Type_With_lhs = (String -> Name
Core.Name String
"lhs")

_Type_With_rhs :: Name
_Type_With_rhs = (String -> Name
Core.Name String
"rhs")

data Type_And = 
  Type_And {
    Type_And -> Type
type_AndLhs :: Type,
    Type_And -> Type
type_AndRhs :: Type}
  deriving (Type_And -> Type_And -> Bool
(Type_And -> Type_And -> Bool)
-> (Type_And -> Type_And -> Bool) -> Eq Type_And
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_And -> Type_And -> Bool
== :: Type_And -> Type_And -> Bool
$c/= :: Type_And -> Type_And -> Bool
/= :: Type_And -> Type_And -> Bool
Eq, Eq Type_And
Eq Type_And =>
(Type_And -> Type_And -> Ordering)
-> (Type_And -> Type_And -> Bool)
-> (Type_And -> Type_And -> Bool)
-> (Type_And -> Type_And -> Bool)
-> (Type_And -> Type_And -> Bool)
-> (Type_And -> Type_And -> Type_And)
-> (Type_And -> Type_And -> Type_And)
-> Ord Type_And
Type_And -> Type_And -> Bool
Type_And -> Type_And -> Ordering
Type_And -> Type_And -> Type_And
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_And -> Type_And -> Ordering
compare :: Type_And -> Type_And -> Ordering
$c< :: Type_And -> Type_And -> Bool
< :: Type_And -> Type_And -> Bool
$c<= :: Type_And -> Type_And -> Bool
<= :: Type_And -> Type_And -> Bool
$c> :: Type_And -> Type_And -> Bool
> :: Type_And -> Type_And -> Bool
$c>= :: Type_And -> Type_And -> Bool
>= :: Type_And -> Type_And -> Bool
$cmax :: Type_And -> Type_And -> Type_And
max :: Type_And -> Type_And -> Type_And
$cmin :: Type_And -> Type_And -> Type_And
min :: Type_And -> Type_And -> Type_And
Ord, ReadPrec [Type_And]
ReadPrec Type_And
Int -> ReadS Type_And
ReadS [Type_And]
(Int -> ReadS Type_And)
-> ReadS [Type_And]
-> ReadPrec Type_And
-> ReadPrec [Type_And]
-> Read Type_And
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_And
readsPrec :: Int -> ReadS Type_And
$creadList :: ReadS [Type_And]
readList :: ReadS [Type_And]
$creadPrec :: ReadPrec Type_And
readPrec :: ReadPrec Type_And
$creadListPrec :: ReadPrec [Type_And]
readListPrec :: ReadPrec [Type_And]
Read, Int -> Type_And -> String -> String
[Type_And] -> String -> String
Type_And -> String
(Int -> Type_And -> String -> String)
-> (Type_And -> String)
-> ([Type_And] -> String -> String)
-> Show Type_And
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_And -> String -> String
showsPrec :: Int -> Type_And -> String -> String
$cshow :: Type_And -> String
show :: Type_And -> String
$cshowList :: [Type_And] -> String -> String
showList :: [Type_And] -> String -> String
Show)

_Type_And :: Name
_Type_And = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.And")

_Type_And_lhs :: Name
_Type_And_lhs = (String -> Name
Core.Name String
"lhs")

_Type_And_rhs :: Name
_Type_And_rhs = (String -> Name
Core.Name String
"rhs")

data Type_Or = 
  Type_Or {
    Type_Or -> Type
type_OrLhs :: Type,
    Type_Or -> Type
type_OrRhs :: Type}
  deriving (Type_Or -> Type_Or -> Bool
(Type_Or -> Type_Or -> Bool)
-> (Type_Or -> Type_Or -> Bool) -> Eq Type_Or
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Or -> Type_Or -> Bool
== :: Type_Or -> Type_Or -> Bool
$c/= :: Type_Or -> Type_Or -> Bool
/= :: Type_Or -> Type_Or -> Bool
Eq, Eq Type_Or
Eq Type_Or =>
(Type_Or -> Type_Or -> Ordering)
-> (Type_Or -> Type_Or -> Bool)
-> (Type_Or -> Type_Or -> Bool)
-> (Type_Or -> Type_Or -> Bool)
-> (Type_Or -> Type_Or -> Bool)
-> (Type_Or -> Type_Or -> Type_Or)
-> (Type_Or -> Type_Or -> Type_Or)
-> Ord Type_Or
Type_Or -> Type_Or -> Bool
Type_Or -> Type_Or -> Ordering
Type_Or -> Type_Or -> Type_Or
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Or -> Type_Or -> Ordering
compare :: Type_Or -> Type_Or -> Ordering
$c< :: Type_Or -> Type_Or -> Bool
< :: Type_Or -> Type_Or -> Bool
$c<= :: Type_Or -> Type_Or -> Bool
<= :: Type_Or -> Type_Or -> Bool
$c> :: Type_Or -> Type_Or -> Bool
> :: Type_Or -> Type_Or -> Bool
$c>= :: Type_Or -> Type_Or -> Bool
>= :: Type_Or -> Type_Or -> Bool
$cmax :: Type_Or -> Type_Or -> Type_Or
max :: Type_Or -> Type_Or -> Type_Or
$cmin :: Type_Or -> Type_Or -> Type_Or
min :: Type_Or -> Type_Or -> Type_Or
Ord, ReadPrec [Type_Or]
ReadPrec Type_Or
Int -> ReadS Type_Or
ReadS [Type_Or]
(Int -> ReadS Type_Or)
-> ReadS [Type_Or]
-> ReadPrec Type_Or
-> ReadPrec [Type_Or]
-> Read Type_Or
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Or
readsPrec :: Int -> ReadS Type_Or
$creadList :: ReadS [Type_Or]
readList :: ReadS [Type_Or]
$creadPrec :: ReadPrec Type_Or
readPrec :: ReadPrec Type_Or
$creadListPrec :: ReadPrec [Type_Or]
readListPrec :: ReadPrec [Type_Or]
Read, Int -> Type_Or -> String -> String
[Type_Or] -> String -> String
Type_Or -> String
(Int -> Type_Or -> String -> String)
-> (Type_Or -> String)
-> ([Type_Or] -> String -> String)
-> Show Type_Or
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Or -> String -> String
showsPrec :: Int -> Type_Or -> String -> String
$cshow :: Type_Or -> String
show :: Type_Or -> String
$cshowList :: [Type_Or] -> String -> String
showList :: [Type_Or] -> String -> String
Show)

_Type_Or :: Name
_Type_Or = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Or")

_Type_Or_lhs :: Name
_Type_Or_lhs = (String -> Name
Core.Name String
"lhs")

_Type_Or_rhs :: Name
_Type_Or_rhs = (String -> Name
Core.Name String
"rhs")

data Type_Refine = 
  Type_Refine {
    Type_Refine -> Maybe Type
type_RefineTpe :: (Maybe Type),
    Type_Refine -> [Stat]
type_RefineStats :: [Stat]}
  deriving (Type_Refine -> Type_Refine -> Bool
(Type_Refine -> Type_Refine -> Bool)
-> (Type_Refine -> Type_Refine -> Bool) -> Eq Type_Refine
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Refine -> Type_Refine -> Bool
== :: Type_Refine -> Type_Refine -> Bool
$c/= :: Type_Refine -> Type_Refine -> Bool
/= :: Type_Refine -> Type_Refine -> Bool
Eq, Eq Type_Refine
Eq Type_Refine =>
(Type_Refine -> Type_Refine -> Ordering)
-> (Type_Refine -> Type_Refine -> Bool)
-> (Type_Refine -> Type_Refine -> Bool)
-> (Type_Refine -> Type_Refine -> Bool)
-> (Type_Refine -> Type_Refine -> Bool)
-> (Type_Refine -> Type_Refine -> Type_Refine)
-> (Type_Refine -> Type_Refine -> Type_Refine)
-> Ord Type_Refine
Type_Refine -> Type_Refine -> Bool
Type_Refine -> Type_Refine -> Ordering
Type_Refine -> Type_Refine -> Type_Refine
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Refine -> Type_Refine -> Ordering
compare :: Type_Refine -> Type_Refine -> Ordering
$c< :: Type_Refine -> Type_Refine -> Bool
< :: Type_Refine -> Type_Refine -> Bool
$c<= :: Type_Refine -> Type_Refine -> Bool
<= :: Type_Refine -> Type_Refine -> Bool
$c> :: Type_Refine -> Type_Refine -> Bool
> :: Type_Refine -> Type_Refine -> Bool
$c>= :: Type_Refine -> Type_Refine -> Bool
>= :: Type_Refine -> Type_Refine -> Bool
$cmax :: Type_Refine -> Type_Refine -> Type_Refine
max :: Type_Refine -> Type_Refine -> Type_Refine
$cmin :: Type_Refine -> Type_Refine -> Type_Refine
min :: Type_Refine -> Type_Refine -> Type_Refine
Ord, ReadPrec [Type_Refine]
ReadPrec Type_Refine
Int -> ReadS Type_Refine
ReadS [Type_Refine]
(Int -> ReadS Type_Refine)
-> ReadS [Type_Refine]
-> ReadPrec Type_Refine
-> ReadPrec [Type_Refine]
-> Read Type_Refine
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Refine
readsPrec :: Int -> ReadS Type_Refine
$creadList :: ReadS [Type_Refine]
readList :: ReadS [Type_Refine]
$creadPrec :: ReadPrec Type_Refine
readPrec :: ReadPrec Type_Refine
$creadListPrec :: ReadPrec [Type_Refine]
readListPrec :: ReadPrec [Type_Refine]
Read, Int -> Type_Refine -> String -> String
[Type_Refine] -> String -> String
Type_Refine -> String
(Int -> Type_Refine -> String -> String)
-> (Type_Refine -> String)
-> ([Type_Refine] -> String -> String)
-> Show Type_Refine
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Refine -> String -> String
showsPrec :: Int -> Type_Refine -> String -> String
$cshow :: Type_Refine -> String
show :: Type_Refine -> String
$cshowList :: [Type_Refine] -> String -> String
showList :: [Type_Refine] -> String -> String
Show)

_Type_Refine :: Name
_Type_Refine = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Refine")

_Type_Refine_tpe :: Name
_Type_Refine_tpe = (String -> Name
Core.Name String
"tpe")

_Type_Refine_stats :: Name
_Type_Refine_stats = (String -> Name
Core.Name String
"stats")

data Type_Existential = 
  Type_Existential {
    Type_Existential -> Type
type_ExistentialTpe :: Type,
    Type_Existential -> [Stat]
type_ExistentialStats :: [Stat]}
  deriving (Type_Existential -> Type_Existential -> Bool
(Type_Existential -> Type_Existential -> Bool)
-> (Type_Existential -> Type_Existential -> Bool)
-> Eq Type_Existential
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Existential -> Type_Existential -> Bool
== :: Type_Existential -> Type_Existential -> Bool
$c/= :: Type_Existential -> Type_Existential -> Bool
/= :: Type_Existential -> Type_Existential -> Bool
Eq, Eq Type_Existential
Eq Type_Existential =>
(Type_Existential -> Type_Existential -> Ordering)
-> (Type_Existential -> Type_Existential -> Bool)
-> (Type_Existential -> Type_Existential -> Bool)
-> (Type_Existential -> Type_Existential -> Bool)
-> (Type_Existential -> Type_Existential -> Bool)
-> (Type_Existential -> Type_Existential -> Type_Existential)
-> (Type_Existential -> Type_Existential -> Type_Existential)
-> Ord Type_Existential
Type_Existential -> Type_Existential -> Bool
Type_Existential -> Type_Existential -> Ordering
Type_Existential -> Type_Existential -> Type_Existential
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Existential -> Type_Existential -> Ordering
compare :: Type_Existential -> Type_Existential -> Ordering
$c< :: Type_Existential -> Type_Existential -> Bool
< :: Type_Existential -> Type_Existential -> Bool
$c<= :: Type_Existential -> Type_Existential -> Bool
<= :: Type_Existential -> Type_Existential -> Bool
$c> :: Type_Existential -> Type_Existential -> Bool
> :: Type_Existential -> Type_Existential -> Bool
$c>= :: Type_Existential -> Type_Existential -> Bool
>= :: Type_Existential -> Type_Existential -> Bool
$cmax :: Type_Existential -> Type_Existential -> Type_Existential
max :: Type_Existential -> Type_Existential -> Type_Existential
$cmin :: Type_Existential -> Type_Existential -> Type_Existential
min :: Type_Existential -> Type_Existential -> Type_Existential
Ord, ReadPrec [Type_Existential]
ReadPrec Type_Existential
Int -> ReadS Type_Existential
ReadS [Type_Existential]
(Int -> ReadS Type_Existential)
-> ReadS [Type_Existential]
-> ReadPrec Type_Existential
-> ReadPrec [Type_Existential]
-> Read Type_Existential
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Existential
readsPrec :: Int -> ReadS Type_Existential
$creadList :: ReadS [Type_Existential]
readList :: ReadS [Type_Existential]
$creadPrec :: ReadPrec Type_Existential
readPrec :: ReadPrec Type_Existential
$creadListPrec :: ReadPrec [Type_Existential]
readListPrec :: ReadPrec [Type_Existential]
Read, Int -> Type_Existential -> String -> String
[Type_Existential] -> String -> String
Type_Existential -> String
(Int -> Type_Existential -> String -> String)
-> (Type_Existential -> String)
-> ([Type_Existential] -> String -> String)
-> Show Type_Existential
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Existential -> String -> String
showsPrec :: Int -> Type_Existential -> String -> String
$cshow :: Type_Existential -> String
show :: Type_Existential -> String
$cshowList :: [Type_Existential] -> String -> String
showList :: [Type_Existential] -> String -> String
Show)

_Type_Existential :: Name
_Type_Existential = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Existential")

_Type_Existential_tpe :: Name
_Type_Existential_tpe = (String -> Name
Core.Name String
"tpe")

_Type_Existential_stats :: Name
_Type_Existential_stats = (String -> Name
Core.Name String
"stats")

data Type_Annotate = 
  Type_Annotate {
    Type_Annotate -> Type
type_AnnotateTpe :: Type,
    Type_Annotate -> [Mod_Annot]
type_AnnotateAnnots :: [Mod_Annot]}
  deriving (Type_Annotate -> Type_Annotate -> Bool
(Type_Annotate -> Type_Annotate -> Bool)
-> (Type_Annotate -> Type_Annotate -> Bool) -> Eq Type_Annotate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Annotate -> Type_Annotate -> Bool
== :: Type_Annotate -> Type_Annotate -> Bool
$c/= :: Type_Annotate -> Type_Annotate -> Bool
/= :: Type_Annotate -> Type_Annotate -> Bool
Eq, Eq Type_Annotate
Eq Type_Annotate =>
(Type_Annotate -> Type_Annotate -> Ordering)
-> (Type_Annotate -> Type_Annotate -> Bool)
-> (Type_Annotate -> Type_Annotate -> Bool)
-> (Type_Annotate -> Type_Annotate -> Bool)
-> (Type_Annotate -> Type_Annotate -> Bool)
-> (Type_Annotate -> Type_Annotate -> Type_Annotate)
-> (Type_Annotate -> Type_Annotate -> Type_Annotate)
-> Ord Type_Annotate
Type_Annotate -> Type_Annotate -> Bool
Type_Annotate -> Type_Annotate -> Ordering
Type_Annotate -> Type_Annotate -> Type_Annotate
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Annotate -> Type_Annotate -> Ordering
compare :: Type_Annotate -> Type_Annotate -> Ordering
$c< :: Type_Annotate -> Type_Annotate -> Bool
< :: Type_Annotate -> Type_Annotate -> Bool
$c<= :: Type_Annotate -> Type_Annotate -> Bool
<= :: Type_Annotate -> Type_Annotate -> Bool
$c> :: Type_Annotate -> Type_Annotate -> Bool
> :: Type_Annotate -> Type_Annotate -> Bool
$c>= :: Type_Annotate -> Type_Annotate -> Bool
>= :: Type_Annotate -> Type_Annotate -> Bool
$cmax :: Type_Annotate -> Type_Annotate -> Type_Annotate
max :: Type_Annotate -> Type_Annotate -> Type_Annotate
$cmin :: Type_Annotate -> Type_Annotate -> Type_Annotate
min :: Type_Annotate -> Type_Annotate -> Type_Annotate
Ord, ReadPrec [Type_Annotate]
ReadPrec Type_Annotate
Int -> ReadS Type_Annotate
ReadS [Type_Annotate]
(Int -> ReadS Type_Annotate)
-> ReadS [Type_Annotate]
-> ReadPrec Type_Annotate
-> ReadPrec [Type_Annotate]
-> Read Type_Annotate
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Annotate
readsPrec :: Int -> ReadS Type_Annotate
$creadList :: ReadS [Type_Annotate]
readList :: ReadS [Type_Annotate]
$creadPrec :: ReadPrec Type_Annotate
readPrec :: ReadPrec Type_Annotate
$creadListPrec :: ReadPrec [Type_Annotate]
readListPrec :: ReadPrec [Type_Annotate]
Read, Int -> Type_Annotate -> String -> String
[Type_Annotate] -> String -> String
Type_Annotate -> String
(Int -> Type_Annotate -> String -> String)
-> (Type_Annotate -> String)
-> ([Type_Annotate] -> String -> String)
-> Show Type_Annotate
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Annotate -> String -> String
showsPrec :: Int -> Type_Annotate -> String -> String
$cshow :: Type_Annotate -> String
show :: Type_Annotate -> String
$cshowList :: [Type_Annotate] -> String -> String
showList :: [Type_Annotate] -> String -> String
Show)

_Type_Annotate :: Name
_Type_Annotate = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Annotate")

_Type_Annotate_tpe :: Name
_Type_Annotate_tpe = (String -> Name
Core.Name String
"tpe")

_Type_Annotate_annots :: Name
_Type_Annotate_annots = (String -> Name
Core.Name String
"annots")

data Type_Lambda = 
  Type_Lambda {
    Type_Lambda -> [Type_Param]
type_LambdaTparams :: [Type_Param],
    Type_Lambda -> Type
type_LambdaTpe :: Type}
  deriving (Type_Lambda -> Type_Lambda -> Bool
(Type_Lambda -> Type_Lambda -> Bool)
-> (Type_Lambda -> Type_Lambda -> Bool) -> Eq Type_Lambda
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Lambda -> Type_Lambda -> Bool
== :: Type_Lambda -> Type_Lambda -> Bool
$c/= :: Type_Lambda -> Type_Lambda -> Bool
/= :: Type_Lambda -> Type_Lambda -> Bool
Eq, Eq Type_Lambda
Eq Type_Lambda =>
(Type_Lambda -> Type_Lambda -> Ordering)
-> (Type_Lambda -> Type_Lambda -> Bool)
-> (Type_Lambda -> Type_Lambda -> Bool)
-> (Type_Lambda -> Type_Lambda -> Bool)
-> (Type_Lambda -> Type_Lambda -> Bool)
-> (Type_Lambda -> Type_Lambda -> Type_Lambda)
-> (Type_Lambda -> Type_Lambda -> Type_Lambda)
-> Ord Type_Lambda
Type_Lambda -> Type_Lambda -> Bool
Type_Lambda -> Type_Lambda -> Ordering
Type_Lambda -> Type_Lambda -> Type_Lambda
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Lambda -> Type_Lambda -> Ordering
compare :: Type_Lambda -> Type_Lambda -> Ordering
$c< :: Type_Lambda -> Type_Lambda -> Bool
< :: Type_Lambda -> Type_Lambda -> Bool
$c<= :: Type_Lambda -> Type_Lambda -> Bool
<= :: Type_Lambda -> Type_Lambda -> Bool
$c> :: Type_Lambda -> Type_Lambda -> Bool
> :: Type_Lambda -> Type_Lambda -> Bool
$c>= :: Type_Lambda -> Type_Lambda -> Bool
>= :: Type_Lambda -> Type_Lambda -> Bool
$cmax :: Type_Lambda -> Type_Lambda -> Type_Lambda
max :: Type_Lambda -> Type_Lambda -> Type_Lambda
$cmin :: Type_Lambda -> Type_Lambda -> Type_Lambda
min :: Type_Lambda -> Type_Lambda -> Type_Lambda
Ord, ReadPrec [Type_Lambda]
ReadPrec Type_Lambda
Int -> ReadS Type_Lambda
ReadS [Type_Lambda]
(Int -> ReadS Type_Lambda)
-> ReadS [Type_Lambda]
-> ReadPrec Type_Lambda
-> ReadPrec [Type_Lambda]
-> Read Type_Lambda
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Lambda
readsPrec :: Int -> ReadS Type_Lambda
$creadList :: ReadS [Type_Lambda]
readList :: ReadS [Type_Lambda]
$creadPrec :: ReadPrec Type_Lambda
readPrec :: ReadPrec Type_Lambda
$creadListPrec :: ReadPrec [Type_Lambda]
readListPrec :: ReadPrec [Type_Lambda]
Read, Int -> Type_Lambda -> String -> String
[Type_Lambda] -> String -> String
Type_Lambda -> String
(Int -> Type_Lambda -> String -> String)
-> (Type_Lambda -> String)
-> ([Type_Lambda] -> String -> String)
-> Show Type_Lambda
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Lambda -> String -> String
showsPrec :: Int -> Type_Lambda -> String -> String
$cshow :: Type_Lambda -> String
show :: Type_Lambda -> String
$cshowList :: [Type_Lambda] -> String -> String
showList :: [Type_Lambda] -> String -> String
Show)

_Type_Lambda :: Name
_Type_Lambda = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Lambda")

_Type_Lambda_tparams :: Name
_Type_Lambda_tparams = (String -> Name
Core.Name String
"tparams")

_Type_Lambda_tpe :: Name
_Type_Lambda_tpe = (String -> Name
Core.Name String
"tpe")

data Type_Macro = 
  Type_Macro {
    Type_Macro -> Data
type_MacroBody :: Data}
  deriving (Type_Macro -> Type_Macro -> Bool
(Type_Macro -> Type_Macro -> Bool)
-> (Type_Macro -> Type_Macro -> Bool) -> Eq Type_Macro
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Macro -> Type_Macro -> Bool
== :: Type_Macro -> Type_Macro -> Bool
$c/= :: Type_Macro -> Type_Macro -> Bool
/= :: Type_Macro -> Type_Macro -> Bool
Eq, Eq Type_Macro
Eq Type_Macro =>
(Type_Macro -> Type_Macro -> Ordering)
-> (Type_Macro -> Type_Macro -> Bool)
-> (Type_Macro -> Type_Macro -> Bool)
-> (Type_Macro -> Type_Macro -> Bool)
-> (Type_Macro -> Type_Macro -> Bool)
-> (Type_Macro -> Type_Macro -> Type_Macro)
-> (Type_Macro -> Type_Macro -> Type_Macro)
-> Ord Type_Macro
Type_Macro -> Type_Macro -> Bool
Type_Macro -> Type_Macro -> Ordering
Type_Macro -> Type_Macro -> Type_Macro
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Macro -> Type_Macro -> Ordering
compare :: Type_Macro -> Type_Macro -> Ordering
$c< :: Type_Macro -> Type_Macro -> Bool
< :: Type_Macro -> Type_Macro -> Bool
$c<= :: Type_Macro -> Type_Macro -> Bool
<= :: Type_Macro -> Type_Macro -> Bool
$c> :: Type_Macro -> Type_Macro -> Bool
> :: Type_Macro -> Type_Macro -> Bool
$c>= :: Type_Macro -> Type_Macro -> Bool
>= :: Type_Macro -> Type_Macro -> Bool
$cmax :: Type_Macro -> Type_Macro -> Type_Macro
max :: Type_Macro -> Type_Macro -> Type_Macro
$cmin :: Type_Macro -> Type_Macro -> Type_Macro
min :: Type_Macro -> Type_Macro -> Type_Macro
Ord, ReadPrec [Type_Macro]
ReadPrec Type_Macro
Int -> ReadS Type_Macro
ReadS [Type_Macro]
(Int -> ReadS Type_Macro)
-> ReadS [Type_Macro]
-> ReadPrec Type_Macro
-> ReadPrec [Type_Macro]
-> Read Type_Macro
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Macro
readsPrec :: Int -> ReadS Type_Macro
$creadList :: ReadS [Type_Macro]
readList :: ReadS [Type_Macro]
$creadPrec :: ReadPrec Type_Macro
readPrec :: ReadPrec Type_Macro
$creadListPrec :: ReadPrec [Type_Macro]
readListPrec :: ReadPrec [Type_Macro]
Read, Int -> Type_Macro -> String -> String
[Type_Macro] -> String -> String
Type_Macro -> String
(Int -> Type_Macro -> String -> String)
-> (Type_Macro -> String)
-> ([Type_Macro] -> String -> String)
-> Show Type_Macro
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Macro -> String -> String
showsPrec :: Int -> Type_Macro -> String -> String
$cshow :: Type_Macro -> String
show :: Type_Macro -> String
$cshowList :: [Type_Macro] -> String -> String
showList :: [Type_Macro] -> String -> String
Show)

_Type_Macro :: Name
_Type_Macro = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Macro")

_Type_Macro_body :: Name
_Type_Macro_body = (String -> Name
Core.Name String
"body")

data Type_Method = 
  Type_Method {
    Type_Method -> [[Data_Param]]
type_MethodParamss :: [[Data_Param]],
    Type_Method -> Type
type_MethodTpe :: Type}
  deriving (Type_Method -> Type_Method -> Bool
(Type_Method -> Type_Method -> Bool)
-> (Type_Method -> Type_Method -> Bool) -> Eq Type_Method
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Method -> Type_Method -> Bool
== :: Type_Method -> Type_Method -> Bool
$c/= :: Type_Method -> Type_Method -> Bool
/= :: Type_Method -> Type_Method -> Bool
Eq, Eq Type_Method
Eq Type_Method =>
(Type_Method -> Type_Method -> Ordering)
-> (Type_Method -> Type_Method -> Bool)
-> (Type_Method -> Type_Method -> Bool)
-> (Type_Method -> Type_Method -> Bool)
-> (Type_Method -> Type_Method -> Bool)
-> (Type_Method -> Type_Method -> Type_Method)
-> (Type_Method -> Type_Method -> Type_Method)
-> Ord Type_Method
Type_Method -> Type_Method -> Bool
Type_Method -> Type_Method -> Ordering
Type_Method -> Type_Method -> Type_Method
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Method -> Type_Method -> Ordering
compare :: Type_Method -> Type_Method -> Ordering
$c< :: Type_Method -> Type_Method -> Bool
< :: Type_Method -> Type_Method -> Bool
$c<= :: Type_Method -> Type_Method -> Bool
<= :: Type_Method -> Type_Method -> Bool
$c> :: Type_Method -> Type_Method -> Bool
> :: Type_Method -> Type_Method -> Bool
$c>= :: Type_Method -> Type_Method -> Bool
>= :: Type_Method -> Type_Method -> Bool
$cmax :: Type_Method -> Type_Method -> Type_Method
max :: Type_Method -> Type_Method -> Type_Method
$cmin :: Type_Method -> Type_Method -> Type_Method
min :: Type_Method -> Type_Method -> Type_Method
Ord, ReadPrec [Type_Method]
ReadPrec Type_Method
Int -> ReadS Type_Method
ReadS [Type_Method]
(Int -> ReadS Type_Method)
-> ReadS [Type_Method]
-> ReadPrec Type_Method
-> ReadPrec [Type_Method]
-> Read Type_Method
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Method
readsPrec :: Int -> ReadS Type_Method
$creadList :: ReadS [Type_Method]
readList :: ReadS [Type_Method]
$creadPrec :: ReadPrec Type_Method
readPrec :: ReadPrec Type_Method
$creadListPrec :: ReadPrec [Type_Method]
readListPrec :: ReadPrec [Type_Method]
Read, Int -> Type_Method -> String -> String
[Type_Method] -> String -> String
Type_Method -> String
(Int -> Type_Method -> String -> String)
-> (Type_Method -> String)
-> ([Type_Method] -> String -> String)
-> Show Type_Method
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Method -> String -> String
showsPrec :: Int -> Type_Method -> String -> String
$cshow :: Type_Method -> String
show :: Type_Method -> String
$cshowList :: [Type_Method] -> String -> String
showList :: [Type_Method] -> String -> String
Show)

_Type_Method :: Name
_Type_Method = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Method")

_Type_Method_paramss :: Name
_Type_Method_paramss = (String -> Name
Core.Name String
"paramss")

_Type_Method_tpe :: Name
_Type_Method_tpe = (String -> Name
Core.Name String
"tpe")

data Type_Placeholder = 
  Type_Placeholder {
    Type_Placeholder -> Type_Bounds
type_PlaceholderBounds :: Type_Bounds}
  deriving (Type_Placeholder -> Type_Placeholder -> Bool
(Type_Placeholder -> Type_Placeholder -> Bool)
-> (Type_Placeholder -> Type_Placeholder -> Bool)
-> Eq Type_Placeholder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Placeholder -> Type_Placeholder -> Bool
== :: Type_Placeholder -> Type_Placeholder -> Bool
$c/= :: Type_Placeholder -> Type_Placeholder -> Bool
/= :: Type_Placeholder -> Type_Placeholder -> Bool
Eq, Eq Type_Placeholder
Eq Type_Placeholder =>
(Type_Placeholder -> Type_Placeholder -> Ordering)
-> (Type_Placeholder -> Type_Placeholder -> Bool)
-> (Type_Placeholder -> Type_Placeholder -> Bool)
-> (Type_Placeholder -> Type_Placeholder -> Bool)
-> (Type_Placeholder -> Type_Placeholder -> Bool)
-> (Type_Placeholder -> Type_Placeholder -> Type_Placeholder)
-> (Type_Placeholder -> Type_Placeholder -> Type_Placeholder)
-> Ord Type_Placeholder
Type_Placeholder -> Type_Placeholder -> Bool
Type_Placeholder -> Type_Placeholder -> Ordering
Type_Placeholder -> Type_Placeholder -> Type_Placeholder
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Placeholder -> Type_Placeholder -> Ordering
compare :: Type_Placeholder -> Type_Placeholder -> Ordering
$c< :: Type_Placeholder -> Type_Placeholder -> Bool
< :: Type_Placeholder -> Type_Placeholder -> Bool
$c<= :: Type_Placeholder -> Type_Placeholder -> Bool
<= :: Type_Placeholder -> Type_Placeholder -> Bool
$c> :: Type_Placeholder -> Type_Placeholder -> Bool
> :: Type_Placeholder -> Type_Placeholder -> Bool
$c>= :: Type_Placeholder -> Type_Placeholder -> Bool
>= :: Type_Placeholder -> Type_Placeholder -> Bool
$cmax :: Type_Placeholder -> Type_Placeholder -> Type_Placeholder
max :: Type_Placeholder -> Type_Placeholder -> Type_Placeholder
$cmin :: Type_Placeholder -> Type_Placeholder -> Type_Placeholder
min :: Type_Placeholder -> Type_Placeholder -> Type_Placeholder
Ord, ReadPrec [Type_Placeholder]
ReadPrec Type_Placeholder
Int -> ReadS Type_Placeholder
ReadS [Type_Placeholder]
(Int -> ReadS Type_Placeholder)
-> ReadS [Type_Placeholder]
-> ReadPrec Type_Placeholder
-> ReadPrec [Type_Placeholder]
-> Read Type_Placeholder
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Placeholder
readsPrec :: Int -> ReadS Type_Placeholder
$creadList :: ReadS [Type_Placeholder]
readList :: ReadS [Type_Placeholder]
$creadPrec :: ReadPrec Type_Placeholder
readPrec :: ReadPrec Type_Placeholder
$creadListPrec :: ReadPrec [Type_Placeholder]
readListPrec :: ReadPrec [Type_Placeholder]
Read, Int -> Type_Placeholder -> String -> String
[Type_Placeholder] -> String -> String
Type_Placeholder -> String
(Int -> Type_Placeholder -> String -> String)
-> (Type_Placeholder -> String)
-> ([Type_Placeholder] -> String -> String)
-> Show Type_Placeholder
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Placeholder -> String -> String
showsPrec :: Int -> Type_Placeholder -> String -> String
$cshow :: Type_Placeholder -> String
show :: Type_Placeholder -> String
$cshowList :: [Type_Placeholder] -> String -> String
showList :: [Type_Placeholder] -> String -> String
Show)

_Type_Placeholder :: Name
_Type_Placeholder = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Placeholder")

_Type_Placeholder_bounds :: Name
_Type_Placeholder_bounds = (String -> Name
Core.Name String
"bounds")

data Type_Bounds = 
  Type_Bounds {
    Type_Bounds -> Maybe Type
type_BoundsLo :: (Maybe Type),
    Type_Bounds -> Maybe Type
type_BoundsHi :: (Maybe Type)}
  deriving (Type_Bounds -> Type_Bounds -> Bool
(Type_Bounds -> Type_Bounds -> Bool)
-> (Type_Bounds -> Type_Bounds -> Bool) -> Eq Type_Bounds
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Bounds -> Type_Bounds -> Bool
== :: Type_Bounds -> Type_Bounds -> Bool
$c/= :: Type_Bounds -> Type_Bounds -> Bool
/= :: Type_Bounds -> Type_Bounds -> Bool
Eq, Eq Type_Bounds
Eq Type_Bounds =>
(Type_Bounds -> Type_Bounds -> Ordering)
-> (Type_Bounds -> Type_Bounds -> Bool)
-> (Type_Bounds -> Type_Bounds -> Bool)
-> (Type_Bounds -> Type_Bounds -> Bool)
-> (Type_Bounds -> Type_Bounds -> Bool)
-> (Type_Bounds -> Type_Bounds -> Type_Bounds)
-> (Type_Bounds -> Type_Bounds -> Type_Bounds)
-> Ord Type_Bounds
Type_Bounds -> Type_Bounds -> Bool
Type_Bounds -> Type_Bounds -> Ordering
Type_Bounds -> Type_Bounds -> Type_Bounds
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Bounds -> Type_Bounds -> Ordering
compare :: Type_Bounds -> Type_Bounds -> Ordering
$c< :: Type_Bounds -> Type_Bounds -> Bool
< :: Type_Bounds -> Type_Bounds -> Bool
$c<= :: Type_Bounds -> Type_Bounds -> Bool
<= :: Type_Bounds -> Type_Bounds -> Bool
$c> :: Type_Bounds -> Type_Bounds -> Bool
> :: Type_Bounds -> Type_Bounds -> Bool
$c>= :: Type_Bounds -> Type_Bounds -> Bool
>= :: Type_Bounds -> Type_Bounds -> Bool
$cmax :: Type_Bounds -> Type_Bounds -> Type_Bounds
max :: Type_Bounds -> Type_Bounds -> Type_Bounds
$cmin :: Type_Bounds -> Type_Bounds -> Type_Bounds
min :: Type_Bounds -> Type_Bounds -> Type_Bounds
Ord, ReadPrec [Type_Bounds]
ReadPrec Type_Bounds
Int -> ReadS Type_Bounds
ReadS [Type_Bounds]
(Int -> ReadS Type_Bounds)
-> ReadS [Type_Bounds]
-> ReadPrec Type_Bounds
-> ReadPrec [Type_Bounds]
-> Read Type_Bounds
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Bounds
readsPrec :: Int -> ReadS Type_Bounds
$creadList :: ReadS [Type_Bounds]
readList :: ReadS [Type_Bounds]
$creadPrec :: ReadPrec Type_Bounds
readPrec :: ReadPrec Type_Bounds
$creadListPrec :: ReadPrec [Type_Bounds]
readListPrec :: ReadPrec [Type_Bounds]
Read, Int -> Type_Bounds -> String -> String
[Type_Bounds] -> String -> String
Type_Bounds -> String
(Int -> Type_Bounds -> String -> String)
-> (Type_Bounds -> String)
-> ([Type_Bounds] -> String -> String)
-> Show Type_Bounds
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Bounds -> String -> String
showsPrec :: Int -> Type_Bounds -> String -> String
$cshow :: Type_Bounds -> String
show :: Type_Bounds -> String
$cshowList :: [Type_Bounds] -> String -> String
showList :: [Type_Bounds] -> String -> String
Show)

_Type_Bounds :: Name
_Type_Bounds = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Bounds")

_Type_Bounds_lo :: Name
_Type_Bounds_lo = (String -> Name
Core.Name String
"lo")

_Type_Bounds_hi :: Name
_Type_Bounds_hi = (String -> Name
Core.Name String
"hi")

data Type_ByName = 
  Type_ByName {
    Type_ByName -> Type
type_ByNameTpe :: Type}
  deriving (Type_ByName -> Type_ByName -> Bool
(Type_ByName -> Type_ByName -> Bool)
-> (Type_ByName -> Type_ByName -> Bool) -> Eq Type_ByName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_ByName -> Type_ByName -> Bool
== :: Type_ByName -> Type_ByName -> Bool
$c/= :: Type_ByName -> Type_ByName -> Bool
/= :: Type_ByName -> Type_ByName -> Bool
Eq, Eq Type_ByName
Eq Type_ByName =>
(Type_ByName -> Type_ByName -> Ordering)
-> (Type_ByName -> Type_ByName -> Bool)
-> (Type_ByName -> Type_ByName -> Bool)
-> (Type_ByName -> Type_ByName -> Bool)
-> (Type_ByName -> Type_ByName -> Bool)
-> (Type_ByName -> Type_ByName -> Type_ByName)
-> (Type_ByName -> Type_ByName -> Type_ByName)
-> Ord Type_ByName
Type_ByName -> Type_ByName -> Bool
Type_ByName -> Type_ByName -> Ordering
Type_ByName -> Type_ByName -> Type_ByName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_ByName -> Type_ByName -> Ordering
compare :: Type_ByName -> Type_ByName -> Ordering
$c< :: Type_ByName -> Type_ByName -> Bool
< :: Type_ByName -> Type_ByName -> Bool
$c<= :: Type_ByName -> Type_ByName -> Bool
<= :: Type_ByName -> Type_ByName -> Bool
$c> :: Type_ByName -> Type_ByName -> Bool
> :: Type_ByName -> Type_ByName -> Bool
$c>= :: Type_ByName -> Type_ByName -> Bool
>= :: Type_ByName -> Type_ByName -> Bool
$cmax :: Type_ByName -> Type_ByName -> Type_ByName
max :: Type_ByName -> Type_ByName -> Type_ByName
$cmin :: Type_ByName -> Type_ByName -> Type_ByName
min :: Type_ByName -> Type_ByName -> Type_ByName
Ord, ReadPrec [Type_ByName]
ReadPrec Type_ByName
Int -> ReadS Type_ByName
ReadS [Type_ByName]
(Int -> ReadS Type_ByName)
-> ReadS [Type_ByName]
-> ReadPrec Type_ByName
-> ReadPrec [Type_ByName]
-> Read Type_ByName
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_ByName
readsPrec :: Int -> ReadS Type_ByName
$creadList :: ReadS [Type_ByName]
readList :: ReadS [Type_ByName]
$creadPrec :: ReadPrec Type_ByName
readPrec :: ReadPrec Type_ByName
$creadListPrec :: ReadPrec [Type_ByName]
readListPrec :: ReadPrec [Type_ByName]
Read, Int -> Type_ByName -> String -> String
[Type_ByName] -> String -> String
Type_ByName -> String
(Int -> Type_ByName -> String -> String)
-> (Type_ByName -> String)
-> ([Type_ByName] -> String -> String)
-> Show Type_ByName
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_ByName -> String -> String
showsPrec :: Int -> Type_ByName -> String -> String
$cshow :: Type_ByName -> String
show :: Type_ByName -> String
$cshowList :: [Type_ByName] -> String -> String
showList :: [Type_ByName] -> String -> String
Show)

_Type_ByName :: Name
_Type_ByName = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.ByName")

_Type_ByName_tpe :: Name
_Type_ByName_tpe = (String -> Name
Core.Name String
"tpe")

data Type_Repeated = 
  Type_Repeated {
    Type_Repeated -> Type
type_RepeatedTpe :: Type}
  deriving (Type_Repeated -> Type_Repeated -> Bool
(Type_Repeated -> Type_Repeated -> Bool)
-> (Type_Repeated -> Type_Repeated -> Bool) -> Eq Type_Repeated
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Repeated -> Type_Repeated -> Bool
== :: Type_Repeated -> Type_Repeated -> Bool
$c/= :: Type_Repeated -> Type_Repeated -> Bool
/= :: Type_Repeated -> Type_Repeated -> Bool
Eq, Eq Type_Repeated
Eq Type_Repeated =>
(Type_Repeated -> Type_Repeated -> Ordering)
-> (Type_Repeated -> Type_Repeated -> Bool)
-> (Type_Repeated -> Type_Repeated -> Bool)
-> (Type_Repeated -> Type_Repeated -> Bool)
-> (Type_Repeated -> Type_Repeated -> Bool)
-> (Type_Repeated -> Type_Repeated -> Type_Repeated)
-> (Type_Repeated -> Type_Repeated -> Type_Repeated)
-> Ord Type_Repeated
Type_Repeated -> Type_Repeated -> Bool
Type_Repeated -> Type_Repeated -> Ordering
Type_Repeated -> Type_Repeated -> Type_Repeated
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Repeated -> Type_Repeated -> Ordering
compare :: Type_Repeated -> Type_Repeated -> Ordering
$c< :: Type_Repeated -> Type_Repeated -> Bool
< :: Type_Repeated -> Type_Repeated -> Bool
$c<= :: Type_Repeated -> Type_Repeated -> Bool
<= :: Type_Repeated -> Type_Repeated -> Bool
$c> :: Type_Repeated -> Type_Repeated -> Bool
> :: Type_Repeated -> Type_Repeated -> Bool
$c>= :: Type_Repeated -> Type_Repeated -> Bool
>= :: Type_Repeated -> Type_Repeated -> Bool
$cmax :: Type_Repeated -> Type_Repeated -> Type_Repeated
max :: Type_Repeated -> Type_Repeated -> Type_Repeated
$cmin :: Type_Repeated -> Type_Repeated -> Type_Repeated
min :: Type_Repeated -> Type_Repeated -> Type_Repeated
Ord, ReadPrec [Type_Repeated]
ReadPrec Type_Repeated
Int -> ReadS Type_Repeated
ReadS [Type_Repeated]
(Int -> ReadS Type_Repeated)
-> ReadS [Type_Repeated]
-> ReadPrec Type_Repeated
-> ReadPrec [Type_Repeated]
-> Read Type_Repeated
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Repeated
readsPrec :: Int -> ReadS Type_Repeated
$creadList :: ReadS [Type_Repeated]
readList :: ReadS [Type_Repeated]
$creadPrec :: ReadPrec Type_Repeated
readPrec :: ReadPrec Type_Repeated
$creadListPrec :: ReadPrec [Type_Repeated]
readListPrec :: ReadPrec [Type_Repeated]
Read, Int -> Type_Repeated -> String -> String
[Type_Repeated] -> String -> String
Type_Repeated -> String
(Int -> Type_Repeated -> String -> String)
-> (Type_Repeated -> String)
-> ([Type_Repeated] -> String -> String)
-> Show Type_Repeated
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Repeated -> String -> String
showsPrec :: Int -> Type_Repeated -> String -> String
$cshow :: Type_Repeated -> String
show :: Type_Repeated -> String
$cshowList :: [Type_Repeated] -> String -> String
showList :: [Type_Repeated] -> String -> String
Show)

_Type_Repeated :: Name
_Type_Repeated = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Repeated")

_Type_Repeated_tpe :: Name
_Type_Repeated_tpe = (String -> Name
Core.Name String
"tpe")

data Type_Var = 
  Type_Var {
    Type_Var -> Type_Name
type_VarName :: Type_Name}
  deriving (Type_Var -> Type_Var -> Bool
(Type_Var -> Type_Var -> Bool)
-> (Type_Var -> Type_Var -> Bool) -> Eq Type_Var
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Var -> Type_Var -> Bool
== :: Type_Var -> Type_Var -> Bool
$c/= :: Type_Var -> Type_Var -> Bool
/= :: Type_Var -> Type_Var -> Bool
Eq, Eq Type_Var
Eq Type_Var =>
(Type_Var -> Type_Var -> Ordering)
-> (Type_Var -> Type_Var -> Bool)
-> (Type_Var -> Type_Var -> Bool)
-> (Type_Var -> Type_Var -> Bool)
-> (Type_Var -> Type_Var -> Bool)
-> (Type_Var -> Type_Var -> Type_Var)
-> (Type_Var -> Type_Var -> Type_Var)
-> Ord Type_Var
Type_Var -> Type_Var -> Bool
Type_Var -> Type_Var -> Ordering
Type_Var -> Type_Var -> Type_Var
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Var -> Type_Var -> Ordering
compare :: Type_Var -> Type_Var -> Ordering
$c< :: Type_Var -> Type_Var -> Bool
< :: Type_Var -> Type_Var -> Bool
$c<= :: Type_Var -> Type_Var -> Bool
<= :: Type_Var -> Type_Var -> Bool
$c> :: Type_Var -> Type_Var -> Bool
> :: Type_Var -> Type_Var -> Bool
$c>= :: Type_Var -> Type_Var -> Bool
>= :: Type_Var -> Type_Var -> Bool
$cmax :: Type_Var -> Type_Var -> Type_Var
max :: Type_Var -> Type_Var -> Type_Var
$cmin :: Type_Var -> Type_Var -> Type_Var
min :: Type_Var -> Type_Var -> Type_Var
Ord, ReadPrec [Type_Var]
ReadPrec Type_Var
Int -> ReadS Type_Var
ReadS [Type_Var]
(Int -> ReadS Type_Var)
-> ReadS [Type_Var]
-> ReadPrec Type_Var
-> ReadPrec [Type_Var]
-> Read Type_Var
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Var
readsPrec :: Int -> ReadS Type_Var
$creadList :: ReadS [Type_Var]
readList :: ReadS [Type_Var]
$creadPrec :: ReadPrec Type_Var
readPrec :: ReadPrec Type_Var
$creadListPrec :: ReadPrec [Type_Var]
readListPrec :: ReadPrec [Type_Var]
Read, Int -> Type_Var -> String -> String
[Type_Var] -> String -> String
Type_Var -> String
(Int -> Type_Var -> String -> String)
-> (Type_Var -> String)
-> ([Type_Var] -> String -> String)
-> Show Type_Var
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Var -> String -> String
showsPrec :: Int -> Type_Var -> String -> String
$cshow :: Type_Var -> String
show :: Type_Var -> String
$cshowList :: [Type_Var] -> String -> String
showList :: [Type_Var] -> String -> String
Show)

_Type_Var :: Name
_Type_Var = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Var")

_Type_Var_name :: Name
_Type_Var_name = (String -> Name
Core.Name String
"name")

data Type_TypedParam = 
  Type_TypedParam {
    Type_TypedParam -> Name
type_TypedParamName :: Name,
    Type_TypedParam -> Type
type_TypedParamTyp :: Type}
  deriving (Type_TypedParam -> Type_TypedParam -> Bool
(Type_TypedParam -> Type_TypedParam -> Bool)
-> (Type_TypedParam -> Type_TypedParam -> Bool)
-> Eq Type_TypedParam
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_TypedParam -> Type_TypedParam -> Bool
== :: Type_TypedParam -> Type_TypedParam -> Bool
$c/= :: Type_TypedParam -> Type_TypedParam -> Bool
/= :: Type_TypedParam -> Type_TypedParam -> Bool
Eq, Eq Type_TypedParam
Eq Type_TypedParam =>
(Type_TypedParam -> Type_TypedParam -> Ordering)
-> (Type_TypedParam -> Type_TypedParam -> Bool)
-> (Type_TypedParam -> Type_TypedParam -> Bool)
-> (Type_TypedParam -> Type_TypedParam -> Bool)
-> (Type_TypedParam -> Type_TypedParam -> Bool)
-> (Type_TypedParam -> Type_TypedParam -> Type_TypedParam)
-> (Type_TypedParam -> Type_TypedParam -> Type_TypedParam)
-> Ord Type_TypedParam
Type_TypedParam -> Type_TypedParam -> Bool
Type_TypedParam -> Type_TypedParam -> Ordering
Type_TypedParam -> Type_TypedParam -> Type_TypedParam
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_TypedParam -> Type_TypedParam -> Ordering
compare :: Type_TypedParam -> Type_TypedParam -> Ordering
$c< :: Type_TypedParam -> Type_TypedParam -> Bool
< :: Type_TypedParam -> Type_TypedParam -> Bool
$c<= :: Type_TypedParam -> Type_TypedParam -> Bool
<= :: Type_TypedParam -> Type_TypedParam -> Bool
$c> :: Type_TypedParam -> Type_TypedParam -> Bool
> :: Type_TypedParam -> Type_TypedParam -> Bool
$c>= :: Type_TypedParam -> Type_TypedParam -> Bool
>= :: Type_TypedParam -> Type_TypedParam -> Bool
$cmax :: Type_TypedParam -> Type_TypedParam -> Type_TypedParam
max :: Type_TypedParam -> Type_TypedParam -> Type_TypedParam
$cmin :: Type_TypedParam -> Type_TypedParam -> Type_TypedParam
min :: Type_TypedParam -> Type_TypedParam -> Type_TypedParam
Ord, ReadPrec [Type_TypedParam]
ReadPrec Type_TypedParam
Int -> ReadS Type_TypedParam
ReadS [Type_TypedParam]
(Int -> ReadS Type_TypedParam)
-> ReadS [Type_TypedParam]
-> ReadPrec Type_TypedParam
-> ReadPrec [Type_TypedParam]
-> Read Type_TypedParam
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_TypedParam
readsPrec :: Int -> ReadS Type_TypedParam
$creadList :: ReadS [Type_TypedParam]
readList :: ReadS [Type_TypedParam]
$creadPrec :: ReadPrec Type_TypedParam
readPrec :: ReadPrec Type_TypedParam
$creadListPrec :: ReadPrec [Type_TypedParam]
readListPrec :: ReadPrec [Type_TypedParam]
Read, Int -> Type_TypedParam -> String -> String
[Type_TypedParam] -> String -> String
Type_TypedParam -> String
(Int -> Type_TypedParam -> String -> String)
-> (Type_TypedParam -> String)
-> ([Type_TypedParam] -> String -> String)
-> Show Type_TypedParam
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_TypedParam -> String -> String
showsPrec :: Int -> Type_TypedParam -> String -> String
$cshow :: Type_TypedParam -> String
show :: Type_TypedParam -> String
$cshowList :: [Type_TypedParam] -> String -> String
showList :: [Type_TypedParam] -> String -> String
Show)

_Type_TypedParam :: Name
_Type_TypedParam = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.TypedParam")

_Type_TypedParam_name :: Name
_Type_TypedParam_name = (String -> Name
Core.Name String
"name")

_Type_TypedParam_typ :: Name
_Type_TypedParam_typ = (String -> Name
Core.Name String
"typ")

data Type_Param = 
  Type_Param {
    Type_Param -> [Mod]
type_ParamMods :: [Mod],
    Type_Param -> Name
type_ParamName :: Name,
    Type_Param -> [Type_Param]
type_ParamTparams :: [Type_Param],
    Type_Param -> [Type_Bounds]
type_ParamTbounds :: [Type_Bounds],
    Type_Param -> [Type]
type_ParamVbounds :: [Type],
    Type_Param -> [Type]
type_ParamCbounds :: [Type]}
  deriving (Type_Param -> Type_Param -> Bool
(Type_Param -> Type_Param -> Bool)
-> (Type_Param -> Type_Param -> Bool) -> Eq Type_Param
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Param -> Type_Param -> Bool
== :: Type_Param -> Type_Param -> Bool
$c/= :: Type_Param -> Type_Param -> Bool
/= :: Type_Param -> Type_Param -> Bool
Eq, Eq Type_Param
Eq Type_Param =>
(Type_Param -> Type_Param -> Ordering)
-> (Type_Param -> Type_Param -> Bool)
-> (Type_Param -> Type_Param -> Bool)
-> (Type_Param -> Type_Param -> Bool)
-> (Type_Param -> Type_Param -> Bool)
-> (Type_Param -> Type_Param -> Type_Param)
-> (Type_Param -> Type_Param -> Type_Param)
-> Ord Type_Param
Type_Param -> Type_Param -> Bool
Type_Param -> Type_Param -> Ordering
Type_Param -> Type_Param -> Type_Param
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Param -> Type_Param -> Ordering
compare :: Type_Param -> Type_Param -> Ordering
$c< :: Type_Param -> Type_Param -> Bool
< :: Type_Param -> Type_Param -> Bool
$c<= :: Type_Param -> Type_Param -> Bool
<= :: Type_Param -> Type_Param -> Bool
$c> :: Type_Param -> Type_Param -> Bool
> :: Type_Param -> Type_Param -> Bool
$c>= :: Type_Param -> Type_Param -> Bool
>= :: Type_Param -> Type_Param -> Bool
$cmax :: Type_Param -> Type_Param -> Type_Param
max :: Type_Param -> Type_Param -> Type_Param
$cmin :: Type_Param -> Type_Param -> Type_Param
min :: Type_Param -> Type_Param -> Type_Param
Ord, ReadPrec [Type_Param]
ReadPrec Type_Param
Int -> ReadS Type_Param
ReadS [Type_Param]
(Int -> ReadS Type_Param)
-> ReadS [Type_Param]
-> ReadPrec Type_Param
-> ReadPrec [Type_Param]
-> Read Type_Param
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Param
readsPrec :: Int -> ReadS Type_Param
$creadList :: ReadS [Type_Param]
readList :: ReadS [Type_Param]
$creadPrec :: ReadPrec Type_Param
readPrec :: ReadPrec Type_Param
$creadListPrec :: ReadPrec [Type_Param]
readListPrec :: ReadPrec [Type_Param]
Read, Int -> Type_Param -> String -> String
[Type_Param] -> String -> String
Type_Param -> String
(Int -> Type_Param -> String -> String)
-> (Type_Param -> String)
-> ([Type_Param] -> String -> String)
-> Show Type_Param
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Param -> String -> String
showsPrec :: Int -> Type_Param -> String -> String
$cshow :: Type_Param -> String
show :: Type_Param -> String
$cshowList :: [Type_Param] -> String -> String
showList :: [Type_Param] -> String -> String
Show)

_Type_Param :: Name
_Type_Param = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Param")

_Type_Param_mods :: Name
_Type_Param_mods = (String -> Name
Core.Name String
"mods")

_Type_Param_name :: Name
_Type_Param_name = (String -> Name
Core.Name String
"name")

_Type_Param_tparams :: Name
_Type_Param_tparams = (String -> Name
Core.Name String
"tparams")

_Type_Param_tbounds :: Name
_Type_Param_tbounds = (String -> Name
Core.Name String
"tbounds")

_Type_Param_vbounds :: Name
_Type_Param_vbounds = (String -> Name
Core.Name String
"vbounds")

_Type_Param_cbounds :: Name
_Type_Param_cbounds = (String -> Name
Core.Name String
"cbounds")

data Type_Match = 
  Type_Match {
    Type_Match -> Type
type_MatchTpe :: Type,
    Type_Match -> [TypeCase]
type_MatchCases :: [TypeCase]}
  deriving (Type_Match -> Type_Match -> Bool
(Type_Match -> Type_Match -> Bool)
-> (Type_Match -> Type_Match -> Bool) -> Eq Type_Match
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Type_Match -> Type_Match -> Bool
== :: Type_Match -> Type_Match -> Bool
$c/= :: Type_Match -> Type_Match -> Bool
/= :: Type_Match -> Type_Match -> Bool
Eq, Eq Type_Match
Eq Type_Match =>
(Type_Match -> Type_Match -> Ordering)
-> (Type_Match -> Type_Match -> Bool)
-> (Type_Match -> Type_Match -> Bool)
-> (Type_Match -> Type_Match -> Bool)
-> (Type_Match -> Type_Match -> Bool)
-> (Type_Match -> Type_Match -> Type_Match)
-> (Type_Match -> Type_Match -> Type_Match)
-> Ord Type_Match
Type_Match -> Type_Match -> Bool
Type_Match -> Type_Match -> Ordering
Type_Match -> Type_Match -> Type_Match
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Type_Match -> Type_Match -> Ordering
compare :: Type_Match -> Type_Match -> Ordering
$c< :: Type_Match -> Type_Match -> Bool
< :: Type_Match -> Type_Match -> Bool
$c<= :: Type_Match -> Type_Match -> Bool
<= :: Type_Match -> Type_Match -> Bool
$c> :: Type_Match -> Type_Match -> Bool
> :: Type_Match -> Type_Match -> Bool
$c>= :: Type_Match -> Type_Match -> Bool
>= :: Type_Match -> Type_Match -> Bool
$cmax :: Type_Match -> Type_Match -> Type_Match
max :: Type_Match -> Type_Match -> Type_Match
$cmin :: Type_Match -> Type_Match -> Type_Match
min :: Type_Match -> Type_Match -> Type_Match
Ord, ReadPrec [Type_Match]
ReadPrec Type_Match
Int -> ReadS Type_Match
ReadS [Type_Match]
(Int -> ReadS Type_Match)
-> ReadS [Type_Match]
-> ReadPrec Type_Match
-> ReadPrec [Type_Match]
-> Read Type_Match
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Type_Match
readsPrec :: Int -> ReadS Type_Match
$creadList :: ReadS [Type_Match]
readList :: ReadS [Type_Match]
$creadPrec :: ReadPrec Type_Match
readPrec :: ReadPrec Type_Match
$creadListPrec :: ReadPrec [Type_Match]
readListPrec :: ReadPrec [Type_Match]
Read, Int -> Type_Match -> String -> String
[Type_Match] -> String -> String
Type_Match -> String
(Int -> Type_Match -> String -> String)
-> (Type_Match -> String)
-> ([Type_Match] -> String -> String)
-> Show Type_Match
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Type_Match -> String -> String
showsPrec :: Int -> Type_Match -> String -> String
$cshow :: Type_Match -> String
show :: Type_Match -> String
$cshowList :: [Type_Match] -> String -> String
showList :: [Type_Match] -> String -> String
Show)

_Type_Match :: Name
_Type_Match = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Type.Match")

_Type_Match_tpe :: Name
_Type_Match_tpe = (String -> Name
Core.Name String
"tpe")

_Type_Match_cases :: Name
_Type_Match_cases = (String -> Name
Core.Name String
"cases")

data Pat = 
  PatVar Pat_Var |
  PatWildcard  |
  PatSeqWildcard  |
  PatBind Pat_Bind |
  PatAlternative Pat_Alternative |
  PatTuple Pat_Tuple |
  PatRepeated Pat_Repeated |
  PatExtract Pat_Extract |
  PatExtractInfix Pat_ExtractInfix |
  PatInterpolate Pat_Interpolate |
  PatXml Pat_Xml |
  PatTyped Pat_Typed |
  PatMacro Pat_Macro |
  PatGiven Pat_Given
  deriving (Pat -> Pat -> Bool
(Pat -> Pat -> Bool) -> (Pat -> Pat -> Bool) -> Eq Pat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pat -> Pat -> Bool
== :: Pat -> Pat -> Bool
$c/= :: Pat -> Pat -> Bool
/= :: Pat -> Pat -> Bool
Eq, Eq Pat
Eq Pat =>
(Pat -> Pat -> Ordering)
-> (Pat -> Pat -> Bool)
-> (Pat -> Pat -> Bool)
-> (Pat -> Pat -> Bool)
-> (Pat -> Pat -> Bool)
-> (Pat -> Pat -> Pat)
-> (Pat -> Pat -> Pat)
-> Ord Pat
Pat -> Pat -> Bool
Pat -> Pat -> Ordering
Pat -> Pat -> Pat
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Pat -> Pat -> Ordering
compare :: Pat -> Pat -> Ordering
$c< :: Pat -> Pat -> Bool
< :: Pat -> Pat -> Bool
$c<= :: Pat -> Pat -> Bool
<= :: Pat -> Pat -> Bool
$c> :: Pat -> Pat -> Bool
> :: Pat -> Pat -> Bool
$c>= :: Pat -> Pat -> Bool
>= :: Pat -> Pat -> Bool
$cmax :: Pat -> Pat -> Pat
max :: Pat -> Pat -> Pat
$cmin :: Pat -> Pat -> Pat
min :: Pat -> Pat -> Pat
Ord, ReadPrec [Pat]
ReadPrec Pat
Int -> ReadS Pat
ReadS [Pat]
(Int -> ReadS Pat)
-> ReadS [Pat] -> ReadPrec Pat -> ReadPrec [Pat] -> Read Pat
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Pat
readsPrec :: Int -> ReadS Pat
$creadList :: ReadS [Pat]
readList :: ReadS [Pat]
$creadPrec :: ReadPrec Pat
readPrec :: ReadPrec Pat
$creadListPrec :: ReadPrec [Pat]
readListPrec :: ReadPrec [Pat]
Read, Int -> Pat -> String -> String
[Pat] -> String -> String
Pat -> String
(Int -> Pat -> String -> String)
-> (Pat -> String) -> ([Pat] -> String -> String) -> Show Pat
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Pat -> String -> String
showsPrec :: Int -> Pat -> String -> String
$cshow :: Pat -> String
show :: Pat -> String
$cshowList :: [Pat] -> String -> String
showList :: [Pat] -> String -> String
Show)

_Pat :: Name
_Pat = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Pat")

_Pat_var :: Name
_Pat_var = (String -> Name
Core.Name String
"var")

_Pat_wildcard :: Name
_Pat_wildcard = (String -> Name
Core.Name String
"wildcard")

_Pat_seqWildcard :: Name
_Pat_seqWildcard = (String -> Name
Core.Name String
"seqWildcard")

_Pat_bind :: Name
_Pat_bind = (String -> Name
Core.Name String
"bind")

_Pat_alternative :: Name
_Pat_alternative = (String -> Name
Core.Name String
"alternative")

_Pat_tuple :: Name
_Pat_tuple = (String -> Name
Core.Name String
"tuple")

_Pat_repeated :: Name
_Pat_repeated = (String -> Name
Core.Name String
"repeated")

_Pat_extract :: Name
_Pat_extract = (String -> Name
Core.Name String
"extract")

_Pat_extractInfix :: Name
_Pat_extractInfix = (String -> Name
Core.Name String
"extractInfix")

_Pat_interpolate :: Name
_Pat_interpolate = (String -> Name
Core.Name String
"interpolate")

_Pat_xml :: Name
_Pat_xml = (String -> Name
Core.Name String
"xml")

_Pat_typed :: Name
_Pat_typed = (String -> Name
Core.Name String
"typed")

_Pat_macro :: Name
_Pat_macro = (String -> Name
Core.Name String
"macro")

_Pat_given :: Name
_Pat_given = (String -> Name
Core.Name String
"given")

data Pat_Var = 
  Pat_Var {
    Pat_Var -> Data_Name
pat_VarName :: Data_Name}
  deriving (Pat_Var -> Pat_Var -> Bool
(Pat_Var -> Pat_Var -> Bool)
-> (Pat_Var -> Pat_Var -> Bool) -> Eq Pat_Var
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pat_Var -> Pat_Var -> Bool
== :: Pat_Var -> Pat_Var -> Bool
$c/= :: Pat_Var -> Pat_Var -> Bool
/= :: Pat_Var -> Pat_Var -> Bool
Eq, Eq Pat_Var
Eq Pat_Var =>
(Pat_Var -> Pat_Var -> Ordering)
-> (Pat_Var -> Pat_Var -> Bool)
-> (Pat_Var -> Pat_Var -> Bool)
-> (Pat_Var -> Pat_Var -> Bool)
-> (Pat_Var -> Pat_Var -> Bool)
-> (Pat_Var -> Pat_Var -> Pat_Var)
-> (Pat_Var -> Pat_Var -> Pat_Var)
-> Ord Pat_Var
Pat_Var -> Pat_Var -> Bool
Pat_Var -> Pat_Var -> Ordering
Pat_Var -> Pat_Var -> Pat_Var
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Pat_Var -> Pat_Var -> Ordering
compare :: Pat_Var -> Pat_Var -> Ordering
$c< :: Pat_Var -> Pat_Var -> Bool
< :: Pat_Var -> Pat_Var -> Bool
$c<= :: Pat_Var -> Pat_Var -> Bool
<= :: Pat_Var -> Pat_Var -> Bool
$c> :: Pat_Var -> Pat_Var -> Bool
> :: Pat_Var -> Pat_Var -> Bool
$c>= :: Pat_Var -> Pat_Var -> Bool
>= :: Pat_Var -> Pat_Var -> Bool
$cmax :: Pat_Var -> Pat_Var -> Pat_Var
max :: Pat_Var -> Pat_Var -> Pat_Var
$cmin :: Pat_Var -> Pat_Var -> Pat_Var
min :: Pat_Var -> Pat_Var -> Pat_Var
Ord, ReadPrec [Pat_Var]
ReadPrec Pat_Var
Int -> ReadS Pat_Var
ReadS [Pat_Var]
(Int -> ReadS Pat_Var)
-> ReadS [Pat_Var]
-> ReadPrec Pat_Var
-> ReadPrec [Pat_Var]
-> Read Pat_Var
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Pat_Var
readsPrec :: Int -> ReadS Pat_Var
$creadList :: ReadS [Pat_Var]
readList :: ReadS [Pat_Var]
$creadPrec :: ReadPrec Pat_Var
readPrec :: ReadPrec Pat_Var
$creadListPrec :: ReadPrec [Pat_Var]
readListPrec :: ReadPrec [Pat_Var]
Read, Int -> Pat_Var -> String -> String
[Pat_Var] -> String -> String
Pat_Var -> String
(Int -> Pat_Var -> String -> String)
-> (Pat_Var -> String)
-> ([Pat_Var] -> String -> String)
-> Show Pat_Var
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Pat_Var -> String -> String
showsPrec :: Int -> Pat_Var -> String -> String
$cshow :: Pat_Var -> String
show :: Pat_Var -> String
$cshowList :: [Pat_Var] -> String -> String
showList :: [Pat_Var] -> String -> String
Show)

_Pat_Var :: Name
_Pat_Var = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Pat.Var")

_Pat_Var_name :: Name
_Pat_Var_name = (String -> Name
Core.Name String
"name")

data Pat_Bind = 
  Pat_Bind {
    Pat_Bind -> Pat
pat_BindLhs :: Pat,
    Pat_Bind -> Pat
pat_BindRhs :: Pat}
  deriving (Pat_Bind -> Pat_Bind -> Bool
(Pat_Bind -> Pat_Bind -> Bool)
-> (Pat_Bind -> Pat_Bind -> Bool) -> Eq Pat_Bind
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pat_Bind -> Pat_Bind -> Bool
== :: Pat_Bind -> Pat_Bind -> Bool
$c/= :: Pat_Bind -> Pat_Bind -> Bool
/= :: Pat_Bind -> Pat_Bind -> Bool
Eq, Eq Pat_Bind
Eq Pat_Bind =>
(Pat_Bind -> Pat_Bind -> Ordering)
-> (Pat_Bind -> Pat_Bind -> Bool)
-> (Pat_Bind -> Pat_Bind -> Bool)
-> (Pat_Bind -> Pat_Bind -> Bool)
-> (Pat_Bind -> Pat_Bind -> Bool)
-> (Pat_Bind -> Pat_Bind -> Pat_Bind)
-> (Pat_Bind -> Pat_Bind -> Pat_Bind)
-> Ord Pat_Bind
Pat_Bind -> Pat_Bind -> Bool
Pat_Bind -> Pat_Bind -> Ordering
Pat_Bind -> Pat_Bind -> Pat_Bind
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Pat_Bind -> Pat_Bind -> Ordering
compare :: Pat_Bind -> Pat_Bind -> Ordering
$c< :: Pat_Bind -> Pat_Bind -> Bool
< :: Pat_Bind -> Pat_Bind -> Bool
$c<= :: Pat_Bind -> Pat_Bind -> Bool
<= :: Pat_Bind -> Pat_Bind -> Bool
$c> :: Pat_Bind -> Pat_Bind -> Bool
> :: Pat_Bind -> Pat_Bind -> Bool
$c>= :: Pat_Bind -> Pat_Bind -> Bool
>= :: Pat_Bind -> Pat_Bind -> Bool
$cmax :: Pat_Bind -> Pat_Bind -> Pat_Bind
max :: Pat_Bind -> Pat_Bind -> Pat_Bind
$cmin :: Pat_Bind -> Pat_Bind -> Pat_Bind
min :: Pat_Bind -> Pat_Bind -> Pat_Bind
Ord, ReadPrec [Pat_Bind]
ReadPrec Pat_Bind
Int -> ReadS Pat_Bind
ReadS [Pat_Bind]
(Int -> ReadS Pat_Bind)
-> ReadS [Pat_Bind]
-> ReadPrec Pat_Bind
-> ReadPrec [Pat_Bind]
-> Read Pat_Bind
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Pat_Bind
readsPrec :: Int -> ReadS Pat_Bind
$creadList :: ReadS [Pat_Bind]
readList :: ReadS [Pat_Bind]
$creadPrec :: ReadPrec Pat_Bind
readPrec :: ReadPrec Pat_Bind
$creadListPrec :: ReadPrec [Pat_Bind]
readListPrec :: ReadPrec [Pat_Bind]
Read, Int -> Pat_Bind -> String -> String
[Pat_Bind] -> String -> String
Pat_Bind -> String
(Int -> Pat_Bind -> String -> String)
-> (Pat_Bind -> String)
-> ([Pat_Bind] -> String -> String)
-> Show Pat_Bind
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Pat_Bind -> String -> String
showsPrec :: Int -> Pat_Bind -> String -> String
$cshow :: Pat_Bind -> String
show :: Pat_Bind -> String
$cshowList :: [Pat_Bind] -> String -> String
showList :: [Pat_Bind] -> String -> String
Show)

_Pat_Bind :: Name
_Pat_Bind = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Pat.Bind")

_Pat_Bind_lhs :: Name
_Pat_Bind_lhs = (String -> Name
Core.Name String
"lhs")

_Pat_Bind_rhs :: Name
_Pat_Bind_rhs = (String -> Name
Core.Name String
"rhs")

data Pat_Alternative = 
  Pat_Alternative {
    Pat_Alternative -> Pat
pat_AlternativeLhs :: Pat,
    Pat_Alternative -> Pat
pat_AlternativeRhs :: Pat}
  deriving (Pat_Alternative -> Pat_Alternative -> Bool
(Pat_Alternative -> Pat_Alternative -> Bool)
-> (Pat_Alternative -> Pat_Alternative -> Bool)
-> Eq Pat_Alternative
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pat_Alternative -> Pat_Alternative -> Bool
== :: Pat_Alternative -> Pat_Alternative -> Bool
$c/= :: Pat_Alternative -> Pat_Alternative -> Bool
/= :: Pat_Alternative -> Pat_Alternative -> Bool
Eq, Eq Pat_Alternative
Eq Pat_Alternative =>
(Pat_Alternative -> Pat_Alternative -> Ordering)
-> (Pat_Alternative -> Pat_Alternative -> Bool)
-> (Pat_Alternative -> Pat_Alternative -> Bool)
-> (Pat_Alternative -> Pat_Alternative -> Bool)
-> (Pat_Alternative -> Pat_Alternative -> Bool)
-> (Pat_Alternative -> Pat_Alternative -> Pat_Alternative)
-> (Pat_Alternative -> Pat_Alternative -> Pat_Alternative)
-> Ord Pat_Alternative
Pat_Alternative -> Pat_Alternative -> Bool
Pat_Alternative -> Pat_Alternative -> Ordering
Pat_Alternative -> Pat_Alternative -> Pat_Alternative
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Pat_Alternative -> Pat_Alternative -> Ordering
compare :: Pat_Alternative -> Pat_Alternative -> Ordering
$c< :: Pat_Alternative -> Pat_Alternative -> Bool
< :: Pat_Alternative -> Pat_Alternative -> Bool
$c<= :: Pat_Alternative -> Pat_Alternative -> Bool
<= :: Pat_Alternative -> Pat_Alternative -> Bool
$c> :: Pat_Alternative -> Pat_Alternative -> Bool
> :: Pat_Alternative -> Pat_Alternative -> Bool
$c>= :: Pat_Alternative -> Pat_Alternative -> Bool
>= :: Pat_Alternative -> Pat_Alternative -> Bool
$cmax :: Pat_Alternative -> Pat_Alternative -> Pat_Alternative
max :: Pat_Alternative -> Pat_Alternative -> Pat_Alternative
$cmin :: Pat_Alternative -> Pat_Alternative -> Pat_Alternative
min :: Pat_Alternative -> Pat_Alternative -> Pat_Alternative
Ord, ReadPrec [Pat_Alternative]
ReadPrec Pat_Alternative
Int -> ReadS Pat_Alternative
ReadS [Pat_Alternative]
(Int -> ReadS Pat_Alternative)
-> ReadS [Pat_Alternative]
-> ReadPrec Pat_Alternative
-> ReadPrec [Pat_Alternative]
-> Read Pat_Alternative
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Pat_Alternative
readsPrec :: Int -> ReadS Pat_Alternative
$creadList :: ReadS [Pat_Alternative]
readList :: ReadS [Pat_Alternative]
$creadPrec :: ReadPrec Pat_Alternative
readPrec :: ReadPrec Pat_Alternative
$creadListPrec :: ReadPrec [Pat_Alternative]
readListPrec :: ReadPrec [Pat_Alternative]
Read, Int -> Pat_Alternative -> String -> String
[Pat_Alternative] -> String -> String
Pat_Alternative -> String
(Int -> Pat_Alternative -> String -> String)
-> (Pat_Alternative -> String)
-> ([Pat_Alternative] -> String -> String)
-> Show Pat_Alternative
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Pat_Alternative -> String -> String
showsPrec :: Int -> Pat_Alternative -> String -> String
$cshow :: Pat_Alternative -> String
show :: Pat_Alternative -> String
$cshowList :: [Pat_Alternative] -> String -> String
showList :: [Pat_Alternative] -> String -> String
Show)

_Pat_Alternative :: Name
_Pat_Alternative = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Pat.Alternative")

_Pat_Alternative_lhs :: Name
_Pat_Alternative_lhs = (String -> Name
Core.Name String
"lhs")

_Pat_Alternative_rhs :: Name
_Pat_Alternative_rhs = (String -> Name
Core.Name String
"rhs")

data Pat_Tuple = 
  Pat_Tuple {
    Pat_Tuple -> [Pat]
pat_TupleArgs :: [Pat]}
  deriving (Pat_Tuple -> Pat_Tuple -> Bool
(Pat_Tuple -> Pat_Tuple -> Bool)
-> (Pat_Tuple -> Pat_Tuple -> Bool) -> Eq Pat_Tuple
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pat_Tuple -> Pat_Tuple -> Bool
== :: Pat_Tuple -> Pat_Tuple -> Bool
$c/= :: Pat_Tuple -> Pat_Tuple -> Bool
/= :: Pat_Tuple -> Pat_Tuple -> Bool
Eq, Eq Pat_Tuple
Eq Pat_Tuple =>
(Pat_Tuple -> Pat_Tuple -> Ordering)
-> (Pat_Tuple -> Pat_Tuple -> Bool)
-> (Pat_Tuple -> Pat_Tuple -> Bool)
-> (Pat_Tuple -> Pat_Tuple -> Bool)
-> (Pat_Tuple -> Pat_Tuple -> Bool)
-> (Pat_Tuple -> Pat_Tuple -> Pat_Tuple)
-> (Pat_Tuple -> Pat_Tuple -> Pat_Tuple)
-> Ord Pat_Tuple
Pat_Tuple -> Pat_Tuple -> Bool
Pat_Tuple -> Pat_Tuple -> Ordering
Pat_Tuple -> Pat_Tuple -> Pat_Tuple
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Pat_Tuple -> Pat_Tuple -> Ordering
compare :: Pat_Tuple -> Pat_Tuple -> Ordering
$c< :: Pat_Tuple -> Pat_Tuple -> Bool
< :: Pat_Tuple -> Pat_Tuple -> Bool
$c<= :: Pat_Tuple -> Pat_Tuple -> Bool
<= :: Pat_Tuple -> Pat_Tuple -> Bool
$c> :: Pat_Tuple -> Pat_Tuple -> Bool
> :: Pat_Tuple -> Pat_Tuple -> Bool
$c>= :: Pat_Tuple -> Pat_Tuple -> Bool
>= :: Pat_Tuple -> Pat_Tuple -> Bool
$cmax :: Pat_Tuple -> Pat_Tuple -> Pat_Tuple
max :: Pat_Tuple -> Pat_Tuple -> Pat_Tuple
$cmin :: Pat_Tuple -> Pat_Tuple -> Pat_Tuple
min :: Pat_Tuple -> Pat_Tuple -> Pat_Tuple
Ord, ReadPrec [Pat_Tuple]
ReadPrec Pat_Tuple
Int -> ReadS Pat_Tuple
ReadS [Pat_Tuple]
(Int -> ReadS Pat_Tuple)
-> ReadS [Pat_Tuple]
-> ReadPrec Pat_Tuple
-> ReadPrec [Pat_Tuple]
-> Read Pat_Tuple
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Pat_Tuple
readsPrec :: Int -> ReadS Pat_Tuple
$creadList :: ReadS [Pat_Tuple]
readList :: ReadS [Pat_Tuple]
$creadPrec :: ReadPrec Pat_Tuple
readPrec :: ReadPrec Pat_Tuple
$creadListPrec :: ReadPrec [Pat_Tuple]
readListPrec :: ReadPrec [Pat_Tuple]
Read, Int -> Pat_Tuple -> String -> String
[Pat_Tuple] -> String -> String
Pat_Tuple -> String
(Int -> Pat_Tuple -> String -> String)
-> (Pat_Tuple -> String)
-> ([Pat_Tuple] -> String -> String)
-> Show Pat_Tuple
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Pat_Tuple -> String -> String
showsPrec :: Int -> Pat_Tuple -> String -> String
$cshow :: Pat_Tuple -> String
show :: Pat_Tuple -> String
$cshowList :: [Pat_Tuple] -> String -> String
showList :: [Pat_Tuple] -> String -> String
Show)

_Pat_Tuple :: Name
_Pat_Tuple = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Pat.Tuple")

_Pat_Tuple_args :: Name
_Pat_Tuple_args = (String -> Name
Core.Name String
"args")

data Pat_Repeated = 
  Pat_Repeated {
    Pat_Repeated -> Data_Name
pat_RepeatedName :: Data_Name}
  deriving (Pat_Repeated -> Pat_Repeated -> Bool
(Pat_Repeated -> Pat_Repeated -> Bool)
-> (Pat_Repeated -> Pat_Repeated -> Bool) -> Eq Pat_Repeated
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pat_Repeated -> Pat_Repeated -> Bool
== :: Pat_Repeated -> Pat_Repeated -> Bool
$c/= :: Pat_Repeated -> Pat_Repeated -> Bool
/= :: Pat_Repeated -> Pat_Repeated -> Bool
Eq, Eq Pat_Repeated
Eq Pat_Repeated =>
(Pat_Repeated -> Pat_Repeated -> Ordering)
-> (Pat_Repeated -> Pat_Repeated -> Bool)
-> (Pat_Repeated -> Pat_Repeated -> Bool)
-> (Pat_Repeated -> Pat_Repeated -> Bool)
-> (Pat_Repeated -> Pat_Repeated -> Bool)
-> (Pat_Repeated -> Pat_Repeated -> Pat_Repeated)
-> (Pat_Repeated -> Pat_Repeated -> Pat_Repeated)
-> Ord Pat_Repeated
Pat_Repeated -> Pat_Repeated -> Bool
Pat_Repeated -> Pat_Repeated -> Ordering
Pat_Repeated -> Pat_Repeated -> Pat_Repeated
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Pat_Repeated -> Pat_Repeated -> Ordering
compare :: Pat_Repeated -> Pat_Repeated -> Ordering
$c< :: Pat_Repeated -> Pat_Repeated -> Bool
< :: Pat_Repeated -> Pat_Repeated -> Bool
$c<= :: Pat_Repeated -> Pat_Repeated -> Bool
<= :: Pat_Repeated -> Pat_Repeated -> Bool
$c> :: Pat_Repeated -> Pat_Repeated -> Bool
> :: Pat_Repeated -> Pat_Repeated -> Bool
$c>= :: Pat_Repeated -> Pat_Repeated -> Bool
>= :: Pat_Repeated -> Pat_Repeated -> Bool
$cmax :: Pat_Repeated -> Pat_Repeated -> Pat_Repeated
max :: Pat_Repeated -> Pat_Repeated -> Pat_Repeated
$cmin :: Pat_Repeated -> Pat_Repeated -> Pat_Repeated
min :: Pat_Repeated -> Pat_Repeated -> Pat_Repeated
Ord, ReadPrec [Pat_Repeated]
ReadPrec Pat_Repeated
Int -> ReadS Pat_Repeated
ReadS [Pat_Repeated]
(Int -> ReadS Pat_Repeated)
-> ReadS [Pat_Repeated]
-> ReadPrec Pat_Repeated
-> ReadPrec [Pat_Repeated]
-> Read Pat_Repeated
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Pat_Repeated
readsPrec :: Int -> ReadS Pat_Repeated
$creadList :: ReadS [Pat_Repeated]
readList :: ReadS [Pat_Repeated]
$creadPrec :: ReadPrec Pat_Repeated
readPrec :: ReadPrec Pat_Repeated
$creadListPrec :: ReadPrec [Pat_Repeated]
readListPrec :: ReadPrec [Pat_Repeated]
Read, Int -> Pat_Repeated -> String -> String
[Pat_Repeated] -> String -> String
Pat_Repeated -> String
(Int -> Pat_Repeated -> String -> String)
-> (Pat_Repeated -> String)
-> ([Pat_Repeated] -> String -> String)
-> Show Pat_Repeated
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Pat_Repeated -> String -> String
showsPrec :: Int -> Pat_Repeated -> String -> String
$cshow :: Pat_Repeated -> String
show :: Pat_Repeated -> String
$cshowList :: [Pat_Repeated] -> String -> String
showList :: [Pat_Repeated] -> String -> String
Show)

_Pat_Repeated :: Name
_Pat_Repeated = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Pat.Repeated")

_Pat_Repeated_name :: Name
_Pat_Repeated_name = (String -> Name
Core.Name String
"name")

data Pat_Extract = 
  Pat_Extract {
    Pat_Extract -> Data
pat_ExtractFun :: Data,
    Pat_Extract -> [Pat]
pat_ExtractArgs :: [Pat]}
  deriving (Pat_Extract -> Pat_Extract -> Bool
(Pat_Extract -> Pat_Extract -> Bool)
-> (Pat_Extract -> Pat_Extract -> Bool) -> Eq Pat_Extract
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pat_Extract -> Pat_Extract -> Bool
== :: Pat_Extract -> Pat_Extract -> Bool
$c/= :: Pat_Extract -> Pat_Extract -> Bool
/= :: Pat_Extract -> Pat_Extract -> Bool
Eq, Eq Pat_Extract
Eq Pat_Extract =>
(Pat_Extract -> Pat_Extract -> Ordering)
-> (Pat_Extract -> Pat_Extract -> Bool)
-> (Pat_Extract -> Pat_Extract -> Bool)
-> (Pat_Extract -> Pat_Extract -> Bool)
-> (Pat_Extract -> Pat_Extract -> Bool)
-> (Pat_Extract -> Pat_Extract -> Pat_Extract)
-> (Pat_Extract -> Pat_Extract -> Pat_Extract)
-> Ord Pat_Extract
Pat_Extract -> Pat_Extract -> Bool
Pat_Extract -> Pat_Extract -> Ordering
Pat_Extract -> Pat_Extract -> Pat_Extract
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Pat_Extract -> Pat_Extract -> Ordering
compare :: Pat_Extract -> Pat_Extract -> Ordering
$c< :: Pat_Extract -> Pat_Extract -> Bool
< :: Pat_Extract -> Pat_Extract -> Bool
$c<= :: Pat_Extract -> Pat_Extract -> Bool
<= :: Pat_Extract -> Pat_Extract -> Bool
$c> :: Pat_Extract -> Pat_Extract -> Bool
> :: Pat_Extract -> Pat_Extract -> Bool
$c>= :: Pat_Extract -> Pat_Extract -> Bool
>= :: Pat_Extract -> Pat_Extract -> Bool
$cmax :: Pat_Extract -> Pat_Extract -> Pat_Extract
max :: Pat_Extract -> Pat_Extract -> Pat_Extract
$cmin :: Pat_Extract -> Pat_Extract -> Pat_Extract
min :: Pat_Extract -> Pat_Extract -> Pat_Extract
Ord, ReadPrec [Pat_Extract]
ReadPrec Pat_Extract
Int -> ReadS Pat_Extract
ReadS [Pat_Extract]
(Int -> ReadS Pat_Extract)
-> ReadS [Pat_Extract]
-> ReadPrec Pat_Extract
-> ReadPrec [Pat_Extract]
-> Read Pat_Extract
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Pat_Extract
readsPrec :: Int -> ReadS Pat_Extract
$creadList :: ReadS [Pat_Extract]
readList :: ReadS [Pat_Extract]
$creadPrec :: ReadPrec Pat_Extract
readPrec :: ReadPrec Pat_Extract
$creadListPrec :: ReadPrec [Pat_Extract]
readListPrec :: ReadPrec [Pat_Extract]
Read, Int -> Pat_Extract -> String -> String
[Pat_Extract] -> String -> String
Pat_Extract -> String
(Int -> Pat_Extract -> String -> String)
-> (Pat_Extract -> String)
-> ([Pat_Extract] -> String -> String)
-> Show Pat_Extract
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Pat_Extract -> String -> String
showsPrec :: Int -> Pat_Extract -> String -> String
$cshow :: Pat_Extract -> String
show :: Pat_Extract -> String
$cshowList :: [Pat_Extract] -> String -> String
showList :: [Pat_Extract] -> String -> String
Show)

_Pat_Extract :: Name
_Pat_Extract = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Pat.Extract")

_Pat_Extract_fun :: Name
_Pat_Extract_fun = (String -> Name
Core.Name String
"fun")

_Pat_Extract_args :: Name
_Pat_Extract_args = (String -> Name
Core.Name String
"args")

data Pat_ExtractInfix = 
  Pat_ExtractInfix {
    Pat_ExtractInfix -> Pat
pat_ExtractInfixLhs :: Pat,
    Pat_ExtractInfix -> Data_Name
pat_ExtractInfixOp :: Data_Name,
    Pat_ExtractInfix -> [Pat]
pat_ExtractInfixRhs :: [Pat]}
  deriving (Pat_ExtractInfix -> Pat_ExtractInfix -> Bool
(Pat_ExtractInfix -> Pat_ExtractInfix -> Bool)
-> (Pat_ExtractInfix -> Pat_ExtractInfix -> Bool)
-> Eq Pat_ExtractInfix
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pat_ExtractInfix -> Pat_ExtractInfix -> Bool
== :: Pat_ExtractInfix -> Pat_ExtractInfix -> Bool
$c/= :: Pat_ExtractInfix -> Pat_ExtractInfix -> Bool
/= :: Pat_ExtractInfix -> Pat_ExtractInfix -> Bool
Eq, Eq Pat_ExtractInfix
Eq Pat_ExtractInfix =>
(Pat_ExtractInfix -> Pat_ExtractInfix -> Ordering)
-> (Pat_ExtractInfix -> Pat_ExtractInfix -> Bool)
-> (Pat_ExtractInfix -> Pat_ExtractInfix -> Bool)
-> (Pat_ExtractInfix -> Pat_ExtractInfix -> Bool)
-> (Pat_ExtractInfix -> Pat_ExtractInfix -> Bool)
-> (Pat_ExtractInfix -> Pat_ExtractInfix -> Pat_ExtractInfix)
-> (Pat_ExtractInfix -> Pat_ExtractInfix -> Pat_ExtractInfix)
-> Ord Pat_ExtractInfix
Pat_ExtractInfix -> Pat_ExtractInfix -> Bool
Pat_ExtractInfix -> Pat_ExtractInfix -> Ordering
Pat_ExtractInfix -> Pat_ExtractInfix -> Pat_ExtractInfix
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Pat_ExtractInfix -> Pat_ExtractInfix -> Ordering
compare :: Pat_ExtractInfix -> Pat_ExtractInfix -> Ordering
$c< :: Pat_ExtractInfix -> Pat_ExtractInfix -> Bool
< :: Pat_ExtractInfix -> Pat_ExtractInfix -> Bool
$c<= :: Pat_ExtractInfix -> Pat_ExtractInfix -> Bool
<= :: Pat_ExtractInfix -> Pat_ExtractInfix -> Bool
$c> :: Pat_ExtractInfix -> Pat_ExtractInfix -> Bool
> :: Pat_ExtractInfix -> Pat_ExtractInfix -> Bool
$c>= :: Pat_ExtractInfix -> Pat_ExtractInfix -> Bool
>= :: Pat_ExtractInfix -> Pat_ExtractInfix -> Bool
$cmax :: Pat_ExtractInfix -> Pat_ExtractInfix -> Pat_ExtractInfix
max :: Pat_ExtractInfix -> Pat_ExtractInfix -> Pat_ExtractInfix
$cmin :: Pat_ExtractInfix -> Pat_ExtractInfix -> Pat_ExtractInfix
min :: Pat_ExtractInfix -> Pat_ExtractInfix -> Pat_ExtractInfix
Ord, ReadPrec [Pat_ExtractInfix]
ReadPrec Pat_ExtractInfix
Int -> ReadS Pat_ExtractInfix
ReadS [Pat_ExtractInfix]
(Int -> ReadS Pat_ExtractInfix)
-> ReadS [Pat_ExtractInfix]
-> ReadPrec Pat_ExtractInfix
-> ReadPrec [Pat_ExtractInfix]
-> Read Pat_ExtractInfix
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Pat_ExtractInfix
readsPrec :: Int -> ReadS Pat_ExtractInfix
$creadList :: ReadS [Pat_ExtractInfix]
readList :: ReadS [Pat_ExtractInfix]
$creadPrec :: ReadPrec Pat_ExtractInfix
readPrec :: ReadPrec Pat_ExtractInfix
$creadListPrec :: ReadPrec [Pat_ExtractInfix]
readListPrec :: ReadPrec [Pat_ExtractInfix]
Read, Int -> Pat_ExtractInfix -> String -> String
[Pat_ExtractInfix] -> String -> String
Pat_ExtractInfix -> String
(Int -> Pat_ExtractInfix -> String -> String)
-> (Pat_ExtractInfix -> String)
-> ([Pat_ExtractInfix] -> String -> String)
-> Show Pat_ExtractInfix
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Pat_ExtractInfix -> String -> String
showsPrec :: Int -> Pat_ExtractInfix -> String -> String
$cshow :: Pat_ExtractInfix -> String
show :: Pat_ExtractInfix -> String
$cshowList :: [Pat_ExtractInfix] -> String -> String
showList :: [Pat_ExtractInfix] -> String -> String
Show)

_Pat_ExtractInfix :: Name
_Pat_ExtractInfix = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Pat.ExtractInfix")

_Pat_ExtractInfix_lhs :: Name
_Pat_ExtractInfix_lhs = (String -> Name
Core.Name String
"lhs")

_Pat_ExtractInfix_op :: Name
_Pat_ExtractInfix_op = (String -> Name
Core.Name String
"op")

_Pat_ExtractInfix_rhs :: Name
_Pat_ExtractInfix_rhs = (String -> Name
Core.Name String
"rhs")

data Pat_Interpolate = 
  Pat_Interpolate {
    Pat_Interpolate -> Data_Name
pat_InterpolatePrefix :: Data_Name,
    Pat_Interpolate -> [Lit]
pat_InterpolateParts :: [Lit]}
  deriving (Pat_Interpolate -> Pat_Interpolate -> Bool
(Pat_Interpolate -> Pat_Interpolate -> Bool)
-> (Pat_Interpolate -> Pat_Interpolate -> Bool)
-> Eq Pat_Interpolate
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pat_Interpolate -> Pat_Interpolate -> Bool
== :: Pat_Interpolate -> Pat_Interpolate -> Bool
$c/= :: Pat_Interpolate -> Pat_Interpolate -> Bool
/= :: Pat_Interpolate -> Pat_Interpolate -> Bool
Eq, Eq Pat_Interpolate
Eq Pat_Interpolate =>
(Pat_Interpolate -> Pat_Interpolate -> Ordering)
-> (Pat_Interpolate -> Pat_Interpolate -> Bool)
-> (Pat_Interpolate -> Pat_Interpolate -> Bool)
-> (Pat_Interpolate -> Pat_Interpolate -> Bool)
-> (Pat_Interpolate -> Pat_Interpolate -> Bool)
-> (Pat_Interpolate -> Pat_Interpolate -> Pat_Interpolate)
-> (Pat_Interpolate -> Pat_Interpolate -> Pat_Interpolate)
-> Ord Pat_Interpolate
Pat_Interpolate -> Pat_Interpolate -> Bool
Pat_Interpolate -> Pat_Interpolate -> Ordering
Pat_Interpolate -> Pat_Interpolate -> Pat_Interpolate
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Pat_Interpolate -> Pat_Interpolate -> Ordering
compare :: Pat_Interpolate -> Pat_Interpolate -> Ordering
$c< :: Pat_Interpolate -> Pat_Interpolate -> Bool
< :: Pat_Interpolate -> Pat_Interpolate -> Bool
$c<= :: Pat_Interpolate -> Pat_Interpolate -> Bool
<= :: Pat_Interpolate -> Pat_Interpolate -> Bool
$c> :: Pat_Interpolate -> Pat_Interpolate -> Bool
> :: Pat_Interpolate -> Pat_Interpolate -> Bool
$c>= :: Pat_Interpolate -> Pat_Interpolate -> Bool
>= :: Pat_Interpolate -> Pat_Interpolate -> Bool
$cmax :: Pat_Interpolate -> Pat_Interpolate -> Pat_Interpolate
max :: Pat_Interpolate -> Pat_Interpolate -> Pat_Interpolate
$cmin :: Pat_Interpolate -> Pat_Interpolate -> Pat_Interpolate
min :: Pat_Interpolate -> Pat_Interpolate -> Pat_Interpolate
Ord, ReadPrec [Pat_Interpolate]
ReadPrec Pat_Interpolate
Int -> ReadS Pat_Interpolate
ReadS [Pat_Interpolate]
(Int -> ReadS Pat_Interpolate)
-> ReadS [Pat_Interpolate]
-> ReadPrec Pat_Interpolate
-> ReadPrec [Pat_Interpolate]
-> Read Pat_Interpolate
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Pat_Interpolate
readsPrec :: Int -> ReadS Pat_Interpolate
$creadList :: ReadS [Pat_Interpolate]
readList :: ReadS [Pat_Interpolate]
$creadPrec :: ReadPrec Pat_Interpolate
readPrec :: ReadPrec Pat_Interpolate
$creadListPrec :: ReadPrec [Pat_Interpolate]
readListPrec :: ReadPrec [Pat_Interpolate]
Read, Int -> Pat_Interpolate -> String -> String
[Pat_Interpolate] -> String -> String
Pat_Interpolate -> String
(Int -> Pat_Interpolate -> String -> String)
-> (Pat_Interpolate -> String)
-> ([Pat_Interpolate] -> String -> String)
-> Show Pat_Interpolate
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Pat_Interpolate -> String -> String
showsPrec :: Int -> Pat_Interpolate -> String -> String
$cshow :: Pat_Interpolate -> String
show :: Pat_Interpolate -> String
$cshowList :: [Pat_Interpolate] -> String -> String
showList :: [Pat_Interpolate] -> String -> String
Show)

_Pat_Interpolate :: Name
_Pat_Interpolate = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Pat.Interpolate")

_Pat_Interpolate_prefix :: Name
_Pat_Interpolate_prefix = (String -> Name
Core.Name String
"prefix")

_Pat_Interpolate_parts :: Name
_Pat_Interpolate_parts = (String -> Name
Core.Name String
"parts")

data Pat_Xml = 
  Pat_Xml {
    Pat_Xml -> [Lit]
pat_XmlParts :: [Lit],
    Pat_Xml -> [Pat]
pat_XmlArgs :: [Pat]}
  deriving (Pat_Xml -> Pat_Xml -> Bool
(Pat_Xml -> Pat_Xml -> Bool)
-> (Pat_Xml -> Pat_Xml -> Bool) -> Eq Pat_Xml
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pat_Xml -> Pat_Xml -> Bool
== :: Pat_Xml -> Pat_Xml -> Bool
$c/= :: Pat_Xml -> Pat_Xml -> Bool
/= :: Pat_Xml -> Pat_Xml -> Bool
Eq, Eq Pat_Xml
Eq Pat_Xml =>
(Pat_Xml -> Pat_Xml -> Ordering)
-> (Pat_Xml -> Pat_Xml -> Bool)
-> (Pat_Xml -> Pat_Xml -> Bool)
-> (Pat_Xml -> Pat_Xml -> Bool)
-> (Pat_Xml -> Pat_Xml -> Bool)
-> (Pat_Xml -> Pat_Xml -> Pat_Xml)
-> (Pat_Xml -> Pat_Xml -> Pat_Xml)
-> Ord Pat_Xml
Pat_Xml -> Pat_Xml -> Bool
Pat_Xml -> Pat_Xml -> Ordering
Pat_Xml -> Pat_Xml -> Pat_Xml
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Pat_Xml -> Pat_Xml -> Ordering
compare :: Pat_Xml -> Pat_Xml -> Ordering
$c< :: Pat_Xml -> Pat_Xml -> Bool
< :: Pat_Xml -> Pat_Xml -> Bool
$c<= :: Pat_Xml -> Pat_Xml -> Bool
<= :: Pat_Xml -> Pat_Xml -> Bool
$c> :: Pat_Xml -> Pat_Xml -> Bool
> :: Pat_Xml -> Pat_Xml -> Bool
$c>= :: Pat_Xml -> Pat_Xml -> Bool
>= :: Pat_Xml -> Pat_Xml -> Bool
$cmax :: Pat_Xml -> Pat_Xml -> Pat_Xml
max :: Pat_Xml -> Pat_Xml -> Pat_Xml
$cmin :: Pat_Xml -> Pat_Xml -> Pat_Xml
min :: Pat_Xml -> Pat_Xml -> Pat_Xml
Ord, ReadPrec [Pat_Xml]
ReadPrec Pat_Xml
Int -> ReadS Pat_Xml
ReadS [Pat_Xml]
(Int -> ReadS Pat_Xml)
-> ReadS [Pat_Xml]
-> ReadPrec Pat_Xml
-> ReadPrec [Pat_Xml]
-> Read Pat_Xml
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Pat_Xml
readsPrec :: Int -> ReadS Pat_Xml
$creadList :: ReadS [Pat_Xml]
readList :: ReadS [Pat_Xml]
$creadPrec :: ReadPrec Pat_Xml
readPrec :: ReadPrec Pat_Xml
$creadListPrec :: ReadPrec [Pat_Xml]
readListPrec :: ReadPrec [Pat_Xml]
Read, Int -> Pat_Xml -> String -> String
[Pat_Xml] -> String -> String
Pat_Xml -> String
(Int -> Pat_Xml -> String -> String)
-> (Pat_Xml -> String)
-> ([Pat_Xml] -> String -> String)
-> Show Pat_Xml
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Pat_Xml -> String -> String
showsPrec :: Int -> Pat_Xml -> String -> String
$cshow :: Pat_Xml -> String
show :: Pat_Xml -> String
$cshowList :: [Pat_Xml] -> String -> String
showList :: [Pat_Xml] -> String -> String
Show)

_Pat_Xml :: Name
_Pat_Xml = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Pat.Xml")

_Pat_Xml_parts :: Name
_Pat_Xml_parts = (String -> Name
Core.Name String
"parts")

_Pat_Xml_args :: Name
_Pat_Xml_args = (String -> Name
Core.Name String
"args")

data Pat_Typed = 
  Pat_Typed {
    Pat_Typed -> Pat
pat_TypedLhs :: Pat,
    Pat_Typed -> Type
pat_TypedRhs :: Type}
  deriving (Pat_Typed -> Pat_Typed -> Bool
(Pat_Typed -> Pat_Typed -> Bool)
-> (Pat_Typed -> Pat_Typed -> Bool) -> Eq Pat_Typed
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pat_Typed -> Pat_Typed -> Bool
== :: Pat_Typed -> Pat_Typed -> Bool
$c/= :: Pat_Typed -> Pat_Typed -> Bool
/= :: Pat_Typed -> Pat_Typed -> Bool
Eq, Eq Pat_Typed
Eq Pat_Typed =>
(Pat_Typed -> Pat_Typed -> Ordering)
-> (Pat_Typed -> Pat_Typed -> Bool)
-> (Pat_Typed -> Pat_Typed -> Bool)
-> (Pat_Typed -> Pat_Typed -> Bool)
-> (Pat_Typed -> Pat_Typed -> Bool)
-> (Pat_Typed -> Pat_Typed -> Pat_Typed)
-> (Pat_Typed -> Pat_Typed -> Pat_Typed)
-> Ord Pat_Typed
Pat_Typed -> Pat_Typed -> Bool
Pat_Typed -> Pat_Typed -> Ordering
Pat_Typed -> Pat_Typed -> Pat_Typed
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Pat_Typed -> Pat_Typed -> Ordering
compare :: Pat_Typed -> Pat_Typed -> Ordering
$c< :: Pat_Typed -> Pat_Typed -> Bool
< :: Pat_Typed -> Pat_Typed -> Bool
$c<= :: Pat_Typed -> Pat_Typed -> Bool
<= :: Pat_Typed -> Pat_Typed -> Bool
$c> :: Pat_Typed -> Pat_Typed -> Bool
> :: Pat_Typed -> Pat_Typed -> Bool
$c>= :: Pat_Typed -> Pat_Typed -> Bool
>= :: Pat_Typed -> Pat_Typed -> Bool
$cmax :: Pat_Typed -> Pat_Typed -> Pat_Typed
max :: Pat_Typed -> Pat_Typed -> Pat_Typed
$cmin :: Pat_Typed -> Pat_Typed -> Pat_Typed
min :: Pat_Typed -> Pat_Typed -> Pat_Typed
Ord, ReadPrec [Pat_Typed]
ReadPrec Pat_Typed
Int -> ReadS Pat_Typed
ReadS [Pat_Typed]
(Int -> ReadS Pat_Typed)
-> ReadS [Pat_Typed]
-> ReadPrec Pat_Typed
-> ReadPrec [Pat_Typed]
-> Read Pat_Typed
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Pat_Typed
readsPrec :: Int -> ReadS Pat_Typed
$creadList :: ReadS [Pat_Typed]
readList :: ReadS [Pat_Typed]
$creadPrec :: ReadPrec Pat_Typed
readPrec :: ReadPrec Pat_Typed
$creadListPrec :: ReadPrec [Pat_Typed]
readListPrec :: ReadPrec [Pat_Typed]
Read, Int -> Pat_Typed -> String -> String
[Pat_Typed] -> String -> String
Pat_Typed -> String
(Int -> Pat_Typed -> String -> String)
-> (Pat_Typed -> String)
-> ([Pat_Typed] -> String -> String)
-> Show Pat_Typed
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Pat_Typed -> String -> String
showsPrec :: Int -> Pat_Typed -> String -> String
$cshow :: Pat_Typed -> String
show :: Pat_Typed -> String
$cshowList :: [Pat_Typed] -> String -> String
showList :: [Pat_Typed] -> String -> String
Show)

_Pat_Typed :: Name
_Pat_Typed = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Pat.Typed")

_Pat_Typed_lhs :: Name
_Pat_Typed_lhs = (String -> Name
Core.Name String
"lhs")

_Pat_Typed_rhs :: Name
_Pat_Typed_rhs = (String -> Name
Core.Name String
"rhs")

data Pat_Macro = 
  Pat_Macro {
    Pat_Macro -> Data
pat_MacroBody :: Data}
  deriving (Pat_Macro -> Pat_Macro -> Bool
(Pat_Macro -> Pat_Macro -> Bool)
-> (Pat_Macro -> Pat_Macro -> Bool) -> Eq Pat_Macro
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pat_Macro -> Pat_Macro -> Bool
== :: Pat_Macro -> Pat_Macro -> Bool
$c/= :: Pat_Macro -> Pat_Macro -> Bool
/= :: Pat_Macro -> Pat_Macro -> Bool
Eq, Eq Pat_Macro
Eq Pat_Macro =>
(Pat_Macro -> Pat_Macro -> Ordering)
-> (Pat_Macro -> Pat_Macro -> Bool)
-> (Pat_Macro -> Pat_Macro -> Bool)
-> (Pat_Macro -> Pat_Macro -> Bool)
-> (Pat_Macro -> Pat_Macro -> Bool)
-> (Pat_Macro -> Pat_Macro -> Pat_Macro)
-> (Pat_Macro -> Pat_Macro -> Pat_Macro)
-> Ord Pat_Macro
Pat_Macro -> Pat_Macro -> Bool
Pat_Macro -> Pat_Macro -> Ordering
Pat_Macro -> Pat_Macro -> Pat_Macro
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Pat_Macro -> Pat_Macro -> Ordering
compare :: Pat_Macro -> Pat_Macro -> Ordering
$c< :: Pat_Macro -> Pat_Macro -> Bool
< :: Pat_Macro -> Pat_Macro -> Bool
$c<= :: Pat_Macro -> Pat_Macro -> Bool
<= :: Pat_Macro -> Pat_Macro -> Bool
$c> :: Pat_Macro -> Pat_Macro -> Bool
> :: Pat_Macro -> Pat_Macro -> Bool
$c>= :: Pat_Macro -> Pat_Macro -> Bool
>= :: Pat_Macro -> Pat_Macro -> Bool
$cmax :: Pat_Macro -> Pat_Macro -> Pat_Macro
max :: Pat_Macro -> Pat_Macro -> Pat_Macro
$cmin :: Pat_Macro -> Pat_Macro -> Pat_Macro
min :: Pat_Macro -> Pat_Macro -> Pat_Macro
Ord, ReadPrec [Pat_Macro]
ReadPrec Pat_Macro
Int -> ReadS Pat_Macro
ReadS [Pat_Macro]
(Int -> ReadS Pat_Macro)
-> ReadS [Pat_Macro]
-> ReadPrec Pat_Macro
-> ReadPrec [Pat_Macro]
-> Read Pat_Macro
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Pat_Macro
readsPrec :: Int -> ReadS Pat_Macro
$creadList :: ReadS [Pat_Macro]
readList :: ReadS [Pat_Macro]
$creadPrec :: ReadPrec Pat_Macro
readPrec :: ReadPrec Pat_Macro
$creadListPrec :: ReadPrec [Pat_Macro]
readListPrec :: ReadPrec [Pat_Macro]
Read, Int -> Pat_Macro -> String -> String
[Pat_Macro] -> String -> String
Pat_Macro -> String
(Int -> Pat_Macro -> String -> String)
-> (Pat_Macro -> String)
-> ([Pat_Macro] -> String -> String)
-> Show Pat_Macro
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Pat_Macro -> String -> String
showsPrec :: Int -> Pat_Macro -> String -> String
$cshow :: Pat_Macro -> String
show :: Pat_Macro -> String
$cshowList :: [Pat_Macro] -> String -> String
showList :: [Pat_Macro] -> String -> String
Show)

_Pat_Macro :: Name
_Pat_Macro = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Pat.Macro")

_Pat_Macro_body :: Name
_Pat_Macro_body = (String -> Name
Core.Name String
"body")

data Pat_Given = 
  Pat_Given {
    Pat_Given -> Type
pat_GivenTpe :: Type}
  deriving (Pat_Given -> Pat_Given -> Bool
(Pat_Given -> Pat_Given -> Bool)
-> (Pat_Given -> Pat_Given -> Bool) -> Eq Pat_Given
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pat_Given -> Pat_Given -> Bool
== :: Pat_Given -> Pat_Given -> Bool
$c/= :: Pat_Given -> Pat_Given -> Bool
/= :: Pat_Given -> Pat_Given -> Bool
Eq, Eq Pat_Given
Eq Pat_Given =>
(Pat_Given -> Pat_Given -> Ordering)
-> (Pat_Given -> Pat_Given -> Bool)
-> (Pat_Given -> Pat_Given -> Bool)
-> (Pat_Given -> Pat_Given -> Bool)
-> (Pat_Given -> Pat_Given -> Bool)
-> (Pat_Given -> Pat_Given -> Pat_Given)
-> (Pat_Given -> Pat_Given -> Pat_Given)
-> Ord Pat_Given
Pat_Given -> Pat_Given -> Bool
Pat_Given -> Pat_Given -> Ordering
Pat_Given -> Pat_Given -> Pat_Given
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Pat_Given -> Pat_Given -> Ordering
compare :: Pat_Given -> Pat_Given -> Ordering
$c< :: Pat_Given -> Pat_Given -> Bool
< :: Pat_Given -> Pat_Given -> Bool
$c<= :: Pat_Given -> Pat_Given -> Bool
<= :: Pat_Given -> Pat_Given -> Bool
$c> :: Pat_Given -> Pat_Given -> Bool
> :: Pat_Given -> Pat_Given -> Bool
$c>= :: Pat_Given -> Pat_Given -> Bool
>= :: Pat_Given -> Pat_Given -> Bool
$cmax :: Pat_Given -> Pat_Given -> Pat_Given
max :: Pat_Given -> Pat_Given -> Pat_Given
$cmin :: Pat_Given -> Pat_Given -> Pat_Given
min :: Pat_Given -> Pat_Given -> Pat_Given
Ord, ReadPrec [Pat_Given]
ReadPrec Pat_Given
Int -> ReadS Pat_Given
ReadS [Pat_Given]
(Int -> ReadS Pat_Given)
-> ReadS [Pat_Given]
-> ReadPrec Pat_Given
-> ReadPrec [Pat_Given]
-> Read Pat_Given
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Pat_Given
readsPrec :: Int -> ReadS Pat_Given
$creadList :: ReadS [Pat_Given]
readList :: ReadS [Pat_Given]
$creadPrec :: ReadPrec Pat_Given
readPrec :: ReadPrec Pat_Given
$creadListPrec :: ReadPrec [Pat_Given]
readListPrec :: ReadPrec [Pat_Given]
Read, Int -> Pat_Given -> String -> String
[Pat_Given] -> String -> String
Pat_Given -> String
(Int -> Pat_Given -> String -> String)
-> (Pat_Given -> String)
-> ([Pat_Given] -> String -> String)
-> Show Pat_Given
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Pat_Given -> String -> String
showsPrec :: Int -> Pat_Given -> String -> String
$cshow :: Pat_Given -> String
show :: Pat_Given -> String
$cshowList :: [Pat_Given] -> String -> String
showList :: [Pat_Given] -> String -> String
Show)

_Pat_Given :: Name
_Pat_Given = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Pat.Given")

_Pat_Given_tpe :: Name
_Pat_Given_tpe = (String -> Name
Core.Name String
"tpe")

data Member = 
  MemberTerm Member_Data |
  MemberType Member_Type |
  MemberTermParam Data_Param |
  MemberTypeParam Type_Param |
  MemberSelf Self
  deriving (Member -> Member -> Bool
(Member -> Member -> Bool)
-> (Member -> Member -> Bool) -> Eq Member
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Member -> Member -> Bool
== :: Member -> Member -> Bool
$c/= :: Member -> Member -> Bool
/= :: Member -> Member -> Bool
Eq, Eq Member
Eq Member =>
(Member -> Member -> Ordering)
-> (Member -> Member -> Bool)
-> (Member -> Member -> Bool)
-> (Member -> Member -> Bool)
-> (Member -> Member -> Bool)
-> (Member -> Member -> Member)
-> (Member -> Member -> Member)
-> Ord Member
Member -> Member -> Bool
Member -> Member -> Ordering
Member -> Member -> Member
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Member -> Member -> Ordering
compare :: Member -> Member -> Ordering
$c< :: Member -> Member -> Bool
< :: Member -> Member -> Bool
$c<= :: Member -> Member -> Bool
<= :: Member -> Member -> Bool
$c> :: Member -> Member -> Bool
> :: Member -> Member -> Bool
$c>= :: Member -> Member -> Bool
>= :: Member -> Member -> Bool
$cmax :: Member -> Member -> Member
max :: Member -> Member -> Member
$cmin :: Member -> Member -> Member
min :: Member -> Member -> Member
Ord, ReadPrec [Member]
ReadPrec Member
Int -> ReadS Member
ReadS [Member]
(Int -> ReadS Member)
-> ReadS [Member]
-> ReadPrec Member
-> ReadPrec [Member]
-> Read Member
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Member
readsPrec :: Int -> ReadS Member
$creadList :: ReadS [Member]
readList :: ReadS [Member]
$creadPrec :: ReadPrec Member
readPrec :: ReadPrec Member
$creadListPrec :: ReadPrec [Member]
readListPrec :: ReadPrec [Member]
Read, Int -> Member -> String -> String
[Member] -> String -> String
Member -> String
(Int -> Member -> String -> String)
-> (Member -> String)
-> ([Member] -> String -> String)
-> Show Member
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Member -> String -> String
showsPrec :: Int -> Member -> String -> String
$cshow :: Member -> String
show :: Member -> String
$cshowList :: [Member] -> String -> String
showList :: [Member] -> String -> String
Show)

_Member :: Name
_Member = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Member")

_Member_term :: Name
_Member_term = (String -> Name
Core.Name String
"term")

_Member_type :: Name
_Member_type = (String -> Name
Core.Name String
"type")

_Member_termParam :: Name
_Member_termParam = (String -> Name
Core.Name String
"termParam")

_Member_typeParam :: Name
_Member_typeParam = (String -> Name
Core.Name String
"typeParam")

_Member_self :: Name
_Member_self = (String -> Name
Core.Name String
"self")

data Member_Data = 
  Member_DataPkg Pkg |
  Member_DataObject Pkg_Object
  deriving (Member_Data -> Member_Data -> Bool
(Member_Data -> Member_Data -> Bool)
-> (Member_Data -> Member_Data -> Bool) -> Eq Member_Data
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Member_Data -> Member_Data -> Bool
== :: Member_Data -> Member_Data -> Bool
$c/= :: Member_Data -> Member_Data -> Bool
/= :: Member_Data -> Member_Data -> Bool
Eq, Eq Member_Data
Eq Member_Data =>
(Member_Data -> Member_Data -> Ordering)
-> (Member_Data -> Member_Data -> Bool)
-> (Member_Data -> Member_Data -> Bool)
-> (Member_Data -> Member_Data -> Bool)
-> (Member_Data -> Member_Data -> Bool)
-> (Member_Data -> Member_Data -> Member_Data)
-> (Member_Data -> Member_Data -> Member_Data)
-> Ord Member_Data
Member_Data -> Member_Data -> Bool
Member_Data -> Member_Data -> Ordering
Member_Data -> Member_Data -> Member_Data
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Member_Data -> Member_Data -> Ordering
compare :: Member_Data -> Member_Data -> Ordering
$c< :: Member_Data -> Member_Data -> Bool
< :: Member_Data -> Member_Data -> Bool
$c<= :: Member_Data -> Member_Data -> Bool
<= :: Member_Data -> Member_Data -> Bool
$c> :: Member_Data -> Member_Data -> Bool
> :: Member_Data -> Member_Data -> Bool
$c>= :: Member_Data -> Member_Data -> Bool
>= :: Member_Data -> Member_Data -> Bool
$cmax :: Member_Data -> Member_Data -> Member_Data
max :: Member_Data -> Member_Data -> Member_Data
$cmin :: Member_Data -> Member_Data -> Member_Data
min :: Member_Data -> Member_Data -> Member_Data
Ord, ReadPrec [Member_Data]
ReadPrec Member_Data
Int -> ReadS Member_Data
ReadS [Member_Data]
(Int -> ReadS Member_Data)
-> ReadS [Member_Data]
-> ReadPrec Member_Data
-> ReadPrec [Member_Data]
-> Read Member_Data
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Member_Data
readsPrec :: Int -> ReadS Member_Data
$creadList :: ReadS [Member_Data]
readList :: ReadS [Member_Data]
$creadPrec :: ReadPrec Member_Data
readPrec :: ReadPrec Member_Data
$creadListPrec :: ReadPrec [Member_Data]
readListPrec :: ReadPrec [Member_Data]
Read, Int -> Member_Data -> String -> String
[Member_Data] -> String -> String
Member_Data -> String
(Int -> Member_Data -> String -> String)
-> (Member_Data -> String)
-> ([Member_Data] -> String -> String)
-> Show Member_Data
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Member_Data -> String -> String
showsPrec :: Int -> Member_Data -> String -> String
$cshow :: Member_Data -> String
show :: Member_Data -> String
$cshowList :: [Member_Data] -> String -> String
showList :: [Member_Data] -> String -> String
Show)

_Member_Data :: Name
_Member_Data = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Member.Data")

_Member_Data_pkg :: Name
_Member_Data_pkg = (String -> Name
Core.Name String
"pkg")

_Member_Data_object :: Name
_Member_Data_object = (String -> Name
Core.Name String
"object")

data Member_Type = 
  Member_Type {
    Member_Type -> Type_Name
member_TypeName :: Type_Name}
  deriving (Member_Type -> Member_Type -> Bool
(Member_Type -> Member_Type -> Bool)
-> (Member_Type -> Member_Type -> Bool) -> Eq Member_Type
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Member_Type -> Member_Type -> Bool
== :: Member_Type -> Member_Type -> Bool
$c/= :: Member_Type -> Member_Type -> Bool
/= :: Member_Type -> Member_Type -> Bool
Eq, Eq Member_Type
Eq Member_Type =>
(Member_Type -> Member_Type -> Ordering)
-> (Member_Type -> Member_Type -> Bool)
-> (Member_Type -> Member_Type -> Bool)
-> (Member_Type -> Member_Type -> Bool)
-> (Member_Type -> Member_Type -> Bool)
-> (Member_Type -> Member_Type -> Member_Type)
-> (Member_Type -> Member_Type -> Member_Type)
-> Ord Member_Type
Member_Type -> Member_Type -> Bool
Member_Type -> Member_Type -> Ordering
Member_Type -> Member_Type -> Member_Type
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Member_Type -> Member_Type -> Ordering
compare :: Member_Type -> Member_Type -> Ordering
$c< :: Member_Type -> Member_Type -> Bool
< :: Member_Type -> Member_Type -> Bool
$c<= :: Member_Type -> Member_Type -> Bool
<= :: Member_Type -> Member_Type -> Bool
$c> :: Member_Type -> Member_Type -> Bool
> :: Member_Type -> Member_Type -> Bool
$c>= :: Member_Type -> Member_Type -> Bool
>= :: Member_Type -> Member_Type -> Bool
$cmax :: Member_Type -> Member_Type -> Member_Type
max :: Member_Type -> Member_Type -> Member_Type
$cmin :: Member_Type -> Member_Type -> Member_Type
min :: Member_Type -> Member_Type -> Member_Type
Ord, ReadPrec [Member_Type]
ReadPrec Member_Type
Int -> ReadS Member_Type
ReadS [Member_Type]
(Int -> ReadS Member_Type)
-> ReadS [Member_Type]
-> ReadPrec Member_Type
-> ReadPrec [Member_Type]
-> Read Member_Type
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Member_Type
readsPrec :: Int -> ReadS Member_Type
$creadList :: ReadS [Member_Type]
readList :: ReadS [Member_Type]
$creadPrec :: ReadPrec Member_Type
readPrec :: ReadPrec Member_Type
$creadListPrec :: ReadPrec [Member_Type]
readListPrec :: ReadPrec [Member_Type]
Read, Int -> Member_Type -> String -> String
[Member_Type] -> String -> String
Member_Type -> String
(Int -> Member_Type -> String -> String)
-> (Member_Type -> String)
-> ([Member_Type] -> String -> String)
-> Show Member_Type
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Member_Type -> String -> String
showsPrec :: Int -> Member_Type -> String -> String
$cshow :: Member_Type -> String
show :: Member_Type -> String
$cshowList :: [Member_Type] -> String -> String
showList :: [Member_Type] -> String -> String
Show)

_Member_Type :: Name
_Member_Type = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Member.Type")

_Member_Type_name :: Name
_Member_Type_name = (String -> Name
Core.Name String
"name")

data Decl = 
  DeclVal Decl_Val |
  DeclVar Decl_Var |
  DeclDef Decl_Def |
  DeclType Decl_Type |
  DeclGiven Decl_Given
  deriving (Decl -> Decl -> Bool
(Decl -> Decl -> Bool) -> (Decl -> Decl -> Bool) -> Eq Decl
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Decl -> Decl -> Bool
== :: Decl -> Decl -> Bool
$c/= :: Decl -> Decl -> Bool
/= :: Decl -> Decl -> Bool
Eq, Eq Decl
Eq Decl =>
(Decl -> Decl -> Ordering)
-> (Decl -> Decl -> Bool)
-> (Decl -> Decl -> Bool)
-> (Decl -> Decl -> Bool)
-> (Decl -> Decl -> Bool)
-> (Decl -> Decl -> Decl)
-> (Decl -> Decl -> Decl)
-> Ord Decl
Decl -> Decl -> Bool
Decl -> Decl -> Ordering
Decl -> Decl -> Decl
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Decl -> Decl -> Ordering
compare :: Decl -> Decl -> Ordering
$c< :: Decl -> Decl -> Bool
< :: Decl -> Decl -> Bool
$c<= :: Decl -> Decl -> Bool
<= :: Decl -> Decl -> Bool
$c> :: Decl -> Decl -> Bool
> :: Decl -> Decl -> Bool
$c>= :: Decl -> Decl -> Bool
>= :: Decl -> Decl -> Bool
$cmax :: Decl -> Decl -> Decl
max :: Decl -> Decl -> Decl
$cmin :: Decl -> Decl -> Decl
min :: Decl -> Decl -> Decl
Ord, ReadPrec [Decl]
ReadPrec Decl
Int -> ReadS Decl
ReadS [Decl]
(Int -> ReadS Decl)
-> ReadS [Decl] -> ReadPrec Decl -> ReadPrec [Decl] -> Read Decl
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Decl
readsPrec :: Int -> ReadS Decl
$creadList :: ReadS [Decl]
readList :: ReadS [Decl]
$creadPrec :: ReadPrec Decl
readPrec :: ReadPrec Decl
$creadListPrec :: ReadPrec [Decl]
readListPrec :: ReadPrec [Decl]
Read, Int -> Decl -> String -> String
[Decl] -> String -> String
Decl -> String
(Int -> Decl -> String -> String)
-> (Decl -> String) -> ([Decl] -> String -> String) -> Show Decl
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Decl -> String -> String
showsPrec :: Int -> Decl -> String -> String
$cshow :: Decl -> String
show :: Decl -> String
$cshowList :: [Decl] -> String -> String
showList :: [Decl] -> String -> String
Show)

_Decl :: Name
_Decl = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Decl")

_Decl_val :: Name
_Decl_val = (String -> Name
Core.Name String
"val")

_Decl_var :: Name
_Decl_var = (String -> Name
Core.Name String
"var")

_Decl_def :: Name
_Decl_def = (String -> Name
Core.Name String
"def")

_Decl_type :: Name
_Decl_type = (String -> Name
Core.Name String
"type")

_Decl_given :: Name
_Decl_given = (String -> Name
Core.Name String
"given")

data Decl_Val = 
  Decl_Val {
    Decl_Val -> [Mod]
decl_ValMods :: [Mod],
    Decl_Val -> [Pat]
decl_ValPats :: [Pat],
    Decl_Val -> Type
decl_ValDecltpe :: Type}
  deriving (Decl_Val -> Decl_Val -> Bool
(Decl_Val -> Decl_Val -> Bool)
-> (Decl_Val -> Decl_Val -> Bool) -> Eq Decl_Val
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Decl_Val -> Decl_Val -> Bool
== :: Decl_Val -> Decl_Val -> Bool
$c/= :: Decl_Val -> Decl_Val -> Bool
/= :: Decl_Val -> Decl_Val -> Bool
Eq, Eq Decl_Val
Eq Decl_Val =>
(Decl_Val -> Decl_Val -> Ordering)
-> (Decl_Val -> Decl_Val -> Bool)
-> (Decl_Val -> Decl_Val -> Bool)
-> (Decl_Val -> Decl_Val -> Bool)
-> (Decl_Val -> Decl_Val -> Bool)
-> (Decl_Val -> Decl_Val -> Decl_Val)
-> (Decl_Val -> Decl_Val -> Decl_Val)
-> Ord Decl_Val
Decl_Val -> Decl_Val -> Bool
Decl_Val -> Decl_Val -> Ordering
Decl_Val -> Decl_Val -> Decl_Val
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Decl_Val -> Decl_Val -> Ordering
compare :: Decl_Val -> Decl_Val -> Ordering
$c< :: Decl_Val -> Decl_Val -> Bool
< :: Decl_Val -> Decl_Val -> Bool
$c<= :: Decl_Val -> Decl_Val -> Bool
<= :: Decl_Val -> Decl_Val -> Bool
$c> :: Decl_Val -> Decl_Val -> Bool
> :: Decl_Val -> Decl_Val -> Bool
$c>= :: Decl_Val -> Decl_Val -> Bool
>= :: Decl_Val -> Decl_Val -> Bool
$cmax :: Decl_Val -> Decl_Val -> Decl_Val
max :: Decl_Val -> Decl_Val -> Decl_Val
$cmin :: Decl_Val -> Decl_Val -> Decl_Val
min :: Decl_Val -> Decl_Val -> Decl_Val
Ord, ReadPrec [Decl_Val]
ReadPrec Decl_Val
Int -> ReadS Decl_Val
ReadS [Decl_Val]
(Int -> ReadS Decl_Val)
-> ReadS [Decl_Val]
-> ReadPrec Decl_Val
-> ReadPrec [Decl_Val]
-> Read Decl_Val
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Decl_Val
readsPrec :: Int -> ReadS Decl_Val
$creadList :: ReadS [Decl_Val]
readList :: ReadS [Decl_Val]
$creadPrec :: ReadPrec Decl_Val
readPrec :: ReadPrec Decl_Val
$creadListPrec :: ReadPrec [Decl_Val]
readListPrec :: ReadPrec [Decl_Val]
Read, Int -> Decl_Val -> String -> String
[Decl_Val] -> String -> String
Decl_Val -> String
(Int -> Decl_Val -> String -> String)
-> (Decl_Val -> String)
-> ([Decl_Val] -> String -> String)
-> Show Decl_Val
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Decl_Val -> String -> String
showsPrec :: Int -> Decl_Val -> String -> String
$cshow :: Decl_Val -> String
show :: Decl_Val -> String
$cshowList :: [Decl_Val] -> String -> String
showList :: [Decl_Val] -> String -> String
Show)

_Decl_Val :: Name
_Decl_Val = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Decl.Val")

_Decl_Val_mods :: Name
_Decl_Val_mods = (String -> Name
Core.Name String
"mods")

_Decl_Val_pats :: Name
_Decl_Val_pats = (String -> Name
Core.Name String
"pats")

_Decl_Val_decltpe :: Name
_Decl_Val_decltpe = (String -> Name
Core.Name String
"decltpe")

data Decl_Var = 
  Decl_Var {
    Decl_Var -> [Mod]
decl_VarMods :: [Mod],
    Decl_Var -> [Pat]
decl_VarPats :: [Pat],
    Decl_Var -> Type
decl_VarDecltpe :: Type}
  deriving (Decl_Var -> Decl_Var -> Bool
(Decl_Var -> Decl_Var -> Bool)
-> (Decl_Var -> Decl_Var -> Bool) -> Eq Decl_Var
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Decl_Var -> Decl_Var -> Bool
== :: Decl_Var -> Decl_Var -> Bool
$c/= :: Decl_Var -> Decl_Var -> Bool
/= :: Decl_Var -> Decl_Var -> Bool
Eq, Eq Decl_Var
Eq Decl_Var =>
(Decl_Var -> Decl_Var -> Ordering)
-> (Decl_Var -> Decl_Var -> Bool)
-> (Decl_Var -> Decl_Var -> Bool)
-> (Decl_Var -> Decl_Var -> Bool)
-> (Decl_Var -> Decl_Var -> Bool)
-> (Decl_Var -> Decl_Var -> Decl_Var)
-> (Decl_Var -> Decl_Var -> Decl_Var)
-> Ord Decl_Var
Decl_Var -> Decl_Var -> Bool
Decl_Var -> Decl_Var -> Ordering
Decl_Var -> Decl_Var -> Decl_Var
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Decl_Var -> Decl_Var -> Ordering
compare :: Decl_Var -> Decl_Var -> Ordering
$c< :: Decl_Var -> Decl_Var -> Bool
< :: Decl_Var -> Decl_Var -> Bool
$c<= :: Decl_Var -> Decl_Var -> Bool
<= :: Decl_Var -> Decl_Var -> Bool
$c> :: Decl_Var -> Decl_Var -> Bool
> :: Decl_Var -> Decl_Var -> Bool
$c>= :: Decl_Var -> Decl_Var -> Bool
>= :: Decl_Var -> Decl_Var -> Bool
$cmax :: Decl_Var -> Decl_Var -> Decl_Var
max :: Decl_Var -> Decl_Var -> Decl_Var
$cmin :: Decl_Var -> Decl_Var -> Decl_Var
min :: Decl_Var -> Decl_Var -> Decl_Var
Ord, ReadPrec [Decl_Var]
ReadPrec Decl_Var
Int -> ReadS Decl_Var
ReadS [Decl_Var]
(Int -> ReadS Decl_Var)
-> ReadS [Decl_Var]
-> ReadPrec Decl_Var
-> ReadPrec [Decl_Var]
-> Read Decl_Var
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Decl_Var
readsPrec :: Int -> ReadS Decl_Var
$creadList :: ReadS [Decl_Var]
readList :: ReadS [Decl_Var]
$creadPrec :: ReadPrec Decl_Var
readPrec :: ReadPrec Decl_Var
$creadListPrec :: ReadPrec [Decl_Var]
readListPrec :: ReadPrec [Decl_Var]
Read, Int -> Decl_Var -> String -> String
[Decl_Var] -> String -> String
Decl_Var -> String
(Int -> Decl_Var -> String -> String)
-> (Decl_Var -> String)
-> ([Decl_Var] -> String -> String)
-> Show Decl_Var
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Decl_Var -> String -> String
showsPrec :: Int -> Decl_Var -> String -> String
$cshow :: Decl_Var -> String
show :: Decl_Var -> String
$cshowList :: [Decl_Var] -> String -> String
showList :: [Decl_Var] -> String -> String
Show)

_Decl_Var :: Name
_Decl_Var = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Decl.Var")

_Decl_Var_mods :: Name
_Decl_Var_mods = (String -> Name
Core.Name String
"mods")

_Decl_Var_pats :: Name
_Decl_Var_pats = (String -> Name
Core.Name String
"pats")

_Decl_Var_decltpe :: Name
_Decl_Var_decltpe = (String -> Name
Core.Name String
"decltpe")

data Decl_Def = 
  Decl_Def {
    Decl_Def -> [Mod]
decl_DefMods :: [Mod],
    Decl_Def -> Data_Name
decl_DefName :: Data_Name,
    Decl_Def -> [Type_Param]
decl_DefTparams :: [Type_Param],
    Decl_Def -> [[Data_Param]]
decl_DefParamss :: [[Data_Param]],
    Decl_Def -> Type
decl_DefDecltpe :: Type}
  deriving (Decl_Def -> Decl_Def -> Bool
(Decl_Def -> Decl_Def -> Bool)
-> (Decl_Def -> Decl_Def -> Bool) -> Eq Decl_Def
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Decl_Def -> Decl_Def -> Bool
== :: Decl_Def -> Decl_Def -> Bool
$c/= :: Decl_Def -> Decl_Def -> Bool
/= :: Decl_Def -> Decl_Def -> Bool
Eq, Eq Decl_Def
Eq Decl_Def =>
(Decl_Def -> Decl_Def -> Ordering)
-> (Decl_Def -> Decl_Def -> Bool)
-> (Decl_Def -> Decl_Def -> Bool)
-> (Decl_Def -> Decl_Def -> Bool)
-> (Decl_Def -> Decl_Def -> Bool)
-> (Decl_Def -> Decl_Def -> Decl_Def)
-> (Decl_Def -> Decl_Def -> Decl_Def)
-> Ord Decl_Def
Decl_Def -> Decl_Def -> Bool
Decl_Def -> Decl_Def -> Ordering
Decl_Def -> Decl_Def -> Decl_Def
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Decl_Def -> Decl_Def -> Ordering
compare :: Decl_Def -> Decl_Def -> Ordering
$c< :: Decl_Def -> Decl_Def -> Bool
< :: Decl_Def -> Decl_Def -> Bool
$c<= :: Decl_Def -> Decl_Def -> Bool
<= :: Decl_Def -> Decl_Def -> Bool
$c> :: Decl_Def -> Decl_Def -> Bool
> :: Decl_Def -> Decl_Def -> Bool
$c>= :: Decl_Def -> Decl_Def -> Bool
>= :: Decl_Def -> Decl_Def -> Bool
$cmax :: Decl_Def -> Decl_Def -> Decl_Def
max :: Decl_Def -> Decl_Def -> Decl_Def
$cmin :: Decl_Def -> Decl_Def -> Decl_Def
min :: Decl_Def -> Decl_Def -> Decl_Def
Ord, ReadPrec [Decl_Def]
ReadPrec Decl_Def
Int -> ReadS Decl_Def
ReadS [Decl_Def]
(Int -> ReadS Decl_Def)
-> ReadS [Decl_Def]
-> ReadPrec Decl_Def
-> ReadPrec [Decl_Def]
-> Read Decl_Def
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Decl_Def
readsPrec :: Int -> ReadS Decl_Def
$creadList :: ReadS [Decl_Def]
readList :: ReadS [Decl_Def]
$creadPrec :: ReadPrec Decl_Def
readPrec :: ReadPrec Decl_Def
$creadListPrec :: ReadPrec [Decl_Def]
readListPrec :: ReadPrec [Decl_Def]
Read, Int -> Decl_Def -> String -> String
[Decl_Def] -> String -> String
Decl_Def -> String
(Int -> Decl_Def -> String -> String)
-> (Decl_Def -> String)
-> ([Decl_Def] -> String -> String)
-> Show Decl_Def
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Decl_Def -> String -> String
showsPrec :: Int -> Decl_Def -> String -> String
$cshow :: Decl_Def -> String
show :: Decl_Def -> String
$cshowList :: [Decl_Def] -> String -> String
showList :: [Decl_Def] -> String -> String
Show)

_Decl_Def :: Name
_Decl_Def = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Decl.Def")

_Decl_Def_mods :: Name
_Decl_Def_mods = (String -> Name
Core.Name String
"mods")

_Decl_Def_name :: Name
_Decl_Def_name = (String -> Name
Core.Name String
"name")

_Decl_Def_tparams :: Name
_Decl_Def_tparams = (String -> Name
Core.Name String
"tparams")

_Decl_Def_paramss :: Name
_Decl_Def_paramss = (String -> Name
Core.Name String
"paramss")

_Decl_Def_decltpe :: Name
_Decl_Def_decltpe = (String -> Name
Core.Name String
"decltpe")

data Decl_Type = 
  Decl_Type {
    Decl_Type -> [Mod]
decl_TypeMods :: [Mod],
    Decl_Type -> Type_Name
decl_TypeName :: Type_Name,
    Decl_Type -> [Type_Param]
decl_TypeTparams :: [Type_Param],
    Decl_Type -> Type_Bounds
decl_TypeBounds :: Type_Bounds}
  deriving (Decl_Type -> Decl_Type -> Bool
(Decl_Type -> Decl_Type -> Bool)
-> (Decl_Type -> Decl_Type -> Bool) -> Eq Decl_Type
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Decl_Type -> Decl_Type -> Bool
== :: Decl_Type -> Decl_Type -> Bool
$c/= :: Decl_Type -> Decl_Type -> Bool
/= :: Decl_Type -> Decl_Type -> Bool
Eq, Eq Decl_Type
Eq Decl_Type =>
(Decl_Type -> Decl_Type -> Ordering)
-> (Decl_Type -> Decl_Type -> Bool)
-> (Decl_Type -> Decl_Type -> Bool)
-> (Decl_Type -> Decl_Type -> Bool)
-> (Decl_Type -> Decl_Type -> Bool)
-> (Decl_Type -> Decl_Type -> Decl_Type)
-> (Decl_Type -> Decl_Type -> Decl_Type)
-> Ord Decl_Type
Decl_Type -> Decl_Type -> Bool
Decl_Type -> Decl_Type -> Ordering
Decl_Type -> Decl_Type -> Decl_Type
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Decl_Type -> Decl_Type -> Ordering
compare :: Decl_Type -> Decl_Type -> Ordering
$c< :: Decl_Type -> Decl_Type -> Bool
< :: Decl_Type -> Decl_Type -> Bool
$c<= :: Decl_Type -> Decl_Type -> Bool
<= :: Decl_Type -> Decl_Type -> Bool
$c> :: Decl_Type -> Decl_Type -> Bool
> :: Decl_Type -> Decl_Type -> Bool
$c>= :: Decl_Type -> Decl_Type -> Bool
>= :: Decl_Type -> Decl_Type -> Bool
$cmax :: Decl_Type -> Decl_Type -> Decl_Type
max :: Decl_Type -> Decl_Type -> Decl_Type
$cmin :: Decl_Type -> Decl_Type -> Decl_Type
min :: Decl_Type -> Decl_Type -> Decl_Type
Ord, ReadPrec [Decl_Type]
ReadPrec Decl_Type
Int -> ReadS Decl_Type
ReadS [Decl_Type]
(Int -> ReadS Decl_Type)
-> ReadS [Decl_Type]
-> ReadPrec Decl_Type
-> ReadPrec [Decl_Type]
-> Read Decl_Type
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Decl_Type
readsPrec :: Int -> ReadS Decl_Type
$creadList :: ReadS [Decl_Type]
readList :: ReadS [Decl_Type]
$creadPrec :: ReadPrec Decl_Type
readPrec :: ReadPrec Decl_Type
$creadListPrec :: ReadPrec [Decl_Type]
readListPrec :: ReadPrec [Decl_Type]
Read, Int -> Decl_Type -> String -> String
[Decl_Type] -> String -> String
Decl_Type -> String
(Int -> Decl_Type -> String -> String)
-> (Decl_Type -> String)
-> ([Decl_Type] -> String -> String)
-> Show Decl_Type
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Decl_Type -> String -> String
showsPrec :: Int -> Decl_Type -> String -> String
$cshow :: Decl_Type -> String
show :: Decl_Type -> String
$cshowList :: [Decl_Type] -> String -> String
showList :: [Decl_Type] -> String -> String
Show)

_Decl_Type :: Name
_Decl_Type = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Decl.Type")

_Decl_Type_mods :: Name
_Decl_Type_mods = (String -> Name
Core.Name String
"mods")

_Decl_Type_name :: Name
_Decl_Type_name = (String -> Name
Core.Name String
"name")

_Decl_Type_tparams :: Name
_Decl_Type_tparams = (String -> Name
Core.Name String
"tparams")

_Decl_Type_bounds :: Name
_Decl_Type_bounds = (String -> Name
Core.Name String
"bounds")

data Decl_Given = 
  Decl_Given {
    Decl_Given -> [Mod]
decl_GivenMods :: [Mod],
    Decl_Given -> Data_Name
decl_GivenName :: Data_Name,
    Decl_Given -> [Type_Param]
decl_GivenTparams :: [Type_Param],
    Decl_Given -> [[Data_Param]]
decl_GivenSparams :: [[Data_Param]],
    Decl_Given -> Type
decl_GivenDecltpe :: Type}
  deriving (Decl_Given -> Decl_Given -> Bool
(Decl_Given -> Decl_Given -> Bool)
-> (Decl_Given -> Decl_Given -> Bool) -> Eq Decl_Given
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Decl_Given -> Decl_Given -> Bool
== :: Decl_Given -> Decl_Given -> Bool
$c/= :: Decl_Given -> Decl_Given -> Bool
/= :: Decl_Given -> Decl_Given -> Bool
Eq, Eq Decl_Given
Eq Decl_Given =>
(Decl_Given -> Decl_Given -> Ordering)
-> (Decl_Given -> Decl_Given -> Bool)
-> (Decl_Given -> Decl_Given -> Bool)
-> (Decl_Given -> Decl_Given -> Bool)
-> (Decl_Given -> Decl_Given -> Bool)
-> (Decl_Given -> Decl_Given -> Decl_Given)
-> (Decl_Given -> Decl_Given -> Decl_Given)
-> Ord Decl_Given
Decl_Given -> Decl_Given -> Bool
Decl_Given -> Decl_Given -> Ordering
Decl_Given -> Decl_Given -> Decl_Given
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Decl_Given -> Decl_Given -> Ordering
compare :: Decl_Given -> Decl_Given -> Ordering
$c< :: Decl_Given -> Decl_Given -> Bool
< :: Decl_Given -> Decl_Given -> Bool
$c<= :: Decl_Given -> Decl_Given -> Bool
<= :: Decl_Given -> Decl_Given -> Bool
$c> :: Decl_Given -> Decl_Given -> Bool
> :: Decl_Given -> Decl_Given -> Bool
$c>= :: Decl_Given -> Decl_Given -> Bool
>= :: Decl_Given -> Decl_Given -> Bool
$cmax :: Decl_Given -> Decl_Given -> Decl_Given
max :: Decl_Given -> Decl_Given -> Decl_Given
$cmin :: Decl_Given -> Decl_Given -> Decl_Given
min :: Decl_Given -> Decl_Given -> Decl_Given
Ord, ReadPrec [Decl_Given]
ReadPrec Decl_Given
Int -> ReadS Decl_Given
ReadS [Decl_Given]
(Int -> ReadS Decl_Given)
-> ReadS [Decl_Given]
-> ReadPrec Decl_Given
-> ReadPrec [Decl_Given]
-> Read Decl_Given
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Decl_Given
readsPrec :: Int -> ReadS Decl_Given
$creadList :: ReadS [Decl_Given]
readList :: ReadS [Decl_Given]
$creadPrec :: ReadPrec Decl_Given
readPrec :: ReadPrec Decl_Given
$creadListPrec :: ReadPrec [Decl_Given]
readListPrec :: ReadPrec [Decl_Given]
Read, Int -> Decl_Given -> String -> String
[Decl_Given] -> String -> String
Decl_Given -> String
(Int -> Decl_Given -> String -> String)
-> (Decl_Given -> String)
-> ([Decl_Given] -> String -> String)
-> Show Decl_Given
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Decl_Given -> String -> String
showsPrec :: Int -> Decl_Given -> String -> String
$cshow :: Decl_Given -> String
show :: Decl_Given -> String
$cshowList :: [Decl_Given] -> String -> String
showList :: [Decl_Given] -> String -> String
Show)

_Decl_Given :: Name
_Decl_Given = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Decl.Given")

_Decl_Given_mods :: Name
_Decl_Given_mods = (String -> Name
Core.Name String
"mods")

_Decl_Given_name :: Name
_Decl_Given_name = (String -> Name
Core.Name String
"name")

_Decl_Given_tparams :: Name
_Decl_Given_tparams = (String -> Name
Core.Name String
"tparams")

_Decl_Given_sparams :: Name
_Decl_Given_sparams = (String -> Name
Core.Name String
"sparams")

_Decl_Given_decltpe :: Name
_Decl_Given_decltpe = (String -> Name
Core.Name String
"decltpe")

data Defn = 
  DefnVal Defn_Val |
  DefnVar Defn_Var |
  DefnGiven Defn_Given |
  DefnEnum Defn_Enum |
  DefnEnumCase Defn_EnumCase |
  DefnRepeatedEnumCase Defn_RepeatedEnumCase |
  DefnGivenAlias Defn_GivenAlias |
  DefnExtensionGroup Defn_ExtensionGroup |
  DefnDef Defn_Def |
  DefnMacro Defn_Macro |
  DefnType Defn_Type |
  DefnClass Defn_Class |
  DefnTrait Defn_Trait |
  DefnObject Defn_Object
  deriving (Defn -> Defn -> Bool
(Defn -> Defn -> Bool) -> (Defn -> Defn -> Bool) -> Eq Defn
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Defn -> Defn -> Bool
== :: Defn -> Defn -> Bool
$c/= :: Defn -> Defn -> Bool
/= :: Defn -> Defn -> Bool
Eq, Eq Defn
Eq Defn =>
(Defn -> Defn -> Ordering)
-> (Defn -> Defn -> Bool)
-> (Defn -> Defn -> Bool)
-> (Defn -> Defn -> Bool)
-> (Defn -> Defn -> Bool)
-> (Defn -> Defn -> Defn)
-> (Defn -> Defn -> Defn)
-> Ord Defn
Defn -> Defn -> Bool
Defn -> Defn -> Ordering
Defn -> Defn -> Defn
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Defn -> Defn -> Ordering
compare :: Defn -> Defn -> Ordering
$c< :: Defn -> Defn -> Bool
< :: Defn -> Defn -> Bool
$c<= :: Defn -> Defn -> Bool
<= :: Defn -> Defn -> Bool
$c> :: Defn -> Defn -> Bool
> :: Defn -> Defn -> Bool
$c>= :: Defn -> Defn -> Bool
>= :: Defn -> Defn -> Bool
$cmax :: Defn -> Defn -> Defn
max :: Defn -> Defn -> Defn
$cmin :: Defn -> Defn -> Defn
min :: Defn -> Defn -> Defn
Ord, ReadPrec [Defn]
ReadPrec Defn
Int -> ReadS Defn
ReadS [Defn]
(Int -> ReadS Defn)
-> ReadS [Defn] -> ReadPrec Defn -> ReadPrec [Defn] -> Read Defn
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Defn
readsPrec :: Int -> ReadS Defn
$creadList :: ReadS [Defn]
readList :: ReadS [Defn]
$creadPrec :: ReadPrec Defn
readPrec :: ReadPrec Defn
$creadListPrec :: ReadPrec [Defn]
readListPrec :: ReadPrec [Defn]
Read, Int -> Defn -> String -> String
[Defn] -> String -> String
Defn -> String
(Int -> Defn -> String -> String)
-> (Defn -> String) -> ([Defn] -> String -> String) -> Show Defn
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Defn -> String -> String
showsPrec :: Int -> Defn -> String -> String
$cshow :: Defn -> String
show :: Defn -> String
$cshowList :: [Defn] -> String -> String
showList :: [Defn] -> String -> String
Show)

_Defn :: Name
_Defn = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Defn")

_Defn_val :: Name
_Defn_val = (String -> Name
Core.Name String
"val")

_Defn_var :: Name
_Defn_var = (String -> Name
Core.Name String
"var")

_Defn_given :: Name
_Defn_given = (String -> Name
Core.Name String
"given")

_Defn_enum :: Name
_Defn_enum = (String -> Name
Core.Name String
"enum")

_Defn_enumCase :: Name
_Defn_enumCase = (String -> Name
Core.Name String
"enumCase")

_Defn_repeatedEnumCase :: Name
_Defn_repeatedEnumCase = (String -> Name
Core.Name String
"repeatedEnumCase")

_Defn_givenAlias :: Name
_Defn_givenAlias = (String -> Name
Core.Name String
"givenAlias")

_Defn_extensionGroup :: Name
_Defn_extensionGroup = (String -> Name
Core.Name String
"extensionGroup")

_Defn_def :: Name
_Defn_def = (String -> Name
Core.Name String
"def")

_Defn_macro :: Name
_Defn_macro = (String -> Name
Core.Name String
"macro")

_Defn_type :: Name
_Defn_type = (String -> Name
Core.Name String
"type")

_Defn_class :: Name
_Defn_class = (String -> Name
Core.Name String
"class")

_Defn_trait :: Name
_Defn_trait = (String -> Name
Core.Name String
"trait")

_Defn_object :: Name
_Defn_object = (String -> Name
Core.Name String
"object")

data Defn_Val = 
  Defn_Val {
    Defn_Val -> [Mod]
defn_ValMods :: [Mod],
    Defn_Val -> [Pat]
defn_ValPats :: [Pat],
    Defn_Val -> Maybe Type
defn_ValDecltpe :: (Maybe Type),
    Defn_Val -> Data
defn_ValRhs :: Data}
  deriving (Defn_Val -> Defn_Val -> Bool
(Defn_Val -> Defn_Val -> Bool)
-> (Defn_Val -> Defn_Val -> Bool) -> Eq Defn_Val
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Defn_Val -> Defn_Val -> Bool
== :: Defn_Val -> Defn_Val -> Bool
$c/= :: Defn_Val -> Defn_Val -> Bool
/= :: Defn_Val -> Defn_Val -> Bool
Eq, Eq Defn_Val
Eq Defn_Val =>
(Defn_Val -> Defn_Val -> Ordering)
-> (Defn_Val -> Defn_Val -> Bool)
-> (Defn_Val -> Defn_Val -> Bool)
-> (Defn_Val -> Defn_Val -> Bool)
-> (Defn_Val -> Defn_Val -> Bool)
-> (Defn_Val -> Defn_Val -> Defn_Val)
-> (Defn_Val -> Defn_Val -> Defn_Val)
-> Ord Defn_Val
Defn_Val -> Defn_Val -> Bool
Defn_Val -> Defn_Val -> Ordering
Defn_Val -> Defn_Val -> Defn_Val
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Defn_Val -> Defn_Val -> Ordering
compare :: Defn_Val -> Defn_Val -> Ordering
$c< :: Defn_Val -> Defn_Val -> Bool
< :: Defn_Val -> Defn_Val -> Bool
$c<= :: Defn_Val -> Defn_Val -> Bool
<= :: Defn_Val -> Defn_Val -> Bool
$c> :: Defn_Val -> Defn_Val -> Bool
> :: Defn_Val -> Defn_Val -> Bool
$c>= :: Defn_Val -> Defn_Val -> Bool
>= :: Defn_Val -> Defn_Val -> Bool
$cmax :: Defn_Val -> Defn_Val -> Defn_Val
max :: Defn_Val -> Defn_Val -> Defn_Val
$cmin :: Defn_Val -> Defn_Val -> Defn_Val
min :: Defn_Val -> Defn_Val -> Defn_Val
Ord, ReadPrec [Defn_Val]
ReadPrec Defn_Val
Int -> ReadS Defn_Val
ReadS [Defn_Val]
(Int -> ReadS Defn_Val)
-> ReadS [Defn_Val]
-> ReadPrec Defn_Val
-> ReadPrec [Defn_Val]
-> Read Defn_Val
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Defn_Val
readsPrec :: Int -> ReadS Defn_Val
$creadList :: ReadS [Defn_Val]
readList :: ReadS [Defn_Val]
$creadPrec :: ReadPrec Defn_Val
readPrec :: ReadPrec Defn_Val
$creadListPrec :: ReadPrec [Defn_Val]
readListPrec :: ReadPrec [Defn_Val]
Read, Int -> Defn_Val -> String -> String
[Defn_Val] -> String -> String
Defn_Val -> String
(Int -> Defn_Val -> String -> String)
-> (Defn_Val -> String)
-> ([Defn_Val] -> String -> String)
-> Show Defn_Val
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Defn_Val -> String -> String
showsPrec :: Int -> Defn_Val -> String -> String
$cshow :: Defn_Val -> String
show :: Defn_Val -> String
$cshowList :: [Defn_Val] -> String -> String
showList :: [Defn_Val] -> String -> String
Show)

_Defn_Val :: Name
_Defn_Val = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Defn.Val")

_Defn_Val_mods :: Name
_Defn_Val_mods = (String -> Name
Core.Name String
"mods")

_Defn_Val_pats :: Name
_Defn_Val_pats = (String -> Name
Core.Name String
"pats")

_Defn_Val_decltpe :: Name
_Defn_Val_decltpe = (String -> Name
Core.Name String
"decltpe")

_Defn_Val_rhs :: Name
_Defn_Val_rhs = (String -> Name
Core.Name String
"rhs")

data Defn_Var = 
  Defn_Var {
    Defn_Var -> [Mod]
defn_VarMods :: [Mod],
    Defn_Var -> [Pat]
defn_VarPats :: [Pat],
    Defn_Var -> Type
defn_VarDecltpe :: Type,
    Defn_Var -> Maybe Data
defn_VarRhs :: (Maybe Data)}
  deriving (Defn_Var -> Defn_Var -> Bool
(Defn_Var -> Defn_Var -> Bool)
-> (Defn_Var -> Defn_Var -> Bool) -> Eq Defn_Var
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Defn_Var -> Defn_Var -> Bool
== :: Defn_Var -> Defn_Var -> Bool
$c/= :: Defn_Var -> Defn_Var -> Bool
/= :: Defn_Var -> Defn_Var -> Bool
Eq, Eq Defn_Var
Eq Defn_Var =>
(Defn_Var -> Defn_Var -> Ordering)
-> (Defn_Var -> Defn_Var -> Bool)
-> (Defn_Var -> Defn_Var -> Bool)
-> (Defn_Var -> Defn_Var -> Bool)
-> (Defn_Var -> Defn_Var -> Bool)
-> (Defn_Var -> Defn_Var -> Defn_Var)
-> (Defn_Var -> Defn_Var -> Defn_Var)
-> Ord Defn_Var
Defn_Var -> Defn_Var -> Bool
Defn_Var -> Defn_Var -> Ordering
Defn_Var -> Defn_Var -> Defn_Var
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Defn_Var -> Defn_Var -> Ordering
compare :: Defn_Var -> Defn_Var -> Ordering
$c< :: Defn_Var -> Defn_Var -> Bool
< :: Defn_Var -> Defn_Var -> Bool
$c<= :: Defn_Var -> Defn_Var -> Bool
<= :: Defn_Var -> Defn_Var -> Bool
$c> :: Defn_Var -> Defn_Var -> Bool
> :: Defn_Var -> Defn_Var -> Bool
$c>= :: Defn_Var -> Defn_Var -> Bool
>= :: Defn_Var -> Defn_Var -> Bool
$cmax :: Defn_Var -> Defn_Var -> Defn_Var
max :: Defn_Var -> Defn_Var -> Defn_Var
$cmin :: Defn_Var -> Defn_Var -> Defn_Var
min :: Defn_Var -> Defn_Var -> Defn_Var
Ord, ReadPrec [Defn_Var]
ReadPrec Defn_Var
Int -> ReadS Defn_Var
ReadS [Defn_Var]
(Int -> ReadS Defn_Var)
-> ReadS [Defn_Var]
-> ReadPrec Defn_Var
-> ReadPrec [Defn_Var]
-> Read Defn_Var
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Defn_Var
readsPrec :: Int -> ReadS Defn_Var
$creadList :: ReadS [Defn_Var]
readList :: ReadS [Defn_Var]
$creadPrec :: ReadPrec Defn_Var
readPrec :: ReadPrec Defn_Var
$creadListPrec :: ReadPrec [Defn_Var]
readListPrec :: ReadPrec [Defn_Var]
Read, Int -> Defn_Var -> String -> String
[Defn_Var] -> String -> String
Defn_Var -> String
(Int -> Defn_Var -> String -> String)
-> (Defn_Var -> String)
-> ([Defn_Var] -> String -> String)
-> Show Defn_Var
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Defn_Var -> String -> String
showsPrec :: Int -> Defn_Var -> String -> String
$cshow :: Defn_Var -> String
show :: Defn_Var -> String
$cshowList :: [Defn_Var] -> String -> String
showList :: [Defn_Var] -> String -> String
Show)

_Defn_Var :: Name
_Defn_Var = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Defn.Var")

_Defn_Var_mods :: Name
_Defn_Var_mods = (String -> Name
Core.Name String
"mods")

_Defn_Var_pats :: Name
_Defn_Var_pats = (String -> Name
Core.Name String
"pats")

_Defn_Var_decltpe :: Name
_Defn_Var_decltpe = (String -> Name
Core.Name String
"decltpe")

_Defn_Var_rhs :: Name
_Defn_Var_rhs = (String -> Name
Core.Name String
"rhs")

data Defn_Given = 
  Defn_Given {
    Defn_Given -> [Mod]
defn_GivenMods :: [Mod],
    Defn_Given -> Name
defn_GivenName :: Name,
    Defn_Given -> [[Type_Param]]
defn_GivenTparams :: [[Type_Param]],
    Defn_Given -> [[Data_Param]]
defn_GivenSparams :: [[Data_Param]],
    Defn_Given -> Template
defn_GivenTempl :: Template}
  deriving (Defn_Given -> Defn_Given -> Bool
(Defn_Given -> Defn_Given -> Bool)
-> (Defn_Given -> Defn_Given -> Bool) -> Eq Defn_Given
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Defn_Given -> Defn_Given -> Bool
== :: Defn_Given -> Defn_Given -> Bool
$c/= :: Defn_Given -> Defn_Given -> Bool
/= :: Defn_Given -> Defn_Given -> Bool
Eq, Eq Defn_Given
Eq Defn_Given =>
(Defn_Given -> Defn_Given -> Ordering)
-> (Defn_Given -> Defn_Given -> Bool)
-> (Defn_Given -> Defn_Given -> Bool)
-> (Defn_Given -> Defn_Given -> Bool)
-> (Defn_Given -> Defn_Given -> Bool)
-> (Defn_Given -> Defn_Given -> Defn_Given)
-> (Defn_Given -> Defn_Given -> Defn_Given)
-> Ord Defn_Given
Defn_Given -> Defn_Given -> Bool
Defn_Given -> Defn_Given -> Ordering
Defn_Given -> Defn_Given -> Defn_Given
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Defn_Given -> Defn_Given -> Ordering
compare :: Defn_Given -> Defn_Given -> Ordering
$c< :: Defn_Given -> Defn_Given -> Bool
< :: Defn_Given -> Defn_Given -> Bool
$c<= :: Defn_Given -> Defn_Given -> Bool
<= :: Defn_Given -> Defn_Given -> Bool
$c> :: Defn_Given -> Defn_Given -> Bool
> :: Defn_Given -> Defn_Given -> Bool
$c>= :: Defn_Given -> Defn_Given -> Bool
>= :: Defn_Given -> Defn_Given -> Bool
$cmax :: Defn_Given -> Defn_Given -> Defn_Given
max :: Defn_Given -> Defn_Given -> Defn_Given
$cmin :: Defn_Given -> Defn_Given -> Defn_Given
min :: Defn_Given -> Defn_Given -> Defn_Given
Ord, ReadPrec [Defn_Given]
ReadPrec Defn_Given
Int -> ReadS Defn_Given
ReadS [Defn_Given]
(Int -> ReadS Defn_Given)
-> ReadS [Defn_Given]
-> ReadPrec Defn_Given
-> ReadPrec [Defn_Given]
-> Read Defn_Given
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Defn_Given
readsPrec :: Int -> ReadS Defn_Given
$creadList :: ReadS [Defn_Given]
readList :: ReadS [Defn_Given]
$creadPrec :: ReadPrec Defn_Given
readPrec :: ReadPrec Defn_Given
$creadListPrec :: ReadPrec [Defn_Given]
readListPrec :: ReadPrec [Defn_Given]
Read, Int -> Defn_Given -> String -> String
[Defn_Given] -> String -> String
Defn_Given -> String
(Int -> Defn_Given -> String -> String)
-> (Defn_Given -> String)
-> ([Defn_Given] -> String -> String)
-> Show Defn_Given
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Defn_Given -> String -> String
showsPrec :: Int -> Defn_Given -> String -> String
$cshow :: Defn_Given -> String
show :: Defn_Given -> String
$cshowList :: [Defn_Given] -> String -> String
showList :: [Defn_Given] -> String -> String
Show)

_Defn_Given :: Name
_Defn_Given = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Defn.Given")

_Defn_Given_mods :: Name
_Defn_Given_mods = (String -> Name
Core.Name String
"mods")

_Defn_Given_name :: Name
_Defn_Given_name = (String -> Name
Core.Name String
"name")

_Defn_Given_tparams :: Name
_Defn_Given_tparams = (String -> Name
Core.Name String
"tparams")

_Defn_Given_sparams :: Name
_Defn_Given_sparams = (String -> Name
Core.Name String
"sparams")

_Defn_Given_templ :: Name
_Defn_Given_templ = (String -> Name
Core.Name String
"templ")

data Defn_Enum = 
  Defn_Enum {
    Defn_Enum -> [Mod]
defn_EnumMods :: [Mod],
    Defn_Enum -> Type_Name
defn_EnumName :: Type_Name,
    Defn_Enum -> [Type_Param]
defn_EnumTparams :: [Type_Param],
    Defn_Enum -> Ctor_Primary
defn_EnumCtor :: Ctor_Primary,
    Defn_Enum -> Template
defn_EnumTemplate :: Template}
  deriving (Defn_Enum -> Defn_Enum -> Bool
(Defn_Enum -> Defn_Enum -> Bool)
-> (Defn_Enum -> Defn_Enum -> Bool) -> Eq Defn_Enum
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Defn_Enum -> Defn_Enum -> Bool
== :: Defn_Enum -> Defn_Enum -> Bool
$c/= :: Defn_Enum -> Defn_Enum -> Bool
/= :: Defn_Enum -> Defn_Enum -> Bool
Eq, Eq Defn_Enum
Eq Defn_Enum =>
(Defn_Enum -> Defn_Enum -> Ordering)
-> (Defn_Enum -> Defn_Enum -> Bool)
-> (Defn_Enum -> Defn_Enum -> Bool)
-> (Defn_Enum -> Defn_Enum -> Bool)
-> (Defn_Enum -> Defn_Enum -> Bool)
-> (Defn_Enum -> Defn_Enum -> Defn_Enum)
-> (Defn_Enum -> Defn_Enum -> Defn_Enum)
-> Ord Defn_Enum
Defn_Enum -> Defn_Enum -> Bool
Defn_Enum -> Defn_Enum -> Ordering
Defn_Enum -> Defn_Enum -> Defn_Enum
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Defn_Enum -> Defn_Enum -> Ordering
compare :: Defn_Enum -> Defn_Enum -> Ordering
$c< :: Defn_Enum -> Defn_Enum -> Bool
< :: Defn_Enum -> Defn_Enum -> Bool
$c<= :: Defn_Enum -> Defn_Enum -> Bool
<= :: Defn_Enum -> Defn_Enum -> Bool
$c> :: Defn_Enum -> Defn_Enum -> Bool
> :: Defn_Enum -> Defn_Enum -> Bool
$c>= :: Defn_Enum -> Defn_Enum -> Bool
>= :: Defn_Enum -> Defn_Enum -> Bool
$cmax :: Defn_Enum -> Defn_Enum -> Defn_Enum
max :: Defn_Enum -> Defn_Enum -> Defn_Enum
$cmin :: Defn_Enum -> Defn_Enum -> Defn_Enum
min :: Defn_Enum -> Defn_Enum -> Defn_Enum
Ord, ReadPrec [Defn_Enum]
ReadPrec Defn_Enum
Int -> ReadS Defn_Enum
ReadS [Defn_Enum]
(Int -> ReadS Defn_Enum)
-> ReadS [Defn_Enum]
-> ReadPrec Defn_Enum
-> ReadPrec [Defn_Enum]
-> Read Defn_Enum
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Defn_Enum
readsPrec :: Int -> ReadS Defn_Enum
$creadList :: ReadS [Defn_Enum]
readList :: ReadS [Defn_Enum]
$creadPrec :: ReadPrec Defn_Enum
readPrec :: ReadPrec Defn_Enum
$creadListPrec :: ReadPrec [Defn_Enum]
readListPrec :: ReadPrec [Defn_Enum]
Read, Int -> Defn_Enum -> String -> String
[Defn_Enum] -> String -> String
Defn_Enum -> String
(Int -> Defn_Enum -> String -> String)
-> (Defn_Enum -> String)
-> ([Defn_Enum] -> String -> String)
-> Show Defn_Enum
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Defn_Enum -> String -> String
showsPrec :: Int -> Defn_Enum -> String -> String
$cshow :: Defn_Enum -> String
show :: Defn_Enum -> String
$cshowList :: [Defn_Enum] -> String -> String
showList :: [Defn_Enum] -> String -> String
Show)

_Defn_Enum :: Name
_Defn_Enum = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Defn.Enum")

_Defn_Enum_mods :: Name
_Defn_Enum_mods = (String -> Name
Core.Name String
"mods")

_Defn_Enum_name :: Name
_Defn_Enum_name = (String -> Name
Core.Name String
"name")

_Defn_Enum_tparams :: Name
_Defn_Enum_tparams = (String -> Name
Core.Name String
"tparams")

_Defn_Enum_ctor :: Name
_Defn_Enum_ctor = (String -> Name
Core.Name String
"ctor")

_Defn_Enum_template :: Name
_Defn_Enum_template = (String -> Name
Core.Name String
"template")

data Defn_EnumCase = 
  Defn_EnumCase {
    Defn_EnumCase -> [Mod]
defn_EnumCaseMods :: [Mod],
    Defn_EnumCase -> Data_Name
defn_EnumCaseName :: Data_Name,
    Defn_EnumCase -> [Type_Param]
defn_EnumCaseTparams :: [Type_Param],
    Defn_EnumCase -> Ctor_Primary
defn_EnumCaseCtor :: Ctor_Primary,
    Defn_EnumCase -> [Init]
defn_EnumCaseInits :: [Init]}
  deriving (Defn_EnumCase -> Defn_EnumCase -> Bool
(Defn_EnumCase -> Defn_EnumCase -> Bool)
-> (Defn_EnumCase -> Defn_EnumCase -> Bool) -> Eq Defn_EnumCase
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Defn_EnumCase -> Defn_EnumCase -> Bool
== :: Defn_EnumCase -> Defn_EnumCase -> Bool
$c/= :: Defn_EnumCase -> Defn_EnumCase -> Bool
/= :: Defn_EnumCase -> Defn_EnumCase -> Bool
Eq, Eq Defn_EnumCase
Eq Defn_EnumCase =>
(Defn_EnumCase -> Defn_EnumCase -> Ordering)
-> (Defn_EnumCase -> Defn_EnumCase -> Bool)
-> (Defn_EnumCase -> Defn_EnumCase -> Bool)
-> (Defn_EnumCase -> Defn_EnumCase -> Bool)
-> (Defn_EnumCase -> Defn_EnumCase -> Bool)
-> (Defn_EnumCase -> Defn_EnumCase -> Defn_EnumCase)
-> (Defn_EnumCase -> Defn_EnumCase -> Defn_EnumCase)
-> Ord Defn_EnumCase
Defn_EnumCase -> Defn_EnumCase -> Bool
Defn_EnumCase -> Defn_EnumCase -> Ordering
Defn_EnumCase -> Defn_EnumCase -> Defn_EnumCase
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Defn_EnumCase -> Defn_EnumCase -> Ordering
compare :: Defn_EnumCase -> Defn_EnumCase -> Ordering
$c< :: Defn_EnumCase -> Defn_EnumCase -> Bool
< :: Defn_EnumCase -> Defn_EnumCase -> Bool
$c<= :: Defn_EnumCase -> Defn_EnumCase -> Bool
<= :: Defn_EnumCase -> Defn_EnumCase -> Bool
$c> :: Defn_EnumCase -> Defn_EnumCase -> Bool
> :: Defn_EnumCase -> Defn_EnumCase -> Bool
$c>= :: Defn_EnumCase -> Defn_EnumCase -> Bool
>= :: Defn_EnumCase -> Defn_EnumCase -> Bool
$cmax :: Defn_EnumCase -> Defn_EnumCase -> Defn_EnumCase
max :: Defn_EnumCase -> Defn_EnumCase -> Defn_EnumCase
$cmin :: Defn_EnumCase -> Defn_EnumCase -> Defn_EnumCase
min :: Defn_EnumCase -> Defn_EnumCase -> Defn_EnumCase
Ord, ReadPrec [Defn_EnumCase]
ReadPrec Defn_EnumCase
Int -> ReadS Defn_EnumCase
ReadS [Defn_EnumCase]
(Int -> ReadS Defn_EnumCase)
-> ReadS [Defn_EnumCase]
-> ReadPrec Defn_EnumCase
-> ReadPrec [Defn_EnumCase]
-> Read Defn_EnumCase
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Defn_EnumCase
readsPrec :: Int -> ReadS Defn_EnumCase
$creadList :: ReadS [Defn_EnumCase]
readList :: ReadS [Defn_EnumCase]
$creadPrec :: ReadPrec Defn_EnumCase
readPrec :: ReadPrec Defn_EnumCase
$creadListPrec :: ReadPrec [Defn_EnumCase]
readListPrec :: ReadPrec [Defn_EnumCase]
Read, Int -> Defn_EnumCase -> String -> String
[Defn_EnumCase] -> String -> String
Defn_EnumCase -> String
(Int -> Defn_EnumCase -> String -> String)
-> (Defn_EnumCase -> String)
-> ([Defn_EnumCase] -> String -> String)
-> Show Defn_EnumCase
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Defn_EnumCase -> String -> String
showsPrec :: Int -> Defn_EnumCase -> String -> String
$cshow :: Defn_EnumCase -> String
show :: Defn_EnumCase -> String
$cshowList :: [Defn_EnumCase] -> String -> String
showList :: [Defn_EnumCase] -> String -> String
Show)

_Defn_EnumCase :: Name
_Defn_EnumCase = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Defn.EnumCase")

_Defn_EnumCase_mods :: Name
_Defn_EnumCase_mods = (String -> Name
Core.Name String
"mods")

_Defn_EnumCase_name :: Name
_Defn_EnumCase_name = (String -> Name
Core.Name String
"name")

_Defn_EnumCase_tparams :: Name
_Defn_EnumCase_tparams = (String -> Name
Core.Name String
"tparams")

_Defn_EnumCase_ctor :: Name
_Defn_EnumCase_ctor = (String -> Name
Core.Name String
"ctor")

_Defn_EnumCase_inits :: Name
_Defn_EnumCase_inits = (String -> Name
Core.Name String
"inits")

data Defn_RepeatedEnumCase = 
  Defn_RepeatedEnumCase {
    Defn_RepeatedEnumCase -> [Mod]
defn_RepeatedEnumCaseMods :: [Mod],
    Defn_RepeatedEnumCase -> [Data_Name]
defn_RepeatedEnumCaseCases :: [Data_Name]}
  deriving (Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Bool
(Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Bool)
-> (Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Bool)
-> Eq Defn_RepeatedEnumCase
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Bool
== :: Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Bool
$c/= :: Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Bool
/= :: Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Bool
Eq, Eq Defn_RepeatedEnumCase
Eq Defn_RepeatedEnumCase =>
(Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Ordering)
-> (Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Bool)
-> (Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Bool)
-> (Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Bool)
-> (Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Bool)
-> (Defn_RepeatedEnumCase
    -> Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase)
-> (Defn_RepeatedEnumCase
    -> Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase)
-> Ord Defn_RepeatedEnumCase
Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Bool
Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Ordering
Defn_RepeatedEnumCase
-> Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Ordering
compare :: Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Ordering
$c< :: Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Bool
< :: Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Bool
$c<= :: Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Bool
<= :: Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Bool
$c> :: Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Bool
> :: Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Bool
$c>= :: Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Bool
>= :: Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase -> Bool
$cmax :: Defn_RepeatedEnumCase
-> Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase
max :: Defn_RepeatedEnumCase
-> Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase
$cmin :: Defn_RepeatedEnumCase
-> Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase
min :: Defn_RepeatedEnumCase
-> Defn_RepeatedEnumCase -> Defn_RepeatedEnumCase
Ord, ReadPrec [Defn_RepeatedEnumCase]
ReadPrec Defn_RepeatedEnumCase
Int -> ReadS Defn_RepeatedEnumCase
ReadS [Defn_RepeatedEnumCase]
(Int -> ReadS Defn_RepeatedEnumCase)
-> ReadS [Defn_RepeatedEnumCase]
-> ReadPrec Defn_RepeatedEnumCase
-> ReadPrec [Defn_RepeatedEnumCase]
-> Read Defn_RepeatedEnumCase
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Defn_RepeatedEnumCase
readsPrec :: Int -> ReadS Defn_RepeatedEnumCase
$creadList :: ReadS [Defn_RepeatedEnumCase]
readList :: ReadS [Defn_RepeatedEnumCase]
$creadPrec :: ReadPrec Defn_RepeatedEnumCase
readPrec :: ReadPrec Defn_RepeatedEnumCase
$creadListPrec :: ReadPrec [Defn_RepeatedEnumCase]
readListPrec :: ReadPrec [Defn_RepeatedEnumCase]
Read, Int -> Defn_RepeatedEnumCase -> String -> String
[Defn_RepeatedEnumCase] -> String -> String
Defn_RepeatedEnumCase -> String
(Int -> Defn_RepeatedEnumCase -> String -> String)
-> (Defn_RepeatedEnumCase -> String)
-> ([Defn_RepeatedEnumCase] -> String -> String)
-> Show Defn_RepeatedEnumCase
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Defn_RepeatedEnumCase -> String -> String
showsPrec :: Int -> Defn_RepeatedEnumCase -> String -> String
$cshow :: Defn_RepeatedEnumCase -> String
show :: Defn_RepeatedEnumCase -> String
$cshowList :: [Defn_RepeatedEnumCase] -> String -> String
showList :: [Defn_RepeatedEnumCase] -> String -> String
Show)

_Defn_RepeatedEnumCase :: Name
_Defn_RepeatedEnumCase = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Defn.RepeatedEnumCase")

_Defn_RepeatedEnumCase_mods :: Name
_Defn_RepeatedEnumCase_mods = (String -> Name
Core.Name String
"mods")

_Defn_RepeatedEnumCase_cases :: Name
_Defn_RepeatedEnumCase_cases = (String -> Name
Core.Name String
"cases")

data Defn_GivenAlias = 
  Defn_GivenAlias {
    Defn_GivenAlias -> [Mod]
defn_GivenAliasMods :: [Mod],
    Defn_GivenAlias -> Name
defn_GivenAliasName :: Name,
    Defn_GivenAlias -> [[Type_Param]]
defn_GivenAliasTparams :: [[Type_Param]],
    Defn_GivenAlias -> [[Data_Param]]
defn_GivenAliasSparams :: [[Data_Param]],
    Defn_GivenAlias -> Type
defn_GivenAliasDecltpe :: Type,
    Defn_GivenAlias -> Data
defn_GivenAliasBody :: Data}
  deriving (Defn_GivenAlias -> Defn_GivenAlias -> Bool
(Defn_GivenAlias -> Defn_GivenAlias -> Bool)
-> (Defn_GivenAlias -> Defn_GivenAlias -> Bool)
-> Eq Defn_GivenAlias
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Defn_GivenAlias -> Defn_GivenAlias -> Bool
== :: Defn_GivenAlias -> Defn_GivenAlias -> Bool
$c/= :: Defn_GivenAlias -> Defn_GivenAlias -> Bool
/= :: Defn_GivenAlias -> Defn_GivenAlias -> Bool
Eq, Eq Defn_GivenAlias
Eq Defn_GivenAlias =>
(Defn_GivenAlias -> Defn_GivenAlias -> Ordering)
-> (Defn_GivenAlias -> Defn_GivenAlias -> Bool)
-> (Defn_GivenAlias -> Defn_GivenAlias -> Bool)
-> (Defn_GivenAlias -> Defn_GivenAlias -> Bool)
-> (Defn_GivenAlias -> Defn_GivenAlias -> Bool)
-> (Defn_GivenAlias -> Defn_GivenAlias -> Defn_GivenAlias)
-> (Defn_GivenAlias -> Defn_GivenAlias -> Defn_GivenAlias)
-> Ord Defn_GivenAlias
Defn_GivenAlias -> Defn_GivenAlias -> Bool
Defn_GivenAlias -> Defn_GivenAlias -> Ordering
Defn_GivenAlias -> Defn_GivenAlias -> Defn_GivenAlias
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Defn_GivenAlias -> Defn_GivenAlias -> Ordering
compare :: Defn_GivenAlias -> Defn_GivenAlias -> Ordering
$c< :: Defn_GivenAlias -> Defn_GivenAlias -> Bool
< :: Defn_GivenAlias -> Defn_GivenAlias -> Bool
$c<= :: Defn_GivenAlias -> Defn_GivenAlias -> Bool
<= :: Defn_GivenAlias -> Defn_GivenAlias -> Bool
$c> :: Defn_GivenAlias -> Defn_GivenAlias -> Bool
> :: Defn_GivenAlias -> Defn_GivenAlias -> Bool
$c>= :: Defn_GivenAlias -> Defn_GivenAlias -> Bool
>= :: Defn_GivenAlias -> Defn_GivenAlias -> Bool
$cmax :: Defn_GivenAlias -> Defn_GivenAlias -> Defn_GivenAlias
max :: Defn_GivenAlias -> Defn_GivenAlias -> Defn_GivenAlias
$cmin :: Defn_GivenAlias -> Defn_GivenAlias -> Defn_GivenAlias
min :: Defn_GivenAlias -> Defn_GivenAlias -> Defn_GivenAlias
Ord, ReadPrec [Defn_GivenAlias]
ReadPrec Defn_GivenAlias
Int -> ReadS Defn_GivenAlias
ReadS [Defn_GivenAlias]
(Int -> ReadS Defn_GivenAlias)
-> ReadS [Defn_GivenAlias]
-> ReadPrec Defn_GivenAlias
-> ReadPrec [Defn_GivenAlias]
-> Read Defn_GivenAlias
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Defn_GivenAlias
readsPrec :: Int -> ReadS Defn_GivenAlias
$creadList :: ReadS [Defn_GivenAlias]
readList :: ReadS [Defn_GivenAlias]
$creadPrec :: ReadPrec Defn_GivenAlias
readPrec :: ReadPrec Defn_GivenAlias
$creadListPrec :: ReadPrec [Defn_GivenAlias]
readListPrec :: ReadPrec [Defn_GivenAlias]
Read, Int -> Defn_GivenAlias -> String -> String
[Defn_GivenAlias] -> String -> String
Defn_GivenAlias -> String
(Int -> Defn_GivenAlias -> String -> String)
-> (Defn_GivenAlias -> String)
-> ([Defn_GivenAlias] -> String -> String)
-> Show Defn_GivenAlias
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Defn_GivenAlias -> String -> String
showsPrec :: Int -> Defn_GivenAlias -> String -> String
$cshow :: Defn_GivenAlias -> String
show :: Defn_GivenAlias -> String
$cshowList :: [Defn_GivenAlias] -> String -> String
showList :: [Defn_GivenAlias] -> String -> String
Show)

_Defn_GivenAlias :: Name
_Defn_GivenAlias = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Defn.GivenAlias")

_Defn_GivenAlias_mods :: Name
_Defn_GivenAlias_mods = (String -> Name
Core.Name String
"mods")

_Defn_GivenAlias_name :: Name
_Defn_GivenAlias_name = (String -> Name
Core.Name String
"name")

_Defn_GivenAlias_tparams :: Name
_Defn_GivenAlias_tparams = (String -> Name
Core.Name String
"tparams")

_Defn_GivenAlias_sparams :: Name
_Defn_GivenAlias_sparams = (String -> Name
Core.Name String
"sparams")

_Defn_GivenAlias_decltpe :: Name
_Defn_GivenAlias_decltpe = (String -> Name
Core.Name String
"decltpe")

_Defn_GivenAlias_body :: Name
_Defn_GivenAlias_body = (String -> Name
Core.Name String
"body")

data Defn_ExtensionGroup = 
  Defn_ExtensionGroup {
    Defn_ExtensionGroup -> [Type_Param]
defn_ExtensionGroupTparams :: [Type_Param],
    Defn_ExtensionGroup -> [[Data_Param]]
defn_ExtensionGroupParmss :: [[Data_Param]],
    Defn_ExtensionGroup -> Stat
defn_ExtensionGroupBody :: Stat}
  deriving (Defn_ExtensionGroup -> Defn_ExtensionGroup -> Bool
(Defn_ExtensionGroup -> Defn_ExtensionGroup -> Bool)
-> (Defn_ExtensionGroup -> Defn_ExtensionGroup -> Bool)
-> Eq Defn_ExtensionGroup
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Defn_ExtensionGroup -> Defn_ExtensionGroup -> Bool
== :: Defn_ExtensionGroup -> Defn_ExtensionGroup -> Bool
$c/= :: Defn_ExtensionGroup -> Defn_ExtensionGroup -> Bool
/= :: Defn_ExtensionGroup -> Defn_ExtensionGroup -> Bool
Eq, Eq Defn_ExtensionGroup
Eq Defn_ExtensionGroup =>
(Defn_ExtensionGroup -> Defn_ExtensionGroup -> Ordering)
-> (Defn_ExtensionGroup -> Defn_ExtensionGroup -> Bool)
-> (Defn_ExtensionGroup -> Defn_ExtensionGroup -> Bool)
-> (Defn_ExtensionGroup -> Defn_ExtensionGroup -> Bool)
-> (Defn_ExtensionGroup -> Defn_ExtensionGroup -> Bool)
-> (Defn_ExtensionGroup
    -> Defn_ExtensionGroup -> Defn_ExtensionGroup)
-> (Defn_ExtensionGroup
    -> Defn_ExtensionGroup -> Defn_ExtensionGroup)
-> Ord Defn_ExtensionGroup
Defn_ExtensionGroup -> Defn_ExtensionGroup -> Bool
Defn_ExtensionGroup -> Defn_ExtensionGroup -> Ordering
Defn_ExtensionGroup -> Defn_ExtensionGroup -> Defn_ExtensionGroup
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Defn_ExtensionGroup -> Defn_ExtensionGroup -> Ordering
compare :: Defn_ExtensionGroup -> Defn_ExtensionGroup -> Ordering
$c< :: Defn_ExtensionGroup -> Defn_ExtensionGroup -> Bool
< :: Defn_ExtensionGroup -> Defn_ExtensionGroup -> Bool
$c<= :: Defn_ExtensionGroup -> Defn_ExtensionGroup -> Bool
<= :: Defn_ExtensionGroup -> Defn_ExtensionGroup -> Bool
$c> :: Defn_ExtensionGroup -> Defn_ExtensionGroup -> Bool
> :: Defn_ExtensionGroup -> Defn_ExtensionGroup -> Bool
$c>= :: Defn_ExtensionGroup -> Defn_ExtensionGroup -> Bool
>= :: Defn_ExtensionGroup -> Defn_ExtensionGroup -> Bool
$cmax :: Defn_ExtensionGroup -> Defn_ExtensionGroup -> Defn_ExtensionGroup
max :: Defn_ExtensionGroup -> Defn_ExtensionGroup -> Defn_ExtensionGroup
$cmin :: Defn_ExtensionGroup -> Defn_ExtensionGroup -> Defn_ExtensionGroup
min :: Defn_ExtensionGroup -> Defn_ExtensionGroup -> Defn_ExtensionGroup
Ord, ReadPrec [Defn_ExtensionGroup]
ReadPrec Defn_ExtensionGroup
Int -> ReadS Defn_ExtensionGroup
ReadS [Defn_ExtensionGroup]
(Int -> ReadS Defn_ExtensionGroup)
-> ReadS [Defn_ExtensionGroup]
-> ReadPrec Defn_ExtensionGroup
-> ReadPrec [Defn_ExtensionGroup]
-> Read Defn_ExtensionGroup
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Defn_ExtensionGroup
readsPrec :: Int -> ReadS Defn_ExtensionGroup
$creadList :: ReadS [Defn_ExtensionGroup]
readList :: ReadS [Defn_ExtensionGroup]
$creadPrec :: ReadPrec Defn_ExtensionGroup
readPrec :: ReadPrec Defn_ExtensionGroup
$creadListPrec :: ReadPrec [Defn_ExtensionGroup]
readListPrec :: ReadPrec [Defn_ExtensionGroup]
Read, Int -> Defn_ExtensionGroup -> String -> String
[Defn_ExtensionGroup] -> String -> String
Defn_ExtensionGroup -> String
(Int -> Defn_ExtensionGroup -> String -> String)
-> (Defn_ExtensionGroup -> String)
-> ([Defn_ExtensionGroup] -> String -> String)
-> Show Defn_ExtensionGroup
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Defn_ExtensionGroup -> String -> String
showsPrec :: Int -> Defn_ExtensionGroup -> String -> String
$cshow :: Defn_ExtensionGroup -> String
show :: Defn_ExtensionGroup -> String
$cshowList :: [Defn_ExtensionGroup] -> String -> String
showList :: [Defn_ExtensionGroup] -> String -> String
Show)

_Defn_ExtensionGroup :: Name
_Defn_ExtensionGroup = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Defn.ExtensionGroup")

_Defn_ExtensionGroup_tparams :: Name
_Defn_ExtensionGroup_tparams = (String -> Name
Core.Name String
"tparams")

_Defn_ExtensionGroup_parmss :: Name
_Defn_ExtensionGroup_parmss = (String -> Name
Core.Name String
"parmss")

_Defn_ExtensionGroup_body :: Name
_Defn_ExtensionGroup_body = (String -> Name
Core.Name String
"body")

data Defn_Def = 
  Defn_Def {
    Defn_Def -> [Mod]
defn_DefMods :: [Mod],
    Defn_Def -> Data_Name
defn_DefName :: Data_Name,
    Defn_Def -> [Type_Param]
defn_DefTparams :: [Type_Param],
    Defn_Def -> [[Data_Param]]
defn_DefParamss :: [[Data_Param]],
    Defn_Def -> Maybe Type
defn_DefDecltpe :: (Maybe Type),
    Defn_Def -> Data
defn_DefBody :: Data}
  deriving (Defn_Def -> Defn_Def -> Bool
(Defn_Def -> Defn_Def -> Bool)
-> (Defn_Def -> Defn_Def -> Bool) -> Eq Defn_Def
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Defn_Def -> Defn_Def -> Bool
== :: Defn_Def -> Defn_Def -> Bool
$c/= :: Defn_Def -> Defn_Def -> Bool
/= :: Defn_Def -> Defn_Def -> Bool
Eq, Eq Defn_Def
Eq Defn_Def =>
(Defn_Def -> Defn_Def -> Ordering)
-> (Defn_Def -> Defn_Def -> Bool)
-> (Defn_Def -> Defn_Def -> Bool)
-> (Defn_Def -> Defn_Def -> Bool)
-> (Defn_Def -> Defn_Def -> Bool)
-> (Defn_Def -> Defn_Def -> Defn_Def)
-> (Defn_Def -> Defn_Def -> Defn_Def)
-> Ord Defn_Def
Defn_Def -> Defn_Def -> Bool
Defn_Def -> Defn_Def -> Ordering
Defn_Def -> Defn_Def -> Defn_Def
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Defn_Def -> Defn_Def -> Ordering
compare :: Defn_Def -> Defn_Def -> Ordering
$c< :: Defn_Def -> Defn_Def -> Bool
< :: Defn_Def -> Defn_Def -> Bool
$c<= :: Defn_Def -> Defn_Def -> Bool
<= :: Defn_Def -> Defn_Def -> Bool
$c> :: Defn_Def -> Defn_Def -> Bool
> :: Defn_Def -> Defn_Def -> Bool
$c>= :: Defn_Def -> Defn_Def -> Bool
>= :: Defn_Def -> Defn_Def -> Bool
$cmax :: Defn_Def -> Defn_Def -> Defn_Def
max :: Defn_Def -> Defn_Def -> Defn_Def
$cmin :: Defn_Def -> Defn_Def -> Defn_Def
min :: Defn_Def -> Defn_Def -> Defn_Def
Ord, ReadPrec [Defn_Def]
ReadPrec Defn_Def
Int -> ReadS Defn_Def
ReadS [Defn_Def]
(Int -> ReadS Defn_Def)
-> ReadS [Defn_Def]
-> ReadPrec Defn_Def
-> ReadPrec [Defn_Def]
-> Read Defn_Def
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Defn_Def
readsPrec :: Int -> ReadS Defn_Def
$creadList :: ReadS [Defn_Def]
readList :: ReadS [Defn_Def]
$creadPrec :: ReadPrec Defn_Def
readPrec :: ReadPrec Defn_Def
$creadListPrec :: ReadPrec [Defn_Def]
readListPrec :: ReadPrec [Defn_Def]
Read, Int -> Defn_Def -> String -> String
[Defn_Def] -> String -> String
Defn_Def -> String
(Int -> Defn_Def -> String -> String)
-> (Defn_Def -> String)
-> ([Defn_Def] -> String -> String)
-> Show Defn_Def
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Defn_Def -> String -> String
showsPrec :: Int -> Defn_Def -> String -> String
$cshow :: Defn_Def -> String
show :: Defn_Def -> String
$cshowList :: [Defn_Def] -> String -> String
showList :: [Defn_Def] -> String -> String
Show)

_Defn_Def :: Name
_Defn_Def = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Defn.Def")

_Defn_Def_mods :: Name
_Defn_Def_mods = (String -> Name
Core.Name String
"mods")

_Defn_Def_name :: Name
_Defn_Def_name = (String -> Name
Core.Name String
"name")

_Defn_Def_tparams :: Name
_Defn_Def_tparams = (String -> Name
Core.Name String
"tparams")

_Defn_Def_paramss :: Name
_Defn_Def_paramss = (String -> Name
Core.Name String
"paramss")

_Defn_Def_decltpe :: Name
_Defn_Def_decltpe = (String -> Name
Core.Name String
"decltpe")

_Defn_Def_body :: Name
_Defn_Def_body = (String -> Name
Core.Name String
"body")

data Defn_Macro = 
  Defn_Macro {
    Defn_Macro -> [Mod]
defn_MacroMods :: [Mod],
    Defn_Macro -> Data_Name
defn_MacroName :: Data_Name,
    Defn_Macro -> [Type_Param]
defn_MacroTparams :: [Type_Param],
    Defn_Macro -> [[Data_Param]]
defn_MacroParamss :: [[Data_Param]],
    Defn_Macro -> Maybe Type
defn_MacroDecltpe :: (Maybe Type),
    Defn_Macro -> Data
defn_MacroBody :: Data}
  deriving (Defn_Macro -> Defn_Macro -> Bool
(Defn_Macro -> Defn_Macro -> Bool)
-> (Defn_Macro -> Defn_Macro -> Bool) -> Eq Defn_Macro
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Defn_Macro -> Defn_Macro -> Bool
== :: Defn_Macro -> Defn_Macro -> Bool
$c/= :: Defn_Macro -> Defn_Macro -> Bool
/= :: Defn_Macro -> Defn_Macro -> Bool
Eq, Eq Defn_Macro
Eq Defn_Macro =>
(Defn_Macro -> Defn_Macro -> Ordering)
-> (Defn_Macro -> Defn_Macro -> Bool)
-> (Defn_Macro -> Defn_Macro -> Bool)
-> (Defn_Macro -> Defn_Macro -> Bool)
-> (Defn_Macro -> Defn_Macro -> Bool)
-> (Defn_Macro -> Defn_Macro -> Defn_Macro)
-> (Defn_Macro -> Defn_Macro -> Defn_Macro)
-> Ord Defn_Macro
Defn_Macro -> Defn_Macro -> Bool
Defn_Macro -> Defn_Macro -> Ordering
Defn_Macro -> Defn_Macro -> Defn_Macro
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Defn_Macro -> Defn_Macro -> Ordering
compare :: Defn_Macro -> Defn_Macro -> Ordering
$c< :: Defn_Macro -> Defn_Macro -> Bool
< :: Defn_Macro -> Defn_Macro -> Bool
$c<= :: Defn_Macro -> Defn_Macro -> Bool
<= :: Defn_Macro -> Defn_Macro -> Bool
$c> :: Defn_Macro -> Defn_Macro -> Bool
> :: Defn_Macro -> Defn_Macro -> Bool
$c>= :: Defn_Macro -> Defn_Macro -> Bool
>= :: Defn_Macro -> Defn_Macro -> Bool
$cmax :: Defn_Macro -> Defn_Macro -> Defn_Macro
max :: Defn_Macro -> Defn_Macro -> Defn_Macro
$cmin :: Defn_Macro -> Defn_Macro -> Defn_Macro
min :: Defn_Macro -> Defn_Macro -> Defn_Macro
Ord, ReadPrec [Defn_Macro]
ReadPrec Defn_Macro
Int -> ReadS Defn_Macro
ReadS [Defn_Macro]
(Int -> ReadS Defn_Macro)
-> ReadS [Defn_Macro]
-> ReadPrec Defn_Macro
-> ReadPrec [Defn_Macro]
-> Read Defn_Macro
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Defn_Macro
readsPrec :: Int -> ReadS Defn_Macro
$creadList :: ReadS [Defn_Macro]
readList :: ReadS [Defn_Macro]
$creadPrec :: ReadPrec Defn_Macro
readPrec :: ReadPrec Defn_Macro
$creadListPrec :: ReadPrec [Defn_Macro]
readListPrec :: ReadPrec [Defn_Macro]
Read, Int -> Defn_Macro -> String -> String
[Defn_Macro] -> String -> String
Defn_Macro -> String
(Int -> Defn_Macro -> String -> String)
-> (Defn_Macro -> String)
-> ([Defn_Macro] -> String -> String)
-> Show Defn_Macro
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Defn_Macro -> String -> String
showsPrec :: Int -> Defn_Macro -> String -> String
$cshow :: Defn_Macro -> String
show :: Defn_Macro -> String
$cshowList :: [Defn_Macro] -> String -> String
showList :: [Defn_Macro] -> String -> String
Show)

_Defn_Macro :: Name
_Defn_Macro = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Defn.Macro")

_Defn_Macro_mods :: Name
_Defn_Macro_mods = (String -> Name
Core.Name String
"mods")

_Defn_Macro_name :: Name
_Defn_Macro_name = (String -> Name
Core.Name String
"name")

_Defn_Macro_tparams :: Name
_Defn_Macro_tparams = (String -> Name
Core.Name String
"tparams")

_Defn_Macro_paramss :: Name
_Defn_Macro_paramss = (String -> Name
Core.Name String
"paramss")

_Defn_Macro_decltpe :: Name
_Defn_Macro_decltpe = (String -> Name
Core.Name String
"decltpe")

_Defn_Macro_body :: Name
_Defn_Macro_body = (String -> Name
Core.Name String
"body")

data Defn_Type = 
  Defn_Type {
    Defn_Type -> [Mod]
defn_TypeMods :: [Mod],
    Defn_Type -> Type_Name
defn_TypeName :: Type_Name,
    Defn_Type -> [Type_Param]
defn_TypeTparams :: [Type_Param],
    Defn_Type -> Type
defn_TypeBody :: Type}
  deriving (Defn_Type -> Defn_Type -> Bool
(Defn_Type -> Defn_Type -> Bool)
-> (Defn_Type -> Defn_Type -> Bool) -> Eq Defn_Type
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Defn_Type -> Defn_Type -> Bool
== :: Defn_Type -> Defn_Type -> Bool
$c/= :: Defn_Type -> Defn_Type -> Bool
/= :: Defn_Type -> Defn_Type -> Bool
Eq, Eq Defn_Type
Eq Defn_Type =>
(Defn_Type -> Defn_Type -> Ordering)
-> (Defn_Type -> Defn_Type -> Bool)
-> (Defn_Type -> Defn_Type -> Bool)
-> (Defn_Type -> Defn_Type -> Bool)
-> (Defn_Type -> Defn_Type -> Bool)
-> (Defn_Type -> Defn_Type -> Defn_Type)
-> (Defn_Type -> Defn_Type -> Defn_Type)
-> Ord Defn_Type
Defn_Type -> Defn_Type -> Bool
Defn_Type -> Defn_Type -> Ordering
Defn_Type -> Defn_Type -> Defn_Type
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Defn_Type -> Defn_Type -> Ordering
compare :: Defn_Type -> Defn_Type -> Ordering
$c< :: Defn_Type -> Defn_Type -> Bool
< :: Defn_Type -> Defn_Type -> Bool
$c<= :: Defn_Type -> Defn_Type -> Bool
<= :: Defn_Type -> Defn_Type -> Bool
$c> :: Defn_Type -> Defn_Type -> Bool
> :: Defn_Type -> Defn_Type -> Bool
$c>= :: Defn_Type -> Defn_Type -> Bool
>= :: Defn_Type -> Defn_Type -> Bool
$cmax :: Defn_Type -> Defn_Type -> Defn_Type
max :: Defn_Type -> Defn_Type -> Defn_Type
$cmin :: Defn_Type -> Defn_Type -> Defn_Type
min :: Defn_Type -> Defn_Type -> Defn_Type
Ord, ReadPrec [Defn_Type]
ReadPrec Defn_Type
Int -> ReadS Defn_Type
ReadS [Defn_Type]
(Int -> ReadS Defn_Type)
-> ReadS [Defn_Type]
-> ReadPrec Defn_Type
-> ReadPrec [Defn_Type]
-> Read Defn_Type
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Defn_Type
readsPrec :: Int -> ReadS Defn_Type
$creadList :: ReadS [Defn_Type]
readList :: ReadS [Defn_Type]
$creadPrec :: ReadPrec Defn_Type
readPrec :: ReadPrec Defn_Type
$creadListPrec :: ReadPrec [Defn_Type]
readListPrec :: ReadPrec [Defn_Type]
Read, Int -> Defn_Type -> String -> String
[Defn_Type] -> String -> String
Defn_Type -> String
(Int -> Defn_Type -> String -> String)
-> (Defn_Type -> String)
-> ([Defn_Type] -> String -> String)
-> Show Defn_Type
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Defn_Type -> String -> String
showsPrec :: Int -> Defn_Type -> String -> String
$cshow :: Defn_Type -> String
show :: Defn_Type -> String
$cshowList :: [Defn_Type] -> String -> String
showList :: [Defn_Type] -> String -> String
Show)

_Defn_Type :: Name
_Defn_Type = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Defn.Type")

_Defn_Type_mods :: Name
_Defn_Type_mods = (String -> Name
Core.Name String
"mods")

_Defn_Type_name :: Name
_Defn_Type_name = (String -> Name
Core.Name String
"name")

_Defn_Type_tparams :: Name
_Defn_Type_tparams = (String -> Name
Core.Name String
"tparams")

_Defn_Type_body :: Name
_Defn_Type_body = (String -> Name
Core.Name String
"body")

data Defn_Class = 
  Defn_Class {
    Defn_Class -> [Mod]
defn_ClassMods :: [Mod],
    Defn_Class -> Type_Name
defn_ClassName :: Type_Name,
    Defn_Class -> [Type_Param]
defn_ClassTparams :: [Type_Param],
    Defn_Class -> Ctor_Primary
defn_ClassCtor :: Ctor_Primary,
    Defn_Class -> Template
defn_ClassTemplate :: Template}
  deriving (Defn_Class -> Defn_Class -> Bool
(Defn_Class -> Defn_Class -> Bool)
-> (Defn_Class -> Defn_Class -> Bool) -> Eq Defn_Class
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Defn_Class -> Defn_Class -> Bool
== :: Defn_Class -> Defn_Class -> Bool
$c/= :: Defn_Class -> Defn_Class -> Bool
/= :: Defn_Class -> Defn_Class -> Bool
Eq, Eq Defn_Class
Eq Defn_Class =>
(Defn_Class -> Defn_Class -> Ordering)
-> (Defn_Class -> Defn_Class -> Bool)
-> (Defn_Class -> Defn_Class -> Bool)
-> (Defn_Class -> Defn_Class -> Bool)
-> (Defn_Class -> Defn_Class -> Bool)
-> (Defn_Class -> Defn_Class -> Defn_Class)
-> (Defn_Class -> Defn_Class -> Defn_Class)
-> Ord Defn_Class
Defn_Class -> Defn_Class -> Bool
Defn_Class -> Defn_Class -> Ordering
Defn_Class -> Defn_Class -> Defn_Class
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Defn_Class -> Defn_Class -> Ordering
compare :: Defn_Class -> Defn_Class -> Ordering
$c< :: Defn_Class -> Defn_Class -> Bool
< :: Defn_Class -> Defn_Class -> Bool
$c<= :: Defn_Class -> Defn_Class -> Bool
<= :: Defn_Class -> Defn_Class -> Bool
$c> :: Defn_Class -> Defn_Class -> Bool
> :: Defn_Class -> Defn_Class -> Bool
$c>= :: Defn_Class -> Defn_Class -> Bool
>= :: Defn_Class -> Defn_Class -> Bool
$cmax :: Defn_Class -> Defn_Class -> Defn_Class
max :: Defn_Class -> Defn_Class -> Defn_Class
$cmin :: Defn_Class -> Defn_Class -> Defn_Class
min :: Defn_Class -> Defn_Class -> Defn_Class
Ord, ReadPrec [Defn_Class]
ReadPrec Defn_Class
Int -> ReadS Defn_Class
ReadS [Defn_Class]
(Int -> ReadS Defn_Class)
-> ReadS [Defn_Class]
-> ReadPrec Defn_Class
-> ReadPrec [Defn_Class]
-> Read Defn_Class
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Defn_Class
readsPrec :: Int -> ReadS Defn_Class
$creadList :: ReadS [Defn_Class]
readList :: ReadS [Defn_Class]
$creadPrec :: ReadPrec Defn_Class
readPrec :: ReadPrec Defn_Class
$creadListPrec :: ReadPrec [Defn_Class]
readListPrec :: ReadPrec [Defn_Class]
Read, Int -> Defn_Class -> String -> String
[Defn_Class] -> String -> String
Defn_Class -> String
(Int -> Defn_Class -> String -> String)
-> (Defn_Class -> String)
-> ([Defn_Class] -> String -> String)
-> Show Defn_Class
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Defn_Class -> String -> String
showsPrec :: Int -> Defn_Class -> String -> String
$cshow :: Defn_Class -> String
show :: Defn_Class -> String
$cshowList :: [Defn_Class] -> String -> String
showList :: [Defn_Class] -> String -> String
Show)

_Defn_Class :: Name
_Defn_Class = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Defn.Class")

_Defn_Class_mods :: Name
_Defn_Class_mods = (String -> Name
Core.Name String
"mods")

_Defn_Class_name :: Name
_Defn_Class_name = (String -> Name
Core.Name String
"name")

_Defn_Class_tparams :: Name
_Defn_Class_tparams = (String -> Name
Core.Name String
"tparams")

_Defn_Class_ctor :: Name
_Defn_Class_ctor = (String -> Name
Core.Name String
"ctor")

_Defn_Class_template :: Name
_Defn_Class_template = (String -> Name
Core.Name String
"template")

data Defn_Trait = 
  Defn_Trait {
    Defn_Trait -> [Mod]
defn_TraitMods :: [Mod],
    Defn_Trait -> Type_Name
defn_TraitName :: Type_Name,
    Defn_Trait -> [Type_Param]
defn_TraitTparams :: [Type_Param],
    Defn_Trait -> Ctor_Primary
defn_TraitCtor :: Ctor_Primary,
    Defn_Trait -> Template
defn_TraitTemplate :: Template}
  deriving (Defn_Trait -> Defn_Trait -> Bool
(Defn_Trait -> Defn_Trait -> Bool)
-> (Defn_Trait -> Defn_Trait -> Bool) -> Eq Defn_Trait
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Defn_Trait -> Defn_Trait -> Bool
== :: Defn_Trait -> Defn_Trait -> Bool
$c/= :: Defn_Trait -> Defn_Trait -> Bool
/= :: Defn_Trait -> Defn_Trait -> Bool
Eq, Eq Defn_Trait
Eq Defn_Trait =>
(Defn_Trait -> Defn_Trait -> Ordering)
-> (Defn_Trait -> Defn_Trait -> Bool)
-> (Defn_Trait -> Defn_Trait -> Bool)
-> (Defn_Trait -> Defn_Trait -> Bool)
-> (Defn_Trait -> Defn_Trait -> Bool)
-> (Defn_Trait -> Defn_Trait -> Defn_Trait)
-> (Defn_Trait -> Defn_Trait -> Defn_Trait)
-> Ord Defn_Trait
Defn_Trait -> Defn_Trait -> Bool
Defn_Trait -> Defn_Trait -> Ordering
Defn_Trait -> Defn_Trait -> Defn_Trait
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Defn_Trait -> Defn_Trait -> Ordering
compare :: Defn_Trait -> Defn_Trait -> Ordering
$c< :: Defn_Trait -> Defn_Trait -> Bool
< :: Defn_Trait -> Defn_Trait -> Bool
$c<= :: Defn_Trait -> Defn_Trait -> Bool
<= :: Defn_Trait -> Defn_Trait -> Bool
$c> :: Defn_Trait -> Defn_Trait -> Bool
> :: Defn_Trait -> Defn_Trait -> Bool
$c>= :: Defn_Trait -> Defn_Trait -> Bool
>= :: Defn_Trait -> Defn_Trait -> Bool
$cmax :: Defn_Trait -> Defn_Trait -> Defn_Trait
max :: Defn_Trait -> Defn_Trait -> Defn_Trait
$cmin :: Defn_Trait -> Defn_Trait -> Defn_Trait
min :: Defn_Trait -> Defn_Trait -> Defn_Trait
Ord, ReadPrec [Defn_Trait]
ReadPrec Defn_Trait
Int -> ReadS Defn_Trait
ReadS [Defn_Trait]
(Int -> ReadS Defn_Trait)
-> ReadS [Defn_Trait]
-> ReadPrec Defn_Trait
-> ReadPrec [Defn_Trait]
-> Read Defn_Trait
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Defn_Trait
readsPrec :: Int -> ReadS Defn_Trait
$creadList :: ReadS [Defn_Trait]
readList :: ReadS [Defn_Trait]
$creadPrec :: ReadPrec Defn_Trait
readPrec :: ReadPrec Defn_Trait
$creadListPrec :: ReadPrec [Defn_Trait]
readListPrec :: ReadPrec [Defn_Trait]
Read, Int -> Defn_Trait -> String -> String
[Defn_Trait] -> String -> String
Defn_Trait -> String
(Int -> Defn_Trait -> String -> String)
-> (Defn_Trait -> String)
-> ([Defn_Trait] -> String -> String)
-> Show Defn_Trait
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Defn_Trait -> String -> String
showsPrec :: Int -> Defn_Trait -> String -> String
$cshow :: Defn_Trait -> String
show :: Defn_Trait -> String
$cshowList :: [Defn_Trait] -> String -> String
showList :: [Defn_Trait] -> String -> String
Show)

_Defn_Trait :: Name
_Defn_Trait = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Defn.Trait")

_Defn_Trait_mods :: Name
_Defn_Trait_mods = (String -> Name
Core.Name String
"mods")

_Defn_Trait_name :: Name
_Defn_Trait_name = (String -> Name
Core.Name String
"name")

_Defn_Trait_tparams :: Name
_Defn_Trait_tparams = (String -> Name
Core.Name String
"tparams")

_Defn_Trait_ctor :: Name
_Defn_Trait_ctor = (String -> Name
Core.Name String
"ctor")

_Defn_Trait_template :: Name
_Defn_Trait_template = (String -> Name
Core.Name String
"template")

data Defn_Object = 
  Defn_Object {
    Defn_Object -> Data_Name
defn_ObjectName :: Data_Name}
  deriving (Defn_Object -> Defn_Object -> Bool
(Defn_Object -> Defn_Object -> Bool)
-> (Defn_Object -> Defn_Object -> Bool) -> Eq Defn_Object
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Defn_Object -> Defn_Object -> Bool
== :: Defn_Object -> Defn_Object -> Bool
$c/= :: Defn_Object -> Defn_Object -> Bool
/= :: Defn_Object -> Defn_Object -> Bool
Eq, Eq Defn_Object
Eq Defn_Object =>
(Defn_Object -> Defn_Object -> Ordering)
-> (Defn_Object -> Defn_Object -> Bool)
-> (Defn_Object -> Defn_Object -> Bool)
-> (Defn_Object -> Defn_Object -> Bool)
-> (Defn_Object -> Defn_Object -> Bool)
-> (Defn_Object -> Defn_Object -> Defn_Object)
-> (Defn_Object -> Defn_Object -> Defn_Object)
-> Ord Defn_Object
Defn_Object -> Defn_Object -> Bool
Defn_Object -> Defn_Object -> Ordering
Defn_Object -> Defn_Object -> Defn_Object
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Defn_Object -> Defn_Object -> Ordering
compare :: Defn_Object -> Defn_Object -> Ordering
$c< :: Defn_Object -> Defn_Object -> Bool
< :: Defn_Object -> Defn_Object -> Bool
$c<= :: Defn_Object -> Defn_Object -> Bool
<= :: Defn_Object -> Defn_Object -> Bool
$c> :: Defn_Object -> Defn_Object -> Bool
> :: Defn_Object -> Defn_Object -> Bool
$c>= :: Defn_Object -> Defn_Object -> Bool
>= :: Defn_Object -> Defn_Object -> Bool
$cmax :: Defn_Object -> Defn_Object -> Defn_Object
max :: Defn_Object -> Defn_Object -> Defn_Object
$cmin :: Defn_Object -> Defn_Object -> Defn_Object
min :: Defn_Object -> Defn_Object -> Defn_Object
Ord, ReadPrec [Defn_Object]
ReadPrec Defn_Object
Int -> ReadS Defn_Object
ReadS [Defn_Object]
(Int -> ReadS Defn_Object)
-> ReadS [Defn_Object]
-> ReadPrec Defn_Object
-> ReadPrec [Defn_Object]
-> Read Defn_Object
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Defn_Object
readsPrec :: Int -> ReadS Defn_Object
$creadList :: ReadS [Defn_Object]
readList :: ReadS [Defn_Object]
$creadPrec :: ReadPrec Defn_Object
readPrec :: ReadPrec Defn_Object
$creadListPrec :: ReadPrec [Defn_Object]
readListPrec :: ReadPrec [Defn_Object]
Read, Int -> Defn_Object -> String -> String
[Defn_Object] -> String -> String
Defn_Object -> String
(Int -> Defn_Object -> String -> String)
-> (Defn_Object -> String)
-> ([Defn_Object] -> String -> String)
-> Show Defn_Object
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Defn_Object -> String -> String
showsPrec :: Int -> Defn_Object -> String -> String
$cshow :: Defn_Object -> String
show :: Defn_Object -> String
$cshowList :: [Defn_Object] -> String -> String
showList :: [Defn_Object] -> String -> String
Show)

_Defn_Object :: Name
_Defn_Object = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Defn.Object")

_Defn_Object_name :: Name
_Defn_Object_name = (String -> Name
Core.Name String
"name")

data Pkg = 
  Pkg {
    Pkg -> Data_Name
pkgName :: Data_Name,
    Pkg -> Data_Ref
pkgRef :: Data_Ref,
    Pkg -> [Stat]
pkgStats :: [Stat]}
  deriving (Pkg -> Pkg -> Bool
(Pkg -> Pkg -> Bool) -> (Pkg -> Pkg -> Bool) -> Eq Pkg
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pkg -> Pkg -> Bool
== :: Pkg -> Pkg -> Bool
$c/= :: Pkg -> Pkg -> Bool
/= :: Pkg -> Pkg -> Bool
Eq, Eq Pkg
Eq Pkg =>
(Pkg -> Pkg -> Ordering)
-> (Pkg -> Pkg -> Bool)
-> (Pkg -> Pkg -> Bool)
-> (Pkg -> Pkg -> Bool)
-> (Pkg -> Pkg -> Bool)
-> (Pkg -> Pkg -> Pkg)
-> (Pkg -> Pkg -> Pkg)
-> Ord Pkg
Pkg -> Pkg -> Bool
Pkg -> Pkg -> Ordering
Pkg -> Pkg -> Pkg
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Pkg -> Pkg -> Ordering
compare :: Pkg -> Pkg -> Ordering
$c< :: Pkg -> Pkg -> Bool
< :: Pkg -> Pkg -> Bool
$c<= :: Pkg -> Pkg -> Bool
<= :: Pkg -> Pkg -> Bool
$c> :: Pkg -> Pkg -> Bool
> :: Pkg -> Pkg -> Bool
$c>= :: Pkg -> Pkg -> Bool
>= :: Pkg -> Pkg -> Bool
$cmax :: Pkg -> Pkg -> Pkg
max :: Pkg -> Pkg -> Pkg
$cmin :: Pkg -> Pkg -> Pkg
min :: Pkg -> Pkg -> Pkg
Ord, ReadPrec [Pkg]
ReadPrec Pkg
Int -> ReadS Pkg
ReadS [Pkg]
(Int -> ReadS Pkg)
-> ReadS [Pkg] -> ReadPrec Pkg -> ReadPrec [Pkg] -> Read Pkg
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Pkg
readsPrec :: Int -> ReadS Pkg
$creadList :: ReadS [Pkg]
readList :: ReadS [Pkg]
$creadPrec :: ReadPrec Pkg
readPrec :: ReadPrec Pkg
$creadListPrec :: ReadPrec [Pkg]
readListPrec :: ReadPrec [Pkg]
Read, Int -> Pkg -> String -> String
[Pkg] -> String -> String
Pkg -> String
(Int -> Pkg -> String -> String)
-> (Pkg -> String) -> ([Pkg] -> String -> String) -> Show Pkg
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Pkg -> String -> String
showsPrec :: Int -> Pkg -> String -> String
$cshow :: Pkg -> String
show :: Pkg -> String
$cshowList :: [Pkg] -> String -> String
showList :: [Pkg] -> String -> String
Show)

_Pkg :: Name
_Pkg = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Pkg")

_Pkg_name :: Name
_Pkg_name = (String -> Name
Core.Name String
"name")

_Pkg_ref :: Name
_Pkg_ref = (String -> Name
Core.Name String
"ref")

_Pkg_stats :: Name
_Pkg_stats = (String -> Name
Core.Name String
"stats")

data Pkg_Object = 
  Pkg_Object {
    Pkg_Object -> [Mod]
pkg_ObjectMods :: [Mod],
    Pkg_Object -> Data_Name
pkg_ObjectName :: Data_Name,
    Pkg_Object -> Template
pkg_ObjectTemplate :: Template}
  deriving (Pkg_Object -> Pkg_Object -> Bool
(Pkg_Object -> Pkg_Object -> Bool)
-> (Pkg_Object -> Pkg_Object -> Bool) -> Eq Pkg_Object
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Pkg_Object -> Pkg_Object -> Bool
== :: Pkg_Object -> Pkg_Object -> Bool
$c/= :: Pkg_Object -> Pkg_Object -> Bool
/= :: Pkg_Object -> Pkg_Object -> Bool
Eq, Eq Pkg_Object
Eq Pkg_Object =>
(Pkg_Object -> Pkg_Object -> Ordering)
-> (Pkg_Object -> Pkg_Object -> Bool)
-> (Pkg_Object -> Pkg_Object -> Bool)
-> (Pkg_Object -> Pkg_Object -> Bool)
-> (Pkg_Object -> Pkg_Object -> Bool)
-> (Pkg_Object -> Pkg_Object -> Pkg_Object)
-> (Pkg_Object -> Pkg_Object -> Pkg_Object)
-> Ord Pkg_Object
Pkg_Object -> Pkg_Object -> Bool
Pkg_Object -> Pkg_Object -> Ordering
Pkg_Object -> Pkg_Object -> Pkg_Object
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Pkg_Object -> Pkg_Object -> Ordering
compare :: Pkg_Object -> Pkg_Object -> Ordering
$c< :: Pkg_Object -> Pkg_Object -> Bool
< :: Pkg_Object -> Pkg_Object -> Bool
$c<= :: Pkg_Object -> Pkg_Object -> Bool
<= :: Pkg_Object -> Pkg_Object -> Bool
$c> :: Pkg_Object -> Pkg_Object -> Bool
> :: Pkg_Object -> Pkg_Object -> Bool
$c>= :: Pkg_Object -> Pkg_Object -> Bool
>= :: Pkg_Object -> Pkg_Object -> Bool
$cmax :: Pkg_Object -> Pkg_Object -> Pkg_Object
max :: Pkg_Object -> Pkg_Object -> Pkg_Object
$cmin :: Pkg_Object -> Pkg_Object -> Pkg_Object
min :: Pkg_Object -> Pkg_Object -> Pkg_Object
Ord, ReadPrec [Pkg_Object]
ReadPrec Pkg_Object
Int -> ReadS Pkg_Object
ReadS [Pkg_Object]
(Int -> ReadS Pkg_Object)
-> ReadS [Pkg_Object]
-> ReadPrec Pkg_Object
-> ReadPrec [Pkg_Object]
-> Read Pkg_Object
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Pkg_Object
readsPrec :: Int -> ReadS Pkg_Object
$creadList :: ReadS [Pkg_Object]
readList :: ReadS [Pkg_Object]
$creadPrec :: ReadPrec Pkg_Object
readPrec :: ReadPrec Pkg_Object
$creadListPrec :: ReadPrec [Pkg_Object]
readListPrec :: ReadPrec [Pkg_Object]
Read, Int -> Pkg_Object -> String -> String
[Pkg_Object] -> String -> String
Pkg_Object -> String
(Int -> Pkg_Object -> String -> String)
-> (Pkg_Object -> String)
-> ([Pkg_Object] -> String -> String)
-> Show Pkg_Object
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Pkg_Object -> String -> String
showsPrec :: Int -> Pkg_Object -> String -> String
$cshow :: Pkg_Object -> String
show :: Pkg_Object -> String
$cshowList :: [Pkg_Object] -> String -> String
showList :: [Pkg_Object] -> String -> String
Show)

_Pkg_Object :: Name
_Pkg_Object = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Pkg.Object")

_Pkg_Object_mods :: Name
_Pkg_Object_mods = (String -> Name
Core.Name String
"mods")

_Pkg_Object_name :: Name
_Pkg_Object_name = (String -> Name
Core.Name String
"name")

_Pkg_Object_template :: Name
_Pkg_Object_template = (String -> Name
Core.Name String
"template")

data Ctor = 
  CtorPrimary Ctor_Primary |
  CtorSecondary Ctor_Secondary
  deriving (Ctor -> Ctor -> Bool
(Ctor -> Ctor -> Bool) -> (Ctor -> Ctor -> Bool) -> Eq Ctor
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Ctor -> Ctor -> Bool
== :: Ctor -> Ctor -> Bool
$c/= :: Ctor -> Ctor -> Bool
/= :: Ctor -> Ctor -> Bool
Eq, Eq Ctor
Eq Ctor =>
(Ctor -> Ctor -> Ordering)
-> (Ctor -> Ctor -> Bool)
-> (Ctor -> Ctor -> Bool)
-> (Ctor -> Ctor -> Bool)
-> (Ctor -> Ctor -> Bool)
-> (Ctor -> Ctor -> Ctor)
-> (Ctor -> Ctor -> Ctor)
-> Ord Ctor
Ctor -> Ctor -> Bool
Ctor -> Ctor -> Ordering
Ctor -> Ctor -> Ctor
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Ctor -> Ctor -> Ordering
compare :: Ctor -> Ctor -> Ordering
$c< :: Ctor -> Ctor -> Bool
< :: Ctor -> Ctor -> Bool
$c<= :: Ctor -> Ctor -> Bool
<= :: Ctor -> Ctor -> Bool
$c> :: Ctor -> Ctor -> Bool
> :: Ctor -> Ctor -> Bool
$c>= :: Ctor -> Ctor -> Bool
>= :: Ctor -> Ctor -> Bool
$cmax :: Ctor -> Ctor -> Ctor
max :: Ctor -> Ctor -> Ctor
$cmin :: Ctor -> Ctor -> Ctor
min :: Ctor -> Ctor -> Ctor
Ord, ReadPrec [Ctor]
ReadPrec Ctor
Int -> ReadS Ctor
ReadS [Ctor]
(Int -> ReadS Ctor)
-> ReadS [Ctor] -> ReadPrec Ctor -> ReadPrec [Ctor] -> Read Ctor
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Ctor
readsPrec :: Int -> ReadS Ctor
$creadList :: ReadS [Ctor]
readList :: ReadS [Ctor]
$creadPrec :: ReadPrec Ctor
readPrec :: ReadPrec Ctor
$creadListPrec :: ReadPrec [Ctor]
readListPrec :: ReadPrec [Ctor]
Read, Int -> Ctor -> String -> String
[Ctor] -> String -> String
Ctor -> String
(Int -> Ctor -> String -> String)
-> (Ctor -> String) -> ([Ctor] -> String -> String) -> Show Ctor
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Ctor -> String -> String
showsPrec :: Int -> Ctor -> String -> String
$cshow :: Ctor -> String
show :: Ctor -> String
$cshowList :: [Ctor] -> String -> String
showList :: [Ctor] -> String -> String
Show)

_Ctor :: Name
_Ctor = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Ctor")

_Ctor_primary :: Name
_Ctor_primary = (String -> Name
Core.Name String
"primary")

_Ctor_secondary :: Name
_Ctor_secondary = (String -> Name
Core.Name String
"secondary")

data Ctor_Primary = 
  Ctor_Primary {
    Ctor_Primary -> [Mod]
ctor_PrimaryMods :: [Mod],
    Ctor_Primary -> Name
ctor_PrimaryName :: Name,
    Ctor_Primary -> [[Data_Param]]
ctor_PrimaryParamss :: [[Data_Param]]}
  deriving (Ctor_Primary -> Ctor_Primary -> Bool
(Ctor_Primary -> Ctor_Primary -> Bool)
-> (Ctor_Primary -> Ctor_Primary -> Bool) -> Eq Ctor_Primary
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Ctor_Primary -> Ctor_Primary -> Bool
== :: Ctor_Primary -> Ctor_Primary -> Bool
$c/= :: Ctor_Primary -> Ctor_Primary -> Bool
/= :: Ctor_Primary -> Ctor_Primary -> Bool
Eq, Eq Ctor_Primary
Eq Ctor_Primary =>
(Ctor_Primary -> Ctor_Primary -> Ordering)
-> (Ctor_Primary -> Ctor_Primary -> Bool)
-> (Ctor_Primary -> Ctor_Primary -> Bool)
-> (Ctor_Primary -> Ctor_Primary -> Bool)
-> (Ctor_Primary -> Ctor_Primary -> Bool)
-> (Ctor_Primary -> Ctor_Primary -> Ctor_Primary)
-> (Ctor_Primary -> Ctor_Primary -> Ctor_Primary)
-> Ord Ctor_Primary
Ctor_Primary -> Ctor_Primary -> Bool
Ctor_Primary -> Ctor_Primary -> Ordering
Ctor_Primary -> Ctor_Primary -> Ctor_Primary
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Ctor_Primary -> Ctor_Primary -> Ordering
compare :: Ctor_Primary -> Ctor_Primary -> Ordering
$c< :: Ctor_Primary -> Ctor_Primary -> Bool
< :: Ctor_Primary -> Ctor_Primary -> Bool
$c<= :: Ctor_Primary -> Ctor_Primary -> Bool
<= :: Ctor_Primary -> Ctor_Primary -> Bool
$c> :: Ctor_Primary -> Ctor_Primary -> Bool
> :: Ctor_Primary -> Ctor_Primary -> Bool
$c>= :: Ctor_Primary -> Ctor_Primary -> Bool
>= :: Ctor_Primary -> Ctor_Primary -> Bool
$cmax :: Ctor_Primary -> Ctor_Primary -> Ctor_Primary
max :: Ctor_Primary -> Ctor_Primary -> Ctor_Primary
$cmin :: Ctor_Primary -> Ctor_Primary -> Ctor_Primary
min :: Ctor_Primary -> Ctor_Primary -> Ctor_Primary
Ord, ReadPrec [Ctor_Primary]
ReadPrec Ctor_Primary
Int -> ReadS Ctor_Primary
ReadS [Ctor_Primary]
(Int -> ReadS Ctor_Primary)
-> ReadS [Ctor_Primary]
-> ReadPrec Ctor_Primary
-> ReadPrec [Ctor_Primary]
-> Read Ctor_Primary
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Ctor_Primary
readsPrec :: Int -> ReadS Ctor_Primary
$creadList :: ReadS [Ctor_Primary]
readList :: ReadS [Ctor_Primary]
$creadPrec :: ReadPrec Ctor_Primary
readPrec :: ReadPrec Ctor_Primary
$creadListPrec :: ReadPrec [Ctor_Primary]
readListPrec :: ReadPrec [Ctor_Primary]
Read, Int -> Ctor_Primary -> String -> String
[Ctor_Primary] -> String -> String
Ctor_Primary -> String
(Int -> Ctor_Primary -> String -> String)
-> (Ctor_Primary -> String)
-> ([Ctor_Primary] -> String -> String)
-> Show Ctor_Primary
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Ctor_Primary -> String -> String
showsPrec :: Int -> Ctor_Primary -> String -> String
$cshow :: Ctor_Primary -> String
show :: Ctor_Primary -> String
$cshowList :: [Ctor_Primary] -> String -> String
showList :: [Ctor_Primary] -> String -> String
Show)

_Ctor_Primary :: Name
_Ctor_Primary = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Ctor.Primary")

_Ctor_Primary_mods :: Name
_Ctor_Primary_mods = (String -> Name
Core.Name String
"mods")

_Ctor_Primary_name :: Name
_Ctor_Primary_name = (String -> Name
Core.Name String
"name")

_Ctor_Primary_paramss :: Name
_Ctor_Primary_paramss = (String -> Name
Core.Name String
"paramss")

data Ctor_Secondary = 
  Ctor_Secondary {
    Ctor_Secondary -> [Mod]
ctor_SecondaryMods :: [Mod],
    Ctor_Secondary -> Name
ctor_SecondaryName :: Name,
    Ctor_Secondary -> [[Data_Param]]
ctor_SecondaryParamss :: [[Data_Param]],
    Ctor_Secondary -> Init
ctor_SecondaryInit :: Init,
    Ctor_Secondary -> [Stat]
ctor_SecondaryStats :: [Stat]}
  deriving (Ctor_Secondary -> Ctor_Secondary -> Bool
(Ctor_Secondary -> Ctor_Secondary -> Bool)
-> (Ctor_Secondary -> Ctor_Secondary -> Bool) -> Eq Ctor_Secondary
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Ctor_Secondary -> Ctor_Secondary -> Bool
== :: Ctor_Secondary -> Ctor_Secondary -> Bool
$c/= :: Ctor_Secondary -> Ctor_Secondary -> Bool
/= :: Ctor_Secondary -> Ctor_Secondary -> Bool
Eq, Eq Ctor_Secondary
Eq Ctor_Secondary =>
(Ctor_Secondary -> Ctor_Secondary -> Ordering)
-> (Ctor_Secondary -> Ctor_Secondary -> Bool)
-> (Ctor_Secondary -> Ctor_Secondary -> Bool)
-> (Ctor_Secondary -> Ctor_Secondary -> Bool)
-> (Ctor_Secondary -> Ctor_Secondary -> Bool)
-> (Ctor_Secondary -> Ctor_Secondary -> Ctor_Secondary)
-> (Ctor_Secondary -> Ctor_Secondary -> Ctor_Secondary)
-> Ord Ctor_Secondary
Ctor_Secondary -> Ctor_Secondary -> Bool
Ctor_Secondary -> Ctor_Secondary -> Ordering
Ctor_Secondary -> Ctor_Secondary -> Ctor_Secondary
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Ctor_Secondary -> Ctor_Secondary -> Ordering
compare :: Ctor_Secondary -> Ctor_Secondary -> Ordering
$c< :: Ctor_Secondary -> Ctor_Secondary -> Bool
< :: Ctor_Secondary -> Ctor_Secondary -> Bool
$c<= :: Ctor_Secondary -> Ctor_Secondary -> Bool
<= :: Ctor_Secondary -> Ctor_Secondary -> Bool
$c> :: Ctor_Secondary -> Ctor_Secondary -> Bool
> :: Ctor_Secondary -> Ctor_Secondary -> Bool
$c>= :: Ctor_Secondary -> Ctor_Secondary -> Bool
>= :: Ctor_Secondary -> Ctor_Secondary -> Bool
$cmax :: Ctor_Secondary -> Ctor_Secondary -> Ctor_Secondary
max :: Ctor_Secondary -> Ctor_Secondary -> Ctor_Secondary
$cmin :: Ctor_Secondary -> Ctor_Secondary -> Ctor_Secondary
min :: Ctor_Secondary -> Ctor_Secondary -> Ctor_Secondary
Ord, ReadPrec [Ctor_Secondary]
ReadPrec Ctor_Secondary
Int -> ReadS Ctor_Secondary
ReadS [Ctor_Secondary]
(Int -> ReadS Ctor_Secondary)
-> ReadS [Ctor_Secondary]
-> ReadPrec Ctor_Secondary
-> ReadPrec [Ctor_Secondary]
-> Read Ctor_Secondary
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Ctor_Secondary
readsPrec :: Int -> ReadS Ctor_Secondary
$creadList :: ReadS [Ctor_Secondary]
readList :: ReadS [Ctor_Secondary]
$creadPrec :: ReadPrec Ctor_Secondary
readPrec :: ReadPrec Ctor_Secondary
$creadListPrec :: ReadPrec [Ctor_Secondary]
readListPrec :: ReadPrec [Ctor_Secondary]
Read, Int -> Ctor_Secondary -> String -> String
[Ctor_Secondary] -> String -> String
Ctor_Secondary -> String
(Int -> Ctor_Secondary -> String -> String)
-> (Ctor_Secondary -> String)
-> ([Ctor_Secondary] -> String -> String)
-> Show Ctor_Secondary
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Ctor_Secondary -> String -> String
showsPrec :: Int -> Ctor_Secondary -> String -> String
$cshow :: Ctor_Secondary -> String
show :: Ctor_Secondary -> String
$cshowList :: [Ctor_Secondary] -> String -> String
showList :: [Ctor_Secondary] -> String -> String
Show)

_Ctor_Secondary :: Name
_Ctor_Secondary = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Ctor.Secondary")

_Ctor_Secondary_mods :: Name
_Ctor_Secondary_mods = (String -> Name
Core.Name String
"mods")

_Ctor_Secondary_name :: Name
_Ctor_Secondary_name = (String -> Name
Core.Name String
"name")

_Ctor_Secondary_paramss :: Name
_Ctor_Secondary_paramss = (String -> Name
Core.Name String
"paramss")

_Ctor_Secondary_init :: Name
_Ctor_Secondary_init = (String -> Name
Core.Name String
"init")

_Ctor_Secondary_stats :: Name
_Ctor_Secondary_stats = (String -> Name
Core.Name String
"stats")

data Init = 
  Init {
    Init -> Type
initTpe :: Type,
    Init -> Name
initName :: Name,
    Init -> [[Data]]
initArgss :: [[Data]]}
  deriving (Init -> Init -> Bool
(Init -> Init -> Bool) -> (Init -> Init -> Bool) -> Eq Init
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Init -> Init -> Bool
== :: Init -> Init -> Bool
$c/= :: Init -> Init -> Bool
/= :: Init -> Init -> Bool
Eq, Eq Init
Eq Init =>
(Init -> Init -> Ordering)
-> (Init -> Init -> Bool)
-> (Init -> Init -> Bool)
-> (Init -> Init -> Bool)
-> (Init -> Init -> Bool)
-> (Init -> Init -> Init)
-> (Init -> Init -> Init)
-> Ord Init
Init -> Init -> Bool
Init -> Init -> Ordering
Init -> Init -> Init
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Init -> Init -> Ordering
compare :: Init -> Init -> Ordering
$c< :: Init -> Init -> Bool
< :: Init -> Init -> Bool
$c<= :: Init -> Init -> Bool
<= :: Init -> Init -> Bool
$c> :: Init -> Init -> Bool
> :: Init -> Init -> Bool
$c>= :: Init -> Init -> Bool
>= :: Init -> Init -> Bool
$cmax :: Init -> Init -> Init
max :: Init -> Init -> Init
$cmin :: Init -> Init -> Init
min :: Init -> Init -> Init
Ord, ReadPrec [Init]
ReadPrec Init
Int -> ReadS Init
ReadS [Init]
(Int -> ReadS Init)
-> ReadS [Init] -> ReadPrec Init -> ReadPrec [Init] -> Read Init
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Init
readsPrec :: Int -> ReadS Init
$creadList :: ReadS [Init]
readList :: ReadS [Init]
$creadPrec :: ReadPrec Init
readPrec :: ReadPrec Init
$creadListPrec :: ReadPrec [Init]
readListPrec :: ReadPrec [Init]
Read, Int -> Init -> String -> String
[Init] -> String -> String
Init -> String
(Int -> Init -> String -> String)
-> (Init -> String) -> ([Init] -> String -> String) -> Show Init
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Init -> String -> String
showsPrec :: Int -> Init -> String -> String
$cshow :: Init -> String
show :: Init -> String
$cshowList :: [Init] -> String -> String
showList :: [Init] -> String -> String
Show)

_Init :: Name
_Init = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Init")

_Init_tpe :: Name
_Init_tpe = (String -> Name
Core.Name String
"tpe")

_Init_name :: Name
_Init_name = (String -> Name
Core.Name String
"name")

_Init_argss :: Name
_Init_argss = (String -> Name
Core.Name String
"argss")

data Self = 
  Self {}
  deriving (Self -> Self -> Bool
(Self -> Self -> Bool) -> (Self -> Self -> Bool) -> Eq Self
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Self -> Self -> Bool
== :: Self -> Self -> Bool
$c/= :: Self -> Self -> Bool
/= :: Self -> Self -> Bool
Eq, Eq Self
Eq Self =>
(Self -> Self -> Ordering)
-> (Self -> Self -> Bool)
-> (Self -> Self -> Bool)
-> (Self -> Self -> Bool)
-> (Self -> Self -> Bool)
-> (Self -> Self -> Self)
-> (Self -> Self -> Self)
-> Ord Self
Self -> Self -> Bool
Self -> Self -> Ordering
Self -> Self -> Self
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Self -> Self -> Ordering
compare :: Self -> Self -> Ordering
$c< :: Self -> Self -> Bool
< :: Self -> Self -> Bool
$c<= :: Self -> Self -> Bool
<= :: Self -> Self -> Bool
$c> :: Self -> Self -> Bool
> :: Self -> Self -> Bool
$c>= :: Self -> Self -> Bool
>= :: Self -> Self -> Bool
$cmax :: Self -> Self -> Self
max :: Self -> Self -> Self
$cmin :: Self -> Self -> Self
min :: Self -> Self -> Self
Ord, ReadPrec [Self]
ReadPrec Self
Int -> ReadS Self
ReadS [Self]
(Int -> ReadS Self)
-> ReadS [Self] -> ReadPrec Self -> ReadPrec [Self] -> Read Self
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Self
readsPrec :: Int -> ReadS Self
$creadList :: ReadS [Self]
readList :: ReadS [Self]
$creadPrec :: ReadPrec Self
readPrec :: ReadPrec Self
$creadListPrec :: ReadPrec [Self]
readListPrec :: ReadPrec [Self]
Read, Int -> Self -> String -> String
[Self] -> String -> String
Self -> String
(Int -> Self -> String -> String)
-> (Self -> String) -> ([Self] -> String -> String) -> Show Self
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Self -> String -> String
showsPrec :: Int -> Self -> String -> String
$cshow :: Self -> String
show :: Self -> String
$cshowList :: [Self] -> String -> String
showList :: [Self] -> String -> String
Show)

_Self :: Name
_Self = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Self")

data Template = 
  Template {
    Template -> [Stat]
templateEarly :: [Stat],
    Template -> [Init]
templateInits :: [Init],
    Template -> Self
templateSelf :: Self,
    Template -> [Stat]
templateStats :: [Stat]}
  deriving (Template -> Template -> Bool
(Template -> Template -> Bool)
-> (Template -> Template -> Bool) -> Eq Template
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Template -> Template -> Bool
== :: Template -> Template -> Bool
$c/= :: Template -> Template -> Bool
/= :: Template -> Template -> Bool
Eq, Eq Template
Eq Template =>
(Template -> Template -> Ordering)
-> (Template -> Template -> Bool)
-> (Template -> Template -> Bool)
-> (Template -> Template -> Bool)
-> (Template -> Template -> Bool)
-> (Template -> Template -> Template)
-> (Template -> Template -> Template)
-> Ord Template
Template -> Template -> Bool
Template -> Template -> Ordering
Template -> Template -> Template
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Template -> Template -> Ordering
compare :: Template -> Template -> Ordering
$c< :: Template -> Template -> Bool
< :: Template -> Template -> Bool
$c<= :: Template -> Template -> Bool
<= :: Template -> Template -> Bool
$c> :: Template -> Template -> Bool
> :: Template -> Template -> Bool
$c>= :: Template -> Template -> Bool
>= :: Template -> Template -> Bool
$cmax :: Template -> Template -> Template
max :: Template -> Template -> Template
$cmin :: Template -> Template -> Template
min :: Template -> Template -> Template
Ord, ReadPrec [Template]
ReadPrec Template
Int -> ReadS Template
ReadS [Template]
(Int -> ReadS Template)
-> ReadS [Template]
-> ReadPrec Template
-> ReadPrec [Template]
-> Read Template
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Template
readsPrec :: Int -> ReadS Template
$creadList :: ReadS [Template]
readList :: ReadS [Template]
$creadPrec :: ReadPrec Template
readPrec :: ReadPrec Template
$creadListPrec :: ReadPrec [Template]
readListPrec :: ReadPrec [Template]
Read, Int -> Template -> String -> String
[Template] -> String -> String
Template -> String
(Int -> Template -> String -> String)
-> (Template -> String)
-> ([Template] -> String -> String)
-> Show Template
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Template -> String -> String
showsPrec :: Int -> Template -> String -> String
$cshow :: Template -> String
show :: Template -> String
$cshowList :: [Template] -> String -> String
showList :: [Template] -> String -> String
Show)

_Template :: Name
_Template = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Template")

_Template_early :: Name
_Template_early = (String -> Name
Core.Name String
"early")

_Template_inits :: Name
_Template_inits = (String -> Name
Core.Name String
"inits")

_Template_self :: Name
_Template_self = (String -> Name
Core.Name String
"self")

_Template_stats :: Name
_Template_stats = (String -> Name
Core.Name String
"stats")

data Mod = 
  ModAnnot Mod_Annot |
  ModPrivate Mod_Private |
  ModProtected Mod_Protected |
  ModImplicit  |
  ModFinal  |
  ModSealed  |
  ModOpen  |
  ModSuper  |
  ModOverride  |
  ModCase  |
  ModAbstract  |
  ModCovariant  |
  ModContravariant  |
  ModLazy  |
  ModValParam  |
  ModVarParam  |
  ModInfix  |
  ModInline  |
  ModUsing  |
  ModOpaque  |
  ModTransparent 
  deriving (Mod -> Mod -> Bool
(Mod -> Mod -> Bool) -> (Mod -> Mod -> Bool) -> Eq Mod
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Mod -> Mod -> Bool
== :: Mod -> Mod -> Bool
$c/= :: Mod -> Mod -> Bool
/= :: Mod -> Mod -> Bool
Eq, Eq Mod
Eq Mod =>
(Mod -> Mod -> Ordering)
-> (Mod -> Mod -> Bool)
-> (Mod -> Mod -> Bool)
-> (Mod -> Mod -> Bool)
-> (Mod -> Mod -> Bool)
-> (Mod -> Mod -> Mod)
-> (Mod -> Mod -> Mod)
-> Ord Mod
Mod -> Mod -> Bool
Mod -> Mod -> Ordering
Mod -> Mod -> Mod
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Mod -> Mod -> Ordering
compare :: Mod -> Mod -> Ordering
$c< :: Mod -> Mod -> Bool
< :: Mod -> Mod -> Bool
$c<= :: Mod -> Mod -> Bool
<= :: Mod -> Mod -> Bool
$c> :: Mod -> Mod -> Bool
> :: Mod -> Mod -> Bool
$c>= :: Mod -> Mod -> Bool
>= :: Mod -> Mod -> Bool
$cmax :: Mod -> Mod -> Mod
max :: Mod -> Mod -> Mod
$cmin :: Mod -> Mod -> Mod
min :: Mod -> Mod -> Mod
Ord, ReadPrec [Mod]
ReadPrec Mod
Int -> ReadS Mod
ReadS [Mod]
(Int -> ReadS Mod)
-> ReadS [Mod] -> ReadPrec Mod -> ReadPrec [Mod] -> Read Mod
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Mod
readsPrec :: Int -> ReadS Mod
$creadList :: ReadS [Mod]
readList :: ReadS [Mod]
$creadPrec :: ReadPrec Mod
readPrec :: ReadPrec Mod
$creadListPrec :: ReadPrec [Mod]
readListPrec :: ReadPrec [Mod]
Read, Int -> Mod -> String -> String
[Mod] -> String -> String
Mod -> String
(Int -> Mod -> String -> String)
-> (Mod -> String) -> ([Mod] -> String -> String) -> Show Mod
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Mod -> String -> String
showsPrec :: Int -> Mod -> String -> String
$cshow :: Mod -> String
show :: Mod -> String
$cshowList :: [Mod] -> String -> String
showList :: [Mod] -> String -> String
Show)

_Mod :: Name
_Mod = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Mod")

_Mod_annot :: Name
_Mod_annot = (String -> Name
Core.Name String
"annot")

_Mod_private :: Name
_Mod_private = (String -> Name
Core.Name String
"private")

_Mod_protected :: Name
_Mod_protected = (String -> Name
Core.Name String
"protected")

_Mod_implicit :: Name
_Mod_implicit = (String -> Name
Core.Name String
"implicit")

_Mod_final :: Name
_Mod_final = (String -> Name
Core.Name String
"final")

_Mod_sealed :: Name
_Mod_sealed = (String -> Name
Core.Name String
"sealed")

_Mod_open :: Name
_Mod_open = (String -> Name
Core.Name String
"open")

_Mod_super :: Name
_Mod_super = (String -> Name
Core.Name String
"super")

_Mod_override :: Name
_Mod_override = (String -> Name
Core.Name String
"override")

_Mod_case :: Name
_Mod_case = (String -> Name
Core.Name String
"case")

_Mod_abstract :: Name
_Mod_abstract = (String -> Name
Core.Name String
"abstract")

_Mod_covariant :: Name
_Mod_covariant = (String -> Name
Core.Name String
"covariant")

_Mod_contravariant :: Name
_Mod_contravariant = (String -> Name
Core.Name String
"contravariant")

_Mod_lazy :: Name
_Mod_lazy = (String -> Name
Core.Name String
"lazy")

_Mod_valParam :: Name
_Mod_valParam = (String -> Name
Core.Name String
"valParam")

_Mod_varParam :: Name
_Mod_varParam = (String -> Name
Core.Name String
"varParam")

_Mod_infix :: Name
_Mod_infix = (String -> Name
Core.Name String
"infix")

_Mod_inline :: Name
_Mod_inline = (String -> Name
Core.Name String
"inline")

_Mod_using :: Name
_Mod_using = (String -> Name
Core.Name String
"using")

_Mod_opaque :: Name
_Mod_opaque = (String -> Name
Core.Name String
"opaque")

_Mod_transparent :: Name
_Mod_transparent = (String -> Name
Core.Name String
"transparent")

data Mod_Annot = 
  Mod_Annot {
    Mod_Annot -> Init
mod_AnnotInit :: Init}
  deriving (Mod_Annot -> Mod_Annot -> Bool
(Mod_Annot -> Mod_Annot -> Bool)
-> (Mod_Annot -> Mod_Annot -> Bool) -> Eq Mod_Annot
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Mod_Annot -> Mod_Annot -> Bool
== :: Mod_Annot -> Mod_Annot -> Bool
$c/= :: Mod_Annot -> Mod_Annot -> Bool
/= :: Mod_Annot -> Mod_Annot -> Bool
Eq, Eq Mod_Annot
Eq Mod_Annot =>
(Mod_Annot -> Mod_Annot -> Ordering)
-> (Mod_Annot -> Mod_Annot -> Bool)
-> (Mod_Annot -> Mod_Annot -> Bool)
-> (Mod_Annot -> Mod_Annot -> Bool)
-> (Mod_Annot -> Mod_Annot -> Bool)
-> (Mod_Annot -> Mod_Annot -> Mod_Annot)
-> (Mod_Annot -> Mod_Annot -> Mod_Annot)
-> Ord Mod_Annot
Mod_Annot -> Mod_Annot -> Bool
Mod_Annot -> Mod_Annot -> Ordering
Mod_Annot -> Mod_Annot -> Mod_Annot
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Mod_Annot -> Mod_Annot -> Ordering
compare :: Mod_Annot -> Mod_Annot -> Ordering
$c< :: Mod_Annot -> Mod_Annot -> Bool
< :: Mod_Annot -> Mod_Annot -> Bool
$c<= :: Mod_Annot -> Mod_Annot -> Bool
<= :: Mod_Annot -> Mod_Annot -> Bool
$c> :: Mod_Annot -> Mod_Annot -> Bool
> :: Mod_Annot -> Mod_Annot -> Bool
$c>= :: Mod_Annot -> Mod_Annot -> Bool
>= :: Mod_Annot -> Mod_Annot -> Bool
$cmax :: Mod_Annot -> Mod_Annot -> Mod_Annot
max :: Mod_Annot -> Mod_Annot -> Mod_Annot
$cmin :: Mod_Annot -> Mod_Annot -> Mod_Annot
min :: Mod_Annot -> Mod_Annot -> Mod_Annot
Ord, ReadPrec [Mod_Annot]
ReadPrec Mod_Annot
Int -> ReadS Mod_Annot
ReadS [Mod_Annot]
(Int -> ReadS Mod_Annot)
-> ReadS [Mod_Annot]
-> ReadPrec Mod_Annot
-> ReadPrec [Mod_Annot]
-> Read Mod_Annot
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Mod_Annot
readsPrec :: Int -> ReadS Mod_Annot
$creadList :: ReadS [Mod_Annot]
readList :: ReadS [Mod_Annot]
$creadPrec :: ReadPrec Mod_Annot
readPrec :: ReadPrec Mod_Annot
$creadListPrec :: ReadPrec [Mod_Annot]
readListPrec :: ReadPrec [Mod_Annot]
Read, Int -> Mod_Annot -> String -> String
[Mod_Annot] -> String -> String
Mod_Annot -> String
(Int -> Mod_Annot -> String -> String)
-> (Mod_Annot -> String)
-> ([Mod_Annot] -> String -> String)
-> Show Mod_Annot
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Mod_Annot -> String -> String
showsPrec :: Int -> Mod_Annot -> String -> String
$cshow :: Mod_Annot -> String
show :: Mod_Annot -> String
$cshowList :: [Mod_Annot] -> String -> String
showList :: [Mod_Annot] -> String -> String
Show)

_Mod_Annot :: Name
_Mod_Annot = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Mod.Annot")

_Mod_Annot_init :: Name
_Mod_Annot_init = (String -> Name
Core.Name String
"init")

data Mod_Private = 
  Mod_Private {
    Mod_Private -> Ref
mod_PrivateWithin :: Ref}
  deriving (Mod_Private -> Mod_Private -> Bool
(Mod_Private -> Mod_Private -> Bool)
-> (Mod_Private -> Mod_Private -> Bool) -> Eq Mod_Private
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Mod_Private -> Mod_Private -> Bool
== :: Mod_Private -> Mod_Private -> Bool
$c/= :: Mod_Private -> Mod_Private -> Bool
/= :: Mod_Private -> Mod_Private -> Bool
Eq, Eq Mod_Private
Eq Mod_Private =>
(Mod_Private -> Mod_Private -> Ordering)
-> (Mod_Private -> Mod_Private -> Bool)
-> (Mod_Private -> Mod_Private -> Bool)
-> (Mod_Private -> Mod_Private -> Bool)
-> (Mod_Private -> Mod_Private -> Bool)
-> (Mod_Private -> Mod_Private -> Mod_Private)
-> (Mod_Private -> Mod_Private -> Mod_Private)
-> Ord Mod_Private
Mod_Private -> Mod_Private -> Bool
Mod_Private -> Mod_Private -> Ordering
Mod_Private -> Mod_Private -> Mod_Private
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Mod_Private -> Mod_Private -> Ordering
compare :: Mod_Private -> Mod_Private -> Ordering
$c< :: Mod_Private -> Mod_Private -> Bool
< :: Mod_Private -> Mod_Private -> Bool
$c<= :: Mod_Private -> Mod_Private -> Bool
<= :: Mod_Private -> Mod_Private -> Bool
$c> :: Mod_Private -> Mod_Private -> Bool
> :: Mod_Private -> Mod_Private -> Bool
$c>= :: Mod_Private -> Mod_Private -> Bool
>= :: Mod_Private -> Mod_Private -> Bool
$cmax :: Mod_Private -> Mod_Private -> Mod_Private
max :: Mod_Private -> Mod_Private -> Mod_Private
$cmin :: Mod_Private -> Mod_Private -> Mod_Private
min :: Mod_Private -> Mod_Private -> Mod_Private
Ord, ReadPrec [Mod_Private]
ReadPrec Mod_Private
Int -> ReadS Mod_Private
ReadS [Mod_Private]
(Int -> ReadS Mod_Private)
-> ReadS [Mod_Private]
-> ReadPrec Mod_Private
-> ReadPrec [Mod_Private]
-> Read Mod_Private
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Mod_Private
readsPrec :: Int -> ReadS Mod_Private
$creadList :: ReadS [Mod_Private]
readList :: ReadS [Mod_Private]
$creadPrec :: ReadPrec Mod_Private
readPrec :: ReadPrec Mod_Private
$creadListPrec :: ReadPrec [Mod_Private]
readListPrec :: ReadPrec [Mod_Private]
Read, Int -> Mod_Private -> String -> String
[Mod_Private] -> String -> String
Mod_Private -> String
(Int -> Mod_Private -> String -> String)
-> (Mod_Private -> String)
-> ([Mod_Private] -> String -> String)
-> Show Mod_Private
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Mod_Private -> String -> String
showsPrec :: Int -> Mod_Private -> String -> String
$cshow :: Mod_Private -> String
show :: Mod_Private -> String
$cshowList :: [Mod_Private] -> String -> String
showList :: [Mod_Private] -> String -> String
Show)

_Mod_Private :: Name
_Mod_Private = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Mod.Private")

_Mod_Private_within :: Name
_Mod_Private_within = (String -> Name
Core.Name String
"within")

data Mod_Protected = 
  Mod_Protected {
    Mod_Protected -> Ref
mod_ProtectedWithin :: Ref}
  deriving (Mod_Protected -> Mod_Protected -> Bool
(Mod_Protected -> Mod_Protected -> Bool)
-> (Mod_Protected -> Mod_Protected -> Bool) -> Eq Mod_Protected
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Mod_Protected -> Mod_Protected -> Bool
== :: Mod_Protected -> Mod_Protected -> Bool
$c/= :: Mod_Protected -> Mod_Protected -> Bool
/= :: Mod_Protected -> Mod_Protected -> Bool
Eq, Eq Mod_Protected
Eq Mod_Protected =>
(Mod_Protected -> Mod_Protected -> Ordering)
-> (Mod_Protected -> Mod_Protected -> Bool)
-> (Mod_Protected -> Mod_Protected -> Bool)
-> (Mod_Protected -> Mod_Protected -> Bool)
-> (Mod_Protected -> Mod_Protected -> Bool)
-> (Mod_Protected -> Mod_Protected -> Mod_Protected)
-> (Mod_Protected -> Mod_Protected -> Mod_Protected)
-> Ord Mod_Protected
Mod_Protected -> Mod_Protected -> Bool
Mod_Protected -> Mod_Protected -> Ordering
Mod_Protected -> Mod_Protected -> Mod_Protected
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Mod_Protected -> Mod_Protected -> Ordering
compare :: Mod_Protected -> Mod_Protected -> Ordering
$c< :: Mod_Protected -> Mod_Protected -> Bool
< :: Mod_Protected -> Mod_Protected -> Bool
$c<= :: Mod_Protected -> Mod_Protected -> Bool
<= :: Mod_Protected -> Mod_Protected -> Bool
$c> :: Mod_Protected -> Mod_Protected -> Bool
> :: Mod_Protected -> Mod_Protected -> Bool
$c>= :: Mod_Protected -> Mod_Protected -> Bool
>= :: Mod_Protected -> Mod_Protected -> Bool
$cmax :: Mod_Protected -> Mod_Protected -> Mod_Protected
max :: Mod_Protected -> Mod_Protected -> Mod_Protected
$cmin :: Mod_Protected -> Mod_Protected -> Mod_Protected
min :: Mod_Protected -> Mod_Protected -> Mod_Protected
Ord, ReadPrec [Mod_Protected]
ReadPrec Mod_Protected
Int -> ReadS Mod_Protected
ReadS [Mod_Protected]
(Int -> ReadS Mod_Protected)
-> ReadS [Mod_Protected]
-> ReadPrec Mod_Protected
-> ReadPrec [Mod_Protected]
-> Read Mod_Protected
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Mod_Protected
readsPrec :: Int -> ReadS Mod_Protected
$creadList :: ReadS [Mod_Protected]
readList :: ReadS [Mod_Protected]
$creadPrec :: ReadPrec Mod_Protected
readPrec :: ReadPrec Mod_Protected
$creadListPrec :: ReadPrec [Mod_Protected]
readListPrec :: ReadPrec [Mod_Protected]
Read, Int -> Mod_Protected -> String -> String
[Mod_Protected] -> String -> String
Mod_Protected -> String
(Int -> Mod_Protected -> String -> String)
-> (Mod_Protected -> String)
-> ([Mod_Protected] -> String -> String)
-> Show Mod_Protected
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Mod_Protected -> String -> String
showsPrec :: Int -> Mod_Protected -> String -> String
$cshow :: Mod_Protected -> String
show :: Mod_Protected -> String
$cshowList :: [Mod_Protected] -> String -> String
showList :: [Mod_Protected] -> String -> String
Show)

_Mod_Protected :: Name
_Mod_Protected = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Mod.Protected")

_Mod_Protected_within :: Name
_Mod_Protected_within = (String -> Name
Core.Name String
"within")

data Enumerator = 
  EnumeratorGenerator Enumerator_Generator |
  EnumeratorCaseGenerator Enumerator_CaseGenerator |
  EnumeratorVal Enumerator_Val |
  EnumeratorGuard Enumerator_Guard
  deriving (Enumerator -> Enumerator -> Bool
(Enumerator -> Enumerator -> Bool)
-> (Enumerator -> Enumerator -> Bool) -> Eq Enumerator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Enumerator -> Enumerator -> Bool
== :: Enumerator -> Enumerator -> Bool
$c/= :: Enumerator -> Enumerator -> Bool
/= :: Enumerator -> Enumerator -> Bool
Eq, Eq Enumerator
Eq Enumerator =>
(Enumerator -> Enumerator -> Ordering)
-> (Enumerator -> Enumerator -> Bool)
-> (Enumerator -> Enumerator -> Bool)
-> (Enumerator -> Enumerator -> Bool)
-> (Enumerator -> Enumerator -> Bool)
-> (Enumerator -> Enumerator -> Enumerator)
-> (Enumerator -> Enumerator -> Enumerator)
-> Ord Enumerator
Enumerator -> Enumerator -> Bool
Enumerator -> Enumerator -> Ordering
Enumerator -> Enumerator -> Enumerator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Enumerator -> Enumerator -> Ordering
compare :: Enumerator -> Enumerator -> Ordering
$c< :: Enumerator -> Enumerator -> Bool
< :: Enumerator -> Enumerator -> Bool
$c<= :: Enumerator -> Enumerator -> Bool
<= :: Enumerator -> Enumerator -> Bool
$c> :: Enumerator -> Enumerator -> Bool
> :: Enumerator -> Enumerator -> Bool
$c>= :: Enumerator -> Enumerator -> Bool
>= :: Enumerator -> Enumerator -> Bool
$cmax :: Enumerator -> Enumerator -> Enumerator
max :: Enumerator -> Enumerator -> Enumerator
$cmin :: Enumerator -> Enumerator -> Enumerator
min :: Enumerator -> Enumerator -> Enumerator
Ord, ReadPrec [Enumerator]
ReadPrec Enumerator
Int -> ReadS Enumerator
ReadS [Enumerator]
(Int -> ReadS Enumerator)
-> ReadS [Enumerator]
-> ReadPrec Enumerator
-> ReadPrec [Enumerator]
-> Read Enumerator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Enumerator
readsPrec :: Int -> ReadS Enumerator
$creadList :: ReadS [Enumerator]
readList :: ReadS [Enumerator]
$creadPrec :: ReadPrec Enumerator
readPrec :: ReadPrec Enumerator
$creadListPrec :: ReadPrec [Enumerator]
readListPrec :: ReadPrec [Enumerator]
Read, Int -> Enumerator -> String -> String
[Enumerator] -> String -> String
Enumerator -> String
(Int -> Enumerator -> String -> String)
-> (Enumerator -> String)
-> ([Enumerator] -> String -> String)
-> Show Enumerator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Enumerator -> String -> String
showsPrec :: Int -> Enumerator -> String -> String
$cshow :: Enumerator -> String
show :: Enumerator -> String
$cshowList :: [Enumerator] -> String -> String
showList :: [Enumerator] -> String -> String
Show)

_Enumerator :: Name
_Enumerator = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Enumerator")

_Enumerator_generator :: Name
_Enumerator_generator = (String -> Name
Core.Name String
"generator")

_Enumerator_caseGenerator :: Name
_Enumerator_caseGenerator = (String -> Name
Core.Name String
"caseGenerator")

_Enumerator_val :: Name
_Enumerator_val = (String -> Name
Core.Name String
"val")

_Enumerator_guard :: Name
_Enumerator_guard = (String -> Name
Core.Name String
"guard")

data Enumerator_Generator = 
  Enumerator_Generator {
    Enumerator_Generator -> Pat
enumerator_GeneratorPat :: Pat,
    Enumerator_Generator -> Data
enumerator_GeneratorRhs :: Data}
  deriving (Enumerator_Generator -> Enumerator_Generator -> Bool
(Enumerator_Generator -> Enumerator_Generator -> Bool)
-> (Enumerator_Generator -> Enumerator_Generator -> Bool)
-> Eq Enumerator_Generator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Enumerator_Generator -> Enumerator_Generator -> Bool
== :: Enumerator_Generator -> Enumerator_Generator -> Bool
$c/= :: Enumerator_Generator -> Enumerator_Generator -> Bool
/= :: Enumerator_Generator -> Enumerator_Generator -> Bool
Eq, Eq Enumerator_Generator
Eq Enumerator_Generator =>
(Enumerator_Generator -> Enumerator_Generator -> Ordering)
-> (Enumerator_Generator -> Enumerator_Generator -> Bool)
-> (Enumerator_Generator -> Enumerator_Generator -> Bool)
-> (Enumerator_Generator -> Enumerator_Generator -> Bool)
-> (Enumerator_Generator -> Enumerator_Generator -> Bool)
-> (Enumerator_Generator
    -> Enumerator_Generator -> Enumerator_Generator)
-> (Enumerator_Generator
    -> Enumerator_Generator -> Enumerator_Generator)
-> Ord Enumerator_Generator
Enumerator_Generator -> Enumerator_Generator -> Bool
Enumerator_Generator -> Enumerator_Generator -> Ordering
Enumerator_Generator
-> Enumerator_Generator -> Enumerator_Generator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Enumerator_Generator -> Enumerator_Generator -> Ordering
compare :: Enumerator_Generator -> Enumerator_Generator -> Ordering
$c< :: Enumerator_Generator -> Enumerator_Generator -> Bool
< :: Enumerator_Generator -> Enumerator_Generator -> Bool
$c<= :: Enumerator_Generator -> Enumerator_Generator -> Bool
<= :: Enumerator_Generator -> Enumerator_Generator -> Bool
$c> :: Enumerator_Generator -> Enumerator_Generator -> Bool
> :: Enumerator_Generator -> Enumerator_Generator -> Bool
$c>= :: Enumerator_Generator -> Enumerator_Generator -> Bool
>= :: Enumerator_Generator -> Enumerator_Generator -> Bool
$cmax :: Enumerator_Generator
-> Enumerator_Generator -> Enumerator_Generator
max :: Enumerator_Generator
-> Enumerator_Generator -> Enumerator_Generator
$cmin :: Enumerator_Generator
-> Enumerator_Generator -> Enumerator_Generator
min :: Enumerator_Generator
-> Enumerator_Generator -> Enumerator_Generator
Ord, ReadPrec [Enumerator_Generator]
ReadPrec Enumerator_Generator
Int -> ReadS Enumerator_Generator
ReadS [Enumerator_Generator]
(Int -> ReadS Enumerator_Generator)
-> ReadS [Enumerator_Generator]
-> ReadPrec Enumerator_Generator
-> ReadPrec [Enumerator_Generator]
-> Read Enumerator_Generator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Enumerator_Generator
readsPrec :: Int -> ReadS Enumerator_Generator
$creadList :: ReadS [Enumerator_Generator]
readList :: ReadS [Enumerator_Generator]
$creadPrec :: ReadPrec Enumerator_Generator
readPrec :: ReadPrec Enumerator_Generator
$creadListPrec :: ReadPrec [Enumerator_Generator]
readListPrec :: ReadPrec [Enumerator_Generator]
Read, Int -> Enumerator_Generator -> String -> String
[Enumerator_Generator] -> String -> String
Enumerator_Generator -> String
(Int -> Enumerator_Generator -> String -> String)
-> (Enumerator_Generator -> String)
-> ([Enumerator_Generator] -> String -> String)
-> Show Enumerator_Generator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Enumerator_Generator -> String -> String
showsPrec :: Int -> Enumerator_Generator -> String -> String
$cshow :: Enumerator_Generator -> String
show :: Enumerator_Generator -> String
$cshowList :: [Enumerator_Generator] -> String -> String
showList :: [Enumerator_Generator] -> String -> String
Show)

_Enumerator_Generator :: Name
_Enumerator_Generator = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Enumerator.Generator")

_Enumerator_Generator_pat :: Name
_Enumerator_Generator_pat = (String -> Name
Core.Name String
"pat")

_Enumerator_Generator_rhs :: Name
_Enumerator_Generator_rhs = (String -> Name
Core.Name String
"rhs")

data Enumerator_CaseGenerator = 
  Enumerator_CaseGenerator {
    Enumerator_CaseGenerator -> Pat
enumerator_CaseGeneratorPat :: Pat,
    Enumerator_CaseGenerator -> Data
enumerator_CaseGeneratorRhs :: Data}
  deriving (Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Bool
(Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Bool)
-> (Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Bool)
-> Eq Enumerator_CaseGenerator
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Bool
== :: Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Bool
$c/= :: Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Bool
/= :: Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Bool
Eq, Eq Enumerator_CaseGenerator
Eq Enumerator_CaseGenerator =>
(Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Ordering)
-> (Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Bool)
-> (Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Bool)
-> (Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Bool)
-> (Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Bool)
-> (Enumerator_CaseGenerator
    -> Enumerator_CaseGenerator -> Enumerator_CaseGenerator)
-> (Enumerator_CaseGenerator
    -> Enumerator_CaseGenerator -> Enumerator_CaseGenerator)
-> Ord Enumerator_CaseGenerator
Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Bool
Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Ordering
Enumerator_CaseGenerator
-> Enumerator_CaseGenerator -> Enumerator_CaseGenerator
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Ordering
compare :: Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Ordering
$c< :: Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Bool
< :: Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Bool
$c<= :: Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Bool
<= :: Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Bool
$c> :: Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Bool
> :: Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Bool
$c>= :: Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Bool
>= :: Enumerator_CaseGenerator -> Enumerator_CaseGenerator -> Bool
$cmax :: Enumerator_CaseGenerator
-> Enumerator_CaseGenerator -> Enumerator_CaseGenerator
max :: Enumerator_CaseGenerator
-> Enumerator_CaseGenerator -> Enumerator_CaseGenerator
$cmin :: Enumerator_CaseGenerator
-> Enumerator_CaseGenerator -> Enumerator_CaseGenerator
min :: Enumerator_CaseGenerator
-> Enumerator_CaseGenerator -> Enumerator_CaseGenerator
Ord, ReadPrec [Enumerator_CaseGenerator]
ReadPrec Enumerator_CaseGenerator
Int -> ReadS Enumerator_CaseGenerator
ReadS [Enumerator_CaseGenerator]
(Int -> ReadS Enumerator_CaseGenerator)
-> ReadS [Enumerator_CaseGenerator]
-> ReadPrec Enumerator_CaseGenerator
-> ReadPrec [Enumerator_CaseGenerator]
-> Read Enumerator_CaseGenerator
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Enumerator_CaseGenerator
readsPrec :: Int -> ReadS Enumerator_CaseGenerator
$creadList :: ReadS [Enumerator_CaseGenerator]
readList :: ReadS [Enumerator_CaseGenerator]
$creadPrec :: ReadPrec Enumerator_CaseGenerator
readPrec :: ReadPrec Enumerator_CaseGenerator
$creadListPrec :: ReadPrec [Enumerator_CaseGenerator]
readListPrec :: ReadPrec [Enumerator_CaseGenerator]
Read, Int -> Enumerator_CaseGenerator -> String -> String
[Enumerator_CaseGenerator] -> String -> String
Enumerator_CaseGenerator -> String
(Int -> Enumerator_CaseGenerator -> String -> String)
-> (Enumerator_CaseGenerator -> String)
-> ([Enumerator_CaseGenerator] -> String -> String)
-> Show Enumerator_CaseGenerator
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Enumerator_CaseGenerator -> String -> String
showsPrec :: Int -> Enumerator_CaseGenerator -> String -> String
$cshow :: Enumerator_CaseGenerator -> String
show :: Enumerator_CaseGenerator -> String
$cshowList :: [Enumerator_CaseGenerator] -> String -> String
showList :: [Enumerator_CaseGenerator] -> String -> String
Show)

_Enumerator_CaseGenerator :: Name
_Enumerator_CaseGenerator = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Enumerator.CaseGenerator")

_Enumerator_CaseGenerator_pat :: Name
_Enumerator_CaseGenerator_pat = (String -> Name
Core.Name String
"pat")

_Enumerator_CaseGenerator_rhs :: Name
_Enumerator_CaseGenerator_rhs = (String -> Name
Core.Name String
"rhs")

data Enumerator_Val = 
  Enumerator_Val {
    Enumerator_Val -> Pat
enumerator_ValPat :: Pat,
    Enumerator_Val -> Data
enumerator_ValRhs :: Data}
  deriving (Enumerator_Val -> Enumerator_Val -> Bool
(Enumerator_Val -> Enumerator_Val -> Bool)
-> (Enumerator_Val -> Enumerator_Val -> Bool) -> Eq Enumerator_Val
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Enumerator_Val -> Enumerator_Val -> Bool
== :: Enumerator_Val -> Enumerator_Val -> Bool
$c/= :: Enumerator_Val -> Enumerator_Val -> Bool
/= :: Enumerator_Val -> Enumerator_Val -> Bool
Eq, Eq Enumerator_Val
Eq Enumerator_Val =>
(Enumerator_Val -> Enumerator_Val -> Ordering)
-> (Enumerator_Val -> Enumerator_Val -> Bool)
-> (Enumerator_Val -> Enumerator_Val -> Bool)
-> (Enumerator_Val -> Enumerator_Val -> Bool)
-> (Enumerator_Val -> Enumerator_Val -> Bool)
-> (Enumerator_Val -> Enumerator_Val -> Enumerator_Val)
-> (Enumerator_Val -> Enumerator_Val -> Enumerator_Val)
-> Ord Enumerator_Val
Enumerator_Val -> Enumerator_Val -> Bool
Enumerator_Val -> Enumerator_Val -> Ordering
Enumerator_Val -> Enumerator_Val -> Enumerator_Val
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Enumerator_Val -> Enumerator_Val -> Ordering
compare :: Enumerator_Val -> Enumerator_Val -> Ordering
$c< :: Enumerator_Val -> Enumerator_Val -> Bool
< :: Enumerator_Val -> Enumerator_Val -> Bool
$c<= :: Enumerator_Val -> Enumerator_Val -> Bool
<= :: Enumerator_Val -> Enumerator_Val -> Bool
$c> :: Enumerator_Val -> Enumerator_Val -> Bool
> :: Enumerator_Val -> Enumerator_Val -> Bool
$c>= :: Enumerator_Val -> Enumerator_Val -> Bool
>= :: Enumerator_Val -> Enumerator_Val -> Bool
$cmax :: Enumerator_Val -> Enumerator_Val -> Enumerator_Val
max :: Enumerator_Val -> Enumerator_Val -> Enumerator_Val
$cmin :: Enumerator_Val -> Enumerator_Val -> Enumerator_Val
min :: Enumerator_Val -> Enumerator_Val -> Enumerator_Val
Ord, ReadPrec [Enumerator_Val]
ReadPrec Enumerator_Val
Int -> ReadS Enumerator_Val
ReadS [Enumerator_Val]
(Int -> ReadS Enumerator_Val)
-> ReadS [Enumerator_Val]
-> ReadPrec Enumerator_Val
-> ReadPrec [Enumerator_Val]
-> Read Enumerator_Val
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Enumerator_Val
readsPrec :: Int -> ReadS Enumerator_Val
$creadList :: ReadS [Enumerator_Val]
readList :: ReadS [Enumerator_Val]
$creadPrec :: ReadPrec Enumerator_Val
readPrec :: ReadPrec Enumerator_Val
$creadListPrec :: ReadPrec [Enumerator_Val]
readListPrec :: ReadPrec [Enumerator_Val]
Read, Int -> Enumerator_Val -> String -> String
[Enumerator_Val] -> String -> String
Enumerator_Val -> String
(Int -> Enumerator_Val -> String -> String)
-> (Enumerator_Val -> String)
-> ([Enumerator_Val] -> String -> String)
-> Show Enumerator_Val
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Enumerator_Val -> String -> String
showsPrec :: Int -> Enumerator_Val -> String -> String
$cshow :: Enumerator_Val -> String
show :: Enumerator_Val -> String
$cshowList :: [Enumerator_Val] -> String -> String
showList :: [Enumerator_Val] -> String -> String
Show)

_Enumerator_Val :: Name
_Enumerator_Val = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Enumerator.Val")

_Enumerator_Val_pat :: Name
_Enumerator_Val_pat = (String -> Name
Core.Name String
"pat")

_Enumerator_Val_rhs :: Name
_Enumerator_Val_rhs = (String -> Name
Core.Name String
"rhs")

data Enumerator_Guard = 
  Enumerator_Guard {
    Enumerator_Guard -> Data
enumerator_GuardCond :: Data}
  deriving (Enumerator_Guard -> Enumerator_Guard -> Bool
(Enumerator_Guard -> Enumerator_Guard -> Bool)
-> (Enumerator_Guard -> Enumerator_Guard -> Bool)
-> Eq Enumerator_Guard
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Enumerator_Guard -> Enumerator_Guard -> Bool
== :: Enumerator_Guard -> Enumerator_Guard -> Bool
$c/= :: Enumerator_Guard -> Enumerator_Guard -> Bool
/= :: Enumerator_Guard -> Enumerator_Guard -> Bool
Eq, Eq Enumerator_Guard
Eq Enumerator_Guard =>
(Enumerator_Guard -> Enumerator_Guard -> Ordering)
-> (Enumerator_Guard -> Enumerator_Guard -> Bool)
-> (Enumerator_Guard -> Enumerator_Guard -> Bool)
-> (Enumerator_Guard -> Enumerator_Guard -> Bool)
-> (Enumerator_Guard -> Enumerator_Guard -> Bool)
-> (Enumerator_Guard -> Enumerator_Guard -> Enumerator_Guard)
-> (Enumerator_Guard -> Enumerator_Guard -> Enumerator_Guard)
-> Ord Enumerator_Guard
Enumerator_Guard -> Enumerator_Guard -> Bool
Enumerator_Guard -> Enumerator_Guard -> Ordering
Enumerator_Guard -> Enumerator_Guard -> Enumerator_Guard
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Enumerator_Guard -> Enumerator_Guard -> Ordering
compare :: Enumerator_Guard -> Enumerator_Guard -> Ordering
$c< :: Enumerator_Guard -> Enumerator_Guard -> Bool
< :: Enumerator_Guard -> Enumerator_Guard -> Bool
$c<= :: Enumerator_Guard -> Enumerator_Guard -> Bool
<= :: Enumerator_Guard -> Enumerator_Guard -> Bool
$c> :: Enumerator_Guard -> Enumerator_Guard -> Bool
> :: Enumerator_Guard -> Enumerator_Guard -> Bool
$c>= :: Enumerator_Guard -> Enumerator_Guard -> Bool
>= :: Enumerator_Guard -> Enumerator_Guard -> Bool
$cmax :: Enumerator_Guard -> Enumerator_Guard -> Enumerator_Guard
max :: Enumerator_Guard -> Enumerator_Guard -> Enumerator_Guard
$cmin :: Enumerator_Guard -> Enumerator_Guard -> Enumerator_Guard
min :: Enumerator_Guard -> Enumerator_Guard -> Enumerator_Guard
Ord, ReadPrec [Enumerator_Guard]
ReadPrec Enumerator_Guard
Int -> ReadS Enumerator_Guard
ReadS [Enumerator_Guard]
(Int -> ReadS Enumerator_Guard)
-> ReadS [Enumerator_Guard]
-> ReadPrec Enumerator_Guard
-> ReadPrec [Enumerator_Guard]
-> Read Enumerator_Guard
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Enumerator_Guard
readsPrec :: Int -> ReadS Enumerator_Guard
$creadList :: ReadS [Enumerator_Guard]
readList :: ReadS [Enumerator_Guard]
$creadPrec :: ReadPrec Enumerator_Guard
readPrec :: ReadPrec Enumerator_Guard
$creadListPrec :: ReadPrec [Enumerator_Guard]
readListPrec :: ReadPrec [Enumerator_Guard]
Read, Int -> Enumerator_Guard -> String -> String
[Enumerator_Guard] -> String -> String
Enumerator_Guard -> String
(Int -> Enumerator_Guard -> String -> String)
-> (Enumerator_Guard -> String)
-> ([Enumerator_Guard] -> String -> String)
-> Show Enumerator_Guard
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Enumerator_Guard -> String -> String
showsPrec :: Int -> Enumerator_Guard -> String -> String
$cshow :: Enumerator_Guard -> String
show :: Enumerator_Guard -> String
$cshowList :: [Enumerator_Guard] -> String -> String
showList :: [Enumerator_Guard] -> String -> String
Show)

_Enumerator_Guard :: Name
_Enumerator_Guard = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Enumerator.Guard")

_Enumerator_Guard_cond :: Name
_Enumerator_Guard_cond = (String -> Name
Core.Name String
"cond")

data ImportExportStat = 
  ImportExportStatImport Import |
  ImportExportStatExport Export
  deriving (ImportExportStat -> ImportExportStat -> Bool
(ImportExportStat -> ImportExportStat -> Bool)
-> (ImportExportStat -> ImportExportStat -> Bool)
-> Eq ImportExportStat
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ImportExportStat -> ImportExportStat -> Bool
== :: ImportExportStat -> ImportExportStat -> Bool
$c/= :: ImportExportStat -> ImportExportStat -> Bool
/= :: ImportExportStat -> ImportExportStat -> Bool
Eq, Eq ImportExportStat
Eq ImportExportStat =>
(ImportExportStat -> ImportExportStat -> Ordering)
-> (ImportExportStat -> ImportExportStat -> Bool)
-> (ImportExportStat -> ImportExportStat -> Bool)
-> (ImportExportStat -> ImportExportStat -> Bool)
-> (ImportExportStat -> ImportExportStat -> Bool)
-> (ImportExportStat -> ImportExportStat -> ImportExportStat)
-> (ImportExportStat -> ImportExportStat -> ImportExportStat)
-> Ord ImportExportStat
ImportExportStat -> ImportExportStat -> Bool
ImportExportStat -> ImportExportStat -> Ordering
ImportExportStat -> ImportExportStat -> ImportExportStat
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ImportExportStat -> ImportExportStat -> Ordering
compare :: ImportExportStat -> ImportExportStat -> Ordering
$c< :: ImportExportStat -> ImportExportStat -> Bool
< :: ImportExportStat -> ImportExportStat -> Bool
$c<= :: ImportExportStat -> ImportExportStat -> Bool
<= :: ImportExportStat -> ImportExportStat -> Bool
$c> :: ImportExportStat -> ImportExportStat -> Bool
> :: ImportExportStat -> ImportExportStat -> Bool
$c>= :: ImportExportStat -> ImportExportStat -> Bool
>= :: ImportExportStat -> ImportExportStat -> Bool
$cmax :: ImportExportStat -> ImportExportStat -> ImportExportStat
max :: ImportExportStat -> ImportExportStat -> ImportExportStat
$cmin :: ImportExportStat -> ImportExportStat -> ImportExportStat
min :: ImportExportStat -> ImportExportStat -> ImportExportStat
Ord, ReadPrec [ImportExportStat]
ReadPrec ImportExportStat
Int -> ReadS ImportExportStat
ReadS [ImportExportStat]
(Int -> ReadS ImportExportStat)
-> ReadS [ImportExportStat]
-> ReadPrec ImportExportStat
-> ReadPrec [ImportExportStat]
-> Read ImportExportStat
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ImportExportStat
readsPrec :: Int -> ReadS ImportExportStat
$creadList :: ReadS [ImportExportStat]
readList :: ReadS [ImportExportStat]
$creadPrec :: ReadPrec ImportExportStat
readPrec :: ReadPrec ImportExportStat
$creadListPrec :: ReadPrec [ImportExportStat]
readListPrec :: ReadPrec [ImportExportStat]
Read, Int -> ImportExportStat -> String -> String
[ImportExportStat] -> String -> String
ImportExportStat -> String
(Int -> ImportExportStat -> String -> String)
-> (ImportExportStat -> String)
-> ([ImportExportStat] -> String -> String)
-> Show ImportExportStat
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ImportExportStat -> String -> String
showsPrec :: Int -> ImportExportStat -> String -> String
$cshow :: ImportExportStat -> String
show :: ImportExportStat -> String
$cshowList :: [ImportExportStat] -> String -> String
showList :: [ImportExportStat] -> String -> String
Show)

_ImportExportStat :: Name
_ImportExportStat = (String -> Name
Core.Name String
"hydra/langs/scala/meta.ImportExportStat")

_ImportExportStat_import :: Name
_ImportExportStat_import = (String -> Name
Core.Name String
"import")

_ImportExportStat_export :: Name
_ImportExportStat_export = (String -> Name
Core.Name String
"export")

data Import = 
  Import {
    Import -> [Importer]
importImporters :: [Importer]}
  deriving (Import -> Import -> Bool
(Import -> Import -> Bool)
-> (Import -> Import -> Bool) -> Eq Import
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Import -> Import -> Bool
== :: Import -> Import -> Bool
$c/= :: Import -> Import -> Bool
/= :: Import -> Import -> Bool
Eq, Eq Import
Eq Import =>
(Import -> Import -> Ordering)
-> (Import -> Import -> Bool)
-> (Import -> Import -> Bool)
-> (Import -> Import -> Bool)
-> (Import -> Import -> Bool)
-> (Import -> Import -> Import)
-> (Import -> Import -> Import)
-> Ord Import
Import -> Import -> Bool
Import -> Import -> Ordering
Import -> Import -> Import
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Import -> Import -> Ordering
compare :: Import -> Import -> Ordering
$c< :: Import -> Import -> Bool
< :: Import -> Import -> Bool
$c<= :: Import -> Import -> Bool
<= :: Import -> Import -> Bool
$c> :: Import -> Import -> Bool
> :: Import -> Import -> Bool
$c>= :: Import -> Import -> Bool
>= :: Import -> Import -> Bool
$cmax :: Import -> Import -> Import
max :: Import -> Import -> Import
$cmin :: Import -> Import -> Import
min :: Import -> Import -> Import
Ord, ReadPrec [Import]
ReadPrec Import
Int -> ReadS Import
ReadS [Import]
(Int -> ReadS Import)
-> ReadS [Import]
-> ReadPrec Import
-> ReadPrec [Import]
-> Read Import
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Import
readsPrec :: Int -> ReadS Import
$creadList :: ReadS [Import]
readList :: ReadS [Import]
$creadPrec :: ReadPrec Import
readPrec :: ReadPrec Import
$creadListPrec :: ReadPrec [Import]
readListPrec :: ReadPrec [Import]
Read, Int -> Import -> String -> String
[Import] -> String -> String
Import -> String
(Int -> Import -> String -> String)
-> (Import -> String)
-> ([Import] -> String -> String)
-> Show Import
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Import -> String -> String
showsPrec :: Int -> Import -> String -> String
$cshow :: Import -> String
show :: Import -> String
$cshowList :: [Import] -> String -> String
showList :: [Import] -> String -> String
Show)

_Import :: Name
_Import = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Import")

_Import_importers :: Name
_Import_importers = (String -> Name
Core.Name String
"importers")

data Export = 
  Export {
    Export -> [Importer]
exportImporters :: [Importer]}
  deriving (Export -> Export -> Bool
(Export -> Export -> Bool)
-> (Export -> Export -> Bool) -> Eq Export
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Export -> Export -> Bool
== :: Export -> Export -> Bool
$c/= :: Export -> Export -> Bool
/= :: Export -> Export -> Bool
Eq, Eq Export
Eq Export =>
(Export -> Export -> Ordering)
-> (Export -> Export -> Bool)
-> (Export -> Export -> Bool)
-> (Export -> Export -> Bool)
-> (Export -> Export -> Bool)
-> (Export -> Export -> Export)
-> (Export -> Export -> Export)
-> Ord Export
Export -> Export -> Bool
Export -> Export -> Ordering
Export -> Export -> Export
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Export -> Export -> Ordering
compare :: Export -> Export -> Ordering
$c< :: Export -> Export -> Bool
< :: Export -> Export -> Bool
$c<= :: Export -> Export -> Bool
<= :: Export -> Export -> Bool
$c> :: Export -> Export -> Bool
> :: Export -> Export -> Bool
$c>= :: Export -> Export -> Bool
>= :: Export -> Export -> Bool
$cmax :: Export -> Export -> Export
max :: Export -> Export -> Export
$cmin :: Export -> Export -> Export
min :: Export -> Export -> Export
Ord, ReadPrec [Export]
ReadPrec Export
Int -> ReadS Export
ReadS [Export]
(Int -> ReadS Export)
-> ReadS [Export]
-> ReadPrec Export
-> ReadPrec [Export]
-> Read Export
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Export
readsPrec :: Int -> ReadS Export
$creadList :: ReadS [Export]
readList :: ReadS [Export]
$creadPrec :: ReadPrec Export
readPrec :: ReadPrec Export
$creadListPrec :: ReadPrec [Export]
readListPrec :: ReadPrec [Export]
Read, Int -> Export -> String -> String
[Export] -> String -> String
Export -> String
(Int -> Export -> String -> String)
-> (Export -> String)
-> ([Export] -> String -> String)
-> Show Export
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Export -> String -> String
showsPrec :: Int -> Export -> String -> String
$cshow :: Export -> String
show :: Export -> String
$cshowList :: [Export] -> String -> String
showList :: [Export] -> String -> String
Show)

_Export :: Name
_Export = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Export")

_Export_importers :: Name
_Export_importers = (String -> Name
Core.Name String
"importers")

data Importer = 
  Importer {
    Importer -> Data_Ref
importerRef :: Data_Ref,
    Importer -> [Importee]
importerImportees :: [Importee]}
  deriving (Importer -> Importer -> Bool
(Importer -> Importer -> Bool)
-> (Importer -> Importer -> Bool) -> Eq Importer
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Importer -> Importer -> Bool
== :: Importer -> Importer -> Bool
$c/= :: Importer -> Importer -> Bool
/= :: Importer -> Importer -> Bool
Eq, Eq Importer
Eq Importer =>
(Importer -> Importer -> Ordering)
-> (Importer -> Importer -> Bool)
-> (Importer -> Importer -> Bool)
-> (Importer -> Importer -> Bool)
-> (Importer -> Importer -> Bool)
-> (Importer -> Importer -> Importer)
-> (Importer -> Importer -> Importer)
-> Ord Importer
Importer -> Importer -> Bool
Importer -> Importer -> Ordering
Importer -> Importer -> Importer
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Importer -> Importer -> Ordering
compare :: Importer -> Importer -> Ordering
$c< :: Importer -> Importer -> Bool
< :: Importer -> Importer -> Bool
$c<= :: Importer -> Importer -> Bool
<= :: Importer -> Importer -> Bool
$c> :: Importer -> Importer -> Bool
> :: Importer -> Importer -> Bool
$c>= :: Importer -> Importer -> Bool
>= :: Importer -> Importer -> Bool
$cmax :: Importer -> Importer -> Importer
max :: Importer -> Importer -> Importer
$cmin :: Importer -> Importer -> Importer
min :: Importer -> Importer -> Importer
Ord, ReadPrec [Importer]
ReadPrec Importer
Int -> ReadS Importer
ReadS [Importer]
(Int -> ReadS Importer)
-> ReadS [Importer]
-> ReadPrec Importer
-> ReadPrec [Importer]
-> Read Importer
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Importer
readsPrec :: Int -> ReadS Importer
$creadList :: ReadS [Importer]
readList :: ReadS [Importer]
$creadPrec :: ReadPrec Importer
readPrec :: ReadPrec Importer
$creadListPrec :: ReadPrec [Importer]
readListPrec :: ReadPrec [Importer]
Read, Int -> Importer -> String -> String
[Importer] -> String -> String
Importer -> String
(Int -> Importer -> String -> String)
-> (Importer -> String)
-> ([Importer] -> String -> String)
-> Show Importer
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Importer -> String -> String
showsPrec :: Int -> Importer -> String -> String
$cshow :: Importer -> String
show :: Importer -> String
$cshowList :: [Importer] -> String -> String
showList :: [Importer] -> String -> String
Show)

_Importer :: Name
_Importer = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Importer")

_Importer_ref :: Name
_Importer_ref = (String -> Name
Core.Name String
"ref")

_Importer_importees :: Name
_Importer_importees = (String -> Name
Core.Name String
"importees")

data Importee = 
  ImporteeWildcard  |
  ImporteeGiven Importee_Given |
  ImporteeGivenAll  |
  ImporteeName Importee_Name |
  ImporteeRename Importee_Rename |
  ImporteeUnimport Importee_Unimport
  deriving (Importee -> Importee -> Bool
(Importee -> Importee -> Bool)
-> (Importee -> Importee -> Bool) -> Eq Importee
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Importee -> Importee -> Bool
== :: Importee -> Importee -> Bool
$c/= :: Importee -> Importee -> Bool
/= :: Importee -> Importee -> Bool
Eq, Eq Importee
Eq Importee =>
(Importee -> Importee -> Ordering)
-> (Importee -> Importee -> Bool)
-> (Importee -> Importee -> Bool)
-> (Importee -> Importee -> Bool)
-> (Importee -> Importee -> Bool)
-> (Importee -> Importee -> Importee)
-> (Importee -> Importee -> Importee)
-> Ord Importee
Importee -> Importee -> Bool
Importee -> Importee -> Ordering
Importee -> Importee -> Importee
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Importee -> Importee -> Ordering
compare :: Importee -> Importee -> Ordering
$c< :: Importee -> Importee -> Bool
< :: Importee -> Importee -> Bool
$c<= :: Importee -> Importee -> Bool
<= :: Importee -> Importee -> Bool
$c> :: Importee -> Importee -> Bool
> :: Importee -> Importee -> Bool
$c>= :: Importee -> Importee -> Bool
>= :: Importee -> Importee -> Bool
$cmax :: Importee -> Importee -> Importee
max :: Importee -> Importee -> Importee
$cmin :: Importee -> Importee -> Importee
min :: Importee -> Importee -> Importee
Ord, ReadPrec [Importee]
ReadPrec Importee
Int -> ReadS Importee
ReadS [Importee]
(Int -> ReadS Importee)
-> ReadS [Importee]
-> ReadPrec Importee
-> ReadPrec [Importee]
-> Read Importee
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Importee
readsPrec :: Int -> ReadS Importee
$creadList :: ReadS [Importee]
readList :: ReadS [Importee]
$creadPrec :: ReadPrec Importee
readPrec :: ReadPrec Importee
$creadListPrec :: ReadPrec [Importee]
readListPrec :: ReadPrec [Importee]
Read, Int -> Importee -> String -> String
[Importee] -> String -> String
Importee -> String
(Int -> Importee -> String -> String)
-> (Importee -> String)
-> ([Importee] -> String -> String)
-> Show Importee
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Importee -> String -> String
showsPrec :: Int -> Importee -> String -> String
$cshow :: Importee -> String
show :: Importee -> String
$cshowList :: [Importee] -> String -> String
showList :: [Importee] -> String -> String
Show)

_Importee :: Name
_Importee = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Importee")

_Importee_wildcard :: Name
_Importee_wildcard = (String -> Name
Core.Name String
"wildcard")

_Importee_given :: Name
_Importee_given = (String -> Name
Core.Name String
"given")

_Importee_givenAll :: Name
_Importee_givenAll = (String -> Name
Core.Name String
"givenAll")

_Importee_name :: Name
_Importee_name = (String -> Name
Core.Name String
"name")

_Importee_rename :: Name
_Importee_rename = (String -> Name
Core.Name String
"rename")

_Importee_unimport :: Name
_Importee_unimport = (String -> Name
Core.Name String
"unimport")

data Importee_Given = 
  Importee_Given {
    Importee_Given -> Type
importee_GivenTpe :: Type}
  deriving (Importee_Given -> Importee_Given -> Bool
(Importee_Given -> Importee_Given -> Bool)
-> (Importee_Given -> Importee_Given -> Bool) -> Eq Importee_Given
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Importee_Given -> Importee_Given -> Bool
== :: Importee_Given -> Importee_Given -> Bool
$c/= :: Importee_Given -> Importee_Given -> Bool
/= :: Importee_Given -> Importee_Given -> Bool
Eq, Eq Importee_Given
Eq Importee_Given =>
(Importee_Given -> Importee_Given -> Ordering)
-> (Importee_Given -> Importee_Given -> Bool)
-> (Importee_Given -> Importee_Given -> Bool)
-> (Importee_Given -> Importee_Given -> Bool)
-> (Importee_Given -> Importee_Given -> Bool)
-> (Importee_Given -> Importee_Given -> Importee_Given)
-> (Importee_Given -> Importee_Given -> Importee_Given)
-> Ord Importee_Given
Importee_Given -> Importee_Given -> Bool
Importee_Given -> Importee_Given -> Ordering
Importee_Given -> Importee_Given -> Importee_Given
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Importee_Given -> Importee_Given -> Ordering
compare :: Importee_Given -> Importee_Given -> Ordering
$c< :: Importee_Given -> Importee_Given -> Bool
< :: Importee_Given -> Importee_Given -> Bool
$c<= :: Importee_Given -> Importee_Given -> Bool
<= :: Importee_Given -> Importee_Given -> Bool
$c> :: Importee_Given -> Importee_Given -> Bool
> :: Importee_Given -> Importee_Given -> Bool
$c>= :: Importee_Given -> Importee_Given -> Bool
>= :: Importee_Given -> Importee_Given -> Bool
$cmax :: Importee_Given -> Importee_Given -> Importee_Given
max :: Importee_Given -> Importee_Given -> Importee_Given
$cmin :: Importee_Given -> Importee_Given -> Importee_Given
min :: Importee_Given -> Importee_Given -> Importee_Given
Ord, ReadPrec [Importee_Given]
ReadPrec Importee_Given
Int -> ReadS Importee_Given
ReadS [Importee_Given]
(Int -> ReadS Importee_Given)
-> ReadS [Importee_Given]
-> ReadPrec Importee_Given
-> ReadPrec [Importee_Given]
-> Read Importee_Given
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Importee_Given
readsPrec :: Int -> ReadS Importee_Given
$creadList :: ReadS [Importee_Given]
readList :: ReadS [Importee_Given]
$creadPrec :: ReadPrec Importee_Given
readPrec :: ReadPrec Importee_Given
$creadListPrec :: ReadPrec [Importee_Given]
readListPrec :: ReadPrec [Importee_Given]
Read, Int -> Importee_Given -> String -> String
[Importee_Given] -> String -> String
Importee_Given -> String
(Int -> Importee_Given -> String -> String)
-> (Importee_Given -> String)
-> ([Importee_Given] -> String -> String)
-> Show Importee_Given
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Importee_Given -> String -> String
showsPrec :: Int -> Importee_Given -> String -> String
$cshow :: Importee_Given -> String
show :: Importee_Given -> String
$cshowList :: [Importee_Given] -> String -> String
showList :: [Importee_Given] -> String -> String
Show)

_Importee_Given :: Name
_Importee_Given = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Importee.Given")

_Importee_Given_tpe :: Name
_Importee_Given_tpe = (String -> Name
Core.Name String
"tpe")

data Importee_Name = 
  Importee_Name {
    Importee_Name -> Name
importee_NameName :: Name}
  deriving (Importee_Name -> Importee_Name -> Bool
(Importee_Name -> Importee_Name -> Bool)
-> (Importee_Name -> Importee_Name -> Bool) -> Eq Importee_Name
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Importee_Name -> Importee_Name -> Bool
== :: Importee_Name -> Importee_Name -> Bool
$c/= :: Importee_Name -> Importee_Name -> Bool
/= :: Importee_Name -> Importee_Name -> Bool
Eq, Eq Importee_Name
Eq Importee_Name =>
(Importee_Name -> Importee_Name -> Ordering)
-> (Importee_Name -> Importee_Name -> Bool)
-> (Importee_Name -> Importee_Name -> Bool)
-> (Importee_Name -> Importee_Name -> Bool)
-> (Importee_Name -> Importee_Name -> Bool)
-> (Importee_Name -> Importee_Name -> Importee_Name)
-> (Importee_Name -> Importee_Name -> Importee_Name)
-> Ord Importee_Name
Importee_Name -> Importee_Name -> Bool
Importee_Name -> Importee_Name -> Ordering
Importee_Name -> Importee_Name -> Importee_Name
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Importee_Name -> Importee_Name -> Ordering
compare :: Importee_Name -> Importee_Name -> Ordering
$c< :: Importee_Name -> Importee_Name -> Bool
< :: Importee_Name -> Importee_Name -> Bool
$c<= :: Importee_Name -> Importee_Name -> Bool
<= :: Importee_Name -> Importee_Name -> Bool
$c> :: Importee_Name -> Importee_Name -> Bool
> :: Importee_Name -> Importee_Name -> Bool
$c>= :: Importee_Name -> Importee_Name -> Bool
>= :: Importee_Name -> Importee_Name -> Bool
$cmax :: Importee_Name -> Importee_Name -> Importee_Name
max :: Importee_Name -> Importee_Name -> Importee_Name
$cmin :: Importee_Name -> Importee_Name -> Importee_Name
min :: Importee_Name -> Importee_Name -> Importee_Name
Ord, ReadPrec [Importee_Name]
ReadPrec Importee_Name
Int -> ReadS Importee_Name
ReadS [Importee_Name]
(Int -> ReadS Importee_Name)
-> ReadS [Importee_Name]
-> ReadPrec Importee_Name
-> ReadPrec [Importee_Name]
-> Read Importee_Name
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Importee_Name
readsPrec :: Int -> ReadS Importee_Name
$creadList :: ReadS [Importee_Name]
readList :: ReadS [Importee_Name]
$creadPrec :: ReadPrec Importee_Name
readPrec :: ReadPrec Importee_Name
$creadListPrec :: ReadPrec [Importee_Name]
readListPrec :: ReadPrec [Importee_Name]
Read, Int -> Importee_Name -> String -> String
[Importee_Name] -> String -> String
Importee_Name -> String
(Int -> Importee_Name -> String -> String)
-> (Importee_Name -> String)
-> ([Importee_Name] -> String -> String)
-> Show Importee_Name
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Importee_Name -> String -> String
showsPrec :: Int -> Importee_Name -> String -> String
$cshow :: Importee_Name -> String
show :: Importee_Name -> String
$cshowList :: [Importee_Name] -> String -> String
showList :: [Importee_Name] -> String -> String
Show)

_Importee_Name :: Name
_Importee_Name = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Importee.Name")

_Importee_Name_name :: Name
_Importee_Name_name = (String -> Name
Core.Name String
"name")

data Importee_Rename = 
  Importee_Rename {
    Importee_Rename -> Name
importee_RenameName :: Name,
    Importee_Rename -> Name
importee_RenameRename :: Name}
  deriving (Importee_Rename -> Importee_Rename -> Bool
(Importee_Rename -> Importee_Rename -> Bool)
-> (Importee_Rename -> Importee_Rename -> Bool)
-> Eq Importee_Rename
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Importee_Rename -> Importee_Rename -> Bool
== :: Importee_Rename -> Importee_Rename -> Bool
$c/= :: Importee_Rename -> Importee_Rename -> Bool
/= :: Importee_Rename -> Importee_Rename -> Bool
Eq, Eq Importee_Rename
Eq Importee_Rename =>
(Importee_Rename -> Importee_Rename -> Ordering)
-> (Importee_Rename -> Importee_Rename -> Bool)
-> (Importee_Rename -> Importee_Rename -> Bool)
-> (Importee_Rename -> Importee_Rename -> Bool)
-> (Importee_Rename -> Importee_Rename -> Bool)
-> (Importee_Rename -> Importee_Rename -> Importee_Rename)
-> (Importee_Rename -> Importee_Rename -> Importee_Rename)
-> Ord Importee_Rename
Importee_Rename -> Importee_Rename -> Bool
Importee_Rename -> Importee_Rename -> Ordering
Importee_Rename -> Importee_Rename -> Importee_Rename
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Importee_Rename -> Importee_Rename -> Ordering
compare :: Importee_Rename -> Importee_Rename -> Ordering
$c< :: Importee_Rename -> Importee_Rename -> Bool
< :: Importee_Rename -> Importee_Rename -> Bool
$c<= :: Importee_Rename -> Importee_Rename -> Bool
<= :: Importee_Rename -> Importee_Rename -> Bool
$c> :: Importee_Rename -> Importee_Rename -> Bool
> :: Importee_Rename -> Importee_Rename -> Bool
$c>= :: Importee_Rename -> Importee_Rename -> Bool
>= :: Importee_Rename -> Importee_Rename -> Bool
$cmax :: Importee_Rename -> Importee_Rename -> Importee_Rename
max :: Importee_Rename -> Importee_Rename -> Importee_Rename
$cmin :: Importee_Rename -> Importee_Rename -> Importee_Rename
min :: Importee_Rename -> Importee_Rename -> Importee_Rename
Ord, ReadPrec [Importee_Rename]
ReadPrec Importee_Rename
Int -> ReadS Importee_Rename
ReadS [Importee_Rename]
(Int -> ReadS Importee_Rename)
-> ReadS [Importee_Rename]
-> ReadPrec Importee_Rename
-> ReadPrec [Importee_Rename]
-> Read Importee_Rename
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Importee_Rename
readsPrec :: Int -> ReadS Importee_Rename
$creadList :: ReadS [Importee_Rename]
readList :: ReadS [Importee_Rename]
$creadPrec :: ReadPrec Importee_Rename
readPrec :: ReadPrec Importee_Rename
$creadListPrec :: ReadPrec [Importee_Rename]
readListPrec :: ReadPrec [Importee_Rename]
Read, Int -> Importee_Rename -> String -> String
[Importee_Rename] -> String -> String
Importee_Rename -> String
(Int -> Importee_Rename -> String -> String)
-> (Importee_Rename -> String)
-> ([Importee_Rename] -> String -> String)
-> Show Importee_Rename
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Importee_Rename -> String -> String
showsPrec :: Int -> Importee_Rename -> String -> String
$cshow :: Importee_Rename -> String
show :: Importee_Rename -> String
$cshowList :: [Importee_Rename] -> String -> String
showList :: [Importee_Rename] -> String -> String
Show)

_Importee_Rename :: Name
_Importee_Rename = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Importee.Rename")

_Importee_Rename_name :: Name
_Importee_Rename_name = (String -> Name
Core.Name String
"name")

_Importee_Rename_rename :: Name
_Importee_Rename_rename = (String -> Name
Core.Name String
"rename")

data Importee_Unimport = 
  Importee_Unimport {
    Importee_Unimport -> Name
importee_UnimportName :: Name}
  deriving (Importee_Unimport -> Importee_Unimport -> Bool
(Importee_Unimport -> Importee_Unimport -> Bool)
-> (Importee_Unimport -> Importee_Unimport -> Bool)
-> Eq Importee_Unimport
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Importee_Unimport -> Importee_Unimport -> Bool
== :: Importee_Unimport -> Importee_Unimport -> Bool
$c/= :: Importee_Unimport -> Importee_Unimport -> Bool
/= :: Importee_Unimport -> Importee_Unimport -> Bool
Eq, Eq Importee_Unimport
Eq Importee_Unimport =>
(Importee_Unimport -> Importee_Unimport -> Ordering)
-> (Importee_Unimport -> Importee_Unimport -> Bool)
-> (Importee_Unimport -> Importee_Unimport -> Bool)
-> (Importee_Unimport -> Importee_Unimport -> Bool)
-> (Importee_Unimport -> Importee_Unimport -> Bool)
-> (Importee_Unimport -> Importee_Unimport -> Importee_Unimport)
-> (Importee_Unimport -> Importee_Unimport -> Importee_Unimport)
-> Ord Importee_Unimport
Importee_Unimport -> Importee_Unimport -> Bool
Importee_Unimport -> Importee_Unimport -> Ordering
Importee_Unimport -> Importee_Unimport -> Importee_Unimport
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Importee_Unimport -> Importee_Unimport -> Ordering
compare :: Importee_Unimport -> Importee_Unimport -> Ordering
$c< :: Importee_Unimport -> Importee_Unimport -> Bool
< :: Importee_Unimport -> Importee_Unimport -> Bool
$c<= :: Importee_Unimport -> Importee_Unimport -> Bool
<= :: Importee_Unimport -> Importee_Unimport -> Bool
$c> :: Importee_Unimport -> Importee_Unimport -> Bool
> :: Importee_Unimport -> Importee_Unimport -> Bool
$c>= :: Importee_Unimport -> Importee_Unimport -> Bool
>= :: Importee_Unimport -> Importee_Unimport -> Bool
$cmax :: Importee_Unimport -> Importee_Unimport -> Importee_Unimport
max :: Importee_Unimport -> Importee_Unimport -> Importee_Unimport
$cmin :: Importee_Unimport -> Importee_Unimport -> Importee_Unimport
min :: Importee_Unimport -> Importee_Unimport -> Importee_Unimport
Ord, ReadPrec [Importee_Unimport]
ReadPrec Importee_Unimport
Int -> ReadS Importee_Unimport
ReadS [Importee_Unimport]
(Int -> ReadS Importee_Unimport)
-> ReadS [Importee_Unimport]
-> ReadPrec Importee_Unimport
-> ReadPrec [Importee_Unimport]
-> Read Importee_Unimport
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Importee_Unimport
readsPrec :: Int -> ReadS Importee_Unimport
$creadList :: ReadS [Importee_Unimport]
readList :: ReadS [Importee_Unimport]
$creadPrec :: ReadPrec Importee_Unimport
readPrec :: ReadPrec Importee_Unimport
$creadListPrec :: ReadPrec [Importee_Unimport]
readListPrec :: ReadPrec [Importee_Unimport]
Read, Int -> Importee_Unimport -> String -> String
[Importee_Unimport] -> String -> String
Importee_Unimport -> String
(Int -> Importee_Unimport -> String -> String)
-> (Importee_Unimport -> String)
-> ([Importee_Unimport] -> String -> String)
-> Show Importee_Unimport
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Importee_Unimport -> String -> String
showsPrec :: Int -> Importee_Unimport -> String -> String
$cshow :: Importee_Unimport -> String
show :: Importee_Unimport -> String
$cshowList :: [Importee_Unimport] -> String -> String
showList :: [Importee_Unimport] -> String -> String
Show)

_Importee_Unimport :: Name
_Importee_Unimport = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Importee.Unimport")

_Importee_Unimport_name :: Name
_Importee_Unimport_name = (String -> Name
Core.Name String
"name")

data CaseTree = 
  CaseTreeCase Case |
  CaseTreeTypeCase TypeCase
  deriving (CaseTree -> CaseTree -> Bool
(CaseTree -> CaseTree -> Bool)
-> (CaseTree -> CaseTree -> Bool) -> Eq CaseTree
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: CaseTree -> CaseTree -> Bool
== :: CaseTree -> CaseTree -> Bool
$c/= :: CaseTree -> CaseTree -> Bool
/= :: CaseTree -> CaseTree -> Bool
Eq, Eq CaseTree
Eq CaseTree =>
(CaseTree -> CaseTree -> Ordering)
-> (CaseTree -> CaseTree -> Bool)
-> (CaseTree -> CaseTree -> Bool)
-> (CaseTree -> CaseTree -> Bool)
-> (CaseTree -> CaseTree -> Bool)
-> (CaseTree -> CaseTree -> CaseTree)
-> (CaseTree -> CaseTree -> CaseTree)
-> Ord CaseTree
CaseTree -> CaseTree -> Bool
CaseTree -> CaseTree -> Ordering
CaseTree -> CaseTree -> CaseTree
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: CaseTree -> CaseTree -> Ordering
compare :: CaseTree -> CaseTree -> Ordering
$c< :: CaseTree -> CaseTree -> Bool
< :: CaseTree -> CaseTree -> Bool
$c<= :: CaseTree -> CaseTree -> Bool
<= :: CaseTree -> CaseTree -> Bool
$c> :: CaseTree -> CaseTree -> Bool
> :: CaseTree -> CaseTree -> Bool
$c>= :: CaseTree -> CaseTree -> Bool
>= :: CaseTree -> CaseTree -> Bool
$cmax :: CaseTree -> CaseTree -> CaseTree
max :: CaseTree -> CaseTree -> CaseTree
$cmin :: CaseTree -> CaseTree -> CaseTree
min :: CaseTree -> CaseTree -> CaseTree
Ord, ReadPrec [CaseTree]
ReadPrec CaseTree
Int -> ReadS CaseTree
ReadS [CaseTree]
(Int -> ReadS CaseTree)
-> ReadS [CaseTree]
-> ReadPrec CaseTree
-> ReadPrec [CaseTree]
-> Read CaseTree
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS CaseTree
readsPrec :: Int -> ReadS CaseTree
$creadList :: ReadS [CaseTree]
readList :: ReadS [CaseTree]
$creadPrec :: ReadPrec CaseTree
readPrec :: ReadPrec CaseTree
$creadListPrec :: ReadPrec [CaseTree]
readListPrec :: ReadPrec [CaseTree]
Read, Int -> CaseTree -> String -> String
[CaseTree] -> String -> String
CaseTree -> String
(Int -> CaseTree -> String -> String)
-> (CaseTree -> String)
-> ([CaseTree] -> String -> String)
-> Show CaseTree
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> CaseTree -> String -> String
showsPrec :: Int -> CaseTree -> String -> String
$cshow :: CaseTree -> String
show :: CaseTree -> String
$cshowList :: [CaseTree] -> String -> String
showList :: [CaseTree] -> String -> String
Show)

_CaseTree :: Name
_CaseTree = (String -> Name
Core.Name String
"hydra/langs/scala/meta.CaseTree")

_CaseTree_case :: Name
_CaseTree_case = (String -> Name
Core.Name String
"case")

_CaseTree_typeCase :: Name
_CaseTree_typeCase = (String -> Name
Core.Name String
"typeCase")

data Case = 
  Case {
    Case -> Pat
casePat :: Pat,
    Case -> Maybe Data
caseCond :: (Maybe Data),
    Case -> Data
caseBody :: Data}
  deriving (Case -> Case -> Bool
(Case -> Case -> Bool) -> (Case -> Case -> Bool) -> Eq Case
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Case -> Case -> Bool
== :: Case -> Case -> Bool
$c/= :: Case -> Case -> Bool
/= :: Case -> Case -> Bool
Eq, Eq Case
Eq Case =>
(Case -> Case -> Ordering)
-> (Case -> Case -> Bool)
-> (Case -> Case -> Bool)
-> (Case -> Case -> Bool)
-> (Case -> Case -> Bool)
-> (Case -> Case -> Case)
-> (Case -> Case -> Case)
-> Ord Case
Case -> Case -> Bool
Case -> Case -> Ordering
Case -> Case -> Case
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Case -> Case -> Ordering
compare :: Case -> Case -> Ordering
$c< :: Case -> Case -> Bool
< :: Case -> Case -> Bool
$c<= :: Case -> Case -> Bool
<= :: Case -> Case -> Bool
$c> :: Case -> Case -> Bool
> :: Case -> Case -> Bool
$c>= :: Case -> Case -> Bool
>= :: Case -> Case -> Bool
$cmax :: Case -> Case -> Case
max :: Case -> Case -> Case
$cmin :: Case -> Case -> Case
min :: Case -> Case -> Case
Ord, ReadPrec [Case]
ReadPrec Case
Int -> ReadS Case
ReadS [Case]
(Int -> ReadS Case)
-> ReadS [Case] -> ReadPrec Case -> ReadPrec [Case] -> Read Case
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Case
readsPrec :: Int -> ReadS Case
$creadList :: ReadS [Case]
readList :: ReadS [Case]
$creadPrec :: ReadPrec Case
readPrec :: ReadPrec Case
$creadListPrec :: ReadPrec [Case]
readListPrec :: ReadPrec [Case]
Read, Int -> Case -> String -> String
[Case] -> String -> String
Case -> String
(Int -> Case -> String -> String)
-> (Case -> String) -> ([Case] -> String -> String) -> Show Case
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Case -> String -> String
showsPrec :: Int -> Case -> String -> String
$cshow :: Case -> String
show :: Case -> String
$cshowList :: [Case] -> String -> String
showList :: [Case] -> String -> String
Show)

_Case :: Name
_Case = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Case")

_Case_pat :: Name
_Case_pat = (String -> Name
Core.Name String
"pat")

_Case_cond :: Name
_Case_cond = (String -> Name
Core.Name String
"cond")

_Case_body :: Name
_Case_body = (String -> Name
Core.Name String
"body")

data TypeCase = 
  TypeCase {
    TypeCase -> Type
typeCasePat :: Type,
    TypeCase -> Type
typeCaseBody :: Type}
  deriving (TypeCase -> TypeCase -> Bool
(TypeCase -> TypeCase -> Bool)
-> (TypeCase -> TypeCase -> Bool) -> Eq TypeCase
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TypeCase -> TypeCase -> Bool
== :: TypeCase -> TypeCase -> Bool
$c/= :: TypeCase -> TypeCase -> Bool
/= :: TypeCase -> TypeCase -> Bool
Eq, Eq TypeCase
Eq TypeCase =>
(TypeCase -> TypeCase -> Ordering)
-> (TypeCase -> TypeCase -> Bool)
-> (TypeCase -> TypeCase -> Bool)
-> (TypeCase -> TypeCase -> Bool)
-> (TypeCase -> TypeCase -> Bool)
-> (TypeCase -> TypeCase -> TypeCase)
-> (TypeCase -> TypeCase -> TypeCase)
-> Ord TypeCase
TypeCase -> TypeCase -> Bool
TypeCase -> TypeCase -> Ordering
TypeCase -> TypeCase -> TypeCase
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: TypeCase -> TypeCase -> Ordering
compare :: TypeCase -> TypeCase -> Ordering
$c< :: TypeCase -> TypeCase -> Bool
< :: TypeCase -> TypeCase -> Bool
$c<= :: TypeCase -> TypeCase -> Bool
<= :: TypeCase -> TypeCase -> Bool
$c> :: TypeCase -> TypeCase -> Bool
> :: TypeCase -> TypeCase -> Bool
$c>= :: TypeCase -> TypeCase -> Bool
>= :: TypeCase -> TypeCase -> Bool
$cmax :: TypeCase -> TypeCase -> TypeCase
max :: TypeCase -> TypeCase -> TypeCase
$cmin :: TypeCase -> TypeCase -> TypeCase
min :: TypeCase -> TypeCase -> TypeCase
Ord, ReadPrec [TypeCase]
ReadPrec TypeCase
Int -> ReadS TypeCase
ReadS [TypeCase]
(Int -> ReadS TypeCase)
-> ReadS [TypeCase]
-> ReadPrec TypeCase
-> ReadPrec [TypeCase]
-> Read TypeCase
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS TypeCase
readsPrec :: Int -> ReadS TypeCase
$creadList :: ReadS [TypeCase]
readList :: ReadS [TypeCase]
$creadPrec :: ReadPrec TypeCase
readPrec :: ReadPrec TypeCase
$creadListPrec :: ReadPrec [TypeCase]
readListPrec :: ReadPrec [TypeCase]
Read, Int -> TypeCase -> String -> String
[TypeCase] -> String -> String
TypeCase -> String
(Int -> TypeCase -> String -> String)
-> (TypeCase -> String)
-> ([TypeCase] -> String -> String)
-> Show TypeCase
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> TypeCase -> String -> String
showsPrec :: Int -> TypeCase -> String -> String
$cshow :: TypeCase -> String
show :: TypeCase -> String
$cshowList :: [TypeCase] -> String -> String
showList :: [TypeCase] -> String -> String
Show)

_TypeCase :: Name
_TypeCase = (String -> Name
Core.Name String
"hydra/langs/scala/meta.TypeCase")

_TypeCase_pat :: Name
_TypeCase_pat = (String -> Name
Core.Name String
"pat")

_TypeCase_body :: Name
_TypeCase_body = (String -> Name
Core.Name String
"body")

data Source = 
  Source {
    Source -> [Stat]
sourceStats :: [Stat]}
  deriving (Source -> Source -> Bool
(Source -> Source -> Bool)
-> (Source -> Source -> Bool) -> Eq Source
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Source -> Source -> Bool
== :: Source -> Source -> Bool
$c/= :: Source -> Source -> Bool
/= :: Source -> Source -> Bool
Eq, Eq Source
Eq Source =>
(Source -> Source -> Ordering)
-> (Source -> Source -> Bool)
-> (Source -> Source -> Bool)
-> (Source -> Source -> Bool)
-> (Source -> Source -> Bool)
-> (Source -> Source -> Source)
-> (Source -> Source -> Source)
-> Ord Source
Source -> Source -> Bool
Source -> Source -> Ordering
Source -> Source -> Source
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Source -> Source -> Ordering
compare :: Source -> Source -> Ordering
$c< :: Source -> Source -> Bool
< :: Source -> Source -> Bool
$c<= :: Source -> Source -> Bool
<= :: Source -> Source -> Bool
$c> :: Source -> Source -> Bool
> :: Source -> Source -> Bool
$c>= :: Source -> Source -> Bool
>= :: Source -> Source -> Bool
$cmax :: Source -> Source -> Source
max :: Source -> Source -> Source
$cmin :: Source -> Source -> Source
min :: Source -> Source -> Source
Ord, ReadPrec [Source]
ReadPrec Source
Int -> ReadS Source
ReadS [Source]
(Int -> ReadS Source)
-> ReadS [Source]
-> ReadPrec Source
-> ReadPrec [Source]
-> Read Source
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Source
readsPrec :: Int -> ReadS Source
$creadList :: ReadS [Source]
readList :: ReadS [Source]
$creadPrec :: ReadPrec Source
readPrec :: ReadPrec Source
$creadListPrec :: ReadPrec [Source]
readListPrec :: ReadPrec [Source]
Read, Int -> Source -> String -> String
[Source] -> String -> String
Source -> String
(Int -> Source -> String -> String)
-> (Source -> String)
-> ([Source] -> String -> String)
-> Show Source
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Source -> String -> String
showsPrec :: Int -> Source -> String -> String
$cshow :: Source -> String
show :: Source -> String
$cshowList :: [Source] -> String -> String
showList :: [Source] -> String -> String
Show)

_Source :: Name
_Source = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Source")

_Source_stats :: Name
_Source_stats = (String -> Name
Core.Name String
"stats")

data Quasi = 
  Quasi {}
  deriving (Quasi -> Quasi -> Bool
(Quasi -> Quasi -> Bool) -> (Quasi -> Quasi -> Bool) -> Eq Quasi
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Quasi -> Quasi -> Bool
== :: Quasi -> Quasi -> Bool
$c/= :: Quasi -> Quasi -> Bool
/= :: Quasi -> Quasi -> Bool
Eq, Eq Quasi
Eq Quasi =>
(Quasi -> Quasi -> Ordering)
-> (Quasi -> Quasi -> Bool)
-> (Quasi -> Quasi -> Bool)
-> (Quasi -> Quasi -> Bool)
-> (Quasi -> Quasi -> Bool)
-> (Quasi -> Quasi -> Quasi)
-> (Quasi -> Quasi -> Quasi)
-> Ord Quasi
Quasi -> Quasi -> Bool
Quasi -> Quasi -> Ordering
Quasi -> Quasi -> Quasi
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Quasi -> Quasi -> Ordering
compare :: Quasi -> Quasi -> Ordering
$c< :: Quasi -> Quasi -> Bool
< :: Quasi -> Quasi -> Bool
$c<= :: Quasi -> Quasi -> Bool
<= :: Quasi -> Quasi -> Bool
$c> :: Quasi -> Quasi -> Bool
> :: Quasi -> Quasi -> Bool
$c>= :: Quasi -> Quasi -> Bool
>= :: Quasi -> Quasi -> Bool
$cmax :: Quasi -> Quasi -> Quasi
max :: Quasi -> Quasi -> Quasi
$cmin :: Quasi -> Quasi -> Quasi
min :: Quasi -> Quasi -> Quasi
Ord, ReadPrec [Quasi]
ReadPrec Quasi
Int -> ReadS Quasi
ReadS [Quasi]
(Int -> ReadS Quasi)
-> ReadS [Quasi]
-> ReadPrec Quasi
-> ReadPrec [Quasi]
-> Read Quasi
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Quasi
readsPrec :: Int -> ReadS Quasi
$creadList :: ReadS [Quasi]
readList :: ReadS [Quasi]
$creadPrec :: ReadPrec Quasi
readPrec :: ReadPrec Quasi
$creadListPrec :: ReadPrec [Quasi]
readListPrec :: ReadPrec [Quasi]
Read, Int -> Quasi -> String -> String
[Quasi] -> String -> String
Quasi -> String
(Int -> Quasi -> String -> String)
-> (Quasi -> String) -> ([Quasi] -> String -> String) -> Show Quasi
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> Quasi -> String -> String
showsPrec :: Int -> Quasi -> String -> String
$cshow :: Quasi -> String
show :: Quasi -> String
$cshowList :: [Quasi] -> String -> String
showList :: [Quasi] -> String -> String
Show)

_Quasi :: Name
_Quasi = (String -> Name
Core.Name String
"hydra/langs/scala/meta.Quasi")