diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,29 +1,39 @@
 streaming
 =========
 
-The freely-extended stream on a streamable functor
----------------------------------------------------
 
+
 `Stream` can be used wherever [FreeT](https://hackage.haskell.org/package/free-4.12.1/docs/Control-Monad-Trans-Free.html) is used. The compiler's standard range of optimizations work better for operations written in terms of `Stream`. `FreeT f m r` and `Stream f m r` are of course extremely general, and many functor-general combinators are exported by the general module `Streaming`.
 
-The general idea of streaming
------------------------------
+The freely generated stream on a streamable functor
+----------------------------------------------------
 
-As soon as you consider the idea of an effectful stream of any kind whatsoever, for example, a stream of bytes from a handle, however constituted, you will inevitably be forced to contemplate the idea of a streaming *succession* of *such streams*. Thus, for example, however you imagine your bytes streaming from a handle, you will want to consider a *succession* of *such streams* divided on newlines. Similarly, suppose you have the idea the unfolding of some sort of stream from a Haskell value, a seed - a file name, as it might be. And suppose you *also* have some idea of a stream of such Haskell values - maybe a stream of file names coming from something like `du`, subjected to some filter. Then you will also have the idea of a streaming *succession* of *such unfoldings* linked together end to end in accordance with the initial succession of seed values.
+As soon as you consider the idea of an effectful stream of any kind whatsoever, for example, a stream of bytes from a handle, however constituted, you will inevitably be forced to contemplate the idea of a streaming *succession* of *just such streams*. 
+Thus, for example, however you imagine your bytes streaming from a handle, you will want to consider a *succession* of *such streams* divided on newlines. 
 
-Call those 5 sentences the ABCs of streaming. If you understood these ABCs you have a total comprehension of `Stream f m r`:
+Similarly, suppose you have the idea the unfolding of some sort of stream from a Haskell value, a seed - a file name, as it might be. And suppose you *also* have some idea of a stream of individual Haskell values - maybe a stream of file names coming from something like `du`, subjected to some filter. Then you will also have the idea of a streaming *succession* of *such unfoldings* linked together end to end in accordance with the initial succession of seed values.
 
--   `Stream` itself expresses what the word "succession" meant in the ABCs
+Call the thoughts in that paragraph the ABCs of streaming. If you understood these ABCs you have a total comprehension of `Stream f m r`:
+
+-   `Stream` expresses what the word "succession" meant in the ABCs
 -   The general parameter `f` expresses what was meant by "such streams"
 -   `m` expresses the relevant form of "effect".
 
-General combinators for working with this idea of succession irrespective of the form of succession are contained in the module `Stream`. They can be used, or example, to organize a succession of io-streams `Generator`s or pipes `Producer`s or the effectful bytestreams of the [streaming-bytestring](https://hackage.haskell.org/package/streaming-bytestring) library, or whatever stream-form you can express in a Haskell functor.
+General combinators for working with this idea of succession __irrespective of the form of succession__ are contained in the module `Stream`. They can be used, or example, to organize a succession of io-streams `Generator`s or pipes `Producer`s or the effectful bytestreams of the [streaming-bytestring](https://hackage.haskell.org/package/streaming-bytestring) library, or whatever stream-form you can express in a Haskell functor.
 
-A freely generated stream of connected individual Haskell values is a Producer, Generator or Source
+A freely generated stream of individual Haskell values is a Producer, Generator or Source
 ---------------------------------------------------------------------------------------------------
 
-But, of course, as soon as you grasp the general form of *succession/, you are already in possession of the most basic concrete form: a simple *succession of individual Haskell values\_ one after another. This is just `Stream ((,) a) m r`, or as we write it here, `Stream (Of a) m r`, strictifying the left element of the pair. The pairing just links the present element with the rest of the stream. The primitive `yield` statement just expresses the pairing of the yielded item with the rest of the stream; or rather it is itself the trivial singleton stream. `Streaming.Prelude` is focused on the manipulation of this all-important stream-form, which appears in the streaming IO libraries under titles like:
+But, of course, as soon as you grasp the general form of *succession*, you are already in possession of the most basic concrete form: a simple *succession of individual Haskell values* one after another. This is just `Stream ((,) a) m r`. Here we prefer `Stream (Of a) m r`, strictifying the left element of the pair with 
 
+    data Of a r = !a :> r deriving Functor
+
+Either way, the pairing just links the present element with the rest of the stream. The primitive `yield` statement just expresses the pairing of the yielded item with the rest of the stream; or rather it is itself the trivial singleton stream. 
+
+    yield 17  :: Stream (Of Int) IO ()
+
+`Streaming.Prelude` is focused on the manipulation of this all-important stream-form, which appears in the streaming IO libraries under titles like:
+
     io-streams: Generator a r
     pipes:      Producer a m r
     conduit:    ConduitM () o m r
@@ -42,7 +52,7 @@
 `Streaming.Prelude`
 -------------------
 
-`Streaming.Prelude` closely follows `Pipes.Prelude`. But since it restricts itself to use only of the general idea of streaming, it cleverly \_omits the pipes/:
+`Streaming.Prelude` closely follows `Pipes.Prelude`. But since it restricts itself to use only of the general idea of streaming, it cleverly *omits the pipes*:
 
     ghci> S.stdoutLn $ S.take 2 S.stdinLn
     let's<Enter>
@@ -50,7 +60,7 @@
     stream<Enter>
     stream
 
-Here's a little \_connect and resume/, as the streaming-io experts call it:
+Here's a little *connect and resume*, as the streaming-io experts call it:
 
     ghci> rest <- S.print $ S.splitAt 3 $ S.each [1..10]
     1
@@ -77,7 +87,7 @@
     Prelude.break           :: (a -> Bool) -> [a]               -> ([a],[a])
     Streaming.Prelude.break :: (a -> Bool) -> Stream (Of a) m r -> Stream (Of a) m (Stream (Of a) m r)
 
-It is easy to prove that \_resistance to these types is resistance to effectful streaming itself/. I will labor this point a bit more below, but you can also find it developed, with greater skill, in the documentation for the pipes libraries.
+It is easy to prove that *resistance to these types is resistance to effectful streaming itself*. I will labor this point a bit more below, but you can also find it developed, with greater skill, in the documentation for the pipes libraries.
 
 How come there's not one of those fancy "ListT done right" implementations in here?
 -----------------------------------------------------------------------------------
diff --git a/Streaming.hs b/Streaming.hs
--- a/Streaming.hs
+++ b/Streaming.hs
@@ -8,12 +8,11 @@
    unfold,
    construct,
    for,
-   layer,
-   layers,
+   elevate,
    replicates,
    repeats,
    repeatsM,
-   delay,
+   mwrap,
    wrap,
    
    -- * Transforming streams
diff --git a/Streaming/Internal.hs b/Streaming/Internal.hs
--- a/Streaming/Internal.hs
+++ b/Streaming/Internal.hs
@@ -11,9 +11,9 @@
     , replicates
     , repeats
     , repeatsM
-    , delay
+    , mwrap
     , wrap
-    , layer
+    , elevate
     
     -- * Eliminating a stream
     , intercalates 
@@ -220,10 +220,10 @@
 destroy
   :: (Functor f, Monad m) =>
      Stream f m r -> (f b -> b) -> (m b -> b) -> (r -> b) -> b
-destroy stream0 construct delay done = loop (unexposed stream0) where
+destroy stream0 construct mwrap done = loop (unexposed stream0) where
   loop stream = case stream of
     Return r -> done r
-    Delay m  -> delay (liftM loop m)
+    Delay m  -> mwrap (liftM loop m)
     Step fs  -> construct (fmap loop fs)
 {-# INLINABLE destroy #-}
 
@@ -238,26 +238,26 @@
 >>> :t destroyWith (join . lift) return
 (Monad m, Monad (t m), Functor f, MonadTrans t) =>
      (f (t m a) -> t m a) -> Stream f m a -> t m a  -- iterTM
->>> :t destroyWith delay return
+>>> :t destroyWith mwrap return
 (Monad m, Functor f, Functor f1) =>
      (f (Stream f1 m r) -> Stream f1 m r) -> Stream f m r -> Stream f1 m r
->>> :t destroyWith delay return (wrap . lazily)
+>>> :t destroyWith mwrap return (wrap . lazily)
 Monad m => 
      Stream (Of a) m r -> Stream ((,) a) m r
->>> :t destroyWith delay return (wrap . strictly)
+>>> :t destroyWith mwrap return (wrap . strictly)
 Monad m => 
      Stream ((,) a) m r -> Stream (Of a) m r
->>> :t destroyWith Data.ByteString.Streaming.delay return  
+>>> :t destroyWith Data.ByteString.Streaming.mwrap return  
 (Monad m, Functor f) =>
      (f (ByteString m r) -> ByteString m r) -> Stream f m r -> ByteString m r
->>> :t destroyWith Data.ByteString.Streaming.delay return (\(a:>b) -> consChunk a b) 
+>>> :t destroyWith Data.ByteString.Streaming.mwrap return (\(a:>b) -> consChunk a b) 
 Monad m => 
      Stream (Of B.ByteString) m r -> ByteString m r -- fromChunks
 -}
 destroyWith
   :: (Functor f, Monad m) =>
      (m b -> b) -> (r -> b) -> (f b -> b) -> Stream f m r -> b
-destroyWith delay done construct stream  = destroy stream construct delay done
+destroyWith mwrap done construct stream  = destroy stream construct mwrap done
 
 -- | Reflect a church-encoded stream; cp. @GHC.Exts.build@
 construct
@@ -365,11 +365,15 @@
 
 
 {-| Lift for items in the base functor. Makes a singleton or
-    one-layer succession.`
+    one-layer succession. It is named by similarity to lift: 
+
+> lift :: (Monad m, Functor f)     => m r -> Stream f m r
+> elevate ::  (Monad m, Functor f) => f r -> Stream f m r
 -}
-layer ::  (Monad m, Functor f) => f r -> Stream f m r
-layer fr = Step (fmap Return fr)
 
+elevate ::  (Monad m, Functor f) => f r -> Stream f m r
+elevate fr = Step (fmap Return fr)
+
 {-| Interpolate a layer at each segment. This specializes to e.g.
 
 > intercalates :: (Monad m, Functor f) => Stream f m () -> Stream (Stream f m) m r -> Stream f m r
@@ -553,15 +557,15 @@
 --     See Atkey "Reasoning about Stream Processing with Effects"
 
 
-destroyExposed stream0 construct delay done = loop stream0 where
+destroyExposed stream0 construct mwrap done = loop stream0 where
   loop stream = case stream of
     Return r -> done r
-    Delay m  -> delay (liftM loop m)
+    Delay m  -> mwrap (liftM loop m)
     Step fs  -> construct (fmap loop fs)
 {-# INLINABLE destroyExposed #-}
 
 
-{-| This is akin to the @observe@ of @Pipes.Internal@ . It redelays the layering
+{-| This is akin to the @observe@ of @Pipes.Internal@ . It remwraps the layering
     in instances of @Stream f m r@ so that it replicates that of 
     @FreeT@. 
 
@@ -576,8 +580,8 @@
 
 
 
-delay :: (Monad m, Functor f ) => m (Stream f m r) -> Stream f m r
-delay = Delay
+mwrap :: (Monad m, Functor f ) => m (Stream f m r) -> Stream f m r
+mwrap = Delay
 
 wrap :: (Monad m, Functor f ) => f (Stream f m r) -> Stream f m r
 wrap = Step
diff --git a/Streaming/Prelude.hs b/Streaming/Prelude.hs
--- a/Streaming/Prelude.hs
+++ b/Streaming/Prelude.hs
@@ -50,7 +50,6 @@
     -- $producers
     , yield
     , each
-    , layers
     , unfoldr
     , stdinLn
     , readLn
@@ -62,6 +61,8 @@
     , replicateM
     , enumFrom
     , enumFromThen
+    , randomRs
+    , randoms
     
     -- * Consuming streams of elements
     -- $consumers
@@ -179,7 +180,7 @@
 import Control.Exception (throwIO, try)
 import Data.Monoid (Monoid (..))
 import Data.String (IsString (..))
-
+import qualified System.Random as R
 -- | A left-strict pair; the base functor for streams of individual elements.
 data Of a b = !a :> b
     deriving (Data, Eq, Foldable, Ord,
@@ -727,11 +728,6 @@
 {-# INLINEABLE iterateM #-}
 
 
-layers
-  :: (Monad m, Functor f) =>
-     Stream (Of a) m r -> (a -> f x) -> Stream f m r
-layers stream f = for stream $ layer . f
-{-# INLINE layers #-}
 -- ---------------
 -- length
 -- ---------------
@@ -857,6 +853,41 @@
 product' :: (Monad m, Num a) => Stream (Of a) m r -> m (Of a r)
 product' = fold' (*) 1 id
 {-# INLINE product' #-}
+
+
+-- ---------------
+-- random
+-- ---------------
+
+{- An infinite stream of random items 
+
+>  randoms = liftIO Random.getStdGen >>= unfoldr (return . Right . Random.random)
+
+>>>  S.print $ S.take 4 (S.randoms :: Stream (Of Bool) IO ())
+True
+False
+True
+True
+-}
+randoms :: (R.Random a, MonadIO m) => Stream (Of a) m r
+randoms = do 
+  g <- liftIO $ R.getStdGen
+  unfoldr (return . Right . R.random) g
+
+{- An infinite stream of random items between some bounds
+
+>  randomRs limits = liftIO Random.getStdGen >>= unfoldr (return . Right . Random.randomR limits)
+
+>>> S.print $ S.take 4 $ S.randomRs (0,10^10::Int)
+6489666022
+3984407086
+4271461383
+3632382535
+-}
+randomRs :: (R.Random a, MonadIO m) => (a, a) -> Stream (Of a) m r
+randomRs limits = do 
+  g <- liftIO $ R.getStdGen
+  unfoldr (return . Right . R.randomR limits) g
 
 -- ---------------
 -- read
diff --git a/streaming.cabal b/streaming.cabal
--- a/streaming.cabal
+++ b/streaming.cabal
@@ -1,11 +1,14 @@
 name:                streaming
-version:             0.1.0.20
+version:             0.1.1.0
 cabal-version:       >=1.10
 build-type:          Simple
-synopsis:            an elementary streaming prelude and a free monad transformer optimized for streaming applications
+synopsis:            an elementary streaming prelude and a general monad transformer for streaming applications.
 
 description:         @Streaming.Prelude@ exports an elementary streaming prelude; @Streaming@ exports a free monad transformer 
-                     optimized for streaming applications and replacing @FreeT@. See the readme below for an explanation. 
+                     optimized for streaming applications and replacing @FreeT@. See the 
+                     <https://hackage.haskell.org/package/streaming#readme readme> below
+                     for an explanation. Elementary usage can be divined from the ghci examples in 
+                     @Streaming.Prelude@
                      .
                      Note also the 
                      <https://hackage.haskell.org/package/streaming-bytestring streaming bytestring> 
@@ -45,6 +48,7 @@
                      , mmorph >=1.0 && <1.2
                      , transformers >=0.4 && <0.5
                      , bytestring
+                     , random
 
   default-language:  Haskell2010