packages feed

concrete-haskell-autogen 0.0.0.1 → 0.0.0.2

raw patch · 91 files changed

+1196/−499 lines, 91 filesdep +lens

Dependencies added: lens

Files

concrete-haskell-autogen.cabal view
@@ -1,9 +1,9 @@--- This file has been generated from package.yaml by hpack version 0.14.1.+-- This file has been generated from package.yaml by hpack version 0.17.1. -- -- see: https://github.com/sol/hpack  name:           concrete-haskell-autogen-version:        0.0.0.1+version:        0.0.0.2 synopsis:       Automatically generated Thrift definitions for the Concrete data format. description:    Concrete is a Thrift-based data specification designed for Natural Language Processing (NLP) applications. category:       Data@@ -25,6 +25,7 @@     , bytestring     , containers     , hashable+    , lens     , text     , thrift     , unordered-containers@@ -65,50 +66,137 @@       Data.Concrete.Autogen.SummarizationService       Data.Concrete.Autogen.Access_Types       Data.Concrete.Autogen.Access_Consts+      Data.Concrete.Autogen.Lens.FetchResult+      Data.Concrete.Autogen.Lens.FetchRequest       Data.Concrete.Autogen.Annotate_Types       Data.Concrete.Autogen.Annotate_Consts       Data.Concrete.Autogen.Audio_Types       Data.Concrete.Autogen.Audio_Consts+      Data.Concrete.Autogen.Lens.Sound       Data.Concrete.Autogen.Cluster_Types       Data.Concrete.Autogen.Cluster_Consts+      Data.Concrete.Autogen.Lens.ClusterMember+      Data.Concrete.Autogen.Lens.Cluster+      Data.Concrete.Autogen.Lens.Clustering       Data.Concrete.Autogen.Communication_Types       Data.Concrete.Autogen.Communication_Consts+      Data.Concrete.Autogen.Lens.CommunicationTagging+      Data.Concrete.Autogen.Lens.Communication+      Data.Concrete.Autogen.Lens.CommunicationSet       Data.Concrete.Autogen.Concrete_Types       Data.Concrete.Autogen.Concrete_Consts       Data.Concrete.Autogen.Email_Types       Data.Concrete.Autogen.Email_Consts+      Data.Concrete.Autogen.Lens.EmailAddress+      Data.Concrete.Autogen.Lens.EmailCommunicationInfo       Data.Concrete.Autogen.Entities_Types       Data.Concrete.Autogen.Entities_Consts+      Data.Concrete.Autogen.Lens.Entity+      Data.Concrete.Autogen.Lens.EntitySet+      Data.Concrete.Autogen.Lens.EntityMention+      Data.Concrete.Autogen.Lens.EntityMentionSet       Data.Concrete.Autogen.Ex_Types       Data.Concrete.Autogen.Ex_Consts+      Data.Concrete.Autogen.Lens.ConcreteThriftException       Data.Concrete.Autogen.Language_Types       Data.Concrete.Autogen.Language_Consts+      Data.Concrete.Autogen.Lens.LanguageIdentification       Data.Concrete.Autogen.Learn_Types       Data.Concrete.Autogen.Learn_Consts+      Data.Concrete.Autogen.Lens.AnnotationTask+      Data.Concrete.Autogen.Lens.Annotation       Data.Concrete.Autogen.Linking_Types       Data.Concrete.Autogen.Linking_Consts+      Data.Concrete.Autogen.Lens.LinkTarget+      Data.Concrete.Autogen.Lens.Link+      Data.Concrete.Autogen.Lens.Linking       Data.Concrete.Autogen.Metadata_Types       Data.Concrete.Autogen.Metadata_Consts+      Data.Concrete.Autogen.Lens.TheoryDependencies+      Data.Concrete.Autogen.Lens.Digest+      Data.Concrete.Autogen.Lens.AnnotationMetadata+      Data.Concrete.Autogen.Lens.CommunicationMetadata       Data.Concrete.Autogen.Nitf_Types       Data.Concrete.Autogen.Nitf_Consts+      Data.Concrete.Autogen.Lens.NITFInfo       Data.Concrete.Autogen.Results_Types       Data.Concrete.Autogen.Results_Consts       Data.Concrete.Autogen.Search_Types       Data.Concrete.Autogen.Search_Consts+      Data.Concrete.Autogen.Lens.SearchType+      Data.Concrete.Autogen.Lens.SearchFeedback+      Data.Concrete.Autogen.Lens.SearchCapability+      Data.Concrete.Autogen.Lens.SearchQuery+      Data.Concrete.Autogen.Lens.SearchResultItem+      Data.Concrete.Autogen.Lens.SearchResult       Data.Concrete.Autogen.Services_Types       Data.Concrete.Autogen.Services_Consts+      Data.Concrete.Autogen.Lens.AnnotationTaskType+      Data.Concrete.Autogen.Lens.AnnotationUnitType+      Data.Concrete.Autogen.Lens.ServicesException+      Data.Concrete.Autogen.Lens.NotImplementedException+      Data.Concrete.Autogen.Lens.AsyncContactInfo+      Data.Concrete.Autogen.Lens.AnnotationUnitIdentifier+      Data.Concrete.Autogen.Lens.ServiceInfo       Data.Concrete.Autogen.Situations_Types       Data.Concrete.Autogen.Situations_Consts+      Data.Concrete.Autogen.Lens.Property+      Data.Concrete.Autogen.Lens.Argument+      Data.Concrete.Autogen.Lens.Justification+      Data.Concrete.Autogen.Lens.TimeML+      Data.Concrete.Autogen.Lens.Situation+      Data.Concrete.Autogen.Lens.SituationSet+      Data.Concrete.Autogen.Lens.MentionArgument+      Data.Concrete.Autogen.Lens.SituationMention+      Data.Concrete.Autogen.Lens.SituationMentionSet       Data.Concrete.Autogen.Spans_Types       Data.Concrete.Autogen.Spans_Consts+      Data.Concrete.Autogen.Lens.TextSpan+      Data.Concrete.Autogen.Lens.AudioSpan       Data.Concrete.Autogen.Structure_Types       Data.Concrete.Autogen.Structure_Consts+      Data.Concrete.Autogen.Lens.TokenizationKind+      Data.Concrete.Autogen.Lens.Constituent+      Data.Concrete.Autogen.Lens.Parse+      Data.Concrete.Autogen.Lens.ConstituentRef+      Data.Concrete.Autogen.Lens.Dependency+      Data.Concrete.Autogen.Lens.DependencyParseStructure+      Data.Concrete.Autogen.Lens.DependencyParse+      Data.Concrete.Autogen.Lens.Token+      Data.Concrete.Autogen.Lens.TokenRefSequence+      Data.Concrete.Autogen.Lens.TaggedToken+      Data.Concrete.Autogen.Lens.TokenTagging+      Data.Concrete.Autogen.Lens.LatticePath+      Data.Concrete.Autogen.Lens.Arc+      Data.Concrete.Autogen.Lens.TokenLattice+      Data.Concrete.Autogen.Lens.TokenList+      Data.Concrete.Autogen.Lens.SpanLink+      Data.Concrete.Autogen.Lens.Tokenization+      Data.Concrete.Autogen.Lens.Sentence+      Data.Concrete.Autogen.Lens.Section       Data.Concrete.Autogen.Summarization_Types       Data.Concrete.Autogen.Summarization_Consts+      Data.Concrete.Autogen.Lens.SummarySourceType+      Data.Concrete.Autogen.Lens.SummarizationRequest+      Data.Concrete.Autogen.Lens.SummaryConcept+      Data.Concrete.Autogen.Lens.Summary+      Data.Concrete.Autogen.Lens.SummarizationCapability       Data.Concrete.Autogen.Twitter_Types       Data.Concrete.Autogen.Twitter_Consts+      Data.Concrete.Autogen.Lens.TwitterUser+      Data.Concrete.Autogen.Lens.TwitterLatLong+      Data.Concrete.Autogen.Lens.BoundingBox+      Data.Concrete.Autogen.Lens.PlaceAttributes+      Data.Concrete.Autogen.Lens.UserMention+      Data.Concrete.Autogen.Lens.URL+      Data.Concrete.Autogen.Lens.HashTag+      Data.Concrete.Autogen.Lens.TwitterEntities+      Data.Concrete.Autogen.Lens.TwitterPlace+      Data.Concrete.Autogen.Lens.TwitterCoordinates+      Data.Concrete.Autogen.Lens.TweetInfo       Data.Concrete.Autogen.Uuid_Types       Data.Concrete.Autogen.Uuid_Consts+      Data.Concrete.Autogen.Lens.UUID   other-modules:       Paths_concrete_haskell_autogen   default-language: Haskell2010
+ src/Data/Concrete/Autogen/Lens/Annotation.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Annotation where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Learn_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Annotation
+ src/Data/Concrete/Autogen/Lens/AnnotationMetadata.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.AnnotationMetadata where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Metadata_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''AnnotationMetadata
+ src/Data/Concrete/Autogen/Lens/AnnotationTask.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.AnnotationTask where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Learn_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''AnnotationTask
+ src/Data/Concrete/Autogen/Lens/AnnotationTaskType.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.AnnotationTaskType where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Services_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''AnnotationTaskType
+ src/Data/Concrete/Autogen/Lens/AnnotationUnitIdentifier.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.AnnotationUnitIdentifier where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Services_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''AnnotationUnitIdentifier
+ src/Data/Concrete/Autogen/Lens/AnnotationUnitType.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.AnnotationUnitType where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Services_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''AnnotationUnitType
+ src/Data/Concrete/Autogen/Lens/Arc.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Arc where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Structure_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Arc
+ src/Data/Concrete/Autogen/Lens/Argument.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Argument where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Situations_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Argument
+ src/Data/Concrete/Autogen/Lens/AsyncContactInfo.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.AsyncContactInfo where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Services_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''AsyncContactInfo
+ src/Data/Concrete/Autogen/Lens/AudioSpan.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.AudioSpan where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Spans_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''AudioSpan
+ src/Data/Concrete/Autogen/Lens/BoundingBox.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.BoundingBox where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Twitter_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''BoundingBox
+ src/Data/Concrete/Autogen/Lens/Cluster.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Cluster where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Cluster_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Cluster
+ src/Data/Concrete/Autogen/Lens/ClusterMember.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.ClusterMember where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Cluster_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''ClusterMember
+ src/Data/Concrete/Autogen/Lens/Clustering.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Clustering where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Cluster_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Clustering
+ src/Data/Concrete/Autogen/Lens/Communication.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Communication where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Communication_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Communication
+ src/Data/Concrete/Autogen/Lens/CommunicationMetadata.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.CommunicationMetadata where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Metadata_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''CommunicationMetadata
+ src/Data/Concrete/Autogen/Lens/CommunicationSet.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.CommunicationSet where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Communication_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''CommunicationSet
+ src/Data/Concrete/Autogen/Lens/CommunicationTagging.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.CommunicationTagging where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Communication_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''CommunicationTagging
+ src/Data/Concrete/Autogen/Lens/ConcreteThriftException.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.ConcreteThriftException where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Ex_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''ConcreteThriftException
+ src/Data/Concrete/Autogen/Lens/Constituent.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Constituent where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Structure_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Constituent
+ src/Data/Concrete/Autogen/Lens/ConstituentRef.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.ConstituentRef where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Structure_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''ConstituentRef
+ src/Data/Concrete/Autogen/Lens/Dependency.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Dependency where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Structure_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Dependency
+ src/Data/Concrete/Autogen/Lens/DependencyParse.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.DependencyParse where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Structure_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''DependencyParse
+ src/Data/Concrete/Autogen/Lens/DependencyParseStructure.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.DependencyParseStructure where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Structure_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''DependencyParseStructure
+ src/Data/Concrete/Autogen/Lens/Digest.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Digest where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Metadata_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Digest
+ src/Data/Concrete/Autogen/Lens/EmailAddress.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.EmailAddress where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Email_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''EmailAddress
+ src/Data/Concrete/Autogen/Lens/EmailCommunicationInfo.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.EmailCommunicationInfo where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Email_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''EmailCommunicationInfo
+ src/Data/Concrete/Autogen/Lens/Entity.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Entity where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Entities_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Entity
+ src/Data/Concrete/Autogen/Lens/EntityMention.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.EntityMention where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Entities_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''EntityMention
+ src/Data/Concrete/Autogen/Lens/EntityMentionSet.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.EntityMentionSet where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Entities_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''EntityMentionSet
+ src/Data/Concrete/Autogen/Lens/EntitySet.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.EntitySet where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Entities_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''EntitySet
+ src/Data/Concrete/Autogen/Lens/FetchRequest.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.FetchRequest where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Access_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''FetchRequest
+ src/Data/Concrete/Autogen/Lens/FetchResult.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.FetchResult where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Access_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''FetchResult
+ src/Data/Concrete/Autogen/Lens/HashTag.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.HashTag where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Twitter_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''HashTag
+ src/Data/Concrete/Autogen/Lens/Justification.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Justification where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Situations_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Justification
+ src/Data/Concrete/Autogen/Lens/LanguageIdentification.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.LanguageIdentification where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Language_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''LanguageIdentification
+ src/Data/Concrete/Autogen/Lens/LatticePath.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.LatticePath where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Structure_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''LatticePath
+ src/Data/Concrete/Autogen/Lens/Link.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Link where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Linking_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Link
+ src/Data/Concrete/Autogen/Lens/LinkTarget.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.LinkTarget where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Linking_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''LinkTarget
+ src/Data/Concrete/Autogen/Lens/Linking.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Linking where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Linking_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Linking
+ src/Data/Concrete/Autogen/Lens/MentionArgument.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.MentionArgument where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Situations_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''MentionArgument
+ src/Data/Concrete/Autogen/Lens/NITFInfo.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.NITFInfo where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Nitf_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''NITFInfo
+ src/Data/Concrete/Autogen/Lens/NotImplementedException.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.NotImplementedException where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Services_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''NotImplementedException
+ src/Data/Concrete/Autogen/Lens/Parse.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Parse where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Structure_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Parse
+ src/Data/Concrete/Autogen/Lens/PlaceAttributes.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.PlaceAttributes where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Twitter_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''PlaceAttributes
+ src/Data/Concrete/Autogen/Lens/Property.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Property where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Situations_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Property
+ src/Data/Concrete/Autogen/Lens/SearchCapability.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.SearchCapability where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Search_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''SearchCapability
+ src/Data/Concrete/Autogen/Lens/SearchFeedback.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.SearchFeedback where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Search_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''SearchFeedback
+ src/Data/Concrete/Autogen/Lens/SearchQuery.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.SearchQuery where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Search_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''SearchQuery
+ src/Data/Concrete/Autogen/Lens/SearchResult.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.SearchResult where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Search_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''SearchResult
+ src/Data/Concrete/Autogen/Lens/SearchResultItem.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.SearchResultItem where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Search_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''SearchResultItem
+ src/Data/Concrete/Autogen/Lens/SearchType.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.SearchType where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Search_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''SearchType
+ src/Data/Concrete/Autogen/Lens/Section.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Section where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Structure_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Section
+ src/Data/Concrete/Autogen/Lens/Sentence.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Sentence where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Structure_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Sentence
+ src/Data/Concrete/Autogen/Lens/ServiceInfo.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.ServiceInfo where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Services_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''ServiceInfo
+ src/Data/Concrete/Autogen/Lens/ServicesException.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.ServicesException where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Services_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''ServicesException
+ src/Data/Concrete/Autogen/Lens/Situation.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Situation where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Situations_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Situation
+ src/Data/Concrete/Autogen/Lens/SituationMention.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.SituationMention where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Situations_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''SituationMention
+ src/Data/Concrete/Autogen/Lens/SituationMentionSet.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.SituationMentionSet where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Situations_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''SituationMentionSet
+ src/Data/Concrete/Autogen/Lens/SituationSet.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.SituationSet where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Situations_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''SituationSet
+ src/Data/Concrete/Autogen/Lens/Sound.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Sound where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Audio_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Sound
+ src/Data/Concrete/Autogen/Lens/SpanLink.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.SpanLink where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Structure_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''SpanLink
+ src/Data/Concrete/Autogen/Lens/SummarizationCapability.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.SummarizationCapability where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Summarization_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''SummarizationCapability
+ src/Data/Concrete/Autogen/Lens/SummarizationRequest.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.SummarizationRequest where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Summarization_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''SummarizationRequest
+ src/Data/Concrete/Autogen/Lens/Summary.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Summary where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Summarization_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Summary
+ src/Data/Concrete/Autogen/Lens/SummaryConcept.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.SummaryConcept where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Summarization_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''SummaryConcept
+ src/Data/Concrete/Autogen/Lens/SummarySourceType.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.SummarySourceType where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Summarization_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''SummarySourceType
+ src/Data/Concrete/Autogen/Lens/TaggedToken.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.TaggedToken where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Structure_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''TaggedToken
+ src/Data/Concrete/Autogen/Lens/TextSpan.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.TextSpan where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Spans_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''TextSpan
+ src/Data/Concrete/Autogen/Lens/TheoryDependencies.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.TheoryDependencies where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Metadata_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''TheoryDependencies
+ src/Data/Concrete/Autogen/Lens/TimeML.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.TimeML where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Situations_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''TimeML
+ src/Data/Concrete/Autogen/Lens/Token.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Token where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Structure_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Token
+ src/Data/Concrete/Autogen/Lens/TokenLattice.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.TokenLattice where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Structure_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''TokenLattice
+ src/Data/Concrete/Autogen/Lens/TokenList.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.TokenList where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Structure_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''TokenList
+ src/Data/Concrete/Autogen/Lens/TokenRefSequence.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.TokenRefSequence where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Structure_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''TokenRefSequence
+ src/Data/Concrete/Autogen/Lens/TokenTagging.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.TokenTagging where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Structure_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''TokenTagging
+ src/Data/Concrete/Autogen/Lens/Tokenization.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.Tokenization where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Structure_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''Tokenization
+ src/Data/Concrete/Autogen/Lens/TokenizationKind.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.TokenizationKind where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Structure_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''TokenizationKind
+ src/Data/Concrete/Autogen/Lens/TweetInfo.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.TweetInfo where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Twitter_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''TweetInfo
+ src/Data/Concrete/Autogen/Lens/TwitterCoordinates.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.TwitterCoordinates where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Twitter_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''TwitterCoordinates
+ src/Data/Concrete/Autogen/Lens/TwitterEntities.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.TwitterEntities where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Twitter_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''TwitterEntities
+ src/Data/Concrete/Autogen/Lens/TwitterLatLong.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.TwitterLatLong where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Twitter_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''TwitterLatLong
+ src/Data/Concrete/Autogen/Lens/TwitterPlace.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.TwitterPlace where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Twitter_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''TwitterPlace
+ src/Data/Concrete/Autogen/Lens/TwitterUser.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.TwitterUser where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Twitter_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''TwitterUser
+ src/Data/Concrete/Autogen/Lens/URL.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.URL where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Twitter_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''URL
+ src/Data/Concrete/Autogen/Lens/UUID.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.UUID where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Uuid_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''UUID
+ src/Data/Concrete/Autogen/Lens/UserMention.hs view
@@ -0,0 +1,7 @@+{-# LANGUAGE TemplateHaskell #-}+module Data.Concrete.Autogen.Lens.UserMention where++import Control.Lens (makeLensesWith, classyRules_, lensField, mappingNamer, (&), (.~))+import Data.Concrete.Autogen.Twitter_Types++makeLensesWith (classyRules_ & lensField .~ mappingNamer (\f -> ["c" ++ dropWhile (\c -> c /= '_') f])) ''UserMention
src/Data/Concrete/Autogen/Situations_Types.hs view
@@ -365,12 +365,11 @@   , mentionArgument_entityMentionId :: P.Maybe Uuid_Types.UUID   , mentionArgument_situationMentionId :: P.Maybe Uuid_Types.UUID   , mentionArgument_tokens :: P.Maybe Structure_Types.TokenRefSequence-  , mentionArgument_constituent :: P.Maybe Structure_Types.ConstituentRef   , mentionArgument_confidence :: P.Maybe P.Double   , mentionArgument_propertyList :: P.Maybe (Vector.Vector Property)   } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) instance H.Hashable MentionArgument where-  hashWithSalt salt record = salt   `H.hashWithSalt` mentionArgument_role record   `H.hashWithSalt` mentionArgument_entityMentionId record   `H.hashWithSalt` mentionArgument_situationMentionId record   `H.hashWithSalt` mentionArgument_tokens record   `H.hashWithSalt` mentionArgument_constituent record   `H.hashWithSalt` mentionArgument_confidence record   `H.hashWithSalt` mentionArgument_propertyList record  +  hashWithSalt salt record = salt   `H.hashWithSalt` mentionArgument_role record   `H.hashWithSalt` mentionArgument_entityMentionId record   `H.hashWithSalt` mentionArgument_situationMentionId record   `H.hashWithSalt` mentionArgument_tokens record   `H.hashWithSalt` mentionArgument_confidence record   `H.hashWithSalt` mentionArgument_propertyList record   instance QC.Arbitrary MentionArgument where    arbitrary = M.liftM MentionArgument (M.liftM P.Just QC.arbitrary)           `M.ap`(M.liftM P.Just QC.arbitrary)@@ -378,14 +377,12 @@           `M.ap`(M.liftM P.Just QC.arbitrary)           `M.ap`(M.liftM P.Just QC.arbitrary)           `M.ap`(M.liftM P.Just QC.arbitrary)-          `M.ap`(M.liftM P.Just QC.arbitrary)   shrink obj | obj == default_MentionArgument = []              | P.otherwise = M.catMaybes     [ if obj == default_MentionArgument{mentionArgument_role = mentionArgument_role obj} then P.Nothing else P.Just $ default_MentionArgument{mentionArgument_role = mentionArgument_role obj}     , if obj == default_MentionArgument{mentionArgument_entityMentionId = mentionArgument_entityMentionId obj} then P.Nothing else P.Just $ default_MentionArgument{mentionArgument_entityMentionId = mentionArgument_entityMentionId obj}     , if obj == default_MentionArgument{mentionArgument_situationMentionId = mentionArgument_situationMentionId obj} then P.Nothing else P.Just $ default_MentionArgument{mentionArgument_situationMentionId = mentionArgument_situationMentionId obj}     , if obj == default_MentionArgument{mentionArgument_tokens = mentionArgument_tokens obj} then P.Nothing else P.Just $ default_MentionArgument{mentionArgument_tokens = mentionArgument_tokens obj}-    , if obj == default_MentionArgument{mentionArgument_constituent = mentionArgument_constituent obj} then P.Nothing else P.Just $ default_MentionArgument{mentionArgument_constituent = mentionArgument_constituent obj}     , if obj == default_MentionArgument{mentionArgument_confidence = mentionArgument_confidence obj} then P.Nothing else P.Just $ default_MentionArgument{mentionArgument_confidence = mentionArgument_confidence obj}     , if obj == default_MentionArgument{mentionArgument_propertyList = mentionArgument_propertyList obj} then P.Nothing else P.Just $ default_MentionArgument{mentionArgument_propertyList = mentionArgument_propertyList obj}     ]@@ -397,7 +394,6 @@   , (\_v87 -> (4, ("tokens",Structure_Types.from_TokenRefSequence _v87))) <$> mentionArgument_tokens record   , (\_v87 -> (5, ("confidence",T.TDouble _v87))) <$> mentionArgument_confidence record   , (\_v87 -> (6, ("propertyList",T.TList (T.T_STRUCT typemap_Property) $ P.map (\_v89 -> from_Property _v89) $ Vector.toList _v87))) <$> mentionArgument_propertyList record-  , (\_v87 -> (7, ("constituent",Structure_Types.from_ConstituentRef _v87))) <$> mentionArgument_constituent record   ] write_MentionArgument :: (T.Protocol p, T.Transport t) => p t -> MentionArgument -> P.IO () write_MentionArgument oprot record = T.writeVal oprot $ from_MentionArgument record@@ -409,9 +405,8 @@   mentionArgument_entityMentionId = P.maybe (P.Nothing) (\(_,_val91) -> P.Just (case _val91 of {T.TStruct _val93 -> (Uuid_Types.to_UUID (T.TStruct _val93)); _ -> P.error "wrong type"})) (Map.lookup (2) fields),   mentionArgument_situationMentionId = P.maybe (P.Nothing) (\(_,_val91) -> P.Just (case _val91 of {T.TStruct _val94 -> (Uuid_Types.to_UUID (T.TStruct _val94)); _ -> P.error "wrong type"})) (Map.lookup (3) fields),   mentionArgument_tokens = P.maybe (P.Nothing) (\(_,_val91) -> P.Just (case _val91 of {T.TStruct _val95 -> (Structure_Types.to_TokenRefSequence (T.TStruct _val95)); _ -> P.error "wrong type"})) (Map.lookup (4) fields),-  mentionArgument_constituent = P.maybe (P.Nothing) (\(_,_val91) -> P.Just (case _val91 of {T.TStruct _val96 -> (Structure_Types.to_ConstituentRef (T.TStruct _val96)); _ -> P.error "wrong type"})) (Map.lookup (7) fields),-  mentionArgument_confidence = P.maybe (P.Nothing) (\(_,_val91) -> P.Just (case _val91 of {T.TDouble _val97 -> _val97; _ -> P.error "wrong type"})) (Map.lookup (5) fields),-  mentionArgument_propertyList = P.maybe (P.Nothing) (\(_,_val91) -> P.Just (case _val91 of {T.TList _ _val98 -> (Vector.fromList $ P.map (\_v99 -> (case _v99 of {T.TStruct _val100 -> (to_Property (T.TStruct _val100)); _ -> P.error "wrong type"})) _val98); _ -> P.error "wrong type"})) (Map.lookup (6) fields)+  mentionArgument_confidence = P.maybe (P.Nothing) (\(_,_val91) -> P.Just (case _val91 of {T.TDouble _val96 -> _val96; _ -> P.error "wrong type"})) (Map.lookup (5) fields),+  mentionArgument_propertyList = P.maybe (P.Nothing) (\(_,_val91) -> P.Just (case _val91 of {T.TList _ _val97 -> (Vector.fromList $ P.map (\_v98 -> (case _v98 of {T.TStruct _val99 -> (to_Property (T.TStruct _val99)); _ -> P.error "wrong type"})) _val97); _ -> P.error "wrong type"})) (Map.lookup (6) fields)   } to_MentionArgument _ = P.error "not a struct" read_MentionArgument :: (T.Transport t, T.Protocol p) => p t -> P.IO MentionArgument@@ -419,7 +414,7 @@ decode_MentionArgument :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> MentionArgument decode_MentionArgument iprot bs = to_MentionArgument $ T.deserializeVal iprot (T.T_STRUCT typemap_MentionArgument) bs typemap_MentionArgument :: T.TypeMap-typemap_MentionArgument = Map.fromList [(1,("role",T.T_STRING)),(2,("entityMentionId",(T.T_STRUCT Uuid_Types.typemap_UUID))),(3,("situationMentionId",(T.T_STRUCT Uuid_Types.typemap_UUID))),(4,("tokens",(T.T_STRUCT Structure_Types.typemap_TokenRefSequence))),(5,("confidence",T.T_DOUBLE)),(6,("propertyList",(T.T_LIST (T.T_STRUCT typemap_Property)))),(7,("constituent",(T.T_STRUCT Structure_Types.typemap_ConstituentRef)))]+typemap_MentionArgument = Map.fromList [(1,("role",T.T_STRING)),(2,("entityMentionId",(T.T_STRUCT Uuid_Types.typemap_UUID))),(3,("situationMentionId",(T.T_STRUCT Uuid_Types.typemap_UUID))),(4,("tokens",(T.T_STRUCT Structure_Types.typemap_TokenRefSequence))),(5,("confidence",T.T_DOUBLE)),(6,("propertyList",(T.T_LIST (T.T_STRUCT typemap_Property))))] default_MentionArgument :: MentionArgument default_MentionArgument = MentionArgument{   mentionArgument_role = P.Nothing,@@ -427,8 +422,7 @@   mentionArgument_situationMentionId = P.Nothing,   mentionArgument_tokens = P.Nothing,   mentionArgument_confidence = P.Nothing,-  mentionArgument_propertyList = P.Nothing,-  mentionArgument_constituent = P.Nothing}+  mentionArgument_propertyList = P.Nothing} data SituationMention = SituationMention  { situationMention_uuid :: Uuid_Types.UUID   , situationMention_text :: P.Maybe LT.Text   , situationMention_situationType :: P.Maybe LT.Text@@ -437,11 +431,10 @@   , situationMention_intensity :: P.Maybe P.Double   , situationMention_polarity :: P.Maybe LT.Text   , situationMention_tokens :: P.Maybe Structure_Types.TokenRefSequence-  , situationMention_constituent :: P.Maybe Structure_Types.ConstituentRef   , situationMention_confidence :: P.Maybe P.Double   } deriving (P.Show,P.Eq,G.Generic,TY.Typeable) instance H.Hashable SituationMention where-  hashWithSalt salt record = salt   `H.hashWithSalt` situationMention_uuid record   `H.hashWithSalt` situationMention_text record   `H.hashWithSalt` situationMention_situationType record   `H.hashWithSalt` situationMention_situationKind record   `H.hashWithSalt` situationMention_argumentList record   `H.hashWithSalt` situationMention_intensity record   `H.hashWithSalt` situationMention_polarity record   `H.hashWithSalt` situationMention_tokens record   `H.hashWithSalt` situationMention_constituent record   `H.hashWithSalt` situationMention_confidence record  +  hashWithSalt salt record = salt   `H.hashWithSalt` situationMention_uuid record   `H.hashWithSalt` situationMention_text record   `H.hashWithSalt` situationMention_situationType record   `H.hashWithSalt` situationMention_situationKind record   `H.hashWithSalt` situationMention_argumentList record   `H.hashWithSalt` situationMention_intensity record   `H.hashWithSalt` situationMention_polarity record   `H.hashWithSalt` situationMention_tokens record   `H.hashWithSalt` situationMention_confidence record   instance QC.Arbitrary SituationMention where    arbitrary = M.liftM SituationMention (QC.arbitrary)           `M.ap`(M.liftM P.Just QC.arbitrary)@@ -452,7 +445,6 @@           `M.ap`(M.liftM P.Just QC.arbitrary)           `M.ap`(M.liftM P.Just QC.arbitrary)           `M.ap`(M.liftM P.Just QC.arbitrary)-          `M.ap`(M.liftM P.Just QC.arbitrary)   shrink obj | obj == default_SituationMention = []              | P.otherwise = M.catMaybes     [ if obj == default_SituationMention{situationMention_uuid = situationMention_uuid obj} then P.Nothing else P.Just $ default_SituationMention{situationMention_uuid = situationMention_uuid obj}@@ -463,21 +455,19 @@     , if obj == default_SituationMention{situationMention_intensity = situationMention_intensity obj} then P.Nothing else P.Just $ default_SituationMention{situationMention_intensity = situationMention_intensity obj}     , if obj == default_SituationMention{situationMention_polarity = situationMention_polarity obj} then P.Nothing else P.Just $ default_SituationMention{situationMention_polarity = situationMention_polarity obj}     , if obj == default_SituationMention{situationMention_tokens = situationMention_tokens obj} then P.Nothing else P.Just $ default_SituationMention{situationMention_tokens = situationMention_tokens obj}-    , if obj == default_SituationMention{situationMention_constituent = situationMention_constituent obj} then P.Nothing else P.Just $ default_SituationMention{situationMention_constituent = situationMention_constituent obj}     , if obj == default_SituationMention{situationMention_confidence = situationMention_confidence obj} then P.Nothing else P.Just $ default_SituationMention{situationMention_confidence = situationMention_confidence obj}     ] from_SituationMention :: SituationMention -> T.ThriftVal from_SituationMention record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v103 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v103))) $ situationMention_uuid record-  , (\_v103 -> (2, ("text",T.TString $ E.encodeUtf8 _v103))) <$> situationMention_text record-  , (\_v103 -> (3, ("situationType",T.TString $ E.encodeUtf8 _v103))) <$> situationMention_situationType record-  , (\_v103 -> P.Just (4, ("argumentList",T.TList (T.T_STRUCT typemap_MentionArgument) $ P.map (\_v105 -> from_MentionArgument _v105) $ Vector.toList _v103))) $ situationMention_argumentList record-  , (\_v103 -> (50, ("situationKind",T.TString $ E.encodeUtf8 _v103))) <$> situationMention_situationKind record-  , (\_v103 -> (100, ("intensity",T.TDouble _v103))) <$> situationMention_intensity record-  , (\_v103 -> (101, ("polarity",T.TString $ E.encodeUtf8 _v103))) <$> situationMention_polarity record-  , (\_v103 -> (150, ("tokens",Structure_Types.from_TokenRefSequence _v103))) <$> situationMention_tokens record-  , (\_v103 -> (151, ("constituent",Structure_Types.from_ConstituentRef _v103))) <$> situationMention_constituent record-  , (\_v103 -> (200, ("confidence",T.TDouble _v103))) <$> situationMention_confidence record+  [ (\_v102 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v102))) $ situationMention_uuid record+  , (\_v102 -> (2, ("text",T.TString $ E.encodeUtf8 _v102))) <$> situationMention_text record+  , (\_v102 -> (3, ("situationType",T.TString $ E.encodeUtf8 _v102))) <$> situationMention_situationType record+  , (\_v102 -> P.Just (4, ("argumentList",T.TList (T.T_STRUCT typemap_MentionArgument) $ P.map (\_v104 -> from_MentionArgument _v104) $ Vector.toList _v102))) $ situationMention_argumentList record+  , (\_v102 -> (50, ("situationKind",T.TString $ E.encodeUtf8 _v102))) <$> situationMention_situationKind record+  , (\_v102 -> (100, ("intensity",T.TDouble _v102))) <$> situationMention_intensity record+  , (\_v102 -> (101, ("polarity",T.TString $ E.encodeUtf8 _v102))) <$> situationMention_polarity record+  , (\_v102 -> (150, ("tokens",Structure_Types.from_TokenRefSequence _v102))) <$> situationMention_tokens record+  , (\_v102 -> (200, ("confidence",T.TDouble _v102))) <$> situationMention_confidence record   ] write_SituationMention :: (T.Protocol p, T.Transport t) => p t -> SituationMention -> P.IO () write_SituationMention oprot record = T.writeVal oprot $ from_SituationMention record@@ -485,16 +475,15 @@ encode_SituationMention oprot record = T.serializeVal oprot $ from_SituationMention record to_SituationMention :: T.ThriftVal -> SituationMention to_SituationMention (T.TStruct fields) = SituationMention{-  situationMention_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val107) -> (case _val107 of {T.TStruct _val108 -> (Uuid_Types.to_UUID (T.TStruct _val108)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  situationMention_text = P.maybe (P.Nothing) (\(_,_val107) -> P.Just (case _val107 of {T.TString _val109 -> E.decodeUtf8 _val109; _ -> P.error "wrong type"})) (Map.lookup (2) fields),-  situationMention_situationType = P.maybe (P.Nothing) (\(_,_val107) -> P.Just (case _val107 of {T.TString _val110 -> E.decodeUtf8 _val110; _ -> P.error "wrong type"})) (Map.lookup (3) fields),-  situationMention_situationKind = P.maybe (P.Nothing) (\(_,_val107) -> P.Just (case _val107 of {T.TString _val111 -> E.decodeUtf8 _val111; _ -> P.error "wrong type"})) (Map.lookup (50) fields),-  situationMention_argumentList = P.maybe (P.error "Missing required field: argumentList") (\(_,_val107) -> (case _val107 of {T.TList _ _val112 -> (Vector.fromList $ P.map (\_v113 -> (case _v113 of {T.TStruct _val114 -> (to_MentionArgument (T.TStruct _val114)); _ -> P.error "wrong type"})) _val112); _ -> P.error "wrong type"})) (Map.lookup (4) fields),-  situationMention_intensity = P.maybe (P.Nothing) (\(_,_val107) -> P.Just (case _val107 of {T.TDouble _val115 -> _val115; _ -> P.error "wrong type"})) (Map.lookup (100) fields),-  situationMention_polarity = P.maybe (P.Nothing) (\(_,_val107) -> P.Just (case _val107 of {T.TString _val116 -> E.decodeUtf8 _val116; _ -> P.error "wrong type"})) (Map.lookup (101) fields),-  situationMention_tokens = P.maybe (P.Nothing) (\(_,_val107) -> P.Just (case _val107 of {T.TStruct _val117 -> (Structure_Types.to_TokenRefSequence (T.TStruct _val117)); _ -> P.error "wrong type"})) (Map.lookup (150) fields),-  situationMention_constituent = P.maybe (P.Nothing) (\(_,_val107) -> P.Just (case _val107 of {T.TStruct _val118 -> (Structure_Types.to_ConstituentRef (T.TStruct _val118)); _ -> P.error "wrong type"})) (Map.lookup (151) fields),-  situationMention_confidence = P.maybe (P.Nothing) (\(_,_val107) -> P.Just (case _val107 of {T.TDouble _val119 -> _val119; _ -> P.error "wrong type"})) (Map.lookup (200) fields)+  situationMention_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val106) -> (case _val106 of {T.TStruct _val107 -> (Uuid_Types.to_UUID (T.TStruct _val107)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  situationMention_text = P.maybe (P.Nothing) (\(_,_val106) -> P.Just (case _val106 of {T.TString _val108 -> E.decodeUtf8 _val108; _ -> P.error "wrong type"})) (Map.lookup (2) fields),+  situationMention_situationType = P.maybe (P.Nothing) (\(_,_val106) -> P.Just (case _val106 of {T.TString _val109 -> E.decodeUtf8 _val109; _ -> P.error "wrong type"})) (Map.lookup (3) fields),+  situationMention_situationKind = P.maybe (P.Nothing) (\(_,_val106) -> P.Just (case _val106 of {T.TString _val110 -> E.decodeUtf8 _val110; _ -> P.error "wrong type"})) (Map.lookup (50) fields),+  situationMention_argumentList = P.maybe (P.error "Missing required field: argumentList") (\(_,_val106) -> (case _val106 of {T.TList _ _val111 -> (Vector.fromList $ P.map (\_v112 -> (case _v112 of {T.TStruct _val113 -> (to_MentionArgument (T.TStruct _val113)); _ -> P.error "wrong type"})) _val111); _ -> P.error "wrong type"})) (Map.lookup (4) fields),+  situationMention_intensity = P.maybe (P.Nothing) (\(_,_val106) -> P.Just (case _val106 of {T.TDouble _val114 -> _val114; _ -> P.error "wrong type"})) (Map.lookup (100) fields),+  situationMention_polarity = P.maybe (P.Nothing) (\(_,_val106) -> P.Just (case _val106 of {T.TString _val115 -> E.decodeUtf8 _val115; _ -> P.error "wrong type"})) (Map.lookup (101) fields),+  situationMention_tokens = P.maybe (P.Nothing) (\(_,_val106) -> P.Just (case _val106 of {T.TStruct _val116 -> (Structure_Types.to_TokenRefSequence (T.TStruct _val116)); _ -> P.error "wrong type"})) (Map.lookup (150) fields),+  situationMention_confidence = P.maybe (P.Nothing) (\(_,_val106) -> P.Just (case _val106 of {T.TDouble _val117 -> _val117; _ -> P.error "wrong type"})) (Map.lookup (200) fields)   } to_SituationMention _ = P.error "not a struct" read_SituationMention :: (T.Transport t, T.Protocol p) => p t -> P.IO SituationMention@@ -502,7 +491,7 @@ decode_SituationMention :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> SituationMention decode_SituationMention iprot bs = to_SituationMention $ T.deserializeVal iprot (T.T_STRUCT typemap_SituationMention) bs typemap_SituationMention :: T.TypeMap-typemap_SituationMention = Map.fromList [(1,("uuid",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("text",T.T_STRING)),(3,("situationType",T.T_STRING)),(4,("argumentList",(T.T_LIST (T.T_STRUCT typemap_MentionArgument)))),(50,("situationKind",T.T_STRING)),(100,("intensity",T.T_DOUBLE)),(101,("polarity",T.T_STRING)),(150,("tokens",(T.T_STRUCT Structure_Types.typemap_TokenRefSequence))),(151,("constituent",(T.T_STRUCT Structure_Types.typemap_ConstituentRef))),(200,("confidence",T.T_DOUBLE))]+typemap_SituationMention = Map.fromList [(1,("uuid",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("text",T.T_STRING)),(3,("situationType",T.T_STRING)),(4,("argumentList",(T.T_LIST (T.T_STRUCT typemap_MentionArgument)))),(50,("situationKind",T.T_STRING)),(100,("intensity",T.T_DOUBLE)),(101,("polarity",T.T_STRING)),(150,("tokens",(T.T_STRUCT Structure_Types.typemap_TokenRefSequence))),(200,("confidence",T.T_DOUBLE))] default_SituationMention :: SituationMention default_SituationMention = SituationMention{   situationMention_uuid = Uuid_Types.default_UUID,@@ -513,7 +502,6 @@   situationMention_intensity = P.Nothing,   situationMention_polarity = P.Nothing,   situationMention_tokens = P.Nothing,-  situationMention_constituent = P.Nothing,   situationMention_confidence = P.Nothing} data SituationMentionSet = SituationMentionSet  { situationMentionSet_uuid :: Uuid_Types.UUID   , situationMentionSet_metadata :: Metadata_Types.AnnotationMetadata@@ -536,10 +524,10 @@     ] from_SituationMentionSet :: SituationMentionSet -> T.ThriftVal from_SituationMentionSet record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v122 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v122))) $ situationMentionSet_uuid record-  , (\_v122 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v122))) $ situationMentionSet_metadata record-  , (\_v122 -> P.Just (3, ("mentionList",T.TList (T.T_STRUCT typemap_SituationMention) $ P.map (\_v124 -> from_SituationMention _v124) $ Vector.toList _v122))) $ situationMentionSet_mentionList record-  , (\_v122 -> (4, ("linkingList",T.TList (T.T_STRUCT Linking_Types.typemap_Linking) $ P.map (\_v126 -> Linking_Types.from_Linking _v126) $ Vector.toList _v122))) <$> situationMentionSet_linkingList record+  [ (\_v120 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v120))) $ situationMentionSet_uuid record+  , (\_v120 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v120))) $ situationMentionSet_metadata record+  , (\_v120 -> P.Just (3, ("mentionList",T.TList (T.T_STRUCT typemap_SituationMention) $ P.map (\_v122 -> from_SituationMention _v122) $ Vector.toList _v120))) $ situationMentionSet_mentionList record+  , (\_v120 -> (4, ("linkingList",T.TList (T.T_STRUCT Linking_Types.typemap_Linking) $ P.map (\_v124 -> Linking_Types.from_Linking _v124) $ Vector.toList _v120))) <$> situationMentionSet_linkingList record   ] write_SituationMentionSet :: (T.Protocol p, T.Transport t) => p t -> SituationMentionSet -> P.IO () write_SituationMentionSet oprot record = T.writeVal oprot $ from_SituationMentionSet record@@ -547,10 +535,10 @@ encode_SituationMentionSet oprot record = T.serializeVal oprot $ from_SituationMentionSet record to_SituationMentionSet :: T.ThriftVal -> SituationMentionSet to_SituationMentionSet (T.TStruct fields) = SituationMentionSet{-  situationMentionSet_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val128) -> (case _val128 of {T.TStruct _val129 -> (Uuid_Types.to_UUID (T.TStruct _val129)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  situationMentionSet_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val128) -> (case _val128 of {T.TStruct _val130 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val130)); _ -> P.error "wrong type"})) (Map.lookup (2) fields),-  situationMentionSet_mentionList = P.maybe (P.error "Missing required field: mentionList") (\(_,_val128) -> (case _val128 of {T.TList _ _val131 -> (Vector.fromList $ P.map (\_v132 -> (case _v132 of {T.TStruct _val133 -> (to_SituationMention (T.TStruct _val133)); _ -> P.error "wrong type"})) _val131); _ -> P.error "wrong type"})) (Map.lookup (3) fields),-  situationMentionSet_linkingList = P.maybe (P.Nothing) (\(_,_val128) -> P.Just (case _val128 of {T.TList _ _val134 -> (Vector.fromList $ P.map (\_v135 -> (case _v135 of {T.TStruct _val136 -> (Linking_Types.to_Linking (T.TStruct _val136)); _ -> P.error "wrong type"})) _val134); _ -> P.error "wrong type"})) (Map.lookup (4) fields)+  situationMentionSet_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val126) -> (case _val126 of {T.TStruct _val127 -> (Uuid_Types.to_UUID (T.TStruct _val127)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  situationMentionSet_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val126) -> (case _val126 of {T.TStruct _val128 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val128)); _ -> P.error "wrong type"})) (Map.lookup (2) fields),+  situationMentionSet_mentionList = P.maybe (P.error "Missing required field: mentionList") (\(_,_val126) -> (case _val126 of {T.TList _ _val129 -> (Vector.fromList $ P.map (\_v130 -> (case _v130 of {T.TStruct _val131 -> (to_SituationMention (T.TStruct _val131)); _ -> P.error "wrong type"})) _val129); _ -> P.error "wrong type"})) (Map.lookup (3) fields),+  situationMentionSet_linkingList = P.maybe (P.Nothing) (\(_,_val126) -> P.Just (case _val126 of {T.TList _ _val132 -> (Vector.fromList $ P.map (\_v133 -> (case _v133 of {T.TStruct _val134 -> (Linking_Types.to_Linking (T.TStruct _val134)); _ -> P.error "wrong type"})) _val132); _ -> P.error "wrong type"})) (Map.lookup (4) fields)   } to_SituationMentionSet _ = P.error "not a struct" read_SituationMentionSet :: (T.Transport t, T.Protocol p) => p t -> P.IO SituationMentionSet
src/Data/Concrete/Autogen/Structure_Types.hs view
@@ -56,62 +56,112 @@   hashWithSalt salt = H.hashWithSalt salt P.. P.fromEnum instance QC.Arbitrary TokenizationKind where   arbitrary = QC.elements (P.enumFromTo P.minBound P.maxBound)-data Token = Token  { token_tokenIndex :: I.Int32-  , token_text :: P.Maybe LT.Text-  , token_textSpan :: P.Maybe Spans_Types.TextSpan-  , token_rawTextSpan :: P.Maybe Spans_Types.TextSpan-  , token_audioSpan :: P.Maybe Spans_Types.AudioSpan+data Constituent = Constituent  { constituent_id :: I.Int32+  , constituent_tag :: P.Maybe LT.Text+  , constituent_childList :: (Vector.Vector I.Int32)+  , constituent_headChildIndex :: P.Maybe I.Int32+  , constituent_start :: P.Maybe I.Int32+  , constituent_ending :: P.Maybe I.Int32   } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)-instance H.Hashable Token where-  hashWithSalt salt record = salt   `H.hashWithSalt` token_tokenIndex record   `H.hashWithSalt` token_text record   `H.hashWithSalt` token_textSpan record   `H.hashWithSalt` token_rawTextSpan record   `H.hashWithSalt` token_audioSpan record  -instance QC.Arbitrary Token where -  arbitrary = M.liftM Token (QC.arbitrary)+instance H.Hashable Constituent where+  hashWithSalt salt record = salt   `H.hashWithSalt` constituent_id record   `H.hashWithSalt` constituent_tag record   `H.hashWithSalt` constituent_childList record   `H.hashWithSalt` constituent_headChildIndex record   `H.hashWithSalt` constituent_start record   `H.hashWithSalt` constituent_ending record  +instance QC.Arbitrary Constituent where +  arbitrary = M.liftM Constituent (QC.arbitrary)           `M.ap`(M.liftM P.Just QC.arbitrary)+          `M.ap`(QC.arbitrary)           `M.ap`(M.liftM P.Just QC.arbitrary)           `M.ap`(M.liftM P.Just QC.arbitrary)           `M.ap`(M.liftM P.Just QC.arbitrary)-  shrink obj | obj == default_Token = []+  shrink obj | obj == default_Constituent = []              | P.otherwise = M.catMaybes-    [ if obj == default_Token{token_tokenIndex = token_tokenIndex obj} then P.Nothing else P.Just $ default_Token{token_tokenIndex = token_tokenIndex obj}-    , if obj == default_Token{token_text = token_text obj} then P.Nothing else P.Just $ default_Token{token_text = token_text obj}-    , if obj == default_Token{token_textSpan = token_textSpan obj} then P.Nothing else P.Just $ default_Token{token_textSpan = token_textSpan obj}-    , if obj == default_Token{token_rawTextSpan = token_rawTextSpan obj} then P.Nothing else P.Just $ default_Token{token_rawTextSpan = token_rawTextSpan obj}-    , if obj == default_Token{token_audioSpan = token_audioSpan obj} then P.Nothing else P.Just $ default_Token{token_audioSpan = token_audioSpan obj}+    [ if obj == default_Constituent{constituent_id = constituent_id obj} then P.Nothing else P.Just $ default_Constituent{constituent_id = constituent_id obj}+    , if obj == default_Constituent{constituent_tag = constituent_tag obj} then P.Nothing else P.Just $ default_Constituent{constituent_tag = constituent_tag obj}+    , if obj == default_Constituent{constituent_childList = constituent_childList obj} then P.Nothing else P.Just $ default_Constituent{constituent_childList = constituent_childList obj}+    , if obj == default_Constituent{constituent_headChildIndex = constituent_headChildIndex obj} then P.Nothing else P.Just $ default_Constituent{constituent_headChildIndex = constituent_headChildIndex obj}+    , if obj == default_Constituent{constituent_start = constituent_start obj} then P.Nothing else P.Just $ default_Constituent{constituent_start = constituent_start obj}+    , if obj == default_Constituent{constituent_ending = constituent_ending obj} then P.Nothing else P.Just $ default_Constituent{constituent_ending = constituent_ending obj}     ]-from_Token :: Token -> T.ThriftVal-from_Token record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v2 -> P.Just (1, ("tokenIndex",T.TI32 _v2))) $ token_tokenIndex record-  , (\_v2 -> (2, ("text",T.TString $ E.encodeUtf8 _v2))) <$> token_text record-  , (\_v2 -> (3, ("textSpan",Spans_Types.from_TextSpan _v2))) <$> token_textSpan record-  , (\_v2 -> (4, ("rawTextSpan",Spans_Types.from_TextSpan _v2))) <$> token_rawTextSpan record-  , (\_v2 -> (5, ("audioSpan",Spans_Types.from_AudioSpan _v2))) <$> token_audioSpan record+from_Constituent :: Constituent -> T.ThriftVal+from_Constituent record = T.TStruct $ Map.fromList $ M.catMaybes+  [ (\_v2 -> P.Just (1, ("id",T.TI32 _v2))) $ constituent_id record+  , (\_v2 -> (2, ("tag",T.TString $ E.encodeUtf8 _v2))) <$> constituent_tag record+  , (\_v2 -> P.Just (3, ("childList",T.TList T.T_I32 $ P.map (\_v4 -> T.TI32 _v4) $ Vector.toList _v2))) $ constituent_childList record+  , (\_v2 -> (4, ("headChildIndex",T.TI32 _v2))) <$> constituent_headChildIndex record+  , (\_v2 -> (5, ("start",T.TI32 _v2))) <$> constituent_start record+  , (\_v2 -> (6, ("ending",T.TI32 _v2))) <$> constituent_ending record   ]-write_Token :: (T.Protocol p, T.Transport t) => p t -> Token -> P.IO ()-write_Token oprot record = T.writeVal oprot $ from_Token record-encode_Token :: (T.Protocol p, T.Transport t) => p t -> Token -> LBS.ByteString-encode_Token oprot record = T.serializeVal oprot $ from_Token record-to_Token :: T.ThriftVal -> Token-to_Token (T.TStruct fields) = Token{-  token_tokenIndex = P.maybe (P.error "Missing required field: tokenIndex") (\(_,_val4) -> (case _val4 of {T.TI32 _val5 -> _val5; _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  token_text = P.maybe (P.Nothing) (\(_,_val4) -> P.Just (case _val4 of {T.TString _val6 -> E.decodeUtf8 _val6; _ -> P.error "wrong type"})) (Map.lookup (2) fields),-  token_textSpan = P.maybe (P.Nothing) (\(_,_val4) -> P.Just (case _val4 of {T.TStruct _val7 -> (Spans_Types.to_TextSpan (T.TStruct _val7)); _ -> P.error "wrong type"})) (Map.lookup (3) fields),-  token_rawTextSpan = P.maybe (P.Nothing) (\(_,_val4) -> P.Just (case _val4 of {T.TStruct _val8 -> (Spans_Types.to_TextSpan (T.TStruct _val8)); _ -> P.error "wrong type"})) (Map.lookup (4) fields),-  token_audioSpan = P.maybe (P.Nothing) (\(_,_val4) -> P.Just (case _val4 of {T.TStruct _val9 -> (Spans_Types.to_AudioSpan (T.TStruct _val9)); _ -> P.error "wrong type"})) (Map.lookup (5) fields)+write_Constituent :: (T.Protocol p, T.Transport t) => p t -> Constituent -> P.IO ()+write_Constituent oprot record = T.writeVal oprot $ from_Constituent record+encode_Constituent :: (T.Protocol p, T.Transport t) => p t -> Constituent -> LBS.ByteString+encode_Constituent oprot record = T.serializeVal oprot $ from_Constituent record+to_Constituent :: T.ThriftVal -> Constituent+to_Constituent (T.TStruct fields) = Constituent{+  constituent_id = P.maybe (P.error "Missing required field: id") (\(_,_val6) -> (case _val6 of {T.TI32 _val7 -> _val7; _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  constituent_tag = P.maybe (P.Nothing) (\(_,_val6) -> P.Just (case _val6 of {T.TString _val8 -> E.decodeUtf8 _val8; _ -> P.error "wrong type"})) (Map.lookup (2) fields),+  constituent_childList = P.maybe (P.error "Missing required field: childList") (\(_,_val6) -> (case _val6 of {T.TList _ _val9 -> (Vector.fromList $ P.map (\_v10 -> (case _v10 of {T.TI32 _val11 -> _val11; _ -> P.error "wrong type"})) _val9); _ -> P.error "wrong type"})) (Map.lookup (3) fields),+  constituent_headChildIndex = P.maybe (constituent_headChildIndex default_Constituent) (\(_,_val6) -> P.Just (case _val6 of {T.TI32 _val12 -> _val12; _ -> P.error "wrong type"})) (Map.lookup (4) fields),+  constituent_start = P.maybe (P.Nothing) (\(_,_val6) -> P.Just (case _val6 of {T.TI32 _val13 -> _val13; _ -> P.error "wrong type"})) (Map.lookup (5) fields),+  constituent_ending = P.maybe (P.Nothing) (\(_,_val6) -> P.Just (case _val6 of {T.TI32 _val14 -> _val14; _ -> P.error "wrong type"})) (Map.lookup (6) fields)   }-to_Token _ = P.error "not a struct"-read_Token :: (T.Transport t, T.Protocol p) => p t -> P.IO Token-read_Token iprot = to_Token <$> T.readVal iprot (T.T_STRUCT typemap_Token)-decode_Token :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Token-decode_Token iprot bs = to_Token $ T.deserializeVal iprot (T.T_STRUCT typemap_Token) bs-typemap_Token :: T.TypeMap-typemap_Token = Map.fromList [(1,("tokenIndex",T.T_I32)),(2,("text",T.T_STRING)),(3,("textSpan",(T.T_STRUCT Spans_Types.typemap_TextSpan))),(4,("rawTextSpan",(T.T_STRUCT Spans_Types.typemap_TextSpan))),(5,("audioSpan",(T.T_STRUCT Spans_Types.typemap_AudioSpan)))]-default_Token :: Token-default_Token = Token{-  token_tokenIndex = 0,-  token_text = P.Nothing,-  token_textSpan = P.Nothing,-  token_rawTextSpan = P.Nothing,-  token_audioSpan = P.Nothing}+to_Constituent _ = P.error "not a struct"+read_Constituent :: (T.Transport t, T.Protocol p) => p t -> P.IO Constituent+read_Constituent iprot = to_Constituent <$> T.readVal iprot (T.T_STRUCT typemap_Constituent)+decode_Constituent :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Constituent+decode_Constituent iprot bs = to_Constituent $ T.deserializeVal iprot (T.T_STRUCT typemap_Constituent) bs+typemap_Constituent :: T.TypeMap+typemap_Constituent = Map.fromList [(1,("id",T.T_I32)),(2,("tag",T.T_STRING)),(3,("childList",(T.T_LIST T.T_I32))),(4,("headChildIndex",T.T_I32)),(5,("start",T.T_I32)),(6,("ending",T.T_I32))]+default_Constituent :: Constituent+default_Constituent = Constituent{+  constituent_id = 0,+  constituent_tag = P.Nothing,+  constituent_childList = Vector.empty,+  constituent_headChildIndex = P.Just (-1),+  constituent_start = P.Nothing,+  constituent_ending = P.Nothing}+data Parse = Parse  { parse_uuid :: Uuid_Types.UUID+  , parse_metadata :: Metadata_Types.AnnotationMetadata+  , parse_constituentList :: (Vector.Vector Constituent)+  } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)+instance H.Hashable Parse where+  hashWithSalt salt record = salt   `H.hashWithSalt` parse_uuid record   `H.hashWithSalt` parse_metadata record   `H.hashWithSalt` parse_constituentList record  +instance QC.Arbitrary Parse where +  arbitrary = M.liftM Parse (QC.arbitrary)+          `M.ap`(QC.arbitrary)+          `M.ap`(QC.arbitrary)+  shrink obj | obj == default_Parse = []+             | P.otherwise = M.catMaybes+    [ if obj == default_Parse{parse_uuid = parse_uuid obj} then P.Nothing else P.Just $ default_Parse{parse_uuid = parse_uuid obj}+    , if obj == default_Parse{parse_metadata = parse_metadata obj} then P.Nothing else P.Just $ default_Parse{parse_metadata = parse_metadata obj}+    , if obj == default_Parse{parse_constituentList = parse_constituentList obj} then P.Nothing else P.Just $ default_Parse{parse_constituentList = parse_constituentList obj}+    ]+from_Parse :: Parse -> T.ThriftVal+from_Parse record = T.TStruct $ Map.fromList $ M.catMaybes+  [ (\_v17 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v17))) $ parse_uuid record+  , (\_v17 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v17))) $ parse_metadata record+  , (\_v17 -> P.Just (3, ("constituentList",T.TList (T.T_STRUCT typemap_Constituent) $ P.map (\_v19 -> from_Constituent _v19) $ Vector.toList _v17))) $ parse_constituentList record+  ]+write_Parse :: (T.Protocol p, T.Transport t) => p t -> Parse -> P.IO ()+write_Parse oprot record = T.writeVal oprot $ from_Parse record+encode_Parse :: (T.Protocol p, T.Transport t) => p t -> Parse -> LBS.ByteString+encode_Parse oprot record = T.serializeVal oprot $ from_Parse record+to_Parse :: T.ThriftVal -> Parse+to_Parse (T.TStruct fields) = Parse{+  parse_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val21) -> (case _val21 of {T.TStruct _val22 -> (Uuid_Types.to_UUID (T.TStruct _val22)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  parse_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val21) -> (case _val21 of {T.TStruct _val23 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val23)); _ -> P.error "wrong type"})) (Map.lookup (2) fields),+  parse_constituentList = P.maybe (P.error "Missing required field: constituentList") (\(_,_val21) -> (case _val21 of {T.TList _ _val24 -> (Vector.fromList $ P.map (\_v25 -> (case _v25 of {T.TStruct _val26 -> (to_Constituent (T.TStruct _val26)); _ -> P.error "wrong type"})) _val24); _ -> P.error "wrong type"})) (Map.lookup (3) fields)+  }+to_Parse _ = P.error "not a struct"+read_Parse :: (T.Transport t, T.Protocol p) => p t -> P.IO Parse+read_Parse iprot = to_Parse <$> T.readVal iprot (T.T_STRUCT typemap_Parse)+decode_Parse :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Parse+decode_Parse iprot bs = to_Parse $ T.deserializeVal iprot (T.T_STRUCT typemap_Parse) bs+typemap_Parse :: T.TypeMap+typemap_Parse = Map.fromList [(1,("uuid",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("metadata",(T.T_STRUCT Metadata_Types.typemap_AnnotationMetadata))),(3,("constituentList",(T.T_LIST (T.T_STRUCT typemap_Constituent))))]+default_Parse :: Parse+default_Parse = Parse{+  parse_uuid = Uuid_Types.default_UUID,+  parse_metadata = Metadata_Types.default_AnnotationMetadata,+  parse_constituentList = Vector.empty} data ConstituentRef = ConstituentRef  { constituentRef_parseId :: Uuid_Types.UUID   , constituentRef_constituentIndex :: I.Int32   } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)@@ -127,8 +177,8 @@     ] from_ConstituentRef :: ConstituentRef -> T.ThriftVal from_ConstituentRef record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v12 -> P.Just (1, ("parseId",Uuid_Types.from_UUID _v12))) $ constituentRef_parseId record-  , (\_v12 -> P.Just (2, ("constituentIndex",T.TI32 _v12))) $ constituentRef_constituentIndex record+  [ (\_v29 -> P.Just (1, ("parseId",Uuid_Types.from_UUID _v29))) $ constituentRef_parseId record+  , (\_v29 -> P.Just (2, ("constituentIndex",T.TI32 _v29))) $ constituentRef_constituentIndex record   ] write_ConstituentRef :: (T.Protocol p, T.Transport t) => p t -> ConstituentRef -> P.IO () write_ConstituentRef oprot record = T.writeVal oprot $ from_ConstituentRef record@@ -136,8 +186,8 @@ encode_ConstituentRef oprot record = T.serializeVal oprot $ from_ConstituentRef record to_ConstituentRef :: T.ThriftVal -> ConstituentRef to_ConstituentRef (T.TStruct fields) = ConstituentRef{-  constituentRef_parseId = P.maybe (P.error "Missing required field: parseId") (\(_,_val14) -> (case _val14 of {T.TStruct _val15 -> (Uuid_Types.to_UUID (T.TStruct _val15)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  constituentRef_constituentIndex = P.maybe (P.error "Missing required field: constituentIndex") (\(_,_val14) -> (case _val14 of {T.TI32 _val16 -> _val16; _ -> P.error "wrong type"})) (Map.lookup (2) fields)+  constituentRef_parseId = P.maybe (P.error "Missing required field: parseId") (\(_,_val31) -> (case _val31 of {T.TStruct _val32 -> (Uuid_Types.to_UUID (T.TStruct _val32)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  constituentRef_constituentIndex = P.maybe (P.error "Missing required field: constituentIndex") (\(_,_val31) -> (case _val31 of {T.TI32 _val33 -> _val33; _ -> P.error "wrong type"})) (Map.lookup (2) fields)   } to_ConstituentRef _ = P.error "not a struct" read_ConstituentRef :: (T.Transport t, T.Protocol p) => p t -> P.IO ConstituentRef@@ -150,174 +200,6 @@ default_ConstituentRef = ConstituentRef{   constituentRef_parseId = Uuid_Types.default_UUID,   constituentRef_constituentIndex = 0}-data TokenRefSequence = TokenRefSequence  { tokenRefSequence_tokenIndexList :: (Vector.Vector I.Int32)-  , tokenRefSequence_anchorTokenIndex :: P.Maybe I.Int32-  , tokenRefSequence_tokenizationId :: Uuid_Types.UUID-  , tokenRefSequence_textSpan :: P.Maybe Spans_Types.TextSpan-  , tokenRefSequence_rawTextSpan :: P.Maybe Spans_Types.TextSpan-  , tokenRefSequence_audioSpan :: P.Maybe Spans_Types.AudioSpan-  } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)-instance H.Hashable TokenRefSequence where-  hashWithSalt salt record = salt   `H.hashWithSalt` tokenRefSequence_tokenIndexList record   `H.hashWithSalt` tokenRefSequence_anchorTokenIndex record   `H.hashWithSalt` tokenRefSequence_tokenizationId record   `H.hashWithSalt` tokenRefSequence_textSpan record   `H.hashWithSalt` tokenRefSequence_rawTextSpan record   `H.hashWithSalt` tokenRefSequence_audioSpan record  -instance QC.Arbitrary TokenRefSequence where -  arbitrary = M.liftM TokenRefSequence (QC.arbitrary)-          `M.ap`(M.liftM P.Just QC.arbitrary)-          `M.ap`(QC.arbitrary)-          `M.ap`(M.liftM P.Just QC.arbitrary)-          `M.ap`(M.liftM P.Just QC.arbitrary)-          `M.ap`(M.liftM P.Just QC.arbitrary)-  shrink obj | obj == default_TokenRefSequence = []-             | P.otherwise = M.catMaybes-    [ if obj == default_TokenRefSequence{tokenRefSequence_tokenIndexList = tokenRefSequence_tokenIndexList obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_tokenIndexList = tokenRefSequence_tokenIndexList obj}-    , if obj == default_TokenRefSequence{tokenRefSequence_anchorTokenIndex = tokenRefSequence_anchorTokenIndex obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_anchorTokenIndex = tokenRefSequence_anchorTokenIndex obj}-    , if obj == default_TokenRefSequence{tokenRefSequence_tokenizationId = tokenRefSequence_tokenizationId obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_tokenizationId = tokenRefSequence_tokenizationId obj}-    , if obj == default_TokenRefSequence{tokenRefSequence_textSpan = tokenRefSequence_textSpan obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_textSpan = tokenRefSequence_textSpan obj}-    , if obj == default_TokenRefSequence{tokenRefSequence_rawTextSpan = tokenRefSequence_rawTextSpan obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_rawTextSpan = tokenRefSequence_rawTextSpan obj}-    , if obj == default_TokenRefSequence{tokenRefSequence_audioSpan = tokenRefSequence_audioSpan obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_audioSpan = tokenRefSequence_audioSpan obj}-    ]-from_TokenRefSequence :: TokenRefSequence -> T.ThriftVal-from_TokenRefSequence record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v19 -> P.Just (1, ("tokenIndexList",T.TList T.T_I32 $ P.map (\_v21 -> T.TI32 _v21) $ Vector.toList _v19))) $ tokenRefSequence_tokenIndexList record-  , (\_v19 -> (2, ("anchorTokenIndex",T.TI32 _v19))) <$> tokenRefSequence_anchorTokenIndex record-  , (\_v19 -> P.Just (3, ("tokenizationId",Uuid_Types.from_UUID _v19))) $ tokenRefSequence_tokenizationId record-  , (\_v19 -> (4, ("textSpan",Spans_Types.from_TextSpan _v19))) <$> tokenRefSequence_textSpan record-  , (\_v19 -> (5, ("rawTextSpan",Spans_Types.from_TextSpan _v19))) <$> tokenRefSequence_rawTextSpan record-  , (\_v19 -> (6, ("audioSpan",Spans_Types.from_AudioSpan _v19))) <$> tokenRefSequence_audioSpan record-  ]-write_TokenRefSequence :: (T.Protocol p, T.Transport t) => p t -> TokenRefSequence -> P.IO ()-write_TokenRefSequence oprot record = T.writeVal oprot $ from_TokenRefSequence record-encode_TokenRefSequence :: (T.Protocol p, T.Transport t) => p t -> TokenRefSequence -> LBS.ByteString-encode_TokenRefSequence oprot record = T.serializeVal oprot $ from_TokenRefSequence record-to_TokenRefSequence :: T.ThriftVal -> TokenRefSequence-to_TokenRefSequence (T.TStruct fields) = TokenRefSequence{-  tokenRefSequence_tokenIndexList = P.maybe (P.error "Missing required field: tokenIndexList") (\(_,_val23) -> (case _val23 of {T.TList _ _val24 -> (Vector.fromList $ P.map (\_v25 -> (case _v25 of {T.TI32 _val26 -> _val26; _ -> P.error "wrong type"})) _val24); _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  tokenRefSequence_anchorTokenIndex = P.maybe (tokenRefSequence_anchorTokenIndex default_TokenRefSequence) (\(_,_val23) -> P.Just (case _val23 of {T.TI32 _val27 -> _val27; _ -> P.error "wrong type"})) (Map.lookup (2) fields),-  tokenRefSequence_tokenizationId = P.maybe (P.error "Missing required field: tokenizationId") (\(_,_val23) -> (case _val23 of {T.TStruct _val28 -> (Uuid_Types.to_UUID (T.TStruct _val28)); _ -> P.error "wrong type"})) (Map.lookup (3) fields),-  tokenRefSequence_textSpan = P.maybe (P.Nothing) (\(_,_val23) -> P.Just (case _val23 of {T.TStruct _val29 -> (Spans_Types.to_TextSpan (T.TStruct _val29)); _ -> P.error "wrong type"})) (Map.lookup (4) fields),-  tokenRefSequence_rawTextSpan = P.maybe (P.Nothing) (\(_,_val23) -> P.Just (case _val23 of {T.TStruct _val30 -> (Spans_Types.to_TextSpan (T.TStruct _val30)); _ -> P.error "wrong type"})) (Map.lookup (5) fields),-  tokenRefSequence_audioSpan = P.maybe (P.Nothing) (\(_,_val23) -> P.Just (case _val23 of {T.TStruct _val31 -> (Spans_Types.to_AudioSpan (T.TStruct _val31)); _ -> P.error "wrong type"})) (Map.lookup (6) fields)-  }-to_TokenRefSequence _ = P.error "not a struct"-read_TokenRefSequence :: (T.Transport t, T.Protocol p) => p t -> P.IO TokenRefSequence-read_TokenRefSequence iprot = to_TokenRefSequence <$> T.readVal iprot (T.T_STRUCT typemap_TokenRefSequence)-decode_TokenRefSequence :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> TokenRefSequence-decode_TokenRefSequence iprot bs = to_TokenRefSequence $ T.deserializeVal iprot (T.T_STRUCT typemap_TokenRefSequence) bs-typemap_TokenRefSequence :: T.TypeMap-typemap_TokenRefSequence = Map.fromList [(1,("tokenIndexList",(T.T_LIST T.T_I32))),(2,("anchorTokenIndex",T.T_I32)),(3,("tokenizationId",(T.T_STRUCT Uuid_Types.typemap_UUID))),(4,("textSpan",(T.T_STRUCT Spans_Types.typemap_TextSpan))),(5,("rawTextSpan",(T.T_STRUCT Spans_Types.typemap_TextSpan))),(6,("audioSpan",(T.T_STRUCT Spans_Types.typemap_AudioSpan)))]-default_TokenRefSequence :: TokenRefSequence-default_TokenRefSequence = TokenRefSequence{-  tokenRefSequence_tokenIndexList = Vector.empty,-  tokenRefSequence_anchorTokenIndex = P.Just (-1),-  tokenRefSequence_tokenizationId = Uuid_Types.default_UUID,-  tokenRefSequence_textSpan = P.Nothing,-  tokenRefSequence_rawTextSpan = P.Nothing,-  tokenRefSequence_audioSpan = P.Nothing}-data TaggedToken = TaggedToken  { taggedToken_tokenIndex :: P.Maybe I.Int32-  , taggedToken_tag :: P.Maybe LT.Text-  , taggedToken_confidence :: P.Maybe P.Double-  , taggedToken_tagList :: P.Maybe (Vector.Vector LT.Text)-  , taggedToken_confidenceList :: P.Maybe (Vector.Vector P.Double)-  } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)-instance H.Hashable TaggedToken where-  hashWithSalt salt record = salt   `H.hashWithSalt` taggedToken_tokenIndex record   `H.hashWithSalt` taggedToken_tag record   `H.hashWithSalt` taggedToken_confidence record   `H.hashWithSalt` taggedToken_tagList record   `H.hashWithSalt` taggedToken_confidenceList record  -instance QC.Arbitrary TaggedToken where -  arbitrary = M.liftM TaggedToken (M.liftM P.Just QC.arbitrary)-          `M.ap`(M.liftM P.Just QC.arbitrary)-          `M.ap`(M.liftM P.Just QC.arbitrary)-          `M.ap`(M.liftM P.Just QC.arbitrary)-          `M.ap`(M.liftM P.Just QC.arbitrary)-  shrink obj | obj == default_TaggedToken = []-             | P.otherwise = M.catMaybes-    [ if obj == default_TaggedToken{taggedToken_tokenIndex = taggedToken_tokenIndex obj} then P.Nothing else P.Just $ default_TaggedToken{taggedToken_tokenIndex = taggedToken_tokenIndex obj}-    , if obj == default_TaggedToken{taggedToken_tag = taggedToken_tag obj} then P.Nothing else P.Just $ default_TaggedToken{taggedToken_tag = taggedToken_tag obj}-    , if obj == default_TaggedToken{taggedToken_confidence = taggedToken_confidence obj} then P.Nothing else P.Just $ default_TaggedToken{taggedToken_confidence = taggedToken_confidence obj}-    , if obj == default_TaggedToken{taggedToken_tagList = taggedToken_tagList obj} then P.Nothing else P.Just $ default_TaggedToken{taggedToken_tagList = taggedToken_tagList obj}-    , if obj == default_TaggedToken{taggedToken_confidenceList = taggedToken_confidenceList obj} then P.Nothing else P.Just $ default_TaggedToken{taggedToken_confidenceList = taggedToken_confidenceList obj}-    ]-from_TaggedToken :: TaggedToken -> T.ThriftVal-from_TaggedToken record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v34 -> (1, ("tokenIndex",T.TI32 _v34))) <$> taggedToken_tokenIndex record-  , (\_v34 -> (2, ("tag",T.TString $ E.encodeUtf8 _v34))) <$> taggedToken_tag record-  , (\_v34 -> (3, ("confidence",T.TDouble _v34))) <$> taggedToken_confidence record-  , (\_v34 -> (4, ("tagList",T.TList T.T_STRING $ P.map (\_v36 -> T.TString $ E.encodeUtf8 _v36) $ Vector.toList _v34))) <$> taggedToken_tagList record-  , (\_v34 -> (5, ("confidenceList",T.TList T.T_DOUBLE $ P.map (\_v38 -> T.TDouble _v38) $ Vector.toList _v34))) <$> taggedToken_confidenceList record-  ]-write_TaggedToken :: (T.Protocol p, T.Transport t) => p t -> TaggedToken -> P.IO ()-write_TaggedToken oprot record = T.writeVal oprot $ from_TaggedToken record-encode_TaggedToken :: (T.Protocol p, T.Transport t) => p t -> TaggedToken -> LBS.ByteString-encode_TaggedToken oprot record = T.serializeVal oprot $ from_TaggedToken record-to_TaggedToken :: T.ThriftVal -> TaggedToken-to_TaggedToken (T.TStruct fields) = TaggedToken{-  taggedToken_tokenIndex = P.maybe (P.Nothing) (\(_,_val40) -> P.Just (case _val40 of {T.TI32 _val41 -> _val41; _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  taggedToken_tag = P.maybe (P.Nothing) (\(_,_val40) -> P.Just (case _val40 of {T.TString _val42 -> E.decodeUtf8 _val42; _ -> P.error "wrong type"})) (Map.lookup (2) fields),-  taggedToken_confidence = P.maybe (P.Nothing) (\(_,_val40) -> P.Just (case _val40 of {T.TDouble _val43 -> _val43; _ -> P.error "wrong type"})) (Map.lookup (3) fields),-  taggedToken_tagList = P.maybe (P.Nothing) (\(_,_val40) -> P.Just (case _val40 of {T.TList _ _val44 -> (Vector.fromList $ P.map (\_v45 -> (case _v45 of {T.TString _val46 -> E.decodeUtf8 _val46; _ -> P.error "wrong type"})) _val44); _ -> P.error "wrong type"})) (Map.lookup (4) fields),-  taggedToken_confidenceList = P.maybe (P.Nothing) (\(_,_val40) -> P.Just (case _val40 of {T.TList _ _val47 -> (Vector.fromList $ P.map (\_v48 -> (case _v48 of {T.TDouble _val49 -> _val49; _ -> P.error "wrong type"})) _val47); _ -> P.error "wrong type"})) (Map.lookup (5) fields)-  }-to_TaggedToken _ = P.error "not a struct"-read_TaggedToken :: (T.Transport t, T.Protocol p) => p t -> P.IO TaggedToken-read_TaggedToken iprot = to_TaggedToken <$> T.readVal iprot (T.T_STRUCT typemap_TaggedToken)-decode_TaggedToken :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> TaggedToken-decode_TaggedToken iprot bs = to_TaggedToken $ T.deserializeVal iprot (T.T_STRUCT typemap_TaggedToken) bs-typemap_TaggedToken :: T.TypeMap-typemap_TaggedToken = Map.fromList [(1,("tokenIndex",T.T_I32)),(2,("tag",T.T_STRING)),(3,("confidence",T.T_DOUBLE)),(4,("tagList",(T.T_LIST T.T_STRING))),(5,("confidenceList",(T.T_LIST T.T_DOUBLE)))]-default_TaggedToken :: TaggedToken-default_TaggedToken = TaggedToken{-  taggedToken_tokenIndex = P.Nothing,-  taggedToken_tag = P.Nothing,-  taggedToken_confidence = P.Nothing,-  taggedToken_tagList = P.Nothing,-  taggedToken_confidenceList = P.Nothing}-data TokenTagging = TokenTagging  { tokenTagging_uuid :: Uuid_Types.UUID-  , tokenTagging_metadata :: Metadata_Types.AnnotationMetadata-  , tokenTagging_taggedTokenList :: (Vector.Vector TaggedToken)-  , tokenTagging_taggingType :: P.Maybe LT.Text-  } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)-instance H.Hashable TokenTagging where-  hashWithSalt salt record = salt   `H.hashWithSalt` tokenTagging_uuid record   `H.hashWithSalt` tokenTagging_metadata record   `H.hashWithSalt` tokenTagging_taggedTokenList record   `H.hashWithSalt` tokenTagging_taggingType record  -instance QC.Arbitrary TokenTagging where -  arbitrary = M.liftM TokenTagging (QC.arbitrary)-          `M.ap`(QC.arbitrary)-          `M.ap`(QC.arbitrary)-          `M.ap`(M.liftM P.Just QC.arbitrary)-  shrink obj | obj == default_TokenTagging = []-             | P.otherwise = M.catMaybes-    [ if obj == default_TokenTagging{tokenTagging_uuid = tokenTagging_uuid obj} then P.Nothing else P.Just $ default_TokenTagging{tokenTagging_uuid = tokenTagging_uuid obj}-    , if obj == default_TokenTagging{tokenTagging_metadata = tokenTagging_metadata obj} then P.Nothing else P.Just $ default_TokenTagging{tokenTagging_metadata = tokenTagging_metadata obj}-    , if obj == default_TokenTagging{tokenTagging_taggedTokenList = tokenTagging_taggedTokenList obj} then P.Nothing else P.Just $ default_TokenTagging{tokenTagging_taggedTokenList = tokenTagging_taggedTokenList obj}-    , if obj == default_TokenTagging{tokenTagging_taggingType = tokenTagging_taggingType obj} then P.Nothing else P.Just $ default_TokenTagging{tokenTagging_taggingType = tokenTagging_taggingType obj}-    ]-from_TokenTagging :: TokenTagging -> T.ThriftVal-from_TokenTagging record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v52 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v52))) $ tokenTagging_uuid record-  , (\_v52 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v52))) $ tokenTagging_metadata record-  , (\_v52 -> P.Just (3, ("taggedTokenList",T.TList (T.T_STRUCT typemap_TaggedToken) $ P.map (\_v54 -> from_TaggedToken _v54) $ Vector.toList _v52))) $ tokenTagging_taggedTokenList record-  , (\_v52 -> (4, ("taggingType",T.TString $ E.encodeUtf8 _v52))) <$> tokenTagging_taggingType record-  ]-write_TokenTagging :: (T.Protocol p, T.Transport t) => p t -> TokenTagging -> P.IO ()-write_TokenTagging oprot record = T.writeVal oprot $ from_TokenTagging record-encode_TokenTagging :: (T.Protocol p, T.Transport t) => p t -> TokenTagging -> LBS.ByteString-encode_TokenTagging oprot record = T.serializeVal oprot $ from_TokenTagging record-to_TokenTagging :: T.ThriftVal -> TokenTagging-to_TokenTagging (T.TStruct fields) = TokenTagging{-  tokenTagging_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val56) -> (case _val56 of {T.TStruct _val57 -> (Uuid_Types.to_UUID (T.TStruct _val57)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  tokenTagging_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val56) -> (case _val56 of {T.TStruct _val58 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val58)); _ -> P.error "wrong type"})) (Map.lookup (2) fields),-  tokenTagging_taggedTokenList = P.maybe (P.error "Missing required field: taggedTokenList") (\(_,_val56) -> (case _val56 of {T.TList _ _val59 -> (Vector.fromList $ P.map (\_v60 -> (case _v60 of {T.TStruct _val61 -> (to_TaggedToken (T.TStruct _val61)); _ -> P.error "wrong type"})) _val59); _ -> P.error "wrong type"})) (Map.lookup (3) fields),-  tokenTagging_taggingType = P.maybe (P.Nothing) (\(_,_val56) -> P.Just (case _val56 of {T.TString _val62 -> E.decodeUtf8 _val62; _ -> P.error "wrong type"})) (Map.lookup (4) fields)-  }-to_TokenTagging _ = P.error "not a struct"-read_TokenTagging :: (T.Transport t, T.Protocol p) => p t -> P.IO TokenTagging-read_TokenTagging iprot = to_TokenTagging <$> T.readVal iprot (T.T_STRUCT typemap_TokenTagging)-decode_TokenTagging :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> TokenTagging-decode_TokenTagging iprot bs = to_TokenTagging $ T.deserializeVal iprot (T.T_STRUCT typemap_TokenTagging) bs-typemap_TokenTagging :: T.TypeMap-typemap_TokenTagging = Map.fromList [(1,("uuid",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("metadata",(T.T_STRUCT Metadata_Types.typemap_AnnotationMetadata))),(3,("taggedTokenList",(T.T_LIST (T.T_STRUCT typemap_TaggedToken)))),(4,("taggingType",T.T_STRING))]-default_TokenTagging :: TokenTagging-default_TokenTagging = TokenTagging{-  tokenTagging_uuid = Uuid_Types.default_UUID,-  tokenTagging_metadata = Metadata_Types.default_AnnotationMetadata,-  tokenTagging_taggedTokenList = Vector.empty,-  tokenTagging_taggingType = P.Nothing} data Dependency = Dependency  { dependency_gov :: P.Maybe I.Int32   , dependency_dep :: I.Int32   , dependency_edgeType :: P.Maybe LT.Text@@ -336,9 +218,9 @@     ] from_Dependency :: Dependency -> T.ThriftVal from_Dependency record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v65 -> (1, ("gov",T.TI32 _v65))) <$> dependency_gov record-  , (\_v65 -> P.Just (2, ("dep",T.TI32 _v65))) $ dependency_dep record-  , (\_v65 -> (3, ("edgeType",T.TString $ E.encodeUtf8 _v65))) <$> dependency_edgeType record+  [ (\_v36 -> (1, ("gov",T.TI32 _v36))) <$> dependency_gov record+  , (\_v36 -> P.Just (2, ("dep",T.TI32 _v36))) $ dependency_dep record+  , (\_v36 -> (3, ("edgeType",T.TString $ E.encodeUtf8 _v36))) <$> dependency_edgeType record   ] write_Dependency :: (T.Protocol p, T.Transport t) => p t -> Dependency -> P.IO () write_Dependency oprot record = T.writeVal oprot $ from_Dependency record@@ -346,9 +228,9 @@ encode_Dependency oprot record = T.serializeVal oprot $ from_Dependency record to_Dependency :: T.ThriftVal -> Dependency to_Dependency (T.TStruct fields) = Dependency{-  dependency_gov = P.maybe (dependency_gov default_Dependency) (\(_,_val67) -> P.Just (case _val67 of {T.TI32 _val68 -> _val68; _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  dependency_dep = P.maybe (P.error "Missing required field: dep") (\(_,_val67) -> (case _val67 of {T.TI32 _val69 -> _val69; _ -> P.error "wrong type"})) (Map.lookup (2) fields),-  dependency_edgeType = P.maybe (P.Nothing) (\(_,_val67) -> P.Just (case _val67 of {T.TString _val70 -> E.decodeUtf8 _val70; _ -> P.error "wrong type"})) (Map.lookup (3) fields)+  dependency_gov = P.maybe (dependency_gov default_Dependency) (\(_,_val38) -> P.Just (case _val38 of {T.TI32 _val39 -> _val39; _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  dependency_dep = P.maybe (P.error "Missing required field: dep") (\(_,_val38) -> (case _val38 of {T.TI32 _val40 -> _val40; _ -> P.error "wrong type"})) (Map.lookup (2) fields),+  dependency_edgeType = P.maybe (P.Nothing) (\(_,_val38) -> P.Just (case _val38 of {T.TString _val41 -> E.decodeUtf8 _val41; _ -> P.error "wrong type"})) (Map.lookup (3) fields)   } to_Dependency _ = P.error "not a struct" read_Dependency :: (T.Transport t, T.Protocol p) => p t -> P.IO Dependency@@ -383,10 +265,10 @@     ] from_DependencyParseStructure :: DependencyParseStructure -> T.ThriftVal from_DependencyParseStructure record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v73 -> P.Just (1, ("isAcyclic",T.TBool _v73))) $ dependencyParseStructure_isAcyclic record-  , (\_v73 -> P.Just (2, ("isConnected",T.TBool _v73))) $ dependencyParseStructure_isConnected record-  , (\_v73 -> P.Just (3, ("isSingleHeaded",T.TBool _v73))) $ dependencyParseStructure_isSingleHeaded record-  , (\_v73 -> P.Just (4, ("isProjective",T.TBool _v73))) $ dependencyParseStructure_isProjective record+  [ (\_v44 -> P.Just (1, ("isAcyclic",T.TBool _v44))) $ dependencyParseStructure_isAcyclic record+  , (\_v44 -> P.Just (2, ("isConnected",T.TBool _v44))) $ dependencyParseStructure_isConnected record+  , (\_v44 -> P.Just (3, ("isSingleHeaded",T.TBool _v44))) $ dependencyParseStructure_isSingleHeaded record+  , (\_v44 -> P.Just (4, ("isProjective",T.TBool _v44))) $ dependencyParseStructure_isProjective record   ] write_DependencyParseStructure :: (T.Protocol p, T.Transport t) => p t -> DependencyParseStructure -> P.IO () write_DependencyParseStructure oprot record = T.writeVal oprot $ from_DependencyParseStructure record@@ -394,10 +276,10 @@ encode_DependencyParseStructure oprot record = T.serializeVal oprot $ from_DependencyParseStructure record to_DependencyParseStructure :: T.ThriftVal -> DependencyParseStructure to_DependencyParseStructure (T.TStruct fields) = DependencyParseStructure{-  dependencyParseStructure_isAcyclic = P.maybe (P.error "Missing required field: isAcyclic") (\(_,_val75) -> (case _val75 of {T.TBool _val76 -> _val76; _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  dependencyParseStructure_isConnected = P.maybe (P.error "Missing required field: isConnected") (\(_,_val75) -> (case _val75 of {T.TBool _val77 -> _val77; _ -> P.error "wrong type"})) (Map.lookup (2) fields),-  dependencyParseStructure_isSingleHeaded = P.maybe (P.error "Missing required field: isSingleHeaded") (\(_,_val75) -> (case _val75 of {T.TBool _val78 -> _val78; _ -> P.error "wrong type"})) (Map.lookup (3) fields),-  dependencyParseStructure_isProjective = P.maybe (P.error "Missing required field: isProjective") (\(_,_val75) -> (case _val75 of {T.TBool _val79 -> _val79; _ -> P.error "wrong type"})) (Map.lookup (4) fields)+  dependencyParseStructure_isAcyclic = P.maybe (P.error "Missing required field: isAcyclic") (\(_,_val46) -> (case _val46 of {T.TBool _val47 -> _val47; _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  dependencyParseStructure_isConnected = P.maybe (P.error "Missing required field: isConnected") (\(_,_val46) -> (case _val46 of {T.TBool _val48 -> _val48; _ -> P.error "wrong type"})) (Map.lookup (2) fields),+  dependencyParseStructure_isSingleHeaded = P.maybe (P.error "Missing required field: isSingleHeaded") (\(_,_val46) -> (case _val46 of {T.TBool _val49 -> _val49; _ -> P.error "wrong type"})) (Map.lookup (3) fields),+  dependencyParseStructure_isProjective = P.maybe (P.error "Missing required field: isProjective") (\(_,_val46) -> (case _val46 of {T.TBool _val50 -> _val50; _ -> P.error "wrong type"})) (Map.lookup (4) fields)   } to_DependencyParseStructure _ = P.error "not a struct" read_DependencyParseStructure :: (T.Transport t, T.Protocol p) => p t -> P.IO DependencyParseStructure@@ -433,10 +315,10 @@     ] from_DependencyParse :: DependencyParse -> T.ThriftVal from_DependencyParse record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v82 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v82))) $ dependencyParse_uuid record-  , (\_v82 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v82))) $ dependencyParse_metadata record-  , (\_v82 -> P.Just (3, ("dependencyList",T.TList (T.T_STRUCT typemap_Dependency) $ P.map (\_v84 -> from_Dependency _v84) $ Vector.toList _v82))) $ dependencyParse_dependencyList record-  , (\_v82 -> (4, ("structureInformation",from_DependencyParseStructure _v82))) <$> dependencyParse_structureInformation record+  [ (\_v53 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v53))) $ dependencyParse_uuid record+  , (\_v53 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v53))) $ dependencyParse_metadata record+  , (\_v53 -> P.Just (3, ("dependencyList",T.TList (T.T_STRUCT typemap_Dependency) $ P.map (\_v55 -> from_Dependency _v55) $ Vector.toList _v53))) $ dependencyParse_dependencyList record+  , (\_v53 -> (4, ("structureInformation",from_DependencyParseStructure _v53))) <$> dependencyParse_structureInformation record   ] write_DependencyParse :: (T.Protocol p, T.Transport t) => p t -> DependencyParse -> P.IO () write_DependencyParse oprot record = T.writeVal oprot $ from_DependencyParse record@@ -444,10 +326,10 @@ encode_DependencyParse oprot record = T.serializeVal oprot $ from_DependencyParse record to_DependencyParse :: T.ThriftVal -> DependencyParse to_DependencyParse (T.TStruct fields) = DependencyParse{-  dependencyParse_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val86) -> (case _val86 of {T.TStruct _val87 -> (Uuid_Types.to_UUID (T.TStruct _val87)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  dependencyParse_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val86) -> (case _val86 of {T.TStruct _val88 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val88)); _ -> P.error "wrong type"})) (Map.lookup (2) fields),-  dependencyParse_dependencyList = P.maybe (P.error "Missing required field: dependencyList") (\(_,_val86) -> (case _val86 of {T.TList _ _val89 -> (Vector.fromList $ P.map (\_v90 -> (case _v90 of {T.TStruct _val91 -> (to_Dependency (T.TStruct _val91)); _ -> P.error "wrong type"})) _val89); _ -> P.error "wrong type"})) (Map.lookup (3) fields),-  dependencyParse_structureInformation = P.maybe (P.Nothing) (\(_,_val86) -> P.Just (case _val86 of {T.TStruct _val92 -> (to_DependencyParseStructure (T.TStruct _val92)); _ -> P.error "wrong type"})) (Map.lookup (4) fields)+  dependencyParse_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val57) -> (case _val57 of {T.TStruct _val58 -> (Uuid_Types.to_UUID (T.TStruct _val58)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  dependencyParse_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val57) -> (case _val57 of {T.TStruct _val59 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val59)); _ -> P.error "wrong type"})) (Map.lookup (2) fields),+  dependencyParse_dependencyList = P.maybe (P.error "Missing required field: dependencyList") (\(_,_val57) -> (case _val57 of {T.TList _ _val60 -> (Vector.fromList $ P.map (\_v61 -> (case _v61 of {T.TStruct _val62 -> (to_Dependency (T.TStruct _val62)); _ -> P.error "wrong type"})) _val60); _ -> P.error "wrong type"})) (Map.lookup (3) fields),+  dependencyParse_structureInformation = P.maybe (P.Nothing) (\(_,_val57) -> P.Just (case _val57 of {T.TStruct _val63 -> (to_DependencyParseStructure (T.TStruct _val63)); _ -> P.error "wrong type"})) (Map.lookup (4) fields)   } to_DependencyParse _ = P.error "not a struct" read_DependencyParse :: (T.Transport t, T.Protocol p) => p t -> P.IO DependencyParse@@ -462,112 +344,242 @@   dependencyParse_metadata = Metadata_Types.default_AnnotationMetadata,   dependencyParse_dependencyList = Vector.empty,   dependencyParse_structureInformation = P.Nothing}-data Constituent = Constituent  { constituent_id :: I.Int32-  , constituent_tag :: P.Maybe LT.Text-  , constituent_childList :: (Vector.Vector I.Int32)-  , constituent_headChildIndex :: P.Maybe I.Int32-  , constituent_start :: P.Maybe I.Int32-  , constituent_ending :: P.Maybe I.Int32+data Token = Token  { token_tokenIndex :: I.Int32+  , token_text :: P.Maybe LT.Text+  , token_textSpan :: P.Maybe Spans_Types.TextSpan+  , token_rawTextSpan :: P.Maybe Spans_Types.TextSpan+  , token_audioSpan :: P.Maybe Spans_Types.AudioSpan   } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)-instance H.Hashable Constituent where-  hashWithSalt salt record = salt   `H.hashWithSalt` constituent_id record   `H.hashWithSalt` constituent_tag record   `H.hashWithSalt` constituent_childList record   `H.hashWithSalt` constituent_headChildIndex record   `H.hashWithSalt` constituent_start record   `H.hashWithSalt` constituent_ending record  -instance QC.Arbitrary Constituent where -  arbitrary = M.liftM Constituent (QC.arbitrary)+instance H.Hashable Token where+  hashWithSalt salt record = salt   `H.hashWithSalt` token_tokenIndex record   `H.hashWithSalt` token_text record   `H.hashWithSalt` token_textSpan record   `H.hashWithSalt` token_rawTextSpan record   `H.hashWithSalt` token_audioSpan record  +instance QC.Arbitrary Token where +  arbitrary = M.liftM Token (QC.arbitrary)           `M.ap`(M.liftM P.Just QC.arbitrary)+          `M.ap`(M.liftM P.Just QC.arbitrary)+          `M.ap`(M.liftM P.Just QC.arbitrary)+          `M.ap`(M.liftM P.Just QC.arbitrary)+  shrink obj | obj == default_Token = []+             | P.otherwise = M.catMaybes+    [ if obj == default_Token{token_tokenIndex = token_tokenIndex obj} then P.Nothing else P.Just $ default_Token{token_tokenIndex = token_tokenIndex obj}+    , if obj == default_Token{token_text = token_text obj} then P.Nothing else P.Just $ default_Token{token_text = token_text obj}+    , if obj == default_Token{token_textSpan = token_textSpan obj} then P.Nothing else P.Just $ default_Token{token_textSpan = token_textSpan obj}+    , if obj == default_Token{token_rawTextSpan = token_rawTextSpan obj} then P.Nothing else P.Just $ default_Token{token_rawTextSpan = token_rawTextSpan obj}+    , if obj == default_Token{token_audioSpan = token_audioSpan obj} then P.Nothing else P.Just $ default_Token{token_audioSpan = token_audioSpan obj}+    ]+from_Token :: Token -> T.ThriftVal+from_Token record = T.TStruct $ Map.fromList $ M.catMaybes+  [ (\_v66 -> P.Just (1, ("tokenIndex",T.TI32 _v66))) $ token_tokenIndex record+  , (\_v66 -> (2, ("text",T.TString $ E.encodeUtf8 _v66))) <$> token_text record+  , (\_v66 -> (3, ("textSpan",Spans_Types.from_TextSpan _v66))) <$> token_textSpan record+  , (\_v66 -> (4, ("rawTextSpan",Spans_Types.from_TextSpan _v66))) <$> token_rawTextSpan record+  , (\_v66 -> (5, ("audioSpan",Spans_Types.from_AudioSpan _v66))) <$> token_audioSpan record+  ]+write_Token :: (T.Protocol p, T.Transport t) => p t -> Token -> P.IO ()+write_Token oprot record = T.writeVal oprot $ from_Token record+encode_Token :: (T.Protocol p, T.Transport t) => p t -> Token -> LBS.ByteString+encode_Token oprot record = T.serializeVal oprot $ from_Token record+to_Token :: T.ThriftVal -> Token+to_Token (T.TStruct fields) = Token{+  token_tokenIndex = P.maybe (P.error "Missing required field: tokenIndex") (\(_,_val68) -> (case _val68 of {T.TI32 _val69 -> _val69; _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  token_text = P.maybe (P.Nothing) (\(_,_val68) -> P.Just (case _val68 of {T.TString _val70 -> E.decodeUtf8 _val70; _ -> P.error "wrong type"})) (Map.lookup (2) fields),+  token_textSpan = P.maybe (P.Nothing) (\(_,_val68) -> P.Just (case _val68 of {T.TStruct _val71 -> (Spans_Types.to_TextSpan (T.TStruct _val71)); _ -> P.error "wrong type"})) (Map.lookup (3) fields),+  token_rawTextSpan = P.maybe (P.Nothing) (\(_,_val68) -> P.Just (case _val68 of {T.TStruct _val72 -> (Spans_Types.to_TextSpan (T.TStruct _val72)); _ -> P.error "wrong type"})) (Map.lookup (4) fields),+  token_audioSpan = P.maybe (P.Nothing) (\(_,_val68) -> P.Just (case _val68 of {T.TStruct _val73 -> (Spans_Types.to_AudioSpan (T.TStruct _val73)); _ -> P.error "wrong type"})) (Map.lookup (5) fields)+  }+to_Token _ = P.error "not a struct"+read_Token :: (T.Transport t, T.Protocol p) => p t -> P.IO Token+read_Token iprot = to_Token <$> T.readVal iprot (T.T_STRUCT typemap_Token)+decode_Token :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Token+decode_Token iprot bs = to_Token $ T.deserializeVal iprot (T.T_STRUCT typemap_Token) bs+typemap_Token :: T.TypeMap+typemap_Token = Map.fromList [(1,("tokenIndex",T.T_I32)),(2,("text",T.T_STRING)),(3,("textSpan",(T.T_STRUCT Spans_Types.typemap_TextSpan))),(4,("rawTextSpan",(T.T_STRUCT Spans_Types.typemap_TextSpan))),(5,("audioSpan",(T.T_STRUCT Spans_Types.typemap_AudioSpan)))]+default_Token :: Token+default_Token = Token{+  token_tokenIndex = 0,+  token_text = P.Nothing,+  token_textSpan = P.Nothing,+  token_rawTextSpan = P.Nothing,+  token_audioSpan = P.Nothing}+data TokenRefSequence = TokenRefSequence  { tokenRefSequence_tokenIndexList :: (Vector.Vector I.Int32)+  , tokenRefSequence_anchorTokenIndex :: P.Maybe I.Int32+  , tokenRefSequence_tokenizationId :: Uuid_Types.UUID+  , tokenRefSequence_textSpan :: P.Maybe Spans_Types.TextSpan+  , tokenRefSequence_rawTextSpan :: P.Maybe Spans_Types.TextSpan+  , tokenRefSequence_audioSpan :: P.Maybe Spans_Types.AudioSpan+  , tokenRefSequence_dependencies :: P.Maybe (Vector.Vector Dependency)+  , tokenRefSequence_constituent :: P.Maybe ConstituentRef+  } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)+instance H.Hashable TokenRefSequence where+  hashWithSalt salt record = salt   `H.hashWithSalt` tokenRefSequence_tokenIndexList record   `H.hashWithSalt` tokenRefSequence_anchorTokenIndex record   `H.hashWithSalt` tokenRefSequence_tokenizationId record   `H.hashWithSalt` tokenRefSequence_textSpan record   `H.hashWithSalt` tokenRefSequence_rawTextSpan record   `H.hashWithSalt` tokenRefSequence_audioSpan record   `H.hashWithSalt` tokenRefSequence_dependencies record   `H.hashWithSalt` tokenRefSequence_constituent record  +instance QC.Arbitrary TokenRefSequence where +  arbitrary = M.liftM TokenRefSequence (QC.arbitrary)+          `M.ap`(M.liftM P.Just QC.arbitrary)           `M.ap`(QC.arbitrary)           `M.ap`(M.liftM P.Just QC.arbitrary)           `M.ap`(M.liftM P.Just QC.arbitrary)           `M.ap`(M.liftM P.Just QC.arbitrary)-  shrink obj | obj == default_Constituent = []+          `M.ap`(M.liftM P.Just QC.arbitrary)+          `M.ap`(M.liftM P.Just QC.arbitrary)+  shrink obj | obj == default_TokenRefSequence = []              | P.otherwise = M.catMaybes-    [ if obj == default_Constituent{constituent_id = constituent_id obj} then P.Nothing else P.Just $ default_Constituent{constituent_id = constituent_id obj}-    , if obj == default_Constituent{constituent_tag = constituent_tag obj} then P.Nothing else P.Just $ default_Constituent{constituent_tag = constituent_tag obj}-    , if obj == default_Constituent{constituent_childList = constituent_childList obj} then P.Nothing else P.Just $ default_Constituent{constituent_childList = constituent_childList obj}-    , if obj == default_Constituent{constituent_headChildIndex = constituent_headChildIndex obj} then P.Nothing else P.Just $ default_Constituent{constituent_headChildIndex = constituent_headChildIndex obj}-    , if obj == default_Constituent{constituent_start = constituent_start obj} then P.Nothing else P.Just $ default_Constituent{constituent_start = constituent_start obj}-    , if obj == default_Constituent{constituent_ending = constituent_ending obj} then P.Nothing else P.Just $ default_Constituent{constituent_ending = constituent_ending obj}+    [ if obj == default_TokenRefSequence{tokenRefSequence_tokenIndexList = tokenRefSequence_tokenIndexList obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_tokenIndexList = tokenRefSequence_tokenIndexList obj}+    , if obj == default_TokenRefSequence{tokenRefSequence_anchorTokenIndex = tokenRefSequence_anchorTokenIndex obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_anchorTokenIndex = tokenRefSequence_anchorTokenIndex obj}+    , if obj == default_TokenRefSequence{tokenRefSequence_tokenizationId = tokenRefSequence_tokenizationId obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_tokenizationId = tokenRefSequence_tokenizationId obj}+    , if obj == default_TokenRefSequence{tokenRefSequence_textSpan = tokenRefSequence_textSpan obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_textSpan = tokenRefSequence_textSpan obj}+    , if obj == default_TokenRefSequence{tokenRefSequence_rawTextSpan = tokenRefSequence_rawTextSpan obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_rawTextSpan = tokenRefSequence_rawTextSpan obj}+    , if obj == default_TokenRefSequence{tokenRefSequence_audioSpan = tokenRefSequence_audioSpan obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_audioSpan = tokenRefSequence_audioSpan obj}+    , if obj == default_TokenRefSequence{tokenRefSequence_dependencies = tokenRefSequence_dependencies obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_dependencies = tokenRefSequence_dependencies obj}+    , if obj == default_TokenRefSequence{tokenRefSequence_constituent = tokenRefSequence_constituent obj} then P.Nothing else P.Just $ default_TokenRefSequence{tokenRefSequence_constituent = tokenRefSequence_constituent obj}     ]-from_Constituent :: Constituent -> T.ThriftVal-from_Constituent record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v95 -> P.Just (1, ("id",T.TI32 _v95))) $ constituent_id record-  , (\_v95 -> (2, ("tag",T.TString $ E.encodeUtf8 _v95))) <$> constituent_tag record-  , (\_v95 -> P.Just (3, ("childList",T.TList T.T_I32 $ P.map (\_v97 -> T.TI32 _v97) $ Vector.toList _v95))) $ constituent_childList record-  , (\_v95 -> (4, ("headChildIndex",T.TI32 _v95))) <$> constituent_headChildIndex record-  , (\_v95 -> (5, ("start",T.TI32 _v95))) <$> constituent_start record-  , (\_v95 -> (6, ("ending",T.TI32 _v95))) <$> constituent_ending record+from_TokenRefSequence :: TokenRefSequence -> T.ThriftVal+from_TokenRefSequence record = T.TStruct $ Map.fromList $ M.catMaybes+  [ (\_v76 -> P.Just (1, ("tokenIndexList",T.TList T.T_I32 $ P.map (\_v78 -> T.TI32 _v78) $ Vector.toList _v76))) $ tokenRefSequence_tokenIndexList record+  , (\_v76 -> (2, ("anchorTokenIndex",T.TI32 _v76))) <$> tokenRefSequence_anchorTokenIndex record+  , (\_v76 -> P.Just (3, ("tokenizationId",Uuid_Types.from_UUID _v76))) $ tokenRefSequence_tokenizationId record+  , (\_v76 -> (4, ("textSpan",Spans_Types.from_TextSpan _v76))) <$> tokenRefSequence_textSpan record+  , (\_v76 -> (5, ("rawTextSpan",Spans_Types.from_TextSpan _v76))) <$> tokenRefSequence_rawTextSpan record+  , (\_v76 -> (6, ("audioSpan",Spans_Types.from_AudioSpan _v76))) <$> tokenRefSequence_audioSpan record+  , (\_v76 -> (7, ("dependencies",T.TList (T.T_STRUCT typemap_Dependency) $ P.map (\_v80 -> from_Dependency _v80) $ Vector.toList _v76))) <$> tokenRefSequence_dependencies record+  , (\_v76 -> (8, ("constituent",from_ConstituentRef _v76))) <$> tokenRefSequence_constituent record   ]-write_Constituent :: (T.Protocol p, T.Transport t) => p t -> Constituent -> P.IO ()-write_Constituent oprot record = T.writeVal oprot $ from_Constituent record-encode_Constituent :: (T.Protocol p, T.Transport t) => p t -> Constituent -> LBS.ByteString-encode_Constituent oprot record = T.serializeVal oprot $ from_Constituent record-to_Constituent :: T.ThriftVal -> Constituent-to_Constituent (T.TStruct fields) = Constituent{-  constituent_id = P.maybe (P.error "Missing required field: id") (\(_,_val99) -> (case _val99 of {T.TI32 _val100 -> _val100; _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  constituent_tag = P.maybe (P.Nothing) (\(_,_val99) -> P.Just (case _val99 of {T.TString _val101 -> E.decodeUtf8 _val101; _ -> P.error "wrong type"})) (Map.lookup (2) fields),-  constituent_childList = P.maybe (P.error "Missing required field: childList") (\(_,_val99) -> (case _val99 of {T.TList _ _val102 -> (Vector.fromList $ P.map (\_v103 -> (case _v103 of {T.TI32 _val104 -> _val104; _ -> P.error "wrong type"})) _val102); _ -> P.error "wrong type"})) (Map.lookup (3) fields),-  constituent_headChildIndex = P.maybe (constituent_headChildIndex default_Constituent) (\(_,_val99) -> P.Just (case _val99 of {T.TI32 _val105 -> _val105; _ -> P.error "wrong type"})) (Map.lookup (4) fields),-  constituent_start = P.maybe (P.Nothing) (\(_,_val99) -> P.Just (case _val99 of {T.TI32 _val106 -> _val106; _ -> P.error "wrong type"})) (Map.lookup (5) fields),-  constituent_ending = P.maybe (P.Nothing) (\(_,_val99) -> P.Just (case _val99 of {T.TI32 _val107 -> _val107; _ -> P.error "wrong type"})) (Map.lookup (6) fields)+write_TokenRefSequence :: (T.Protocol p, T.Transport t) => p t -> TokenRefSequence -> P.IO ()+write_TokenRefSequence oprot record = T.writeVal oprot $ from_TokenRefSequence record+encode_TokenRefSequence :: (T.Protocol p, T.Transport t) => p t -> TokenRefSequence -> LBS.ByteString+encode_TokenRefSequence oprot record = T.serializeVal oprot $ from_TokenRefSequence record+to_TokenRefSequence :: T.ThriftVal -> TokenRefSequence+to_TokenRefSequence (T.TStruct fields) = TokenRefSequence{+  tokenRefSequence_tokenIndexList = P.maybe (P.error "Missing required field: tokenIndexList") (\(_,_val82) -> (case _val82 of {T.TList _ _val83 -> (Vector.fromList $ P.map (\_v84 -> (case _v84 of {T.TI32 _val85 -> _val85; _ -> P.error "wrong type"})) _val83); _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  tokenRefSequence_anchorTokenIndex = P.maybe (tokenRefSequence_anchorTokenIndex default_TokenRefSequence) (\(_,_val82) -> P.Just (case _val82 of {T.TI32 _val86 -> _val86; _ -> P.error "wrong type"})) (Map.lookup (2) fields),+  tokenRefSequence_tokenizationId = P.maybe (P.error "Missing required field: tokenizationId") (\(_,_val82) -> (case _val82 of {T.TStruct _val87 -> (Uuid_Types.to_UUID (T.TStruct _val87)); _ -> P.error "wrong type"})) (Map.lookup (3) fields),+  tokenRefSequence_textSpan = P.maybe (P.Nothing) (\(_,_val82) -> P.Just (case _val82 of {T.TStruct _val88 -> (Spans_Types.to_TextSpan (T.TStruct _val88)); _ -> P.error "wrong type"})) (Map.lookup (4) fields),+  tokenRefSequence_rawTextSpan = P.maybe (P.Nothing) (\(_,_val82) -> P.Just (case _val82 of {T.TStruct _val89 -> (Spans_Types.to_TextSpan (T.TStruct _val89)); _ -> P.error "wrong type"})) (Map.lookup (5) fields),+  tokenRefSequence_audioSpan = P.maybe (P.Nothing) (\(_,_val82) -> P.Just (case _val82 of {T.TStruct _val90 -> (Spans_Types.to_AudioSpan (T.TStruct _val90)); _ -> P.error "wrong type"})) (Map.lookup (6) fields),+  tokenRefSequence_dependencies = P.maybe (P.Nothing) (\(_,_val82) -> P.Just (case _val82 of {T.TList _ _val91 -> (Vector.fromList $ P.map (\_v92 -> (case _v92 of {T.TStruct _val93 -> (to_Dependency (T.TStruct _val93)); _ -> P.error "wrong type"})) _val91); _ -> P.error "wrong type"})) (Map.lookup (7) fields),+  tokenRefSequence_constituent = P.maybe (P.Nothing) (\(_,_val82) -> P.Just (case _val82 of {T.TStruct _val94 -> (to_ConstituentRef (T.TStruct _val94)); _ -> P.error "wrong type"})) (Map.lookup (8) fields)   }-to_Constituent _ = P.error "not a struct"-read_Constituent :: (T.Transport t, T.Protocol p) => p t -> P.IO Constituent-read_Constituent iprot = to_Constituent <$> T.readVal iprot (T.T_STRUCT typemap_Constituent)-decode_Constituent :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Constituent-decode_Constituent iprot bs = to_Constituent $ T.deserializeVal iprot (T.T_STRUCT typemap_Constituent) bs-typemap_Constituent :: T.TypeMap-typemap_Constituent = Map.fromList [(1,("id",T.T_I32)),(2,("tag",T.T_STRING)),(3,("childList",(T.T_LIST T.T_I32))),(4,("headChildIndex",T.T_I32)),(5,("start",T.T_I32)),(6,("ending",T.T_I32))]-default_Constituent :: Constituent-default_Constituent = Constituent{-  constituent_id = 0,-  constituent_tag = P.Nothing,-  constituent_childList = Vector.empty,-  constituent_headChildIndex = P.Just (-1),-  constituent_start = P.Nothing,-  constituent_ending = P.Nothing}-data Parse = Parse  { parse_uuid :: Uuid_Types.UUID-  , parse_metadata :: Metadata_Types.AnnotationMetadata-  , parse_constituentList :: (Vector.Vector Constituent)+to_TokenRefSequence _ = P.error "not a struct"+read_TokenRefSequence :: (T.Transport t, T.Protocol p) => p t -> P.IO TokenRefSequence+read_TokenRefSequence iprot = to_TokenRefSequence <$> T.readVal iprot (T.T_STRUCT typemap_TokenRefSequence)+decode_TokenRefSequence :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> TokenRefSequence+decode_TokenRefSequence iprot bs = to_TokenRefSequence $ T.deserializeVal iprot (T.T_STRUCT typemap_TokenRefSequence) bs+typemap_TokenRefSequence :: T.TypeMap+typemap_TokenRefSequence = Map.fromList [(1,("tokenIndexList",(T.T_LIST T.T_I32))),(2,("anchorTokenIndex",T.T_I32)),(3,("tokenizationId",(T.T_STRUCT Uuid_Types.typemap_UUID))),(4,("textSpan",(T.T_STRUCT Spans_Types.typemap_TextSpan))),(5,("rawTextSpan",(T.T_STRUCT Spans_Types.typemap_TextSpan))),(6,("audioSpan",(T.T_STRUCT Spans_Types.typemap_AudioSpan))),(7,("dependencies",(T.T_LIST (T.T_STRUCT typemap_Dependency)))),(8,("constituent",(T.T_STRUCT typemap_ConstituentRef)))]+default_TokenRefSequence :: TokenRefSequence+default_TokenRefSequence = TokenRefSequence{+  tokenRefSequence_tokenIndexList = Vector.empty,+  tokenRefSequence_anchorTokenIndex = P.Just (-1),+  tokenRefSequence_tokenizationId = Uuid_Types.default_UUID,+  tokenRefSequence_textSpan = P.Nothing,+  tokenRefSequence_rawTextSpan = P.Nothing,+  tokenRefSequence_audioSpan = P.Nothing,+  tokenRefSequence_dependencies = P.Nothing,+  tokenRefSequence_constituent = P.Nothing}+data TaggedToken = TaggedToken  { taggedToken_tokenIndex :: P.Maybe I.Int32+  , taggedToken_tag :: P.Maybe LT.Text+  , taggedToken_confidence :: P.Maybe P.Double+  , taggedToken_tagList :: P.Maybe (Vector.Vector LT.Text)+  , taggedToken_confidenceList :: P.Maybe (Vector.Vector P.Double)   } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)-instance H.Hashable Parse where-  hashWithSalt salt record = salt   `H.hashWithSalt` parse_uuid record   `H.hashWithSalt` parse_metadata record   `H.hashWithSalt` parse_constituentList record  -instance QC.Arbitrary Parse where -  arbitrary = M.liftM Parse (QC.arbitrary)+instance H.Hashable TaggedToken where+  hashWithSalt salt record = salt   `H.hashWithSalt` taggedToken_tokenIndex record   `H.hashWithSalt` taggedToken_tag record   `H.hashWithSalt` taggedToken_confidence record   `H.hashWithSalt` taggedToken_tagList record   `H.hashWithSalt` taggedToken_confidenceList record  +instance QC.Arbitrary TaggedToken where +  arbitrary = M.liftM TaggedToken (M.liftM P.Just QC.arbitrary)+          `M.ap`(M.liftM P.Just QC.arbitrary)+          `M.ap`(M.liftM P.Just QC.arbitrary)+          `M.ap`(M.liftM P.Just QC.arbitrary)+          `M.ap`(M.liftM P.Just QC.arbitrary)+  shrink obj | obj == default_TaggedToken = []+             | P.otherwise = M.catMaybes+    [ if obj == default_TaggedToken{taggedToken_tokenIndex = taggedToken_tokenIndex obj} then P.Nothing else P.Just $ default_TaggedToken{taggedToken_tokenIndex = taggedToken_tokenIndex obj}+    , if obj == default_TaggedToken{taggedToken_tag = taggedToken_tag obj} then P.Nothing else P.Just $ default_TaggedToken{taggedToken_tag = taggedToken_tag obj}+    , if obj == default_TaggedToken{taggedToken_confidence = taggedToken_confidence obj} then P.Nothing else P.Just $ default_TaggedToken{taggedToken_confidence = taggedToken_confidence obj}+    , if obj == default_TaggedToken{taggedToken_tagList = taggedToken_tagList obj} then P.Nothing else P.Just $ default_TaggedToken{taggedToken_tagList = taggedToken_tagList obj}+    , if obj == default_TaggedToken{taggedToken_confidenceList = taggedToken_confidenceList obj} then P.Nothing else P.Just $ default_TaggedToken{taggedToken_confidenceList = taggedToken_confidenceList obj}+    ]+from_TaggedToken :: TaggedToken -> T.ThriftVal+from_TaggedToken record = T.TStruct $ Map.fromList $ M.catMaybes+  [ (\_v97 -> (1, ("tokenIndex",T.TI32 _v97))) <$> taggedToken_tokenIndex record+  , (\_v97 -> (2, ("tag",T.TString $ E.encodeUtf8 _v97))) <$> taggedToken_tag record+  , (\_v97 -> (3, ("confidence",T.TDouble _v97))) <$> taggedToken_confidence record+  , (\_v97 -> (4, ("tagList",T.TList T.T_STRING $ P.map (\_v99 -> T.TString $ E.encodeUtf8 _v99) $ Vector.toList _v97))) <$> taggedToken_tagList record+  , (\_v97 -> (5, ("confidenceList",T.TList T.T_DOUBLE $ P.map (\_v101 -> T.TDouble _v101) $ Vector.toList _v97))) <$> taggedToken_confidenceList record+  ]+write_TaggedToken :: (T.Protocol p, T.Transport t) => p t -> TaggedToken -> P.IO ()+write_TaggedToken oprot record = T.writeVal oprot $ from_TaggedToken record+encode_TaggedToken :: (T.Protocol p, T.Transport t) => p t -> TaggedToken -> LBS.ByteString+encode_TaggedToken oprot record = T.serializeVal oprot $ from_TaggedToken record+to_TaggedToken :: T.ThriftVal -> TaggedToken+to_TaggedToken (T.TStruct fields) = TaggedToken{+  taggedToken_tokenIndex = P.maybe (P.Nothing) (\(_,_val103) -> P.Just (case _val103 of {T.TI32 _val104 -> _val104; _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  taggedToken_tag = P.maybe (P.Nothing) (\(_,_val103) -> P.Just (case _val103 of {T.TString _val105 -> E.decodeUtf8 _val105; _ -> P.error "wrong type"})) (Map.lookup (2) fields),+  taggedToken_confidence = P.maybe (P.Nothing) (\(_,_val103) -> P.Just (case _val103 of {T.TDouble _val106 -> _val106; _ -> P.error "wrong type"})) (Map.lookup (3) fields),+  taggedToken_tagList = P.maybe (P.Nothing) (\(_,_val103) -> P.Just (case _val103 of {T.TList _ _val107 -> (Vector.fromList $ P.map (\_v108 -> (case _v108 of {T.TString _val109 -> E.decodeUtf8 _val109; _ -> P.error "wrong type"})) _val107); _ -> P.error "wrong type"})) (Map.lookup (4) fields),+  taggedToken_confidenceList = P.maybe (P.Nothing) (\(_,_val103) -> P.Just (case _val103 of {T.TList _ _val110 -> (Vector.fromList $ P.map (\_v111 -> (case _v111 of {T.TDouble _val112 -> _val112; _ -> P.error "wrong type"})) _val110); _ -> P.error "wrong type"})) (Map.lookup (5) fields)+  }+to_TaggedToken _ = P.error "not a struct"+read_TaggedToken :: (T.Transport t, T.Protocol p) => p t -> P.IO TaggedToken+read_TaggedToken iprot = to_TaggedToken <$> T.readVal iprot (T.T_STRUCT typemap_TaggedToken)+decode_TaggedToken :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> TaggedToken+decode_TaggedToken iprot bs = to_TaggedToken $ T.deserializeVal iprot (T.T_STRUCT typemap_TaggedToken) bs+typemap_TaggedToken :: T.TypeMap+typemap_TaggedToken = Map.fromList [(1,("tokenIndex",T.T_I32)),(2,("tag",T.T_STRING)),(3,("confidence",T.T_DOUBLE)),(4,("tagList",(T.T_LIST T.T_STRING))),(5,("confidenceList",(T.T_LIST T.T_DOUBLE)))]+default_TaggedToken :: TaggedToken+default_TaggedToken = TaggedToken{+  taggedToken_tokenIndex = P.Nothing,+  taggedToken_tag = P.Nothing,+  taggedToken_confidence = P.Nothing,+  taggedToken_tagList = P.Nothing,+  taggedToken_confidenceList = P.Nothing}+data TokenTagging = TokenTagging  { tokenTagging_uuid :: Uuid_Types.UUID+  , tokenTagging_metadata :: Metadata_Types.AnnotationMetadata+  , tokenTagging_taggedTokenList :: (Vector.Vector TaggedToken)+  , tokenTagging_taggingType :: P.Maybe LT.Text+  } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)+instance H.Hashable TokenTagging where+  hashWithSalt salt record = salt   `H.hashWithSalt` tokenTagging_uuid record   `H.hashWithSalt` tokenTagging_metadata record   `H.hashWithSalt` tokenTagging_taggedTokenList record   `H.hashWithSalt` tokenTagging_taggingType record  +instance QC.Arbitrary TokenTagging where +  arbitrary = M.liftM TokenTagging (QC.arbitrary)           `M.ap`(QC.arbitrary)           `M.ap`(QC.arbitrary)-  shrink obj | obj == default_Parse = []+          `M.ap`(M.liftM P.Just QC.arbitrary)+  shrink obj | obj == default_TokenTagging = []              | P.otherwise = M.catMaybes-    [ if obj == default_Parse{parse_uuid = parse_uuid obj} then P.Nothing else P.Just $ default_Parse{parse_uuid = parse_uuid obj}-    , if obj == default_Parse{parse_metadata = parse_metadata obj} then P.Nothing else P.Just $ default_Parse{parse_metadata = parse_metadata obj}-    , if obj == default_Parse{parse_constituentList = parse_constituentList obj} then P.Nothing else P.Just $ default_Parse{parse_constituentList = parse_constituentList obj}+    [ if obj == default_TokenTagging{tokenTagging_uuid = tokenTagging_uuid obj} then P.Nothing else P.Just $ default_TokenTagging{tokenTagging_uuid = tokenTagging_uuid obj}+    , if obj == default_TokenTagging{tokenTagging_metadata = tokenTagging_metadata obj} then P.Nothing else P.Just $ default_TokenTagging{tokenTagging_metadata = tokenTagging_metadata obj}+    , if obj == default_TokenTagging{tokenTagging_taggedTokenList = tokenTagging_taggedTokenList obj} then P.Nothing else P.Just $ default_TokenTagging{tokenTagging_taggedTokenList = tokenTagging_taggedTokenList obj}+    , if obj == default_TokenTagging{tokenTagging_taggingType = tokenTagging_taggingType obj} then P.Nothing else P.Just $ default_TokenTagging{tokenTagging_taggingType = tokenTagging_taggingType obj}     ]-from_Parse :: Parse -> T.ThriftVal-from_Parse record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v110 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v110))) $ parse_uuid record-  , (\_v110 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v110))) $ parse_metadata record-  , (\_v110 -> P.Just (3, ("constituentList",T.TList (T.T_STRUCT typemap_Constituent) $ P.map (\_v112 -> from_Constituent _v112) $ Vector.toList _v110))) $ parse_constituentList record+from_TokenTagging :: TokenTagging -> T.ThriftVal+from_TokenTagging record = T.TStruct $ Map.fromList $ M.catMaybes+  [ (\_v115 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v115))) $ tokenTagging_uuid record+  , (\_v115 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v115))) $ tokenTagging_metadata record+  , (\_v115 -> P.Just (3, ("taggedTokenList",T.TList (T.T_STRUCT typemap_TaggedToken) $ P.map (\_v117 -> from_TaggedToken _v117) $ Vector.toList _v115))) $ tokenTagging_taggedTokenList record+  , (\_v115 -> (4, ("taggingType",T.TString $ E.encodeUtf8 _v115))) <$> tokenTagging_taggingType record   ]-write_Parse :: (T.Protocol p, T.Transport t) => p t -> Parse -> P.IO ()-write_Parse oprot record = T.writeVal oprot $ from_Parse record-encode_Parse :: (T.Protocol p, T.Transport t) => p t -> Parse -> LBS.ByteString-encode_Parse oprot record = T.serializeVal oprot $ from_Parse record-to_Parse :: T.ThriftVal -> Parse-to_Parse (T.TStruct fields) = Parse{-  parse_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val114) -> (case _val114 of {T.TStruct _val115 -> (Uuid_Types.to_UUID (T.TStruct _val115)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  parse_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val114) -> (case _val114 of {T.TStruct _val116 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val116)); _ -> P.error "wrong type"})) (Map.lookup (2) fields),-  parse_constituentList = P.maybe (P.error "Missing required field: constituentList") (\(_,_val114) -> (case _val114 of {T.TList _ _val117 -> (Vector.fromList $ P.map (\_v118 -> (case _v118 of {T.TStruct _val119 -> (to_Constituent (T.TStruct _val119)); _ -> P.error "wrong type"})) _val117); _ -> P.error "wrong type"})) (Map.lookup (3) fields)+write_TokenTagging :: (T.Protocol p, T.Transport t) => p t -> TokenTagging -> P.IO ()+write_TokenTagging oprot record = T.writeVal oprot $ from_TokenTagging record+encode_TokenTagging :: (T.Protocol p, T.Transport t) => p t -> TokenTagging -> LBS.ByteString+encode_TokenTagging oprot record = T.serializeVal oprot $ from_TokenTagging record+to_TokenTagging :: T.ThriftVal -> TokenTagging+to_TokenTagging (T.TStruct fields) = TokenTagging{+  tokenTagging_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val119) -> (case _val119 of {T.TStruct _val120 -> (Uuid_Types.to_UUID (T.TStruct _val120)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  tokenTagging_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val119) -> (case _val119 of {T.TStruct _val121 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val121)); _ -> P.error "wrong type"})) (Map.lookup (2) fields),+  tokenTagging_taggedTokenList = P.maybe (P.error "Missing required field: taggedTokenList") (\(_,_val119) -> (case _val119 of {T.TList _ _val122 -> (Vector.fromList $ P.map (\_v123 -> (case _v123 of {T.TStruct _val124 -> (to_TaggedToken (T.TStruct _val124)); _ -> P.error "wrong type"})) _val122); _ -> P.error "wrong type"})) (Map.lookup (3) fields),+  tokenTagging_taggingType = P.maybe (P.Nothing) (\(_,_val119) -> P.Just (case _val119 of {T.TString _val125 -> E.decodeUtf8 _val125; _ -> P.error "wrong type"})) (Map.lookup (4) fields)   }-to_Parse _ = P.error "not a struct"-read_Parse :: (T.Transport t, T.Protocol p) => p t -> P.IO Parse-read_Parse iprot = to_Parse <$> T.readVal iprot (T.T_STRUCT typemap_Parse)-decode_Parse :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Parse-decode_Parse iprot bs = to_Parse $ T.deserializeVal iprot (T.T_STRUCT typemap_Parse) bs-typemap_Parse :: T.TypeMap-typemap_Parse = Map.fromList [(1,("uuid",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("metadata",(T.T_STRUCT Metadata_Types.typemap_AnnotationMetadata))),(3,("constituentList",(T.T_LIST (T.T_STRUCT typemap_Constituent))))]-default_Parse :: Parse-default_Parse = Parse{-  parse_uuid = Uuid_Types.default_UUID,-  parse_metadata = Metadata_Types.default_AnnotationMetadata,-  parse_constituentList = Vector.empty}+to_TokenTagging _ = P.error "not a struct"+read_TokenTagging :: (T.Transport t, T.Protocol p) => p t -> P.IO TokenTagging+read_TokenTagging iprot = to_TokenTagging <$> T.readVal iprot (T.T_STRUCT typemap_TokenTagging)+decode_TokenTagging :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> TokenTagging+decode_TokenTagging iprot bs = to_TokenTagging $ T.deserializeVal iprot (T.T_STRUCT typemap_TokenTagging) bs+typemap_TokenTagging :: T.TypeMap+typemap_TokenTagging = Map.fromList [(1,("uuid",(T.T_STRUCT Uuid_Types.typemap_UUID))),(2,("metadata",(T.T_STRUCT Metadata_Types.typemap_AnnotationMetadata))),(3,("taggedTokenList",(T.T_LIST (T.T_STRUCT typemap_TaggedToken)))),(4,("taggingType",T.T_STRING))]+default_TokenTagging :: TokenTagging+default_TokenTagging = TokenTagging{+  tokenTagging_uuid = Uuid_Types.default_UUID,+  tokenTagging_metadata = Metadata_Types.default_AnnotationMetadata,+  tokenTagging_taggedTokenList = Vector.empty,+  tokenTagging_taggingType = P.Nothing} data LatticePath = LatticePath  { latticePath_weight :: P.Maybe P.Double   , latticePath_tokenList :: (Vector.Vector Token)   } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)@@ -583,8 +595,8 @@     ] from_LatticePath :: LatticePath -> T.ThriftVal from_LatticePath record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v122 -> (1, ("weight",T.TDouble _v122))) <$> latticePath_weight record-  , (\_v122 -> P.Just (2, ("tokenList",T.TList (T.T_STRUCT typemap_Token) $ P.map (\_v124 -> from_Token _v124) $ Vector.toList _v122))) $ latticePath_tokenList record+  [ (\_v128 -> (1, ("weight",T.TDouble _v128))) <$> latticePath_weight record+  , (\_v128 -> P.Just (2, ("tokenList",T.TList (T.T_STRUCT typemap_Token) $ P.map (\_v130 -> from_Token _v130) $ Vector.toList _v128))) $ latticePath_tokenList record   ] write_LatticePath :: (T.Protocol p, T.Transport t) => p t -> LatticePath -> P.IO () write_LatticePath oprot record = T.writeVal oprot $ from_LatticePath record@@ -592,8 +604,8 @@ encode_LatticePath oprot record = T.serializeVal oprot $ from_LatticePath record to_LatticePath :: T.ThriftVal -> LatticePath to_LatticePath (T.TStruct fields) = LatticePath{-  latticePath_weight = P.maybe (P.Nothing) (\(_,_val126) -> P.Just (case _val126 of {T.TDouble _val127 -> _val127; _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  latticePath_tokenList = P.maybe (P.error "Missing required field: tokenList") (\(_,_val126) -> (case _val126 of {T.TList _ _val128 -> (Vector.fromList $ P.map (\_v129 -> (case _v129 of {T.TStruct _val130 -> (to_Token (T.TStruct _val130)); _ -> P.error "wrong type"})) _val128); _ -> P.error "wrong type"})) (Map.lookup (2) fields)+  latticePath_weight = P.maybe (P.Nothing) (\(_,_val132) -> P.Just (case _val132 of {T.TDouble _val133 -> _val133; _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  latticePath_tokenList = P.maybe (P.error "Missing required field: tokenList") (\(_,_val132) -> (case _val132 of {T.TList _ _val134 -> (Vector.fromList $ P.map (\_v135 -> (case _v135 of {T.TStruct _val136 -> (to_Token (T.TStruct _val136)); _ -> P.error "wrong type"})) _val134); _ -> P.error "wrong type"})) (Map.lookup (2) fields)   } to_LatticePath _ = P.error "not a struct" read_LatticePath :: (T.Transport t, T.Protocol p) => p t -> P.IO LatticePath@@ -627,10 +639,10 @@     ] from_Arc :: Arc -> T.ThriftVal from_Arc record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v133 -> (1, ("src",T.TI32 _v133))) <$> arc_src record-  , (\_v133 -> (2, ("dst",T.TI32 _v133))) <$> arc_dst record-  , (\_v133 -> (3, ("token",from_Token _v133))) <$> arc_token record-  , (\_v133 -> (4, ("weight",T.TDouble _v133))) <$> arc_weight record+  [ (\_v139 -> (1, ("src",T.TI32 _v139))) <$> arc_src record+  , (\_v139 -> (2, ("dst",T.TI32 _v139))) <$> arc_dst record+  , (\_v139 -> (3, ("token",from_Token _v139))) <$> arc_token record+  , (\_v139 -> (4, ("weight",T.TDouble _v139))) <$> arc_weight record   ] write_Arc :: (T.Protocol p, T.Transport t) => p t -> Arc -> P.IO () write_Arc oprot record = T.writeVal oprot $ from_Arc record@@ -638,10 +650,10 @@ encode_Arc oprot record = T.serializeVal oprot $ from_Arc record to_Arc :: T.ThriftVal -> Arc to_Arc (T.TStruct fields) = Arc{-  arc_src = P.maybe (P.Nothing) (\(_,_val135) -> P.Just (case _val135 of {T.TI32 _val136 -> _val136; _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  arc_dst = P.maybe (P.Nothing) (\(_,_val135) -> P.Just (case _val135 of {T.TI32 _val137 -> _val137; _ -> P.error "wrong type"})) (Map.lookup (2) fields),-  arc_token = P.maybe (P.Nothing) (\(_,_val135) -> P.Just (case _val135 of {T.TStruct _val138 -> (to_Token (T.TStruct _val138)); _ -> P.error "wrong type"})) (Map.lookup (3) fields),-  arc_weight = P.maybe (P.Nothing) (\(_,_val135) -> P.Just (case _val135 of {T.TDouble _val139 -> _val139; _ -> P.error "wrong type"})) (Map.lookup (4) fields)+  arc_src = P.maybe (P.Nothing) (\(_,_val141) -> P.Just (case _val141 of {T.TI32 _val142 -> _val142; _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  arc_dst = P.maybe (P.Nothing) (\(_,_val141) -> P.Just (case _val141 of {T.TI32 _val143 -> _val143; _ -> P.error "wrong type"})) (Map.lookup (2) fields),+  arc_token = P.maybe (P.Nothing) (\(_,_val141) -> P.Just (case _val141 of {T.TStruct _val144 -> (to_Token (T.TStruct _val144)); _ -> P.error "wrong type"})) (Map.lookup (3) fields),+  arc_weight = P.maybe (P.Nothing) (\(_,_val141) -> P.Just (case _val141 of {T.TDouble _val145 -> _val145; _ -> P.error "wrong type"})) (Map.lookup (4) fields)   } to_Arc _ = P.error "not a struct" read_Arc :: (T.Transport t, T.Protocol p) => p t -> P.IO Arc@@ -677,10 +689,10 @@     ] from_TokenLattice :: TokenLattice -> T.ThriftVal from_TokenLattice record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v142 -> (1, ("startState",T.TI32 _v142))) <$> tokenLattice_startState record-  , (\_v142 -> (2, ("endState",T.TI32 _v142))) <$> tokenLattice_endState record-  , (\_v142 -> P.Just (3, ("arcList",T.TList (T.T_STRUCT typemap_Arc) $ P.map (\_v144 -> from_Arc _v144) $ Vector.toList _v142))) $ tokenLattice_arcList record-  , (\_v142 -> (4, ("cachedBestPath",from_LatticePath _v142))) <$> tokenLattice_cachedBestPath record+  [ (\_v148 -> (1, ("startState",T.TI32 _v148))) <$> tokenLattice_startState record+  , (\_v148 -> (2, ("endState",T.TI32 _v148))) <$> tokenLattice_endState record+  , (\_v148 -> P.Just (3, ("arcList",T.TList (T.T_STRUCT typemap_Arc) $ P.map (\_v150 -> from_Arc _v150) $ Vector.toList _v148))) $ tokenLattice_arcList record+  , (\_v148 -> (4, ("cachedBestPath",from_LatticePath _v148))) <$> tokenLattice_cachedBestPath record   ] write_TokenLattice :: (T.Protocol p, T.Transport t) => p t -> TokenLattice -> P.IO () write_TokenLattice oprot record = T.writeVal oprot $ from_TokenLattice record@@ -688,10 +700,10 @@ encode_TokenLattice oprot record = T.serializeVal oprot $ from_TokenLattice record to_TokenLattice :: T.ThriftVal -> TokenLattice to_TokenLattice (T.TStruct fields) = TokenLattice{-  tokenLattice_startState = P.maybe (tokenLattice_startState default_TokenLattice) (\(_,_val146) -> P.Just (case _val146 of {T.TI32 _val147 -> _val147; _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  tokenLattice_endState = P.maybe (tokenLattice_endState default_TokenLattice) (\(_,_val146) -> P.Just (case _val146 of {T.TI32 _val148 -> _val148; _ -> P.error "wrong type"})) (Map.lookup (2) fields),-  tokenLattice_arcList = P.maybe (P.error "Missing required field: arcList") (\(_,_val146) -> (case _val146 of {T.TList _ _val149 -> (Vector.fromList $ P.map (\_v150 -> (case _v150 of {T.TStruct _val151 -> (to_Arc (T.TStruct _val151)); _ -> P.error "wrong type"})) _val149); _ -> P.error "wrong type"})) (Map.lookup (3) fields),-  tokenLattice_cachedBestPath = P.maybe (P.Nothing) (\(_,_val146) -> P.Just (case _val146 of {T.TStruct _val152 -> (to_LatticePath (T.TStruct _val152)); _ -> P.error "wrong type"})) (Map.lookup (4) fields)+  tokenLattice_startState = P.maybe (tokenLattice_startState default_TokenLattice) (\(_,_val152) -> P.Just (case _val152 of {T.TI32 _val153 -> _val153; _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  tokenLattice_endState = P.maybe (tokenLattice_endState default_TokenLattice) (\(_,_val152) -> P.Just (case _val152 of {T.TI32 _val154 -> _val154; _ -> P.error "wrong type"})) (Map.lookup (2) fields),+  tokenLattice_arcList = P.maybe (P.error "Missing required field: arcList") (\(_,_val152) -> (case _val152 of {T.TList _ _val155 -> (Vector.fromList $ P.map (\_v156 -> (case _v156 of {T.TStruct _val157 -> (to_Arc (T.TStruct _val157)); _ -> P.error "wrong type"})) _val155); _ -> P.error "wrong type"})) (Map.lookup (3) fields),+  tokenLattice_cachedBestPath = P.maybe (P.Nothing) (\(_,_val152) -> P.Just (case _val152 of {T.TStruct _val158 -> (to_LatticePath (T.TStruct _val158)); _ -> P.error "wrong type"})) (Map.lookup (4) fields)   } to_TokenLattice _ = P.error "not a struct" read_TokenLattice :: (T.Transport t, T.Protocol p) => p t -> P.IO TokenLattice@@ -718,7 +730,7 @@     ] from_TokenList :: TokenList -> T.ThriftVal from_TokenList record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v155 -> P.Just (1, ("tokenList",T.TList (T.T_STRUCT typemap_Token) $ P.map (\_v157 -> from_Token _v157) $ Vector.toList _v155))) $ tokenList_tokenList record+  [ (\_v161 -> P.Just (1, ("tokenList",T.TList (T.T_STRUCT typemap_Token) $ P.map (\_v163 -> from_Token _v163) $ Vector.toList _v161))) $ tokenList_tokenList record   ] write_TokenList :: (T.Protocol p, T.Transport t) => p t -> TokenList -> P.IO () write_TokenList oprot record = T.writeVal oprot $ from_TokenList record@@ -726,7 +738,7 @@ encode_TokenList oprot record = T.serializeVal oprot $ from_TokenList record to_TokenList :: T.ThriftVal -> TokenList to_TokenList (T.TStruct fields) = TokenList{-  tokenList_tokenList = P.maybe (P.error "Missing required field: tokenList") (\(_,_val159) -> (case _val159 of {T.TList _ _val160 -> (Vector.fromList $ P.map (\_v161 -> (case _v161 of {T.TStruct _val162 -> (to_Token (T.TStruct _val162)); _ -> P.error "wrong type"})) _val160); _ -> P.error "wrong type"})) (Map.lookup (1) fields)+  tokenList_tokenList = P.maybe (P.error "Missing required field: tokenList") (\(_,_val165) -> (case _val165 of {T.TList _ _val166 -> (Vector.fromList $ P.map (\_v167 -> (case _v167 of {T.TStruct _val168 -> (to_Token (T.TStruct _val168)); _ -> P.error "wrong type"})) _val166); _ -> P.error "wrong type"})) (Map.lookup (1) fields)   } to_TokenList _ = P.error "not a struct" read_TokenList :: (T.Transport t, T.Protocol p) => p t -> P.IO TokenList@@ -759,10 +771,10 @@     ] from_SpanLink :: SpanLink -> T.ThriftVal from_SpanLink record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v165 -> P.Just (1, ("tokens",from_TokenRefSequence _v165))) $ spanLink_tokens record-  , (\_v165 -> (2, ("concreteTarget",Uuid_Types.from_UUID _v165))) <$> spanLink_concreteTarget record-  , (\_v165 -> (3, ("externalTarget",T.TString $ E.encodeUtf8 _v165))) <$> spanLink_externalTarget record-  , (\_v165 -> P.Just (4, ("linkType",T.TString $ E.encodeUtf8 _v165))) $ spanLink_linkType record+  [ (\_v171 -> P.Just (1, ("tokens",from_TokenRefSequence _v171))) $ spanLink_tokens record+  , (\_v171 -> (2, ("concreteTarget",Uuid_Types.from_UUID _v171))) <$> spanLink_concreteTarget record+  , (\_v171 -> (3, ("externalTarget",T.TString $ E.encodeUtf8 _v171))) <$> spanLink_externalTarget record+  , (\_v171 -> P.Just (4, ("linkType",T.TString $ E.encodeUtf8 _v171))) $ spanLink_linkType record   ] write_SpanLink :: (T.Protocol p, T.Transport t) => p t -> SpanLink -> P.IO () write_SpanLink oprot record = T.writeVal oprot $ from_SpanLink record@@ -770,10 +782,10 @@ encode_SpanLink oprot record = T.serializeVal oprot $ from_SpanLink record to_SpanLink :: T.ThriftVal -> SpanLink to_SpanLink (T.TStruct fields) = SpanLink{-  spanLink_tokens = P.maybe (P.error "Missing required field: tokens") (\(_,_val167) -> (case _val167 of {T.TStruct _val168 -> (to_TokenRefSequence (T.TStruct _val168)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  spanLink_concreteTarget = P.maybe (P.Nothing) (\(_,_val167) -> P.Just (case _val167 of {T.TStruct _val169 -> (Uuid_Types.to_UUID (T.TStruct _val169)); _ -> P.error "wrong type"})) (Map.lookup (2) fields),-  spanLink_externalTarget = P.maybe (P.Nothing) (\(_,_val167) -> P.Just (case _val167 of {T.TString _val170 -> E.decodeUtf8 _val170; _ -> P.error "wrong type"})) (Map.lookup (3) fields),-  spanLink_linkType = P.maybe (P.error "Missing required field: linkType") (\(_,_val167) -> (case _val167 of {T.TString _val171 -> E.decodeUtf8 _val171; _ -> P.error "wrong type"})) (Map.lookup (4) fields)+  spanLink_tokens = P.maybe (P.error "Missing required field: tokens") (\(_,_val173) -> (case _val173 of {T.TStruct _val174 -> (to_TokenRefSequence (T.TStruct _val174)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  spanLink_concreteTarget = P.maybe (P.Nothing) (\(_,_val173) -> P.Just (case _val173 of {T.TStruct _val175 -> (Uuid_Types.to_UUID (T.TStruct _val175)); _ -> P.error "wrong type"})) (Map.lookup (2) fields),+  spanLink_externalTarget = P.maybe (P.Nothing) (\(_,_val173) -> P.Just (case _val173 of {T.TString _val176 -> E.decodeUtf8 _val176; _ -> P.error "wrong type"})) (Map.lookup (3) fields),+  spanLink_linkType = P.maybe (P.error "Missing required field: linkType") (\(_,_val173) -> (case _val173 of {T.TString _val177 -> E.decodeUtf8 _val177; _ -> P.error "wrong type"})) (Map.lookup (4) fields)   } to_SpanLink _ = P.error "not a struct" read_SpanLink :: (T.Transport t, T.Protocol p) => p t -> P.IO SpanLink@@ -824,15 +836,15 @@     ] from_Tokenization :: Tokenization -> T.ThriftVal from_Tokenization record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v174 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v174))) $ tokenization_uuid record-  , (\_v174 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v174))) $ tokenization_metadata record-  , (\_v174 -> (3, ("tokenList",from_TokenList _v174))) <$> tokenization_tokenList record-  , (\_v174 -> (4, ("lattice",from_TokenLattice _v174))) <$> tokenization_lattice record-  , (\_v174 -> P.Just (5, ("kind",T.TI32 $ P.fromIntegral $ P.fromEnum _v174))) $ tokenization_kind record-  , (\_v174 -> (6, ("tokenTaggingList",T.TList (T.T_STRUCT typemap_TokenTagging) $ P.map (\_v176 -> from_TokenTagging _v176) $ Vector.toList _v174))) <$> tokenization_tokenTaggingList record-  , (\_v174 -> (7, ("parseList",T.TList (T.T_STRUCT typemap_Parse) $ P.map (\_v178 -> from_Parse _v178) $ Vector.toList _v174))) <$> tokenization_parseList record-  , (\_v174 -> (8, ("dependencyParseList",T.TList (T.T_STRUCT typemap_DependencyParse) $ P.map (\_v180 -> from_DependencyParse _v180) $ Vector.toList _v174))) <$> tokenization_dependencyParseList record-  , (\_v174 -> (9, ("spanLinkList",T.TList (T.T_STRUCT typemap_SpanLink) $ P.map (\_v182 -> from_SpanLink _v182) $ Vector.toList _v174))) <$> tokenization_spanLinkList record+  [ (\_v180 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v180))) $ tokenization_uuid record+  , (\_v180 -> P.Just (2, ("metadata",Metadata_Types.from_AnnotationMetadata _v180))) $ tokenization_metadata record+  , (\_v180 -> (3, ("tokenList",from_TokenList _v180))) <$> tokenization_tokenList record+  , (\_v180 -> (4, ("lattice",from_TokenLattice _v180))) <$> tokenization_lattice record+  , (\_v180 -> P.Just (5, ("kind",T.TI32 $ P.fromIntegral $ P.fromEnum _v180))) $ tokenization_kind record+  , (\_v180 -> (6, ("tokenTaggingList",T.TList (T.T_STRUCT typemap_TokenTagging) $ P.map (\_v182 -> from_TokenTagging _v182) $ Vector.toList _v180))) <$> tokenization_tokenTaggingList record+  , (\_v180 -> (7, ("parseList",T.TList (T.T_STRUCT typemap_Parse) $ P.map (\_v184 -> from_Parse _v184) $ Vector.toList _v180))) <$> tokenization_parseList record+  , (\_v180 -> (8, ("dependencyParseList",T.TList (T.T_STRUCT typemap_DependencyParse) $ P.map (\_v186 -> from_DependencyParse _v186) $ Vector.toList _v180))) <$> tokenization_dependencyParseList record+  , (\_v180 -> (9, ("spanLinkList",T.TList (T.T_STRUCT typemap_SpanLink) $ P.map (\_v188 -> from_SpanLink _v188) $ Vector.toList _v180))) <$> tokenization_spanLinkList record   ] write_Tokenization :: (T.Protocol p, T.Transport t) => p t -> Tokenization -> P.IO () write_Tokenization oprot record = T.writeVal oprot $ from_Tokenization record@@ -840,15 +852,15 @@ encode_Tokenization oprot record = T.serializeVal oprot $ from_Tokenization record to_Tokenization :: T.ThriftVal -> Tokenization to_Tokenization (T.TStruct fields) = Tokenization{-  tokenization_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val184) -> (case _val184 of {T.TStruct _val185 -> (Uuid_Types.to_UUID (T.TStruct _val185)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  tokenization_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val184) -> (case _val184 of {T.TStruct _val186 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val186)); _ -> P.error "wrong type"})) (Map.lookup (2) fields),-  tokenization_tokenList = P.maybe (P.Nothing) (\(_,_val184) -> P.Just (case _val184 of {T.TStruct _val187 -> (to_TokenList (T.TStruct _val187)); _ -> P.error "wrong type"})) (Map.lookup (3) fields),-  tokenization_lattice = P.maybe (P.Nothing) (\(_,_val184) -> P.Just (case _val184 of {T.TStruct _val188 -> (to_TokenLattice (T.TStruct _val188)); _ -> P.error "wrong type"})) (Map.lookup (4) fields),-  tokenization_kind = P.maybe (P.error "Missing required field: kind") (\(_,_val184) -> (case _val184 of {T.TI32 _val189 -> P.toEnum $ P.fromIntegral _val189; _ -> P.error "wrong type"})) (Map.lookup (5) fields),-  tokenization_tokenTaggingList = P.maybe (P.Nothing) (\(_,_val184) -> P.Just (case _val184 of {T.TList _ _val190 -> (Vector.fromList $ P.map (\_v191 -> (case _v191 of {T.TStruct _val192 -> (to_TokenTagging (T.TStruct _val192)); _ -> P.error "wrong type"})) _val190); _ -> P.error "wrong type"})) (Map.lookup (6) fields),-  tokenization_parseList = P.maybe (P.Nothing) (\(_,_val184) -> P.Just (case _val184 of {T.TList _ _val193 -> (Vector.fromList $ P.map (\_v194 -> (case _v194 of {T.TStruct _val195 -> (to_Parse (T.TStruct _val195)); _ -> P.error "wrong type"})) _val193); _ -> P.error "wrong type"})) (Map.lookup (7) fields),-  tokenization_dependencyParseList = P.maybe (P.Nothing) (\(_,_val184) -> P.Just (case _val184 of {T.TList _ _val196 -> (Vector.fromList $ P.map (\_v197 -> (case _v197 of {T.TStruct _val198 -> (to_DependencyParse (T.TStruct _val198)); _ -> P.error "wrong type"})) _val196); _ -> P.error "wrong type"})) (Map.lookup (8) fields),-  tokenization_spanLinkList = P.maybe (P.Nothing) (\(_,_val184) -> P.Just (case _val184 of {T.TList _ _val199 -> (Vector.fromList $ P.map (\_v200 -> (case _v200 of {T.TStruct _val201 -> (to_SpanLink (T.TStruct _val201)); _ -> P.error "wrong type"})) _val199); _ -> P.error "wrong type"})) (Map.lookup (9) fields)+  tokenization_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val190) -> (case _val190 of {T.TStruct _val191 -> (Uuid_Types.to_UUID (T.TStruct _val191)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  tokenization_metadata = P.maybe (P.error "Missing required field: metadata") (\(_,_val190) -> (case _val190 of {T.TStruct _val192 -> (Metadata_Types.to_AnnotationMetadata (T.TStruct _val192)); _ -> P.error "wrong type"})) (Map.lookup (2) fields),+  tokenization_tokenList = P.maybe (P.Nothing) (\(_,_val190) -> P.Just (case _val190 of {T.TStruct _val193 -> (to_TokenList (T.TStruct _val193)); _ -> P.error "wrong type"})) (Map.lookup (3) fields),+  tokenization_lattice = P.maybe (P.Nothing) (\(_,_val190) -> P.Just (case _val190 of {T.TStruct _val194 -> (to_TokenLattice (T.TStruct _val194)); _ -> P.error "wrong type"})) (Map.lookup (4) fields),+  tokenization_kind = P.maybe (P.error "Missing required field: kind") (\(_,_val190) -> (case _val190 of {T.TI32 _val195 -> P.toEnum $ P.fromIntegral _val195; _ -> P.error "wrong type"})) (Map.lookup (5) fields),+  tokenization_tokenTaggingList = P.maybe (P.Nothing) (\(_,_val190) -> P.Just (case _val190 of {T.TList _ _val196 -> (Vector.fromList $ P.map (\_v197 -> (case _v197 of {T.TStruct _val198 -> (to_TokenTagging (T.TStruct _val198)); _ -> P.error "wrong type"})) _val196); _ -> P.error "wrong type"})) (Map.lookup (6) fields),+  tokenization_parseList = P.maybe (P.Nothing) (\(_,_val190) -> P.Just (case _val190 of {T.TList _ _val199 -> (Vector.fromList $ P.map (\_v200 -> (case _v200 of {T.TStruct _val201 -> (to_Parse (T.TStruct _val201)); _ -> P.error "wrong type"})) _val199); _ -> P.error "wrong type"})) (Map.lookup (7) fields),+  tokenization_dependencyParseList = P.maybe (P.Nothing) (\(_,_val190) -> P.Just (case _val190 of {T.TList _ _val202 -> (Vector.fromList $ P.map (\_v203 -> (case _v203 of {T.TStruct _val204 -> (to_DependencyParse (T.TStruct _val204)); _ -> P.error "wrong type"})) _val202); _ -> P.error "wrong type"})) (Map.lookup (8) fields),+  tokenization_spanLinkList = P.maybe (P.Nothing) (\(_,_val190) -> P.Just (case _val190 of {T.TList _ _val205 -> (Vector.fromList $ P.map (\_v206 -> (case _v206 of {T.TStruct _val207 -> (to_SpanLink (T.TStruct _val207)); _ -> P.error "wrong type"})) _val205); _ -> P.error "wrong type"})) (Map.lookup (9) fields)   } to_Tokenization _ = P.error "not a struct" read_Tokenization :: (T.Transport t, T.Protocol p) => p t -> P.IO Tokenization@@ -892,11 +904,11 @@     ] from_Sentence :: Sentence -> T.ThriftVal from_Sentence record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v204 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v204))) $ sentence_uuid record-  , (\_v204 -> (2, ("tokenization",from_Tokenization _v204))) <$> sentence_tokenization record-  , (\_v204 -> (3, ("textSpan",Spans_Types.from_TextSpan _v204))) <$> sentence_textSpan record-  , (\_v204 -> (4, ("rawTextSpan",Spans_Types.from_TextSpan _v204))) <$> sentence_rawTextSpan record-  , (\_v204 -> (5, ("audioSpan",Spans_Types.from_AudioSpan _v204))) <$> sentence_audioSpan record+  [ (\_v210 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v210))) $ sentence_uuid record+  , (\_v210 -> (2, ("tokenization",from_Tokenization _v210))) <$> sentence_tokenization record+  , (\_v210 -> (3, ("textSpan",Spans_Types.from_TextSpan _v210))) <$> sentence_textSpan record+  , (\_v210 -> (4, ("rawTextSpan",Spans_Types.from_TextSpan _v210))) <$> sentence_rawTextSpan record+  , (\_v210 -> (5, ("audioSpan",Spans_Types.from_AudioSpan _v210))) <$> sentence_audioSpan record   ] write_Sentence :: (T.Protocol p, T.Transport t) => p t -> Sentence -> P.IO () write_Sentence oprot record = T.writeVal oprot $ from_Sentence record@@ -904,11 +916,11 @@ encode_Sentence oprot record = T.serializeVal oprot $ from_Sentence record to_Sentence :: T.ThriftVal -> Sentence to_Sentence (T.TStruct fields) = Sentence{-  sentence_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val206) -> (case _val206 of {T.TStruct _val207 -> (Uuid_Types.to_UUID (T.TStruct _val207)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  sentence_tokenization = P.maybe (P.Nothing) (\(_,_val206) -> P.Just (case _val206 of {T.TStruct _val208 -> (to_Tokenization (T.TStruct _val208)); _ -> P.error "wrong type"})) (Map.lookup (2) fields),-  sentence_textSpan = P.maybe (P.Nothing) (\(_,_val206) -> P.Just (case _val206 of {T.TStruct _val209 -> (Spans_Types.to_TextSpan (T.TStruct _val209)); _ -> P.error "wrong type"})) (Map.lookup (3) fields),-  sentence_rawTextSpan = P.maybe (P.Nothing) (\(_,_val206) -> P.Just (case _val206 of {T.TStruct _val210 -> (Spans_Types.to_TextSpan (T.TStruct _val210)); _ -> P.error "wrong type"})) (Map.lookup (4) fields),-  sentence_audioSpan = P.maybe (P.Nothing) (\(_,_val206) -> P.Just (case _val206 of {T.TStruct _val211 -> (Spans_Types.to_AudioSpan (T.TStruct _val211)); _ -> P.error "wrong type"})) (Map.lookup (5) fields)+  sentence_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val212) -> (case _val212 of {T.TStruct _val213 -> (Uuid_Types.to_UUID (T.TStruct _val213)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  sentence_tokenization = P.maybe (P.Nothing) (\(_,_val212) -> P.Just (case _val212 of {T.TStruct _val214 -> (to_Tokenization (T.TStruct _val214)); _ -> P.error "wrong type"})) (Map.lookup (2) fields),+  sentence_textSpan = P.maybe (P.Nothing) (\(_,_val212) -> P.Just (case _val212 of {T.TStruct _val215 -> (Spans_Types.to_TextSpan (T.TStruct _val215)); _ -> P.error "wrong type"})) (Map.lookup (3) fields),+  sentence_rawTextSpan = P.maybe (P.Nothing) (\(_,_val212) -> P.Just (case _val212 of {T.TStruct _val216 -> (Spans_Types.to_TextSpan (T.TStruct _val216)); _ -> P.error "wrong type"})) (Map.lookup (4) fields),+  sentence_audioSpan = P.maybe (P.Nothing) (\(_,_val212) -> P.Just (case _val212 of {T.TStruct _val217 -> (Spans_Types.to_AudioSpan (T.TStruct _val217)); _ -> P.error "wrong type"})) (Map.lookup (5) fields)   } to_Sentence _ = P.error "not a struct" read_Sentence :: (T.Transport t, T.Protocol p) => p t -> P.IO Sentence@@ -960,15 +972,15 @@     ] from_Section :: Section -> T.ThriftVal from_Section record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v214 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v214))) $ section_uuid record-  , (\_v214 -> (2, ("sentenceList",T.TList (T.T_STRUCT typemap_Sentence) $ P.map (\_v216 -> from_Sentence _v216) $ Vector.toList _v214))) <$> section_sentenceList record-  , (\_v214 -> (3, ("textSpan",Spans_Types.from_TextSpan _v214))) <$> section_textSpan record-  , (\_v214 -> (4, ("rawTextSpan",Spans_Types.from_TextSpan _v214))) <$> section_rawTextSpan record-  , (\_v214 -> P.Just (5, ("kind",T.TString $ E.encodeUtf8 _v214))) $ section_kind record-  , (\_v214 -> (6, ("label",T.TString $ E.encodeUtf8 _v214))) <$> section_label record-  , (\_v214 -> (7, ("numberList",T.TList T.T_I32 $ P.map (\_v218 -> T.TI32 _v218) $ Vector.toList _v214))) <$> section_numberList record-  , (\_v214 -> (8, ("lidList",T.TList (T.T_STRUCT Language_Types.typemap_LanguageIdentification) $ P.map (\_v220 -> Language_Types.from_LanguageIdentification _v220) $ Vector.toList _v214))) <$> section_lidList record-  , (\_v214 -> (9, ("audioSpan",Spans_Types.from_AudioSpan _v214))) <$> section_audioSpan record+  [ (\_v220 -> P.Just (1, ("uuid",Uuid_Types.from_UUID _v220))) $ section_uuid record+  , (\_v220 -> (2, ("sentenceList",T.TList (T.T_STRUCT typemap_Sentence) $ P.map (\_v222 -> from_Sentence _v222) $ Vector.toList _v220))) <$> section_sentenceList record+  , (\_v220 -> (3, ("textSpan",Spans_Types.from_TextSpan _v220))) <$> section_textSpan record+  , (\_v220 -> (4, ("rawTextSpan",Spans_Types.from_TextSpan _v220))) <$> section_rawTextSpan record+  , (\_v220 -> P.Just (5, ("kind",T.TString $ E.encodeUtf8 _v220))) $ section_kind record+  , (\_v220 -> (6, ("label",T.TString $ E.encodeUtf8 _v220))) <$> section_label record+  , (\_v220 -> (7, ("numberList",T.TList T.T_I32 $ P.map (\_v224 -> T.TI32 _v224) $ Vector.toList _v220))) <$> section_numberList record+  , (\_v220 -> (8, ("lidList",T.TList (T.T_STRUCT Language_Types.typemap_LanguageIdentification) $ P.map (\_v226 -> Language_Types.from_LanguageIdentification _v226) $ Vector.toList _v220))) <$> section_lidList record+  , (\_v220 -> (9, ("audioSpan",Spans_Types.from_AudioSpan _v220))) <$> section_audioSpan record   ] write_Section :: (T.Protocol p, T.Transport t) => p t -> Section -> P.IO () write_Section oprot record = T.writeVal oprot $ from_Section record@@ -976,15 +988,15 @@ encode_Section oprot record = T.serializeVal oprot $ from_Section record to_Section :: T.ThriftVal -> Section to_Section (T.TStruct fields) = Section{-  section_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val222) -> (case _val222 of {T.TStruct _val223 -> (Uuid_Types.to_UUID (T.TStruct _val223)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  section_sentenceList = P.maybe (P.Nothing) (\(_,_val222) -> P.Just (case _val222 of {T.TList _ _val224 -> (Vector.fromList $ P.map (\_v225 -> (case _v225 of {T.TStruct _val226 -> (to_Sentence (T.TStruct _val226)); _ -> P.error "wrong type"})) _val224); _ -> P.error "wrong type"})) (Map.lookup (2) fields),-  section_textSpan = P.maybe (P.Nothing) (\(_,_val222) -> P.Just (case _val222 of {T.TStruct _val227 -> (Spans_Types.to_TextSpan (T.TStruct _val227)); _ -> P.error "wrong type"})) (Map.lookup (3) fields),-  section_rawTextSpan = P.maybe (P.Nothing) (\(_,_val222) -> P.Just (case _val222 of {T.TStruct _val228 -> (Spans_Types.to_TextSpan (T.TStruct _val228)); _ -> P.error "wrong type"})) (Map.lookup (4) fields),-  section_audioSpan = P.maybe (P.Nothing) (\(_,_val222) -> P.Just (case _val222 of {T.TStruct _val229 -> (Spans_Types.to_AudioSpan (T.TStruct _val229)); _ -> P.error "wrong type"})) (Map.lookup (9) fields),-  section_kind = P.maybe (P.error "Missing required field: kind") (\(_,_val222) -> (case _val222 of {T.TString _val230 -> E.decodeUtf8 _val230; _ -> P.error "wrong type"})) (Map.lookup (5) fields),-  section_label = P.maybe (P.Nothing) (\(_,_val222) -> P.Just (case _val222 of {T.TString _val231 -> E.decodeUtf8 _val231; _ -> P.error "wrong type"})) (Map.lookup (6) fields),-  section_numberList = P.maybe (P.Nothing) (\(_,_val222) -> P.Just (case _val222 of {T.TList _ _val232 -> (Vector.fromList $ P.map (\_v233 -> (case _v233 of {T.TI32 _val234 -> _val234; _ -> P.error "wrong type"})) _val232); _ -> P.error "wrong type"})) (Map.lookup (7) fields),-  section_lidList = P.maybe (P.Nothing) (\(_,_val222) -> P.Just (case _val222 of {T.TList _ _val235 -> (Vector.fromList $ P.map (\_v236 -> (case _v236 of {T.TStruct _val237 -> (Language_Types.to_LanguageIdentification (T.TStruct _val237)); _ -> P.error "wrong type"})) _val235); _ -> P.error "wrong type"})) (Map.lookup (8) fields)+  section_uuid = P.maybe (P.error "Missing required field: uuid") (\(_,_val228) -> (case _val228 of {T.TStruct _val229 -> (Uuid_Types.to_UUID (T.TStruct _val229)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  section_sentenceList = P.maybe (P.Nothing) (\(_,_val228) -> P.Just (case _val228 of {T.TList _ _val230 -> (Vector.fromList $ P.map (\_v231 -> (case _v231 of {T.TStruct _val232 -> (to_Sentence (T.TStruct _val232)); _ -> P.error "wrong type"})) _val230); _ -> P.error "wrong type"})) (Map.lookup (2) fields),+  section_textSpan = P.maybe (P.Nothing) (\(_,_val228) -> P.Just (case _val228 of {T.TStruct _val233 -> (Spans_Types.to_TextSpan (T.TStruct _val233)); _ -> P.error "wrong type"})) (Map.lookup (3) fields),+  section_rawTextSpan = P.maybe (P.Nothing) (\(_,_val228) -> P.Just (case _val228 of {T.TStruct _val234 -> (Spans_Types.to_TextSpan (T.TStruct _val234)); _ -> P.error "wrong type"})) (Map.lookup (4) fields),+  section_audioSpan = P.maybe (P.Nothing) (\(_,_val228) -> P.Just (case _val228 of {T.TStruct _val235 -> (Spans_Types.to_AudioSpan (T.TStruct _val235)); _ -> P.error "wrong type"})) (Map.lookup (9) fields),+  section_kind = P.maybe (P.error "Missing required field: kind") (\(_,_val228) -> (case _val228 of {T.TString _val236 -> E.decodeUtf8 _val236; _ -> P.error "wrong type"})) (Map.lookup (5) fields),+  section_label = P.maybe (P.Nothing) (\(_,_val228) -> P.Just (case _val228 of {T.TString _val237 -> E.decodeUtf8 _val237; _ -> P.error "wrong type"})) (Map.lookup (6) fields),+  section_numberList = P.maybe (P.Nothing) (\(_,_val228) -> P.Just (case _val228 of {T.TList _ _val238 -> (Vector.fromList $ P.map (\_v239 -> (case _v239 of {T.TI32 _val240 -> _val240; _ -> P.error "wrong type"})) _val238); _ -> P.error "wrong type"})) (Map.lookup (7) fields),+  section_lidList = P.maybe (P.Nothing) (\(_,_val228) -> P.Just (case _val228 of {T.TList _ _val241 -> (Vector.fromList $ P.map (\_v242 -> (case _v242 of {T.TStruct _val243 -> (Language_Types.to_LanguageIdentification (T.TStruct _val243)); _ -> P.error "wrong type"})) _val241); _ -> P.error "wrong type"})) (Map.lookup (8) fields)   } to_Section _ = P.error "not a struct" read_Section :: (T.Transport t, T.Protocol p) => p t -> P.IO Section
src/Data/Concrete/Autogen/Summarization_Types.hs view
@@ -120,44 +120,6 @@   summarizationRequest_sourceType = P.Nothing,   summarizationRequest_sourceIds = P.Nothing,   summarizationRequest_sourceCommunication = P.Nothing}-data Summary = Summary  { summary_summaryCommunication :: P.Maybe Communication_Types.Communication-  , summary_concepts :: P.Maybe (Vector.Vector SummaryConcept)-  } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)-instance H.Hashable Summary where-  hashWithSalt salt record = salt   `H.hashWithSalt` summary_summaryCommunication record   `H.hashWithSalt` summary_concepts record  -instance QC.Arbitrary Summary where -  arbitrary = M.liftM Summary (M.liftM P.Just QC.arbitrary)-          `M.ap`(M.liftM P.Just QC.arbitrary)-  shrink obj | obj == default_Summary = []-             | P.otherwise = M.catMaybes-    [ if obj == default_Summary{summary_summaryCommunication = summary_summaryCommunication obj} then P.Nothing else P.Just $ default_Summary{summary_summaryCommunication = summary_summaryCommunication obj}-    , if obj == default_Summary{summary_concepts = summary_concepts obj} then P.Nothing else P.Just $ default_Summary{summary_concepts = summary_concepts obj}-    ]-from_Summary :: Summary -> T.ThriftVal-from_Summary record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v21 -> (1, ("summaryCommunication",Communication_Types.from_Communication _v21))) <$> summary_summaryCommunication record-  , (\_v21 -> (2, ("concepts",T.TList (T.T_STRUCT typemap_SummaryConcept) $ P.map (\_v23 -> from_SummaryConcept _v23) $ Vector.toList _v21))) <$> summary_concepts record-  ]-write_Summary :: (T.Protocol p, T.Transport t) => p t -> Summary -> P.IO ()-write_Summary oprot record = T.writeVal oprot $ from_Summary record-encode_Summary :: (T.Protocol p, T.Transport t) => p t -> Summary -> LBS.ByteString-encode_Summary oprot record = T.serializeVal oprot $ from_Summary record-to_Summary :: T.ThriftVal -> Summary-to_Summary (T.TStruct fields) = Summary{-  summary_summaryCommunication = P.maybe (P.Nothing) (\(_,_val25) -> P.Just (case _val25 of {T.TStruct _val26 -> (Communication_Types.to_Communication (T.TStruct _val26)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  summary_concepts = P.maybe (P.Nothing) (\(_,_val25) -> P.Just (case _val25 of {T.TList _ _val27 -> (Vector.fromList $ P.map (\_v28 -> (case _v28 of {T.TStruct _val29 -> (to_SummaryConcept (T.TStruct _val29)); _ -> P.error "wrong type"})) _val27); _ -> P.error "wrong type"})) (Map.lookup (2) fields)-  }-to_Summary _ = P.error "not a struct"-read_Summary :: (T.Transport t, T.Protocol p) => p t -> P.IO Summary-read_Summary iprot = to_Summary <$> T.readVal iprot (T.T_STRUCT typemap_Summary)-decode_Summary :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Summary-decode_Summary iprot bs = to_Summary $ T.deserializeVal iprot (T.T_STRUCT typemap_Summary) bs-typemap_Summary :: T.TypeMap-typemap_Summary = Map.fromList [(1,("summaryCommunication",(T.T_STRUCT Communication_Types.typemap_Communication))),(2,("concepts",(T.T_LIST (T.T_STRUCT typemap_SummaryConcept))))]-default_Summary :: Summary-default_Summary = Summary{-  summary_summaryCommunication = P.Nothing,-  summary_concepts = P.Nothing} data SummaryConcept = SummaryConcept  { summaryConcept_tokens :: P.Maybe Structure_Types.TokenRefSequence   , summaryConcept_concept :: P.Maybe LT.Text   , summaryConcept_confidence :: P.Maybe P.Double@@ -179,10 +141,10 @@     ] from_SummaryConcept :: SummaryConcept -> T.ThriftVal from_SummaryConcept record = T.TStruct $ Map.fromList $ M.catMaybes-  [ (\_v32 -> (1, ("tokens",Structure_Types.from_TokenRefSequence _v32))) <$> summaryConcept_tokens record-  , (\_v32 -> (2, ("concept",T.TString $ E.encodeUtf8 _v32))) <$> summaryConcept_concept record-  , (\_v32 -> (3, ("confidence",T.TDouble _v32))) <$> summaryConcept_confidence record-  , (\_v32 -> (4, ("utility",T.TDouble _v32))) <$> summaryConcept_utility record+  [ (\_v21 -> (1, ("tokens",Structure_Types.from_TokenRefSequence _v21))) <$> summaryConcept_tokens record+  , (\_v21 -> (2, ("concept",T.TString $ E.encodeUtf8 _v21))) <$> summaryConcept_concept record+  , (\_v21 -> (3, ("confidence",T.TDouble _v21))) <$> summaryConcept_confidence record+  , (\_v21 -> (4, ("utility",T.TDouble _v21))) <$> summaryConcept_utility record   ] write_SummaryConcept :: (T.Protocol p, T.Transport t) => p t -> SummaryConcept -> P.IO () write_SummaryConcept oprot record = T.writeVal oprot $ from_SummaryConcept record@@ -190,10 +152,10 @@ encode_SummaryConcept oprot record = T.serializeVal oprot $ from_SummaryConcept record to_SummaryConcept :: T.ThriftVal -> SummaryConcept to_SummaryConcept (T.TStruct fields) = SummaryConcept{-  summaryConcept_tokens = P.maybe (P.Nothing) (\(_,_val34) -> P.Just (case _val34 of {T.TStruct _val35 -> (Structure_Types.to_TokenRefSequence (T.TStruct _val35)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),-  summaryConcept_concept = P.maybe (P.Nothing) (\(_,_val34) -> P.Just (case _val34 of {T.TString _val36 -> E.decodeUtf8 _val36; _ -> P.error "wrong type"})) (Map.lookup (2) fields),-  summaryConcept_confidence = P.maybe (summaryConcept_confidence default_SummaryConcept) (\(_,_val34) -> P.Just (case _val34 of {T.TDouble _val37 -> _val37; _ -> P.error "wrong type"})) (Map.lookup (3) fields),-  summaryConcept_utility = P.maybe (summaryConcept_utility default_SummaryConcept) (\(_,_val34) -> P.Just (case _val34 of {T.TDouble _val38 -> _val38; _ -> P.error "wrong type"})) (Map.lookup (4) fields)+  summaryConcept_tokens = P.maybe (P.Nothing) (\(_,_val23) -> P.Just (case _val23 of {T.TStruct _val24 -> (Structure_Types.to_TokenRefSequence (T.TStruct _val24)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  summaryConcept_concept = P.maybe (P.Nothing) (\(_,_val23) -> P.Just (case _val23 of {T.TString _val25 -> E.decodeUtf8 _val25; _ -> P.error "wrong type"})) (Map.lookup (2) fields),+  summaryConcept_confidence = P.maybe (summaryConcept_confidence default_SummaryConcept) (\(_,_val23) -> P.Just (case _val23 of {T.TDouble _val26 -> _val26; _ -> P.error "wrong type"})) (Map.lookup (3) fields),+  summaryConcept_utility = P.maybe (summaryConcept_utility default_SummaryConcept) (\(_,_val23) -> P.Just (case _val23 of {T.TDouble _val27 -> _val27; _ -> P.error "wrong type"})) (Map.lookup (4) fields)   } to_SummaryConcept _ = P.error "not a struct" read_SummaryConcept :: (T.Transport t, T.Protocol p) => p t -> P.IO SummaryConcept@@ -208,6 +170,44 @@   summaryConcept_concept = P.Nothing,   summaryConcept_confidence = P.Just (1),   summaryConcept_utility = P.Just (1)}+data Summary = Summary  { summary_summaryCommunication :: P.Maybe Communication_Types.Communication+  , summary_concepts :: P.Maybe (Vector.Vector SummaryConcept)+  } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)+instance H.Hashable Summary where+  hashWithSalt salt record = salt   `H.hashWithSalt` summary_summaryCommunication record   `H.hashWithSalt` summary_concepts record  +instance QC.Arbitrary Summary where +  arbitrary = M.liftM Summary (M.liftM P.Just QC.arbitrary)+          `M.ap`(M.liftM P.Just QC.arbitrary)+  shrink obj | obj == default_Summary = []+             | P.otherwise = M.catMaybes+    [ if obj == default_Summary{summary_summaryCommunication = summary_summaryCommunication obj} then P.Nothing else P.Just $ default_Summary{summary_summaryCommunication = summary_summaryCommunication obj}+    , if obj == default_Summary{summary_concepts = summary_concepts obj} then P.Nothing else P.Just $ default_Summary{summary_concepts = summary_concepts obj}+    ]+from_Summary :: Summary -> T.ThriftVal+from_Summary record = T.TStruct $ Map.fromList $ M.catMaybes+  [ (\_v30 -> (1, ("summaryCommunication",Communication_Types.from_Communication _v30))) <$> summary_summaryCommunication record+  , (\_v30 -> (2, ("concepts",T.TList (T.T_STRUCT typemap_SummaryConcept) $ P.map (\_v32 -> from_SummaryConcept _v32) $ Vector.toList _v30))) <$> summary_concepts record+  ]+write_Summary :: (T.Protocol p, T.Transport t) => p t -> Summary -> P.IO ()+write_Summary oprot record = T.writeVal oprot $ from_Summary record+encode_Summary :: (T.Protocol p, T.Transport t) => p t -> Summary -> LBS.ByteString+encode_Summary oprot record = T.serializeVal oprot $ from_Summary record+to_Summary :: T.ThriftVal -> Summary+to_Summary (T.TStruct fields) = Summary{+  summary_summaryCommunication = P.maybe (P.Nothing) (\(_,_val34) -> P.Just (case _val34 of {T.TStruct _val35 -> (Communication_Types.to_Communication (T.TStruct _val35)); _ -> P.error "wrong type"})) (Map.lookup (1) fields),+  summary_concepts = P.maybe (P.Nothing) (\(_,_val34) -> P.Just (case _val34 of {T.TList _ _val36 -> (Vector.fromList $ P.map (\_v37 -> (case _v37 of {T.TStruct _val38 -> (to_SummaryConcept (T.TStruct _val38)); _ -> P.error "wrong type"})) _val36); _ -> P.error "wrong type"})) (Map.lookup (2) fields)+  }+to_Summary _ = P.error "not a struct"+read_Summary :: (T.Transport t, T.Protocol p) => p t -> P.IO Summary+read_Summary iprot = to_Summary <$> T.readVal iprot (T.T_STRUCT typemap_Summary)+decode_Summary :: (T.Protocol p, T.Transport t) => p t -> LBS.ByteString -> Summary+decode_Summary iprot bs = to_Summary $ T.deserializeVal iprot (T.T_STRUCT typemap_Summary) bs+typemap_Summary :: T.TypeMap+typemap_Summary = Map.fromList [(1,("summaryCommunication",(T.T_STRUCT Communication_Types.typemap_Communication))),(2,("concepts",(T.T_LIST (T.T_STRUCT typemap_SummaryConcept))))]+default_Summary :: Summary+default_Summary = Summary{+  summary_summaryCommunication = P.Nothing,+  summary_concepts = P.Nothing} data SummarizationCapability = SummarizationCapability  { summarizationCapability_type :: SummarySourceType   , summarizationCapability_lang :: LT.Text   } deriving (P.Show,P.Eq,G.Generic,TY.Typeable)