diff --git a/lib/hs/Setup.lhs b/lib/hs/Setup.lhs
index c9e6d97..d52ae94 100644
--- a/lib/hs/Setup.lhs
+++ b/lib/hs/Setup.lhs
@@ -1,23 +1,21 @@
 #!/usr/bin/env runhaskell
 
-#
-# 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
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied. See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#
+> -- 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
+> -- 
+> --   http://www.apache.org/licenses/LICENSE-2.0
+> -- 
+> -- Unless required by applicable law or agreed to in writing,
+> -- software distributed under the License is distributed on an
+> -- "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+> -- KIND, either express or implied. See the License for the
+> -- specific language governing permissions and limitations
+> -- under the License.
 
 > import Distribution.Simple
 > main = defaultMain
diff --git a/lib/hs/Thrift.cabal b/lib/hs/Thrift.cabal
index feb2e81..37778d7 100644
--- a/lib/hs/Thrift.cabal
+++ b/lib/hs/Thrift.cabal
@@ -18,7 +18,7 @@
 --
 
 Name:           Thrift
-Version:        0.1.1
+Version:        0.2.0
 Cabal-Version:  >= 1.2
 License:        Apache2
 Category:       Foreign
@@ -30,10 +30,11 @@
     src
   Build-Depends:
     base >=4, network, ghc-prim, binary, bytestring, HTTP
-  ghc-options:
-    -fglasgow-exts
-  Extensions:
-    DeriveDataTypeable
   Exposed-Modules:
     Thrift, Thrift.Protocol, Thrift.Transport, Thrift.Protocol.Binary
-    Thrift.Transport.Handle, Thrift.Transport.HttpClient,  Thrift.Server
+    Thrift.Transport.Handle, Thrift.Transport.HttpClient, Thrift.Server
+  Extensions:
+    DeriveDataTypeable, ExistentialQuantification, FlexibleInstances,
+    KindSignatures, MagicHash, RankNTypes,
+    ScopedTypeVariables, TypeSynonymInstances
+
