anchor.diff:    | SuccessfulParse of DateTime
     | FailedParse of string
   
  -type StaticShifts =
  -  {
  -    Labels : string seq
  -    StaticApply : DateTransform
  -    Priority : int
  -  }
  -
  -type RelativeShift =
  -  {
  -    Apply : DateTransform
  -    Labels : string seq
  -  }
  -
  -type AbsoluteShift =
  -  {
  -    Apply:int -> DateTransform
  -    Labels : string seq
  -  }
  -
  -// New
   module Types =
     type SpecificDate =
       | Today
  
positive.code:           ForwardShiftKeywords = ["from"; "after"]
        }
  
    let staticShifts =
      [
        {StaticApply = id ; Labels = conf.Today; Priority = 1}
        {StaticApply = addDay 1 ; Labels = conf.Tomorrow; Priority = 2}
        {StaticApply = addDay -1 ; Labels = conf.Yesterday; Priority = 3}
      ]
  
    let basicShifts =
      [
        {Labels = conf.Day ; Apply = addDay}
        {Labels = conf.Week ; Apply = addWeek}
        {Labels = conf.Fortnight ; Apply = (fun x -> addWeek (2*x))}
        {Labels = conf.Month ; Apply = addMonth}
        {Labels = conf.Year ; Apply = addYear}
      ]
  
    let relativeShifts =
      [
        {RelativeShift.Labels = ["Monday"; "mon" ; "week"] ; Apply = nextOccurenceOf DayOfWeek.Monday}
        {RelativeShift.Labels = ["Tuesday" ; "tue"] ; Apply = nextOccurenceOf DayOfWeek.Tuesday}
        {RelativeShift.Labels = ["Wednesday" ; "wed"] ; Apply = nextOccurenceOf DayOfWeek.Wednesday}
        {RelativeShift.Labels = ["Thursday" ; "thu"] ; Apply = nextOccurenceOf DayOfWeek.Thursday}
        {RelativeShift.Labels = ["Friday" ; "fri"] ; Apply = nextOccurenceOf DayOfWeek.Friday}
        {RelativeShift.Labels = ["Saturday" ; "sat" ; "weekend"] ; Apply = nextOccurenceOf DayOfWeek.Saturday}
        {RelativeShift.Labels = ["Sunday"; "sun"] ; Apply = nextOccurenceOf DayOfWeek.Sunday}
        {RelativeShift.Labels = ["month"] ; Apply = nextMonth}
        {RelativeShift.Labels = ["year"] ; Apply = nextYear}
      ]
  
    let combinedParser =
      let pars, refPar = createParserForwardedToRef()
      refPar := choice [
        InternalParsers.relativeAnchorP staticShifts
        InternalParsers.agoP basicShifts
        InternalParsers.forwardShiftP conf.ForwardShiftKeywords basicShifts pars
        InternalParsers.backShiftP conf.BackShiftKeywords basicShifts pars
        InternalParsers.nextP relativeShifts
        InternalParsers.fallbackP
        ]
      pars
  
    let newParser = NewParsers.completeP
  
    member this.Parse(arg:string, ?baseDate : DateTime) =
      let bDate = defaultArg baseDate DateTime.Now
      //match run (spaces >>. combinedParser .>> eof) arg with
      match run (spaces >>. NewParsers.newCompleteP .>> eof) arg with
        | Success (result, _, _) -> SuccessfulParse(result bDate)
        | Failure(x,y,z) -> FailedParse(x)
  
    member this.ParseAtEnd(arg:string, ?baseDate : DateTime) =
      let bDate = defaultArg baseDate DateTime.Now
      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:       choice [
          relativeDateP |>> Date
          weekdaysP |>> Weekday
          relativeP
          attempt (absoluteP pars)
          fallbackP |>> fun date -> Date(Specific(date))
        ]
      pars
      |>> evaluate
  
  
  type ParserConfig =
  