Thrift: Thrift library package

[ foreign, library ] [ Propose Tags ]

The Thrift Haskell package that shipped with Thrift v.0.5.0, released under the Apache 2.0 license.

[Skip to Readme]
Versions [faq] 0.1.0, 0.1.1,, 0.4.0, 0.5.0,,, 0.6.0,
Dependencies base (==4.*), binary, bytestring, ghc-prim, HTTP, network [details]
License LicenseRef-OtherLicense
Category Foreign
Home page
Uploaded by KirkPeterson at Sat Feb 5 18:58:12 UTC 2011
Distributions NixOS:
Downloads 5576 total (155 in the last 30 days)
Rating (no votes yet) [estimated by rule of succession]
Your Rating
  • λ
  • λ
  • λ
Status Hackage Matrix CI
Docs uploaded by user
Build status unknown [no reports yet]




Maintainer's Corner

For package maintainers and hackage trustees

Readme for Thrift-0.5.0

[back to package description]
Haskell Thrift Bindings


Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
KIND, either express or implied. See the License for the
specific language governing permissions and limitations
under the License.


Use Cabal to compile and install; ./configure uses Cabal underneath, and that
path is not yet well tested. Thrift's library and generated code should compile
with pretty much any GHC extensions or warnings you enable (or disable).
Please report this not being the case as a bug on!default.jspa

Chances you'll need to muck a bit with Cabal flags to install Thrift:

CABAL_CONFIGURE_FLAGS="--user" ./configure

Base Types

The mapping from Thrift types to Haskell's is:

 * double -> Double
 * i8 -> Data.Word.Word8
 * i16 -> Data.Int.Int16
 * i32 -> Data.Int.Int32
 * i64 -> Data.Int.Int64
 * string -> String
 * binary -> Data.ByteString.Lazy
 * bool -> Boolean


Become Haskell 'data' types. Use fromEnum to get out the int value.


Become records. Field labels are ugly, of the form f_STRUCTNAME_FIELDNAME. All
fields are Maybe types.


Identical to structs. Throw them with throwDyn. Catch them with catchDyn.


Just a bunch of functions. You may have to import a bunch of client files to
deal with inheritance.


You should only have to import the last one in the chain of inheritors. To make
an interface, declare a label:

  data MyIface = MyIface

and then declare it an instance of each iface class, starting with the superest
class and proceding down (all the while defining the methods).  Then pass your
label to process as the handler.


Just a function that takes a handler label, protocols. It calls the
superclasses process if there is a superclass.