anchor.diff:  module InternalParsers = 
       open ParserCreators
   
  -    let todayP = 
  -        createParser (id) ["today"; "tdy" ; "now"] 
  -    let tomorrowP = 
  -        createParser (addDay 1) ["tomorow";"tomorrow";"tommorrow";"tommorow";"tmr"] 
  -    let yesterdayP = 
  -        createParser (addDay -1) ["yesterday"; "yest" ; "ye"]     
  +    let todayP labels = 
  +        createParser (id) labels
  +    let tomorrowP labels = 
  +        createParser (addDay 1) labels
  +    let yesterdayP labels = 
  +        createParser (addDay -1) labels    
   
       let shiftP (shiftTypes:AbsoluteShift list) = 
           pint32 .>> spaces 
           .>>. (shiftTypes |> List.map(fun shiftType -> (createParser shiftType.Apply shiftType.Labels)) |> choice) 
   
   
  -    let fromP (shiftType:AbsoluteShift list) parser= 
  +    let forwardShiftP labels (shiftTypes:AbsoluteShift list) parser= 
           attempt (
               pipe2 
  -                (shiftP shiftType .>> createConsumingParser ["from"; "after"])
  +                (shiftP shiftTypes .>> createConsumingParser labels)
                   parser
                   (fun (size, shift) dateTransf -> shift ((size)) >> dateTransf)
           )
  -    let beforeP (shiftType:AbsoluteShift list) parser = 
  +
  +    let backShiftP labels (shiftTypes:AbsoluteShift list) parser = 
           attempt (
               pipe2
  -                (shiftP shiftType .>> createConsumingParser ["before"])
  +                (shiftP shiftTypes .>> createConsumingParser labels)
                   parser
                   (fun (size, shift) dateTransf -> shift ((-size)) >> dateTransf)
           )
  -    let agoP (shiftType:AbsoluteShift list) = 
  +
  +    let agoP (shiftTypes:AbsoluteShift list) = 
           attempt (
  -            shiftP shiftType
  -            .>>? ParserCreators.createConsumingParser ["ago"]
  +            shiftP shiftTypes
  +            .>> ParserCreators.createConsumingParser ["ago"]
               |>> fun (size, shift) -> shift ((-size))
           )
  +
       let fallbackP =
           attempt (
               many1CharsTill
  
positive.code:                         | (false,_) -> fail "date not recognized")
          )    
  
  type DateParser(?baseDate : DateTime) = 
      let bDate = defaultArg baseDate DateTime.Now  
  
      let basicShifts = 
          [
              {Labels = ["days"; "day"] ; Apply = addDay}
              {Labels = ["weeks"; "week"] ; Apply = addWeek}
              {Labels = ["fortnight" ; "fortnights"] ; Apply = (fun x -> addWeek (2*x))}
              {Labels = ["months" ; "month"] ; Apply = addMonth}
              {Labels = ["years" ; "year"] ; Apply = addYear}
          ]
  
      let combinedParser = 
          let pars, refPar = createParserForwardedToRef()     
          refPar := choice [
              InternalParsers.todayP 
              InternalParsers.tomorrowP
              InternalParsers.yesterdayP
              InternalParsers.agoP basicShifts
              InternalParsers.fromP basicShifts pars
              InternalParsers.beforeP basicShifts pars
              InternalParsers.fallbackP
          ]
          pars
      
           
      member this.Parse(arg:string) =
          match run (combinedParser) arg with
              | Success (result, _, __) -> SuccessfulParse(result bDate)
              | Failure(x,y,z) -> FailedParse(x)
  
      member this.ParseAtEnd(arg:string) =
          match run ( manyCharsTillApply anyChar combinedParser (fun x y -> y) .>> eof) arg with
              | Success (result, _, __) -> SuccessfulParse(result bDate)
              | Failure(x,y,z) -> FailedParse(x)
  
negative.code: 
  type ShiftType =
      | DayBased of (int -> DateTransform)
      | Manual of DateTransform
  
  type AbsoluteShift =
      { 
          Apply:int -> DateTransform
          Labels : string seq
      }
  
  type ParserConfig = 
      {
          Yesterday : string list
          Today: string list
          Tomorrow : string list
          Day : string list
          Week : string list
          Fortnight : string list
          Month : string list
          Year : string list
          BackShiftKeywords : string list
          ForwardShiftKeywords : string list
      }
     
  [<AutoOpen>]
  