Language.Thrift.AST

This module defines types that compose a Thrift IDL file.

Most of the types have an optional srcAnnot parameter that represents a source annotation. The parser produces types annotated with their position in the Thrift file (SourcePos). When constructing the AST by hand, you can use (). The types are Functors so you can use fmap to change the annotation on all objects in a tree.

Lenses for attributes of most types are provided for use with the lens library.

Types representing the AST all have Pretty instances to go with them.

AST

data Program srcAnnot

A program represents a single Thrift document.

Constructors

Program

Fields

programHeaders :: [Header srcAnnot]

Headers in a document define includes and namespaces.

programDefinitions :: [Definition srcAnnot]

Types and services defined in the document.

Instances

Functor Program

Eq srcAnnot => Eq (Program srcAnnot)

Data srcAnnot => Data (Program srcAnnot)

Ord srcAnnot => Ord (Program srcAnnot)

Show srcAnnot => Show (Program srcAnnot)

Generic (Program srcAnnot)

type Rep (Program srcAnnot)

headers :: Lens (Program a) [Header a]

definitions :: Lens (Program a) [Definition a]

data Header srcAnnot

Headers for a program.

Constructors

HeaderInclude (Include srcAnnot)

Request to include another Thrift file.

HeaderNamespace (Namespace srcAnnot)

A namespace specifier.

Instances

Functor Header

Eq srcAnnot => Eq (Header srcAnnot)

Data srcAnnot => Data (Header srcAnnot)

Ord srcAnnot => Ord (Header srcAnnot)

Show srcAnnot => Show (Header srcAnnot)

Generic (Header srcAnnot)

type Rep (Header srcAnnot)

data Include srcAnnot

The IDL includes another Thrift file.

include "common.thrift"

typedef common.Foo Bar

Constructors

Include

Fields

includePath :: Text

Path to the included file.

includeSrcAnnot :: srcAnnot

Instances

Functor Include

HasSrcAnnot Include

Eq srcAnnot => Eq (Include srcAnnot)

Data srcAnnot => Data (Include srcAnnot)

Ord srcAnnot => Ord (Include srcAnnot)

Show srcAnnot => Show (Include srcAnnot)

Generic (Include srcAnnot)

type Rep (Include srcAnnot)

path :: Lens (Include a) Text

data Namespace srcAnnot

Namespace directives allows control of the namespace or package name used by the generated code for certain languages.

namespace py my_service.generated

Constructors

Namespace

Fields

namespaceLanguage :: Text

The language for which the namespace is being specified. This may be * to refer to all languages.

namespaceName :: Text

Namespace or package path to use in the generated code for that language.

namespaceSrcAnnot :: srcAnnot

Instances

Functor Namespace

HasSrcAnnot Namespace

Eq srcAnnot => Eq (Namespace srcAnnot)

Data srcAnnot => Data (Namespace srcAnnot)

Ord srcAnnot => Ord (Namespace srcAnnot)

Show srcAnnot => Show (Namespace srcAnnot)

Generic (Namespace srcAnnot)

HasName (Namespace a)

type Rep (Namespace srcAnnot)

language :: Lens (Namespace a) Text

data Definition srcAnnot

A definition either consists of new constants, new types, or new services.

Constructors

ConstDefinition (Const srcAnnot)

A declared constant.

TypeDefinition (Type srcAnnot)

A custom type.

ServiceDefinition (Service srcAnnot)

A service definition.

Instances

Functor Definition

HasSrcAnnot Definition

Eq srcAnnot => Eq (Definition srcAnnot)

Data srcAnnot => Data (Definition srcAnnot)

Ord srcAnnot => Ord (Definition srcAnnot)

Show srcAnnot => Show (Definition srcAnnot)

Generic (Definition srcAnnot)

HasName (Definition a)

type Rep (Definition srcAnnot)

data Const srcAnnot

A declared constant.

const i32 code = 1;

Constructors

Const

Fields

constValueType :: TypeReference srcAnnot

Type of the constant.

constName :: Text

Name of the constant.

constValue :: ConstValue srcAnnot

Value of the constant.

constDocstring :: Docstring

Documentation.

constSrcAnnot :: srcAnnot

Instances

Functor Const

HasValueType Const

HasSrcAnnot Const

Eq srcAnnot => Eq (Const srcAnnot)

Data srcAnnot => Data (Const srcAnnot)

Ord srcAnnot => Ord (Const srcAnnot)

Show srcAnnot => Show (Const srcAnnot)

Generic (Const srcAnnot)

HasDocstring (Const a)

HasName (Const a)

HasValue (Const a) (ConstValue a)

type Rep (Const srcAnnot)

data Service srcAnnot

A service definition.

service MyService {
    // ...
}

Constructors

Service

Fields

serviceName :: Text

Name of the service.

serviceExtends :: Maybe Text

Name of the service this service extends.

serviceFunctions :: [Function srcAnnot]

All the functions defined for the service.

serviceAnnotations :: [TypeAnnotation]

Annotations added to the service.

serviceDocstring :: Docstring

Documentation.

serviceSrcAnnot :: srcAnnot

Instances

Functor Service

HasSrcAnnot Service

Eq srcAnnot => Eq (Service srcAnnot)

Data srcAnnot => Data (Service srcAnnot)

Ord srcAnnot => Ord (Service srcAnnot)

Show srcAnnot => Show (Service srcAnnot)

Generic (Service srcAnnot)

HasDocstring (Service a)

HasAnnotations (Service a)

HasName (Service a)

type Rep (Service srcAnnot)

functions :: Lens (Service a) [Function a]

extends :: Lens (Service a) (Maybe Text)

data Type srcAnnot

Defines the various types that can be declared in Thrift.

Constructors

TypedefType (Typedef srcAnnot)

typedef

EnumType (Enum srcAnnot)

enum

StructType (Struct srcAnnot)

struct

UnionType (Union srcAnnot)

union

ExceptionType (Exception srcAnnot)

exception

SenumType (Senum srcAnnot)

senum

Instances

Functor Type

HasSrcAnnot Type

Eq srcAnnot => Eq (Type srcAnnot)

Data srcAnnot => Data (Type srcAnnot)

Ord srcAnnot => Ord (Type srcAnnot)

Show srcAnnot => Show (Type srcAnnot)

Generic (Type srcAnnot)

HasName (Type a)

type Rep (Type srcAnnot)

data Typedef srcAnnot

A typedef is just an alias for another type.

typedef common.Foo Bar

Constructors

Typedef

Fields

typedefTargetType :: TypeReference srcAnnot

The aliased type.

typedefName :: Text

Name of the new type.

typedefAnnotations :: [TypeAnnotation]

Annotations added to the typedef.

typedefDocstring :: Docstring

Documentation.

typedefSrcAnnot :: srcAnnot

Instances

Functor Typedef

HasSrcAnnot Typedef

Eq srcAnnot => Eq (Typedef srcAnnot)

Data srcAnnot => Data (Typedef srcAnnot)

Ord srcAnnot => Ord (Typedef srcAnnot)

Show srcAnnot => Show (Typedef srcAnnot)

Generic (Typedef srcAnnot)

HasDocstring (Typedef a)

HasAnnotations (Typedef a)

HasName (Typedef a)

type Rep (Typedef srcAnnot)

targetType :: Lens (Typedef a) (TypeReference a)

data Enum srcAnnot

Enums are sets of named integer values.

enum Role {
    User = 1, Admin = 2
}

Constructors

Enum

Fields

enumName :: Text

Name of the enum type.

enumValues :: [EnumDef srcAnnot]

Values defined in the enum.

enumAnnotations :: [TypeAnnotation]

Annotations added to the enum.

enumDocstring :: Docstring

Documentation.

enumSrcAnnot :: srcAnnot

Instances

Functor Enum

HasSrcAnnot Enum

Eq srcAnnot => Eq (Enum srcAnnot)

Data srcAnnot => Data (Enum srcAnnot)

Ord srcAnnot => Ord (Enum srcAnnot)

Show srcAnnot => Show (Enum srcAnnot)

Generic (Enum srcAnnot)

HasDocstring (Enum a)

HasAnnotations (Enum a)

HasName (Enum a)

HasValues (Enum a) [EnumDef a]

type Rep (Enum srcAnnot)

data Struct srcAnnot

A struct definition

struct User {
    1: Role role = Role.User;
}

Constructors

Struct

Fields

structName :: Text

Name of the struct.

structFields :: [Field srcAnnot]

Fields defined in the struct.

structAnnotations :: [TypeAnnotation]

Annotations added to the struct.

structDocstring :: Docstring

Documentation.

structSrcAnnot :: srcAnnot

Instances

Functor Struct

HasFields Struct

HasSrcAnnot Struct

Eq srcAnnot => Eq (Struct srcAnnot)

Data srcAnnot => Data (Struct srcAnnot)

Ord srcAnnot => Ord (Struct srcAnnot)

Show srcAnnot => Show (Struct srcAnnot)

Generic (Struct srcAnnot)

HasDocstring (Struct a)

HasAnnotations (Struct a)

HasName (Struct a)

type Rep (Struct srcAnnot)

data Union srcAnnot

A union of other types.

union Value {
    1: string stringValue;
    2: i32 intValue;
}

Constructors

Union

Fields

unionName :: Text

Name of the union.

unionFields :: [Field srcAnnot]

Fields defined in the union.

unionAnnotations :: [TypeAnnotation]

Annotations added to the union.

unionDocstring :: Docstring

Documentation.

unionSrcAnnot :: srcAnnot

Instances

Functor Union

HasFields Union

HasSrcAnnot Union

Eq srcAnnot => Eq (Union srcAnnot)

Data srcAnnot => Data (Union srcAnnot)

Ord srcAnnot => Ord (Union srcAnnot)

Show srcAnnot => Show (Union srcAnnot)

Generic (Union srcAnnot)

HasDocstring (Union a)

HasAnnotations (Union a)

HasName (Union a)

type Rep (Union srcAnnot)

data Exception srcAnnot

Exception types.

exception UserDoesNotExist {
    1: optional string message
    2: required string username
}

Constructors

Exception

Fields

exceptionName :: Text

Name of the exception.

exceptionFields :: [Field srcAnnot]

Fields defined in the exception.

exceptionAnnotations :: [TypeAnnotation]

Annotations added to the exception.

exceptionDocstring :: Docstring

Documentation.

exceptionSrcAnnot :: srcAnnot

Instances

Functor Exception

HasFields Exception

HasSrcAnnot Exception

Eq srcAnnot => Eq (Exception srcAnnot)

Data srcAnnot => Data (Exception srcAnnot)

Ord srcAnnot => Ord (Exception srcAnnot)

Show srcAnnot => Show (Exception srcAnnot)

Generic (Exception srcAnnot)

HasDocstring (Exception a)

HasAnnotations (Exception a)

HasName (Exception a)

type Rep (Exception srcAnnot)

data Senum srcAnnot

An string-only enum. These are a deprecated feature of Thrift and shouldn't be used.

Constructors

Senum

Fields

senumName :: Text

senumValues :: [Text]

senumAnnotations :: [TypeAnnotation]

Annotations added to the senum.

senumDocstring :: Docstring

Documentation.

senumSrcAnnot :: srcAnnot

Instances

Functor Senum

HasSrcAnnot Senum

Eq srcAnnot => Eq (Senum srcAnnot)

Data srcAnnot => Data (Senum srcAnnot)

Ord srcAnnot => Ord (Senum srcAnnot)

Show srcAnnot => Show (Senum srcAnnot)

Generic (Senum srcAnnot)

HasDocstring (Senum a)

HasAnnotations (Senum a)

HasName (Senum a)

HasValues (Senum a) [Text]

type Rep (Senum srcAnnot)

data FieldRequiredness

Whether a field is required or optional.

Constructors

Required

The field is required.

Optional

The field is optional.

Instances

Eq FieldRequiredness

Data FieldRequiredness

Ord FieldRequiredness

Show FieldRequiredness

Generic FieldRequiredness

type Rep FieldRequiredness

data Field srcAnnot

A field inside a struct, exception, or function parameters list.

Constructors

Field

Fields

fieldIdentifier :: Maybe Integer

Position of the field.

While this is optional, it is recommended that Thrift files always contain specific field IDs.

fieldRequiredness :: Maybe FieldRequiredness

Whether this field is required or not.

Behavior may differ between languages if requiredness is not specified. Therefore it's recommended that requiredness for a field is always specified.

fieldValueType :: TypeReference srcAnnot

Type of value the field holds.

fieldName :: Text

Name of the field.

fieldDefaultValue :: Maybe (ConstValue srcAnnot)

Default value of the field, if any.

fieldAnnotations :: [TypeAnnotation]

Field annotations.

fieldDocstring :: Docstring

Documentation.

fieldSrcAnnot :: srcAnnot

Instances

Functor Field

HasValueType Field

HasSrcAnnot Field

Eq srcAnnot => Eq (Field srcAnnot)

Data srcAnnot => Data (Field srcAnnot)

Ord srcAnnot => Ord (Field srcAnnot)

Show srcAnnot => Show (Field srcAnnot)

Generic (Field srcAnnot)

HasDocstring (Field a)

HasAnnotations (Field a)

HasName (Field a)

type Rep (Field srcAnnot)

identifier :: Lens (Field a) (Maybe Integer)

requiredness :: Lens (Field a) (Maybe FieldRequiredness)

defaultValue :: Lens (Field a) (Maybe (ConstValue a))

data EnumDef srcAnnot

A named value inside an enum.

Constructors

EnumDef

Fields

enumDefName :: Text

Name of the value.

enumDefValue :: Maybe Integer

Value attached to the enum for that name.

enumDefAnnotations :: [TypeAnnotation]

Annotations added to this enum field.

enumDefDocstring :: Docstring

Documentation

enumDefSrcAnnot :: srcAnnot

Instances

Functor EnumDef

HasSrcAnnot EnumDef

Eq srcAnnot => Eq (EnumDef srcAnnot)

Data srcAnnot => Data (EnumDef srcAnnot)

Ord srcAnnot => Ord (EnumDef srcAnnot)

Show srcAnnot => Show (EnumDef srcAnnot)

Generic (EnumDef srcAnnot)

HasDocstring (EnumDef a)

HasAnnotations (EnumDef a)

HasName (EnumDef a)

HasValues (Enum a) [EnumDef a]

HasValue (EnumDef a) (Maybe Integer)

type Rep (EnumDef srcAnnot)

data ConstValue srcAnnot

A constant literal value in the IDL. Only a few basic types, lists, and maps can be presented in Thrift files as literals.

Constants are used for IDL-level constants and default values for fields.

Constructors

ConstInt Integer srcAnnot

An integer. 42

ConstFloat Double srcAnnot

A float. 4.2

ConstLiteral Text srcAnnot

A literal string. "hello"

ConstIdentifier Text srcAnnot

A reference to another constant. Foo.bar

ConstList [ConstValue srcAnnot] srcAnnot

A literal list containing other constant values. [42]

ConstMap [(ConstValue srcAnnot, ConstValue srcAnnot)] srcAnnot

A literal list containing other constant values. {"hellO": 1, "world": 2}

Instances

Functor ConstValue

HasSrcAnnot ConstValue

Eq srcAnnot => Eq (ConstValue srcAnnot)

Data srcAnnot => Data (ConstValue srcAnnot)

Ord srcAnnot => Ord (ConstValue srcAnnot)

Show srcAnnot => Show (ConstValue srcAnnot)

Generic (ConstValue srcAnnot)

HasValue (Const a) (ConstValue a)

type Rep (ConstValue srcAnnot)

data TypeReference srcAnnot

A reference to a type.

Constructors

DefinedType Text srcAnnot

A custom defined type referred to by name.

StringType [TypeAnnotation] srcAnnot

string and annotations.

BinaryType [TypeAnnotation] srcAnnot

binary and annotations.

SListType [TypeAnnotation] srcAnnot

slist and annotations.

BoolType [TypeAnnotation] srcAnnot

bool and annotations.

ByteType [TypeAnnotation] srcAnnot

byte and annotations.

I16Type [TypeAnnotation] srcAnnot

i16 and annotations.

I32Type [TypeAnnotation] srcAnnot

i32 and annotations.

I64Type [TypeAnnotation] srcAnnot

i64 and annotations.

DoubleType [TypeAnnotation] srcAnnot

double and annotations.

MapType (TypeReference srcAnnot) (TypeReference srcAnnot) [TypeAnnotation] srcAnnot

map<foo, bar> and annotations.

SetType (TypeReference srcAnnot) [TypeAnnotation] srcAnnot

set<baz> and annotations.

ListType (TypeReference srcAnnot) [TypeAnnotation] srcAnnot

list<qux> and annotations.

Instances

Functor TypeReference

HasSrcAnnot TypeReference

Eq srcAnnot => Eq (TypeReference srcAnnot)

Data srcAnnot => Data (TypeReference srcAnnot)

Ord srcAnnot => Ord (TypeReference srcAnnot)

Show srcAnnot => Show (TypeReference srcAnnot)

Generic (TypeReference srcAnnot)

type Rep (TypeReference srcAnnot)

data Function srcAnnot

A function defined inside a service.

Constructors

Function

Fields

functionOneWay :: Bool

Whether the function is oneway. If it's one way, it cannot receive repsonses.

functionReturnType :: Maybe (TypeReference srcAnnot)

Return type of the function, or Nothing if it's void or oneway.

functionName :: Text

Name of the function.

functionParameters :: [Field srcAnnot]

Parameters accepted by the function.

functionExceptions :: Maybe [Field srcAnnot]

Exceptions raised by the function, if any.

functionAnnotations :: [TypeAnnotation]

Annotations added to the function.

functionDocstring :: Docstring

Documentation.

functionSrcAnnot :: srcAnnot

Instances

Functor Function

HasSrcAnnot Function

Eq srcAnnot => Eq (Function srcAnnot)

Data srcAnnot => Data (Function srcAnnot)

Ord srcAnnot => Ord (Function srcAnnot)

Show srcAnnot => Show (Function srcAnnot)

Generic (Function srcAnnot)

HasDocstring (Function a)

HasAnnotations (Function a)

HasName (Function a)

type Rep (Function srcAnnot)

oneWay :: Lens (Function a) Bool

returnType :: Lens (Function a) (Maybe (TypeReference a))

parameters :: Lens (Function a) [Field a]

exceptions :: Lens (Function a) (Maybe [Field a])

data TypeAnnotation

Type annoations may be added in various places in the form,

(foo = "bar", baz, qux = "quux")

These do not usually affect code generation but allow for custom logic if writing your own code generator.

Constructors

TypeAnnotation

Fields

typeAnnotationName :: Text

Name of the annotation.

typeAnnotationValue :: Maybe Text

Value for the annotation.

Instances

Eq TypeAnnotation

Data TypeAnnotation

Ord TypeAnnotation

Show TypeAnnotation

Generic TypeAnnotation

HasName TypeAnnotation

HasValue TypeAnnotation (Maybe Text)

type Rep TypeAnnotation

type Docstring = Maybe Text

Docstrings are Javadoc-style comments attached various defined objects.

/**
 * Fetches an item.
 */
Item getItem()

Typeclasses

class HasAnnotations t where

Methods

annotations :: Lens t [TypeAnnotation]

Instances

HasAnnotations (Senum a)

HasAnnotations (Exception a)

HasAnnotations (Union a)

HasAnnotations (Struct a)

HasAnnotations (Enum a)

HasAnnotations (EnumDef a)

HasAnnotations (Typedef a)

HasAnnotations (Service a)

HasAnnotations (Function a)

HasAnnotations (Field a)

class HasDocstring t where

Methods

docstring :: Lens t Docstring

Instances

HasDocstring (Senum a)

HasDocstring (Exception a)

HasDocstring (Union a)

HasDocstring (Struct a)

HasDocstring (Enum a)

HasDocstring (EnumDef a)

HasDocstring (Typedef a)

HasDocstring (Const a)

HasDocstring (Service a)

HasDocstring (Function a)

HasDocstring (Field a)

class HasFields t where

Methods

fields :: Lens (t a) [Field a]

Instances

HasFields Exception

HasFields Union

HasFields Struct

class HasName t where

Methods

name :: Lens t Text

Instances

HasName TypeAnnotation

HasName (Namespace a)

HasName (Definition a)

HasName (Type a)

HasName (Senum a)

HasName (Exception a)

HasName (Union a)

HasName (Struct a)

HasName (Enum a)

HasName (EnumDef a)

HasName (Typedef a)

HasName (Const a)

HasName (Service a)

HasName (Function a)

HasName (Field a)

class HasSrcAnnot t where

Methods

srcAnnot :: Lens (t a) a

Instances

HasSrcAnnot Include

HasSrcAnnot Namespace

HasSrcAnnot Definition

HasSrcAnnot Type

HasSrcAnnot Senum

HasSrcAnnot Exception

HasSrcAnnot Union

HasSrcAnnot Struct

HasSrcAnnot Enum

HasSrcAnnot EnumDef

HasSrcAnnot Typedef

HasSrcAnnot Const

HasSrcAnnot Service

HasSrcAnnot Function

HasSrcAnnot Field

HasSrcAnnot TypeReference

HasSrcAnnot ConstValue

class HasValue s a | s -> a where

Methods

value :: Lens s a

Instances

HasValue TypeAnnotation (Maybe Text)

HasValue (EnumDef a) (Maybe Integer)

HasValue (Const a) (ConstValue a)

class HasValues s a | s -> a where

Methods

values :: Lens s a

Instances

HasValues (Senum a) [Text]

HasValues (Enum a) [EnumDef a]

class HasValueType t where

Methods

valueType :: Lens (t a) (TypeReference a)

Instances

HasValueType Const

HasValueType Field