diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,4 +1,7 @@
 # varying
+
+[![Build Status](https://travis-ci.org/schell/varying.svg)](https://travis-ci.org/schell/varying)
+
 This library provides automaton based varying values useful for both functional
 reactive programming (FRP) and locally stateful programming (LSP). It is 
 influenced by the [netwire](http://hackage.haskell.org/package/netwire) and 
diff --git a/src/Control/Varying/Core.hs b/src/Control/Varying/Core.hs
--- a/src/Control/Varying/Core.hs
+++ b/src/Control/Varying/Core.hs
@@ -109,7 +109,7 @@
 execVar v a = snd <$> (runVar v a)
 
 -- | Loop over a 'Var' that takes no input value.
-loopVar_ :: Monad m => Var m () a -> m ()
+loopVar_ :: (Functor m, Monad m) => Var m () a -> m ()
 loopVar_ v = execVar v () >>= loopVar_
 
 -- | Loop over a 'Var' that produces its own next input value.
@@ -219,7 +219,7 @@
 --
 -- >  fmap (*3) $ accumulate (+) 0
 -- Will sum input values and then multiply the sum by 3.
-instance Monad m => Functor (Var m b) where
+instance (Applicative m, Monad m) => Functor (Var m b) where
     fmap f' v = v ~> var f'
 
 -- | A very simple category instance.
@@ -234,14 +234,14 @@
 --
 -- It is preferable for consistency (and readability) to use 'plug left' ('<~')
 -- and 'plug right' ('~>') instead of ('.') where possible.
-instance Monad m => Category (Var m) where
+instance (Applicative m, Monad m) => Category (Var m) where
     id = var id
     f . g = g ~> f
 
 -- | 'Var's are applicative.
 --
 -- >  (,) <$> pure True <*> var "Applicative"
-instance Monad m => Applicative (Var m a) where
+instance (Applicative m, Monad m) => Applicative (Var m a) where
     pure = var . const
     vf <*> va = Var $ \a -> do (f, vf') <- runVar vf a
                                (b, va') <- runVar va a
@@ -258,7 +258,7 @@
 -- which is equivalent to
 --
 -- >  v = (\ex ey -> (+) <$> ex <*> ey) <$> intEventVar <*> anotherIntEventVar
-instance Monad m => Arrow (Var m) where
+instance (Applicative m, Monad m) => Arrow (Var m) where
     arr = var
     first v = Var $ \(b,d) -> do (c, v') <- runVar v b
                                  return $ ((c,d), first v')
@@ -267,7 +267,7 @@
 --
 -- >  let v = 1 ~> accumulate (+) 0
 -- which will sum the natural numbers.
-instance (Monad m, Num b) => Num (Var m a b) where
+instance (Applicative m, Monad m, Num b) => Num (Var m a b) where
     (+) = liftA2 (+)
     (-) = liftA2 (-)
     (*) = liftA2 (*)
@@ -279,7 +279,7 @@
 --
 -- >  let v = pi ~> accumulate (*) 0.0
 -- which will attempt (and succeed) to multiply pi by zero every step.
-instance (Monad m, Floating b) => Floating (Var m a b) where
+instance (Applicative m, Monad m, Floating b) => Floating (Var m a b) where
     pi = pure pi
     exp = fmap exp
     log = fmap log
@@ -291,7 +291,7 @@
 --
 -- >  let v = 2.5 ~> accumulate (+) 0
 -- which will add 2.5 each step.
-instance (Monad m, Fractional b) => Fractional (Var m a b) where
+instance (Applicative m, Monad m, Fractional b) => Fractional (Var m a b) where
     (/) = liftA2 (/)
     fromRational = pure . fromRational
 --------------------------------------------------------------------------------
diff --git a/src/Control/Varying/Event.hs b/src/Control/Varying/Event.hs
--- a/src/Control/Varying/Event.hs
+++ b/src/Control/Varying/Event.hs
@@ -11,9 +11,6 @@
 --
 --  You can use 'Event' just like you would 'Maybe'.
 --
-{-# LANGUAGE Arrows #-}
-{-# LANGUAGE TypeSynonymInstances #-}
-{-# LANGUAGE PartialTypeSignatures #-}
 module Control.Varying.Event (
     Event(..),
     -- * Transforming event values.
@@ -66,8 +63,8 @@
 import Prelude hiding (until)
 import Control.Varying.Core
 import Control.Applicative
-import Control.Arrow
 import Control.Monad
+import Data.Monoid
 --------------------------------------------------------------------------------
 -- Transforming event values into usable values.
 --------------------------------------------------------------------------------
@@ -88,7 +85,7 @@
 -- stream to produce a value. Once both streams have produced a value, combine
 -- the two using the given combine function and emit an event with the
 -- value.
-latchWith :: Monad m
+latchWith :: (Applicative m, Monad m)
           => (b -> c -> d) -> Var m a (Event b) -> Var m a (Event c)
           -> Var m a (Event d)
 latchWith f vb vc = latchWith' (NoEvent, vb) vc
@@ -102,7 +99,7 @@
 
 -- | Produces values from the first unless the second produces event
 -- values and if so, produces the values of those events.
-orE :: Monad m => Var m a b -> Var m a (Event b) -> Var m a b
+orE :: (Applicative m, Monad m) => Var m a b -> Var m a (Event b) -> Var m a b
 orE y ye = Var $ \a -> do
     (b, y')  <- runVar y a
     (e, ye') <- runVar ye a
@@ -111,11 +108,9 @@
         Event b' -> (b', orE y' ye')
 
 -- | Injects the values of the `vb` into the events of `ve`.
-tagOn :: Monad m => Var m a b -> Var m a (Event c) -> Var m a (Event b)
-tagOn vb ve = proc a -> do
-    b <- vb -< a
-    e <- ve -< a
-    returnA -< b <$ e
+tagOn :: (Applicative m, Monad m)
+      => Var m a b -> Var m a (Event c) -> Var m a (Event b)
+tagOn vb ve = (<$) <$> vb <*> ve
 
 -- | Injects a monadic computation into an event stream, using the event
 -- values of type `b` as a parameter to produce an event stream of type
@@ -123,7 +118,7 @@
 -- previous event is used in a clean up function.
 --
 -- This is like `tagM` but performs a cleanup function first.
---ringM :: Monad m
+--ringM :: (Applicative m, Monad m)
 --      => (c -> m ()) -> (b -> m c) -> Var m a (Event b) -> Var m a (Event c)
 --ringM cln = (go (const $ return ()) .) . tagM
 --    where go f ve = Var $ \a -> do (ec, ve') <- runVar ve a
@@ -134,7 +129,8 @@
 
 -- | Injects a monadic computation into the events of `vb`, providing a way
 -- to perform side-effects inside an `Event` inside a `Var`.
-tagM :: Monad m => (b -> m c) -> Var m a (Event b) -> Var m a (Event c)
+tagM :: (Applicative m, Monad m)
+     => (b -> m c) -> Var m a (Event b) -> Var m a (Event c)
 tagM f vb = Var $ \a -> do
     (eb, vb') <- runVar vb a
     case eb of
@@ -154,17 +150,17 @@
 use a v = (a <$) <$> v
 
 -- | Triggers an `Event ()` when the input value is True.
-onTrue :: Monad m => Var m Bool (Event ())
+onTrue :: (Applicative m, Monad m) => Var m Bool (Event ())
 onTrue = var $ \b -> if b then Event () else NoEvent
 
 -- | Triggers an `Event a` when the input is `Just a`.
-onJust :: Monad m => Var m (Maybe a) (Event a)
+onJust :: (Applicative m, Monad m) => Var m (Maybe a) (Event a)
 onJust = var $ \ma -> case ma of
                                Nothing -> NoEvent
                                Just a  -> Event a
 
 -- | Triggers an `Event a` when the input is a unique value.
-onUnique :: (Monad m, Eq a) => Var m a (Event a)
+onUnique :: (Applicative m, Monad m, Eq a) => Var m a (Event a)
 onUnique = Var $ \a -> return (Event a, trigger a)
     where trigger a' = Var $ \a'' -> let e = if a' == a''
                                              then NoEvent
@@ -176,14 +172,15 @@
 onWhen f = var $ \a -> if f a then Event a else NoEvent
 
 -- | Wraps all produced values of the given var with events.
-toEvent :: Monad m => Var m a b -> Var m a (Event b)
+toEvent :: (Applicative m, Monad m) => Var m a b -> Var m a (Event b)
 toEvent = (~> var Event)
 --------------------------------------------------------------------------------
 -- Using event values
 --------------------------------------------------------------------------------
 -- | Collect all produced values into a monoidal structure using the given
 -- insert function.
-collectWith :: (Monoid b, Monad m) => (a -> b -> b) -> Var m (Event a) b
+collectWith :: (Monoid b, Applicative m, Monad m)
+            => (a -> b -> b) -> Var m (Event a) b
 collectWith f = Var $ \a -> collect' mempty a
     where collect' b e = let b' = case e of
                                         NoEvent -> b
@@ -192,7 +189,7 @@
 
 -- | Collect all produced values into a list. The latest event value will
 -- be at the head of the list.
-collect :: Monad m => Var m (Event a) [a]
+collect :: (Applicative m, Monad m) => Var m (Event a) [a]
 collect = collectWith (:)
 
 -- | Produces the given value until the input events produce a value, then
@@ -203,7 +200,7 @@
 -- @
 -- This is similar to 'hold' except that it takes events from its input value
 -- instead of another 'Var'.
-startingWith, startWith :: Monad m => a -> Var m (Event a) a
+startingWith, startWith :: (Applicative m, Monad m) => a -> Var m (Event a) a
 startingWith = startWith
 startWith a = Var $ \e ->
     return $ case e of
@@ -211,13 +208,13 @@
                  Event a' -> (a', startWith a')
 
 -- | Flipped version of 'hold'.
-holdWith :: Monad m => b -> Var m a (Event b) -> Var m a b
+holdWith :: (Applicative m, Monad m) => b -> Var m a (Event b) -> Var m a b
 holdWith = flip hold
 
 -- | Produces the 'initial' value until the given 'Var' produces an event.
 -- After an event is produced that event's value will be produced until the
 -- next event produced by the given 'Var'.
-hold :: Monad m => Var m a (Event b) -> b -> Var m a b
+hold :: (Applicative m, Monad m) => Var m a (Event b) -> b -> Var m a b
 hold w initial = Var $ \x -> do
     (mb, w') <- runVar w x
     return $ case mb of
@@ -226,13 +223,15 @@
 
 -- | Produce events after the first until the second. After a successful
 -- cycle it will start over.
-between :: Monad m => Var m a (Event b) -> Var m a (Event c) -> Var m a (Event ())
+between :: (Applicative m, Monad m)
+        => Var m a (Event b) -> Var m a (Event c) -> Var m a (Event ())
 between vb vc = (never `before` vb) `andThenE` (toEvent vu `before` vc) `andThen` between vb vc
     where vu = pure ()
 
 -- | Produce events with the initial value only after the input stream has
 -- produced one event.
-after :: Monad m => Var m a b -> Var m a (Event c) -> Var m a (Event b)
+after :: (Applicative m, Monad m)
+      => Var m a b -> Var m a (Event c) -> Var m a (Event b)
 after vb ve = Var $ \a -> do
     (_, vb') <- runVar vb a
     (e, ve') <- runVar ve a
@@ -242,7 +241,7 @@
 
 -- | Like before, but use the value produced by the switching stream to
 -- create a stream to switch to.
-beforeWith :: Monad m
+beforeWith :: (Applicative m, Monad m)
            => Var m a b
            -> (Var m a (Event b), b -> Var m a (Event b))
            -> Var m a (Event b)
@@ -255,7 +254,7 @@
 
 -- | Like before, but sample the value of the second stream once before
 -- inhibiting.
-beforeOne :: Monad m => Var m a b -> Var m a (Event b) -> Var m a (Event b)
+beforeOne :: (Applicative m, Monad m) => Var m a b -> Var m a (Event b) -> Var m a (Event b)
 beforeOne vb ve = Var $ \a -> do
     (b, vb') <- runVar vb a
     (e, ve') <- runVar ve a
@@ -265,12 +264,12 @@
 
 -- | Produce events with the initial varying value only before the second stream
 -- has produced one event.
-before :: Monad m => Var m a b -> Var m a (Event c) -> Var m a (Event b)
+before :: (Applicative m, Monad m) => Var m a b -> Var m a (Event c) -> Var m a (Event b)
 before = until
 
 -- | Produce events with the initial varying value until the input event stream
 -- `ve` produces its first event, then never produce any events.
-until :: Monad m => Var m a b -> Var m a (Event c) -> Var m a (Event b)
+until :: (Applicative m, Monad m) => Var m a b -> Var m a (Event c) -> Var m a (Event b)
 until vb ve = Var $ \a -> do
     (b, vb') <- runVar vb a
     (e, ve') <- runVar ve a
@@ -279,11 +278,11 @@
         NoEvent -> return (Event b, vb' `until` ve')
 
 -- | Produce the given value once and then inhibit forever.
-once :: Monad m => b -> Var m a (Event b)
+once :: (Applicative m, Monad m) => b -> Var m a (Event b)
 once b = Var $ \_ -> return (Event b, never)
 
 -- | Stream through some number of successful events and then inhibit forever.
-takeE :: Monad m => Int -> Var m a (Event b) -> Var m a (Event b)
+takeE :: (Applicative m, Monad m) => Int -> Var m a (Event b) -> Var m a (Event b)
 takeE n ve = Var $ \a -> do
     (eb, ve') <- runVar ve a
     case eb of
@@ -291,29 +290,29 @@
         Event b -> return (Event b, takeE (n-1) ve')
 
 -- | Inhibit all events that don't pass the predicate.
-filterE :: Monad m => (b -> Bool) -> Var m a (Event b) -> Var m a (Event b)
+filterE :: (Applicative m, Monad m) => (b -> Bool) -> Var m a (Event b) -> Var m a (Event b)
 filterE p v = v ~> var check
     where check (Event b) = if p b then Event b else NoEvent
           check _ = NoEvent
 
 -- | Never produces any event values.
-never :: Monad m => Var m b (Event c)
+never :: (Applicative m, Monad m) => Var m b (Event c)
 never = pure NoEvent
 
 -- | Produces events with the initial value forever.
-always :: Monad m => b -> Var m a (Event b)
+always :: (Applicative m, Monad m) => b -> Var m a (Event b)
 always = pure . Event
 --------------------------------------------------------------------------------
 -- Switching on events
 --------------------------------------------------------------------------------
 -- | Produces the first 'Var's Event values until that stops producing, then
 -- switches to the second 'Var'.
-andThen :: Monad m => Var m a (Event b) -> Var m a b -> Var m a b
+andThen :: (Applicative m, Monad m) => Var m a (Event b) -> Var m a b -> Var m a b
 andThen w1 w2 = w1 `andThenWith` const w2
 
 -- | Switches from one event stream to another once the first stops
 -- producing.
-andThenE :: Monad m
+andThenE :: (Applicative m, Monad m)
          => Var m a (Event b) -> Var m a (Event b) -> Var m a (Event b)
 andThenE y1 y2 = Var $ \a -> do
     (e, y1') <- runVar y1 a
@@ -324,7 +323,7 @@
 -- | Switches from one event stream when that stream stops producing. A new
 -- stream is created using the last produced value (or `Nothing`) and used
 -- as the second stream.
-andThenWith :: Monad m
+andThenWith :: (Applicative m, Monad m)
             => Var m a (Event b) -> (Maybe b -> Var m a b) -> Var m a b
 andThenWith = go Nothing
     where go mb w1 f = Var $ \a -> do
@@ -335,7 +334,8 @@
 
 -- | Switches using a mode signal. Signals maintain state for the duration
 -- of the mode.
-switchByMode :: (Monad m, Eq b) => Var m a b -> (b -> Var m a c) -> Var m a c
+switchByMode :: (Applicative m, Monad m, Eq b)
+             => Var m a b -> (b -> Var m a c) -> Var m a c
 switchByMode switch f = Var $ \a -> do
     (b, _) <- runVar switch a
     (_, v) <- runVar (f b) a
@@ -351,7 +351,7 @@
 -- | Produce events of a varying value 'v' only when its input value passes a
 -- predicate 'f'.
 -- 'v' maintains state while cold.
-onlyWhen :: Monad m
+onlyWhen :: (Applicative m, Monad m)
          => Var m a b -- ^ 'v' - The varying value
          -> (a -> Bool) -- ^ 'f' - The predicate to run on 'v''s input values.
          -> Var m a (Event b)
@@ -361,7 +361,7 @@
 -- | Produce events of a varying value 'v' only when an event stream 'h'
 -- produces an event.
 -- 'v' and 'h' maintain state while cold.
-onlyWhenE :: Monad m
+onlyWhenE :: (Applicative m, Monad m)
           => Var m a b -- ^ 'v' - The varying value
           -> Var m a (Event c) -- ^ 'h' - The event stream
           -> Var m a (Event b)
@@ -376,14 +376,14 @@
 --------------------------------------------------------------------------------
 -- | Combine two events streams into one event stream. Like `combine` but
 -- uses a combining function instead of (,).
-combineWith :: Monad m
+combineWith :: (Applicative m, Monad m)
             => (b -> c -> d) -> Var m a (Event b) -> Var m a (Event c)
             -> Var m a (Event d)
 combineWith f vb vc = (uncurry f <$>) <$> (combine vb vc)
 
 -- | Combine two event streams into an event stream of tuples. A tuple is
 -- only produced when both event streams produce a value.
-combine :: Monad m
+combine :: (Applicative m, Monad m)
         => Var m a (Event b) -> Var m a (Event c) -> Var m a (Event (b,c))
 combine vb vc = (\eb ec -> (,) <$> eb <*> ec) <$> vb <*> vc
 --------------------------------------------------------------------------------
diff --git a/src/Control/Varying/Time.hs b/src/Control/Varying/Time.hs
--- a/src/Control/Varying/Time.hs
+++ b/src/Control/Varying/Time.hs
@@ -2,12 +2,12 @@
 --   Copyright:  (c) 2015 Schell Scivally
 --   License:    MIT
 --   Maintainer: Schell Scivally <schell.scivally@synapsegroup.com>
-{-# LANGUAGE Arrows #-}
 {-# LANGUAGE TupleSections #-}
 module Control.Varying.Time where
 
 import Control.Varying.Core
 import Control.Varying.Event hiding (after, before)
+import Control.Applicative
 import Data.Time.Clock
 
 -- | Produces "time" deltas using 'getCurrentTime' and 'diffUTCTime'.
@@ -16,7 +16,8 @@
 
 -- | Produces "time" deltas using a monadic computation and a difference
 -- function.
-delta :: (Num t, Fractional t, Monad m) => m a -> (a -> a -> t) -> Var m b t
+delta :: (Num t, Fractional t, Applicative m, Monad m)
+      => m a -> (a -> a -> t) -> Var m b t
 delta m f = Var $ \_ -> do
     t <- m
     return (0, delta' t)
@@ -30,7 +31,7 @@
 -- | Emits events before accumulating t of input dt.
 -- Note that as soon as we have accumulated >= t we stop emitting events
 -- and there is no guarantee that an event will be emitted at time == t.
-before :: (Monad m, Num t, Ord t) => t -> Var m t (Event ())
+before :: (Applicative m, Monad m, Num t, Ord t) => t -> Var m t (Event ())
 before t = Var $ \dt -> do
     if t - dt >= 0
     then return (Event (), before $ t - dt)
@@ -39,7 +40,7 @@
 -- | Emits events after t input has been accumulated.
 -- Note that event emission is not guaranteed to begin exactly at t,
 -- only at some small delta after t.
-after :: (Monad m, Num t, Ord t) => t -> Var m t (Event ())
+after :: (Applicative m, Monad m, Num t, Ord t) => t -> Var m t (Event ())
 after t = Var $ \dt -> do
     if t - dt <= 0
     then return (Event (), pure $ Event ())
diff --git a/src/Control/Varying/Tween.hs b/src/Control/Varying/Tween.hs
--- a/src/Control/Varying/Tween.hs
+++ b/src/Control/Varying/Tween.hs
@@ -15,16 +15,15 @@
 --   dreams).
 
 --
-{-# LANGUAGE PartialTypeSignatures #-}
 {-# LANGUAGE Arrows #-}
 {-# LANGUAGE Rank2Types #-}
 module Control.Varying.Tween (
     -- * Creating tweens
     -- $creation
     tween,
+    constant,
     -- * Interpolation functions
     -- $lerping
-    constant,
     linear,
     easeInCirc,
     easeOutCirc,
@@ -55,6 +54,7 @@
 import Control.Varying.Event hiding (after, before)
 import Control.Varying.Time
 import Control.Arrow
+import Control.Applicative
 
 --------------------------------------------------------------------------------
 -- $lerping
@@ -152,11 +152,6 @@
 linear :: Num t => Easing t
 linear c t b = c * t + b
 
--- | Ease none.
--- This performs no interpolation over the duration, it just samples at a
--- constant value until the duration is up.
-constant :: (Monad m, Num t, Ord t) => a -> t -> Var m t (Event a)
-constant value duration = use value $ before duration
 --------------------------------------------------------------------------------
 -- $creation
 --
@@ -188,7 +183,7 @@
 -- Keep in mind `tween` must be fed time deltas, not absolute time or
 -- duration. This is mentioned because the author has made that mistake
 -- more than once ;)
-tween :: (Monad m, Fractional t, Ord t)
+tween :: (Applicative m, Monad m, Fractional t, Ord t)
       => Easing t -> t -> t -> t -> Var m t (Event t)
 tween f start end dur = proc dt -> do
     -- Current time as percentage / amount of interpolation (0.0 - 1.0)
@@ -202,8 +197,14 @@
     -- Tag the event with the value.
     returnA -< x <$ e
 
+-- Creates a tween that performs no interpolation over the duration.
+constant :: (Applicative m, Monad m, Num t, Ord t)
+         => a -> t -> Var m t (Event a)
+constant value duration = use value $ before duration
+
 -- | Varies 0.0 to 1.0 linearly for duration `t` and 1.0 after `t`.
-timeAsPercentageOf :: (Monad m, Ord t, Num t, Fractional t) => t -> Var m t t
+timeAsPercentageOf :: (Applicative m, Monad m, Ord t, Num t, Fractional t)
+                   => t -> Var m t t
 timeAsPercentageOf t = proc dt -> do
     t' <- accumulate (+) 0 -< dt
     returnA -< min 1 (t' / t)
diff --git a/src/Example.hs b/src/Example.hs
--- a/src/Example.hs
+++ b/src/Example.hs
@@ -2,6 +2,7 @@
 
 import Control.Varying
 import Control.Varying.Time as Time -- time is not auto-exported
+import Control.Applicative
 import Text.Printf
 
 -- | A simple 2d point type.
@@ -22,7 +23,7 @@
         <~ time
 
 -- An exponential tween back and forth from 0 to 100 over 2 seconds.
-tweenx :: Monad m => Var m Float Float
+tweenx :: (Applicative m, Monad m) => Var m Float Float
 tweenx =
     -- Tweens only happen for a certain duration and so their sample
     -- values have the type (Ord t, Fractional t => Event t). After construction
@@ -48,7 +49,7 @@
                  `andThen` tweenx
 
 -- A quadratic tween back and forth from 0 to 100 over 2 seconds.
-tweeny :: Monad m => Var m Float Float
+tweeny :: (Applicative m, Monad m) => Var m Float Float
 tweeny =
     tween easeOutQuad 0 100 1 `andThenE` tween easeOutQuad 100 0 1 `andThen` tweeny
 
diff --git a/varying.cabal b/varying.cabal
--- a/varying.cabal
+++ b/varying.cabal
@@ -10,7 +10,7 @@
 -- PVP summary:      +-+------- breaking API changes
 --                   | | +----- non-breaking API additions
 --                   | | | +--- code changes with no API change
-version:             0.1.1.1
+version:             0.1.1.2
 
 -- A short (one-line) description of the package.
 synopsis:            Automaton based varying values, event streams and tweening.
@@ -74,7 +74,7 @@
   -- other-extensions:
 
   -- Other library packages from which modules are imported.
-  build-depends:       base >=4.8 && <4.9,
+  build-depends:       base >=4.7 && <4.9,
                        time >=1.5 && <1.6
 
   -- Directories containing source files.
@@ -87,7 +87,7 @@
   ghc-options:         -Wall
 
   -- Other library packages from which modules are imported.
-  build-depends:       base >=4.8 && <4.9,
+  build-depends:       base >=4.7 && <4.9,
                        time >=1.5 && <1.6