diff --git a/Control/Arrow/Internals.hs b/Control/Arrow/Internals.hs
--- a/Control/Arrow/Internals.hs
+++ b/Control/Arrow/Internals.hs
@@ -1,5 +1,3 @@
-{-# OPTIONS_GHC -fglasgow-exts #-}
-
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Arrow.Internals
diff --git a/Control/Arrow/Operations.hs b/Control/Arrow/Operations.hs
--- a/Control/Arrow/Operations.hs
+++ b/Control/Arrow/Operations.hs
@@ -1,5 +1,3 @@
-{-# OPTIONS_GHC -fglasgow-exts #-}
-
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Arrow.Operations
@@ -33,7 +31,6 @@
 	) where
 
 import Control.Arrow
-import Control.Category ((>>>))
 import Data.Monoid
 
 -- $conventions
diff --git a/Control/Arrow/Transformer.hs b/Control/Arrow/Transformer.hs
--- a/Control/Arrow/Transformer.hs
+++ b/Control/Arrow/Transformer.hs
@@ -1,5 +1,3 @@
-{-# OPTIONS_GHC -fglasgow-exts #-}
-
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Arrow.Transformer
@@ -8,7 +6,7 @@
 --
 -- Maintainer  :  ross@soi.city.ac.uk
 -- Stability   :  experimental
--- Portability :  non-portable (multi-parameter type classes)
+-- Portability :  portable
 --
 -- Arrow transformers, for making new arrow types out of old ones.
 
diff --git a/Control/Arrow/Transformer/Automaton.hs b/Control/Arrow/Transformer/Automaton.hs
--- a/Control/Arrow/Transformer/Automaton.hs
+++ b/Control/Arrow/Transformer/Automaton.hs
@@ -1,4 +1,4 @@
-{-# OPTIONS_GHC -fglasgow-exts #-}
+{-# LANGUAGE FlexibleInstances #-}
 
 -----------------------------------------------------------------------------
 -- |
diff --git a/Control/Arrow/Transformer/CoState.hs b/Control/Arrow/Transformer/CoState.hs
--- a/Control/Arrow/Transformer/CoState.hs
+++ b/Control/Arrow/Transformer/CoState.hs
@@ -1,5 +1,3 @@
-{-# OPTIONS_GHC -fglasgow-exts #-}
-
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Arrow.Transformer.CoState
@@ -15,11 +13,9 @@
 -- /TODO:/ define operations for this arrow.
 
 module Control.Arrow.Transformer.CoState(
-		CoStateArrow,
+		CoStateArrow(CoStateArrow),
 	) where
 
-import Control.Arrow.Operations
-
 import Control.Applicative
 import Control.Arrow
 import Control.Category
@@ -27,15 +23,16 @@
 
 import Prelude hiding (id,(.))
 
-newtype CoStateArrow s a b c = CST (a (s -> b) (s -> c))
+newtype CoStateArrow s a b c = CoStateArrow (a (s -> b) (s -> c))
 
 instance Category a => Category (CoStateArrow s a) where
-	id = CST id
-	CST f . CST g = CST (f . g)
+	id = CoStateArrow id
+	CoStateArrow f . CoStateArrow g = CoStateArrow (f . g)
 
 instance Arrow a => Arrow (CoStateArrow s a) where
-	arr f = CST (arr (f .))
-	first (CST f) = CST (arr unzipMap >>> first f >>> arr zipMap)
+	arr f = CoStateArrow (arr (f .))
+	first (CoStateArrow f) =
+		CoStateArrow (arr unzipMap >>> first f >>> arr zipMap)
 
 zipMap :: (s -> a, s -> b) -> (s -> (a,b))
 zipMap h s = (fst h s, snd h s)
@@ -48,13 +45,14 @@
 -- promotions of standard classes
 
 instance ArrowLoop a => ArrowLoop (CoStateArrow s a) where
-	loop (CST f) = CST (loop (arr zipMap >>> f >>> arr unzipMap))
+	loop (CoStateArrow f) =
+		CoStateArrow (loop (arr zipMap >>> f >>> arr unzipMap))
 
 instance ArrowZero a => ArrowZero (CoStateArrow s a) where
-	zeroArrow = CST zeroArrow
+	zeroArrow = CoStateArrow zeroArrow
 
 instance ArrowPlus a => ArrowPlus (CoStateArrow s a) where
-	CST f <+> CST g = CST (f <+> g)
+	CoStateArrow f <+> CoStateArrow g = CoStateArrow (f <+> g)
 
 -- Other instances
 
diff --git a/Control/Arrow/Transformer/Error.hs b/Control/Arrow/Transformer/Error.hs
--- a/Control/Arrow/Transformer/Error.hs
+++ b/Control/Arrow/Transformer/Error.hs
@@ -1,4 +1,4 @@
-{-# OPTIONS_GHC -fglasgow-exts #-}
+{-# LANGUAGE FlexibleInstances #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -15,7 +15,7 @@
 -- /TODO:/ the operations here are inconsistent with other arrow transformers.
 
 module Control.Arrow.Transformer.Error(
-		ErrorArrow,
+		ErrorArrow(ErrorArrow),
 		runError,
 		ArrowAddError(..),
 	) where
diff --git a/Control/Arrow/Transformer/Reader.hs b/Control/Arrow/Transformer/Reader.hs
--- a/Control/Arrow/Transformer/Reader.hs
+++ b/Control/Arrow/Transformer/Reader.hs
@@ -1,4 +1,4 @@
-{-# OPTIONS_GHC -fglasgow-exts #-}
+{-# LANGUAGE FlexibleInstances #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -13,7 +13,7 @@
 -- Arrow transformer that adds a read-only state (i.e. an environment).
 
 module Control.Arrow.Transformer.Reader(
-		ReaderArrow,
+		ReaderArrow(ReaderArrow),
 		runReader,
 		ArrowAddReader(..),
 	) where
diff --git a/Control/Arrow/Transformer/State.hs b/Control/Arrow/Transformer/State.hs
--- a/Control/Arrow/Transformer/State.hs
+++ b/Control/Arrow/Transformer/State.hs
@@ -1,4 +1,4 @@
-{-# OPTIONS_GHC -fglasgow-exts #-}
+{-# LANGUAGE FlexibleInstances #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -15,7 +15,7 @@
 -- /Science of Computer Programming/ 37:67-111, May 2000.
 
 module Control.Arrow.Transformer.State(
-		StateArrow,
+		StateArrow(StateArrow),
 		runState,
 		ArrowAddState(..),
 	) where
@@ -34,21 +34,22 @@
 -- | An arrow type that augments an existing arrow with a modifiable
 -- state.  The 'ArrowState' class contains the operations on this state.
 
-newtype StateArrow s a b c = ST (a (b, s) (c, s))
+newtype StateArrow s a b c = StateArrow (a (b, s) (c, s))
 
 swapsnd :: ((a, b), c) -> ((a, c), b)
 swapsnd ~(~(x, y), z) = ((x, z), y)
 
 instance Category a => Category (StateArrow s a) where
-	id = ST id
-	ST f . ST g = ST (f . g)
+	id = StateArrow id
+	StateArrow f . StateArrow g = StateArrow (f . g)
 
 instance Arrow a => Arrow (StateArrow s a) where
-	arr f = ST (arr (\(x, s) -> (f x, s)))
-	first (ST f) = ST (arr swapsnd >>> first f >>> arr swapsnd)
+	arr f = StateArrow (arr (\(x, s) -> (f x, s)))
+	first (StateArrow f) =
+		StateArrow (arr swapsnd >>> first f >>> arr swapsnd)
 
 instance Arrow a => ArrowTransformer (StateArrow s) a where
-	lift f = ST (first f)
+	lift f = StateArrow (first f)
 
 -- | Encapsulation of a state-using computation, exposing the initial
 -- and final states.
@@ -60,13 +61,13 @@
 -- >		(result, final_state) <- (|runState cmd|) init_state
 
 runState :: Arrow a => StateArrow s a e b -> a (e,s) (b,s)
-runState (ST f) = f
+runState (StateArrow f) = f
 
 -- operations
 
 instance Arrow a => ArrowState s (StateArrow s a) where
-	fetch = ST (arr (\(_, s) -> (s, s)))
-	store = ST (arr (\(s, _) -> ((), s)))
+	fetch = StateArrow (arr (\(_, s) -> (s, s)))
+	store = StateArrow (arr (\(s, _) -> ((), s)))
 
 instance Arrow a => ArrowAddState s (StateArrow s a) a where
 	liftState = lift
@@ -75,18 +76,19 @@
 -- The following promotions follow directly from the arrow transformer.
 
 instance ArrowZero a => ArrowZero (StateArrow s a) where
-	zeroArrow = ST zeroArrow
+	zeroArrow = StateArrow zeroArrow
 
 instance ArrowCircuit a => ArrowCircuit (StateArrow s a) where
 	delay x = lift (delay x)
 
 instance ArrowError ex a => ArrowError ex (StateArrow s a) where
 	raise = lift raise
-	handle (ST f) (ST h) = ST (handle f (arr swapsnd >>> h))
-	tryInUnless (ST f) (ST s) (ST h) =
-		ST (tryInUnless f (arr new_state >>> s) (arr swapsnd >>> h))
+	handle (StateArrow f) (StateArrow h) =
+		StateArrow (handle f (arr swapsnd >>> h))
+	tryInUnless (StateArrow f) (StateArrow s) (StateArrow h) =
+		StateArrow (tryInUnless f (arr new_state >>> s) (arr swapsnd >>> h))
 		where	new_state ((b,_),(c,s')) = ((b,c),s')
-	newError (ST f) = ST (newError f &&& arr snd >>> arr h)
+	newError (StateArrow f) = StateArrow (newError f &&& arr snd >>> arr h)
 		where	h (Left ex, s) = (Left ex, s)
 			h (Right (c, s'), _) = (Right c, s')
 
@@ -94,29 +96,30 @@
 
 instance ArrowReader r a => ArrowReader r (StateArrow s a) where
 	readState = lift readState
-	newReader (ST f) = ST (arr swapsnd >>> newReader f)
+	newReader (StateArrow f) = StateArrow (arr swapsnd >>> newReader f)
 
 instance ArrowWriter w a => ArrowWriter w (StateArrow s a) where
 	write = lift write
-	newWriter (ST f) = ST (newWriter f >>> arr swapsnd)
+	newWriter (StateArrow f) = StateArrow (newWriter f >>> arr swapsnd)
 
 -- liftings of standard classes
 
 instance ArrowChoice a => ArrowChoice (StateArrow s a) where
-	left (ST f) = ST (arr distr >>> left f >>> arr undistr)
+	left (StateArrow f) = StateArrow (arr distr >>> left f >>> arr undistr)
 		where	distr (Left y, s) = Left (y, s)
 			distr (Right z, s) = Right (z, s)
 			undistr (Left (y, s)) = (Left y, s)
 			undistr (Right (z, s)) = (Right z, s)
 
 instance ArrowApply a => ArrowApply (StateArrow s a) where
-	app = ST (arr (\((ST f, x), s) -> (f, (x, s))) >>> app)
+	app = StateArrow (arr (\((StateArrow f, x), s) -> (f, (x, s))) >>> app)
 
 instance ArrowLoop a => ArrowLoop (StateArrow s a) where
-	loop (ST f) = ST (loop (arr swapsnd >>> f >>> arr swapsnd))
+	loop (StateArrow f) =
+		StateArrow (loop (arr swapsnd >>> f >>> arr swapsnd))
 
 instance ArrowPlus a => ArrowPlus (StateArrow s a) where
-	ST f <+> ST g = ST (f <+> g)
+	StateArrow f <+> StateArrow g = StateArrow (f <+> g)
 
 -- Other instances
 
@@ -139,15 +142,16 @@
 
 instance ArrowAddReader r a a' =>
 		ArrowAddReader r (StateArrow s a) (StateArrow s a') where
-	liftReader (ST f) = ST (liftReader f)
-	elimReader (ST f) = ST (arr swapsnd >>> elimReader f)
+	liftReader (StateArrow f) = StateArrow (liftReader f)
+	elimReader (StateArrow f) = StateArrow (arr swapsnd >>> elimReader f)
 
 instance ArrowAddWriter w a a' =>
 		ArrowAddWriter w (StateArrow s a) (StateArrow s a') where
-	liftWriter (ST f) = ST (liftWriter f)
-	elimWriter (ST f) = ST (elimWriter f >>> arr swapsnd)
+	liftWriter (StateArrow f) = StateArrow (liftWriter f)
+	elimWriter (StateArrow f) = StateArrow (elimWriter f >>> arr swapsnd)
 
 instance ArrowAddError ex a a' =>
 		ArrowAddError ex (StateArrow s a) (StateArrow s a') where
-	liftError (ST f) = ST (liftError f)
-	elimError (ST f) (ST h) = ST (elimError f (arr swapsnd >>> h))
+	liftError (StateArrow f) = StateArrow (liftError f)
+	elimError (StateArrow f) (StateArrow h) =
+		StateArrow (elimError f (arr swapsnd >>> h))
diff --git a/Control/Arrow/Transformer/Static.hs b/Control/Arrow/Transformer/Static.hs
--- a/Control/Arrow/Transformer/Static.hs
+++ b/Control/Arrow/Transformer/Static.hs
@@ -1,4 +1,4 @@
-{-# OPTIONS_GHC -fglasgow-exts #-}
+{-# LANGUAGE FlexibleInstances #-}
 
 -----------------------------------------------------------------------------
 -- |
diff --git a/Control/Arrow/Transformer/Stream.hs b/Control/Arrow/Transformer/Stream.hs
--- a/Control/Arrow/Transformer/Stream.hs
+++ b/Control/Arrow/Transformer/Stream.hs
@@ -1,4 +1,4 @@
-{-# OPTIONS_GHC -fglasgow-exts #-}
+{-# LANGUAGE FlexibleInstances, Rank2Types #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -13,7 +13,7 @@
 -- Arrow transformer lifting an arrow to streams.
 
 module Control.Arrow.Transformer.Stream(
-		StreamArrow,
+		StreamArrow(StreamArrow),
 		runStream,
 		StreamMap,
 		StreamMapST, runStreamST,
@@ -38,16 +38,16 @@
 --
 -- /Note/: 'lift' is only a functor if '***' in the underlying arrow is.
 
-newtype StreamArrow a b c = Str (a (Stream b) (Stream c))
+newtype StreamArrow a b c = StreamArrow (a (Stream b) (Stream c))
 
 instance Category a => Category (StreamArrow a) where
-	id = Str id
-	Str f . Str g = Str (f . g)
+	id = StreamArrow id
+	StreamArrow f . StreamArrow g = StreamArrow (f . g)
 
 instance Arrow a => Arrow (StreamArrow a) where
-	arr f = Str (arr (fmap f))
-	first (Str f) =
-		Str (arr Stream.unzip >>> first f >>> arr (uncurry Stream.zip))
+	arr f = StreamArrow (arr (fmap f))
+	first (StreamArrow f) =
+		StreamArrow (arr Stream.unzip >>> first f >>> arr (uncurry Stream.zip))
 
 genmap :: Arrow a => a b c -> a (Stream b) (Stream c)
 genmap f = arr (\xs -> (Stream.head xs, Stream.tail xs)) >>>
@@ -59,7 +59,7 @@
 -- but won't preserve composition unless *** does.
 
 instance Arrow a => ArrowTransformer (StreamArrow) a where
-	lift f = Str (genmap f)
+	lift f = StreamArrow (genmap f)
 
 -- The following promotions follow directly from the arrow transformer.
 
@@ -72,27 +72,28 @@
 
 instance ArrowWriter w a => ArrowWriter w (StreamArrow a) where
 	write = lift write
-	newWriter (Str f) = Str (newWriter f >>> arr strength)
-		where	strength :: Functor w' => (w' a',b) -> w' (a',b)
-			strength (v, y) = fmap (\x -> (x, y)) v
+	newWriter (StreamArrow f) = StreamArrow (newWriter f >>> arr strength)
+	  where	strength :: Functor w' => (w' a',b) -> w' (a',b)
+		strength (v, y) = fmap (\x -> (x, y)) v
 
 -- liftings of standard classes
 
 instance Arrow a => ArrowChoice (StreamArrow a) where
-	left (Str f) = Str ((arr getLeft >>> f) &&& arr id >>> arr replace)
-		where	getLeft (Cons (Left x) xs) = Cons x (getLeft xs)
-			getLeft (Cons (Right _) xs) = getLeft xs
-			replace (~(Cons x xs), Cons (Left _) ys) =
-				Cons (Left x) (replace (xs, ys))
-			replace (xs, Cons (Right y) ys) =
-				Cons (Right y) (replace (xs, ys))
+	left (StreamArrow f) =
+		StreamArrow ((arr getLeft >>> f) &&& arr id >>> arr replace)
+	  where	getLeft (Cons (Left x) xs) = Cons x (getLeft xs)
+		getLeft (Cons (Right _) xs) = getLeft xs
+		replace (~(Cons x xs), Cons (Left _) ys) =
+			Cons (Left x) (replace (xs, ys))
+		replace (xs, Cons (Right y) ys) =
+			Cons (Right y) (replace (xs, ys))
 
 instance ArrowLoop a => ArrowLoop (StreamArrow a) where
-	loop (Str f) =
-		Str (loop (arr (uncurry Stream.zip) >>> f >>> arr Stream.unzip))
+	loop (StreamArrow f) =
+		StreamArrow (loop (arr (uncurry Stream.zip) >>> f >>> arr Stream.unzip))
 
 instance ArrowPlus a => ArrowPlus (StreamArrow a) where
-	Str f <+> Str g = Str (f <+> g)
+	StreamArrow f <+> StreamArrow g = StreamArrow (f <+> g)
 
 -- I don't know of any other useful promotions.
 -- (elimWriter can be promoted, but doesn't seem useful.)
@@ -100,7 +101,7 @@
 -- Circuits
 
 instance ArrowLoop a => ArrowCircuit (StreamArrow a) where
-	delay x = Str (arr (Cons x))
+	delay x = StreamArrow (arr (Cons x))
 
 -- Other instances
 
@@ -132,7 +133,7 @@
 -- elements of that stream.  @ys@ is bound to the output stream.
 
 runStream :: ArrowLoop a => StreamArrow a (e,b) c -> a (e,Stream b) (Stream c)
-runStream (Str f) = arr (\(e, xs) -> fmap (\x -> (e, x)) xs) >>> f
+runStream (StreamArrow f) = arr (\(e, xs) -> fmap (\x -> (e, x)) xs) >>> f
 
 instance ArrowLoop a => ArrowAddStream (StreamArrow a) a where
 	liftStream = lift
@@ -156,4 +157,5 @@
 -- | Encapsulate a local state.
 
 runStreamST :: (forall s. StreamMapST s e c) -> StreamMap e c
-runStreamST cf = Str $ \ input -> runST (let Str (Kleisli f) = cf in f input)
+runStreamST cf = StreamArrow $ \ input ->
+	runST (let StreamArrow (Kleisli f) = cf in f input)
diff --git a/Control/Arrow/Transformer/Writer.hs b/Control/Arrow/Transformer/Writer.hs
--- a/Control/Arrow/Transformer/Writer.hs
+++ b/Control/Arrow/Transformer/Writer.hs
@@ -1,4 +1,4 @@
-{-# OPTIONS_GHC -fglasgow-exts #-}
+{-# LANGUAGE FlexibleInstances #-}
 
 -----------------------------------------------------------------------------
 -- |
@@ -13,7 +13,7 @@
 -- Arrow transformer that adds accumulation of output.
 
 module Control.Arrow.Transformer.Writer(
-		WriterArrow,
+		WriterArrow(WriterArrow),
 		runWriter,
 		ArrowAddWriter(..),
 	) where
diff --git a/arrows.cabal b/arrows.cabal
--- a/arrows.cabal
+++ b/arrows.cabal
@@ -1,5 +1,5 @@
 Name:           arrows
-Version:        0.4.2.0
+Version:        0.4.3.0
 Build-Depends:  base >= 4.0 && < 6, Stream
 Build-Type:     Simple
 License:        BSD3