diff --git a/Changelog b/Changelog
--- a/Changelog
+++ b/Changelog
@@ -1,11 +1,34 @@
+-> 0.2.0    fixes few docs bugs,
+
+			new functions in CsoundExpr.Base.Score :
+
+			extends TemporalFunctor with new methods
+			tmap, dmap, tdmap for mapping dependent on time/duration,
+			enveloping on Score level (diminuendo or crescendo)
+			
+			WARNING : API changes : tmap is now dmap and tmap stands for time			
+			dependent mapping (not duration as it was before),
+
+			new class Sustainable, adds ability for legato and pedal (sustain,
+			sustainBy functions)
+
+			new class TemporalStretch, adds ability to stretch score depndent
+			on note's start time (ritardando or accelerando)
+
+			adds list-like operations on Scores : reverseS, takeS, dropS
+
+			new function in CsoundExpr.Base.Arithmetic 		
+			^+ - shift with Irate
+			
+
 -> 0.1.0    new type BoolRate, functional if/then/else is possible
 			new operators : <^>, <%>
 			scaling becomes ^* (due to <* is defined as lower then for signals)
 
--> 0.0.3    fix a bug with p-fields assignment
+-> 0.0.3    fixes a bug with p-fields assignment
 
--> 0.0.2    fix a bug in dependencies
+-> 0.0.2    fixes a bug in dependencies
 
--> 0.0.1    add Tutorial
+-> 0.0.1    adds Tutorial
 
 0.0
diff --git a/csound-expression.cabal b/csound-expression.cabal
--- a/csound-expression.cabal
+++ b/csound-expression.cabal
@@ -1,12 +1,14 @@
 Name:          csound-expression
-Version:       0.1.0
+Version:       0.2.0
 Cabal-Version: >= 1.2
 License:       BSD3
 License-File:  LICENSE
 Author:	       Anton Kholomiov
 Maintainer:    <anton.kholomiov@gmail.com>
 Synopsis:      Csound combinator library
-Description:   Csound code generator. See "CsoundExpr.Tutorial" for guides and examples.
+Description:   Csound code generator. See "CsoundExpr.Tutorial" for guides and examples. 
+
+               WARNING : API changes (see TemporalFunctor method tmap, and ./Changelog)
 Category:      Sound, Music
 Stability:     Experimental
 Tested-With:   GHC==6.12.1
@@ -18,7 +20,7 @@
 Library
   Build-Depends:
         base >= 4, base < 5, containers, mtl == 2.0.1.0, pretty, 
-        filepath, directory, haskell98, Boolean, temporal-media == 0.0
+        filepath, directory, haskell98, Boolean, temporal-media == 0.1.0
   Hs-Source-Dirs:      src/
   Exposed-Modules:
         CsoundExpr
diff --git a/src/CsoundExpr/Base/Arithmetic.hs b/src/CsoundExpr/Base/Arithmetic.hs
--- a/src/CsoundExpr/Base/Arithmetic.hs
+++ b/src/CsoundExpr/Base/Arithmetic.hs
@@ -6,7 +6,7 @@
 -- | Arithmetic operators
 
 module CsoundExpr.Base.Arithmetic 
-	(Opr2, (<+>), neg, (<->), (<*>), (</>), (<^>), (<%>), (^*))
+	(Opr2, (<+>), neg, (<->), (<*>), (</>), (<^>), (<%>), (^*), (^+))
 where
 
 import Prelude hiding (div)
@@ -24,7 +24,7 @@
 import CsoundExpr.Base.Boolean
 
 infixr 9  ^* 
-infixr 8  <^>
+infixr 8  ^+, <^>
 infixr 7  <*>, </>
 infixr 6  <+>, <->, <%>
 
@@ -62,17 +62,19 @@
 ----------------------------------------------------------
 -- Type inference
 
-(<+>), (<->), (<*>), (</>), (<^>), (<%>) :: (X a, X b, X (Opr2 a b)) => a -> b -> Opr2 a b
+(<+>), (<->), (<*>), (</>) :: (X a, X b, X (Opr2 a b)) => a -> b -> Opr2 a b
 
 (<+>) = subst $ opr2 "+" (+)
 (<->) = subst $ opr2 "-" (-)
 (<*>) = subst $ opr2 "*" (*)
 (</>) = subst $ opr2 "/" (/)
 
--- | "power of" operator
+-- | \"power of\" operator
+(<^>) :: (X a, X b, X (Opr2 a b)) => a -> b -> Opr2 a b
 (<^>) = subst $ opr2 "^" (**)
 
 -- | modulus operator
+(<%>) :: (X a, X b, X (Opr2 a b)) => a -> b -> Opr2 a b
 (<%>) = subst $ opr2 "%" modDouble
 
 -- | negation
@@ -83,6 +85,9 @@
 (^*) :: X a => Irate -> a -> a
 (^*) = subst $ opr2 "*" (*)
 
+-- | shifting
+(^+) :: X a => Irate -> a -> a
+(^+) = subst $ opr2 "+" (+)
 
 modDouble :: Double -> Double -> Double
 modDouble a b = signum a * until ( < b') (+ (-b')) a'
diff --git a/src/CsoundExpr/Base/Header.hs b/src/CsoundExpr/Base/Header.hs
--- a/src/CsoundExpr/Base/Header.hs
+++ b/src/CsoundExpr/Base/Header.hs
@@ -156,6 +156,6 @@
 		gSr     <=> 44100,
 		gKr     <=> 4410,
 		gKsmps  <=> 10,
-		gNchnls <=> 1]
+		gNchnls <=> 2]
 
 
diff --git a/src/CsoundExpr/Base/Score.hs b/src/CsoundExpr/Base/Score.hs
--- a/src/CsoundExpr/Base/Score.hs
+++ b/src/CsoundExpr/Base/Score.hs
@@ -1,15 +1,36 @@
 {-# LANGUAGE FlexibleContexts #-}
 module CsoundExpr.Base.Score (
-	Arrangeable(..),
-	Time, Dur, Score, toList,
-	dur, rest, stretch, note, delay,
-	line, chord, loop, cut, tmap)
+    -- * Types
+	Time, Dur, Score, 
+    -- * Constructors
+    rest, note, toList,
+    -- * Duration querry
+	dur, 
+    -- * Arrangers
+    Arrangeable(..),
+	line, chord, loop, trill, rondo, reprise, 
+    -- * Transformers
+    -- ** In time domain
+    delay, 
+    stretch, tstretch, 
+    cut, takeS, dropS, reverseS,
+    pedal, pedalBy,
+    sustain, sustainBy,
+    -- ** Mappings
+    tmap, dmap, tdmap, 
+    -- * Misc
+    tmapRel, dmapRel, tdmapRel, tstretchRel,
+    linseg
+)
 where
 
 import CsoundExpr.Translator.Types(Time, Dur)
 import qualified Temporal.Media as M
-import Temporal.Media(Arrangeable(..))
+import Temporal.Media(Arrangeable(..), linseg)
 
+import Control.Arrow(second)
+
+
 -- | representing score
 type Score a = M.MediaUnit Dur () a
 
@@ -26,6 +47,41 @@
 stretch :: M.Stretchable Dur a => Dur -> a -> a
 stretch = M.stretch
 
+-- | stretch in time domain depndent on note's time
+tstretch :: M.TemporalStretchable Dur a => (Time -> Dur) -> a -> a
+tstretch = M.tstretch
+
+-- | relative 'tstretch' 
+--
+-- time normalized by durtion of value
+tstretchRel :: M.TemporalStretchable Dur a => (Time -> Dur) -> a -> a
+tstretchRel = M.tstretchRel
+
+-- | adds given amount of duration to all notes
+sustain :: Dur -> Score a -> Score a
+sustain = M.sustain
+
+-- | general sustain
+sustainBy :: (Time -> Dur -> a -> (b, Dur)) -> Score a -> Score b
+sustainBy = M.sustainBy
+
+-- | adds sustain, but total duration of score elements remains unchaged
+--
+-- notes are sustained within total duration interval.
+-- adds given amount of time to all notes.
+pedal :: Dur -> Score a -> Score a 
+pedal dt' = pedalBy (\t dt a -> (a, dt + dt'))
+
+-- | general \"pedal\"
+--
+-- total duration of score element remains unchanged. notes are sustained within total duration interval
+pedalBy :: (Time -> Dur -> a -> (b, Dur)) -> Score a -> Score b
+pedalBy f x = M.sustainBy f' x
+    where d = dur x
+          f' t dt a = second (min (d - t)) $ f t dt a 
+                       
+        
+
 -- | constructor of score
 note :: Dur -> a -> Score a
 note = M.temp
@@ -44,14 +100,79 @@
 loop :: Arrangeable a => Int -> a -> a
 loop = M.loop
 
+-- | loop for two groups of notes
+trill :: Arrangeable a => Int -> a -> a -> a
+trill n a b = loop n $ line [a, b]
+
+-- | rondo form
+--
+-- >rondo a b c = line [a, b, a, c, a]
+rondo :: Arrangeable a => a -> a -> a -> a
+rondo a b c = line [a, b, a, c, a]
+
+-- | reprise form
+--
+-- >reprise a b1 b2 = line [a, b1, a, b2]
+reprise :: Arrangeable a => a -> a -> a -> a
+reprise a b c = line [a, b, a, c]
+
 -- | extracting score parts in some time interval.
 -- it reverses output if @t1 < t0@.
 cut :: Dur -> Dur -> Score a -> Score a
 cut = M.cut
 
--- | temporal functor
-tmap :: (Dur -> a -> b) -> Score a -> Score b
+-- | take sub-score from begining
+takeS :: Dur -> Score a -> Score a
+takeS = M.take
+
+-- | drop sub-score
+dropS :: Dur -> Score a -> Score a
+dropS = M.drop
+
+-- | reverse score
+reverseS :: Score a -> Score a
+reverseS = M.reverse
+
+-- | temporal functor 'tmap' method for scores
+--
+-- map with time
+tmap :: (Time -> a -> b) -> Score a -> Score b
 tmap = M.tmap
+
+-- |  temporal functor 'dmap' method for scores
+--
+-- map with duration
+dmap :: (Dur -> a -> b) -> Score a -> Score b
+dmap = M.dmap
+
+-- | temporal functor 'tdmap' method for scores
+--
+-- map with time and duration
+tdmap :: (Time -> Dur -> a -> b) -> Score a -> Score b
+tdmap = M.tdmap
+
+
+-- | relative 'tmap' 
+--
+-- map with time normalized by total duration value
+tmapRel :: (Time -> a -> b) -> Score a -> Score b
+tmapRel = M.tmapRel
+
+-- |  relative 'dmap' 
+--
+-- map with duration normalized by total duration value
+dmapRel :: (Dur -> a -> b) -> Score a -> Score b
+dmapRel = M.dmapRel
+
+-- | relative 'tdmap'
+--
+-- map with time and duration normalized by total duration value
+tdmapRel :: (Time -> Dur -> a -> b) -> Score a -> Score b
+tdmapRel = M.tdmapRel
+
+
+
+
 
 -- | transform 'Score' to 'EventList'
 toList :: Score a -> M.EventList Dur a
diff --git a/src/CsoundExpr/Tutorial/Composition.hs b/src/CsoundExpr/Tutorial/Composition.hs
--- a/src/CsoundExpr/Tutorial/Composition.hs
+++ b/src/CsoundExpr/Tutorial/Composition.hs
@@ -109,13 +109,40 @@
     
     -- ** TemporalFunctor
     {-|
-    There is class called 'TemporalFunctor' with method 'tmap'. 
-    First argument of tmap's function means function from duration 
-    of value @t@ and value itself @a@ to new value @b@.
+    There is class called 'TemporalFunctor' with methods for time/duration dependent mapping.
+    There are methods 
+    
+    
+    'tmap' - for time dependent mapping, 
+    
+    'dmap' - for duration dependent mapping and
 
+    'tdmap' - for time/duration dependent mapping. 
+    
+
     >class Dur t => TemporalFunctor f where
-    >    tmap :: (t -> a -> b) -> f a -> f b
+    >    tmap  :: (t -> a -> b)      -> f a -> f b
+    >    dmap  :: (t -> a -> b)      -> f a -> f b
+    >    tdmap :: (t -> t -> a -> b) -> f a -> f b
 
+    Note in 'Score' can be thought of as an event that happens in some time @t@ 
+    and lasts for some time @d@. Thus note carries three parametters value @a@, start time @t@ 
+    and duration time @d@. 'TemporalFunctor' provides different mappings over time parameters.
+
+    First argument of 'tmap' function means function from start time of
+    note and note's value @a@ to new value @b@
+
+
+    example : fadeOut
+
+    >instr :: Irate -> SignalOut
+    >instr vol = out $ oscilA [] vol (num 440) $ gen10 4096 [1]
+    >
+    >sco = fmap instr $ tmap (\t v -> double (5 - t) * v) $ loop 5 $ note 1 1000    
+
+    First argument of dmap's function means function from duration 
+    of value @t@ and value itself @a@ to new value @b@.
+
     It allows to construct instruments that can rely on note duration.
 
     >instr :: Dur -> Irate -> SignalOut
@@ -127,11 +154,22 @@
     >v1 = 1.5 * v0
     >v0 = 5000
     >
-    >sco = tmap instr $ line [note 0.5 v1, note 0.5 v0, rest 1, note 2 v1]
+    >sco = dmap instr $ line [note 0.5 v1, note 0.5 v0, rest 1, note 2 v1]
 
     Note : 
 
-    >stretch t (tmap instr sco) =/= tmap instr (stretch t sco)
+    >stretch t (dmap instr sco) =/= dmap instr (stretch t sco)
+
+    'tdmap' combines 'tmap' and 'dmap' behavior. It's first argument is a function from
+    time, duration and value to value.
+
+    There are helping functions 'tmapRel', 'dmapRel' and 'tdmapRel'. They express 
+    time/duration dependent mapping with normalization in time domain. All time values are notmalized by 
+    total duration of value.
+
+    @sco@ of fadeOut example can be rewritten as
+
+    >sco = fmap instr $ tmapRel (\t v -> double (1 - t) * v ) $ loop 5 $ note 1 5000 
 
    -}
 
diff --git a/src/CsoundExpr/Tutorial/Orchestra.hs b/src/CsoundExpr/Tutorial/Orchestra.hs
--- a/src/CsoundExpr/Tutorial/Orchestra.hs
+++ b/src/CsoundExpr/Tutorial/Orchestra.hs
@@ -303,9 +303,9 @@
 		delay 12 $ loop 4 scoBass, 
 		scoDrums] 
 
-scoAahs1 = loop 2 $ tmap aahs $ soloNotes [d 1, cs 1, e 0, fs 0]
-scoAahs2 = loop 2 $ tmap aahs $ soloNotes [d 1, cs 1, a 0, d 0]
-scoAahs3 = loop 2 $ tmap aahs $ soloNotes [a 0, cs 1, g 0, fs 0]
+scoAahs1 = loop 2 $ dmap aahs $ soloNotes [d 1, cs 1, e 0, fs 0]
+scoAahs2 = loop 2 $ dmap aahs $ soloNotes [d 1, cs 1, a 0, d 0]
+scoAahs3 = loop 2 $ dmap aahs $ soloNotes [a 0, cs 1, g 0, fs 0]
 
 solo = delay 20 $ chord [
 		scoAahs1,