anchor.diff:  
   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>]
  
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: module InternalParsers = 
      open ParserCreators
  
      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 forwardShiftP labels (shiftTypes:AbsoluteShift list) parser= 
          attempt (
              pipe2 
                  (shiftP shiftTypes .>> createConsumingParser labels)
                  parser
                  (fun (size, shift) dateTransf -> shift ((size)) >> dateTransf)
          )
  
      let backShiftP labels (shiftTypes:AbsoluteShift list) parser = 
          attempt (
              pipe2
                  (shiftP shiftTypes .>> createConsumingParser labels)
                  parser
                  (fun (size, shift) dateTransf -> shift ((-size)) >> dateTransf)
          )
  
      let agoP (shiftTypes:AbsoluteShift list) = 
          attempt (
              shiftP shiftTypes
              .>> ParserCreators.createConsumingParser ["ago"]
              |>> fun (size, shift) -> shift ((-size))
          )
  
      let fallbackP =
          attempt (
              many1CharsTill
  