sclass EnglishDateParser > DateStructures {
  replace P with ParsedWithTokens.
  
  bool assumeFuture = true; // e.g. for "tuesday" [not used]
  LS tok;
  int maxTokens = 3;

  // "top dogs" are the longest non-overlapping parses
  L<P<SomeDate>> topDogs(S s) {
    ret pwt_topDogs(pwt_filterByType SomeDate(allParses(s)));
  }
  
  SomeDate parse(S s) {
    ret getVar(first(topDogs(s)));
  }
  
  ItIt<P> allParses(S s) {
    // tokenize, initialize
    L<P<S>> initials = pwt_initial(tok = javaTok(s), maxTokens);
    new L<P> out;
    
    // find numbers
    L<P<Int>> numbers = pwt_transform(number(), initials);

    // find ordinals (1st, 2nd, ...)
    new L<P<Int>> ordinals;
    for (P<Int> number : numbers)
      for (P<S> ord : parseToTheRight(fixedToken("st", "nd", "rd", "th"), number))
        ordinals.add(pwt_combine(number, ord));
    //print(+ordinals);
    
    // "in <n> days"
    for (P<Int> number : numbers)
      for (P<S> in : parseToTheLeft(fixedToken("in"), number))
        for (P<S> days : parseToTheRight(fixedToken("day", "days"), number))
          out.add(pwt_combine(new TodayPlus(number!), in, days));
    
    // "<n> days from now"
    for (P<Int> number : numbers)
      for (P<S> daysFromNow : parseToTheRight(fixedToken("day from now", "days from now"), number))
        out.add(pwt_combine(new TodayPlus(number!), number, daysFromNow));
    
    L<P<Int>> years = pwt_filter isYear(numbers);
    out.addAll(years);

    L<P<Int>> months = pwt_filter isMonthNr(numbers);
    L<P<Int>> dayOfMonths = pwt_filter isDayOfMonth(numbers);
    
    L<P<Weekday>> weekdays = pwt_transform(weekday(), initials);
    out.addAll(weekdays);

    // month names
    L<P<Month>> monthNames = pwt_transform(monthName(), initials);
    out.addAll(monthNames);

    // month name + year, e.g. "February 2020"
    out.addAll(pwt_combine(monthNames, years, (month, year) -> new Month(month.month, new Year(year))));

    // month name + ordinal, e.g. "March 4th"
    out.addAll(pwt_combine(monthNames, ordinals, (month, ord) -> new Day(ord, month)));

    // yesterday, today, tomorrow
    out.addAll(pwt_transform(t ->
      eqic(t, "yesterday") ? new TodayPlus(-1) :
      eqic(t, "today") ? new TodayPlus(0) :
      new TodayPlus(1),
      pwt_transform(fixedToken("yesterday", "today", "tomorrow"), initials)));
      
    // last/this/next week
    for (P<S> week : pwt_transform(fixedToken("week"), initials))
      for (P<S> which : parseToTheLeft(fixedToken("last", "this", "next"), week))
        out.add(pwt_combine(new CurrentWeekPlus(
          eqic(which!, "last") ? -1
          : eqic(which!, "this") ? 0 : 1), which, week));
    
    // "next <weekday>"
    for (P<Weekday> weekday : weekdays)
      for (P<S> next : parseToTheLeft(fixedToken("next"), weekday))
        out.add(pwt_combine(new Weekday(weekday->weekday, new CurrentWeekPlus(1)), next, weekday));

    for (P<Int> year : years)
      for (P<S> slash : parseToTheRight(fixedToken("/"), year))
        for (P<Int> month : pwt_toTheRightOf(months, slash))
          for (P<S> slash2 : parseToTheRight(fixedToken("/"), month))
            for (P<Int> day : pwt_toTheRightOf(dayOfMonths, slash2))
              out.add(pwt_combine(new Day(day!, new Month(month!, new Year(year!))), year, day));

    L<P<Hour>> hours = pwt_transform numberToHour(numbers);
    L<P<Int>> minutes = pwt_filter isMinute(numbers);
    L<P<Int>> seconds = minutes;

    L<P<S>> colons = pwt_filter(t -> eq(t, ":"), initials);

    // 15:12 etc.
    L<P<Minute>> hoursAndMinutes = pwt_combine(hours, colons, minutes, (h, _, m) -> new Minute(m, h));
    out.addAll(hoursAndMinutes);

    L<P<Second>> hoursAndMinutesAndSeconds = pwt_combine(hoursAndMinutes, colons, seconds,
      (hm, _, second) -> new Second(second, hm));
    out.addAll(hoursAndMinutesAndSeconds);

    L<P<S>> amPMs = pwt_transform(fixedToken("am", "pm"), initials);

    // 3 am, 5 pm etc.
    L<P<Hour>> amPMTimes = pwt_combine(numbers, amPMs, (hour, amPM) -> !between(hour, 1, 12) ? null : new Hour(hour, eqic(amPM, "pm")));
    out.addAll(amPMTimes);

    // between 1 and 2 pm
    for (P<Hour> time : amPMTimes)
      for (P<S> and : parseToTheLeft(fixedToken("and"), time))
        for (P<Hour> hour : pwt_toTheLeftOf(hours, and))
          out.add(pwt_combine(new Between(new Hour(hour->hour, time->isPM), time!), time, hour));
        
    ret itIt(out);
  }

  IF1<S, Int> number() { ret s -> isInteger(s) ? parseInt(s) : null; }
  
  bool isYear(int n) { ret between(n, 1900, 2100); }
  bool isMonthNr(int n) { ret between(n, 1, 12); }
  bool isDayOfMonth(int n) { ret between(n, 1, 31); }
  bool isHour(int n) { ret between(n, 0, 23); }
  bool isMinute(int n) { ret between(n, 0, 59); }
  bool isSecond(int n) { ret between(n, 0, 59); }

  Hour numberToHour(int n) { ret !isHour(n) ? null : n > 12 ? new Hour(n-12, true) : new Hour(n, null); }

  IF1<S> fixedToken(S... tokens) { ret fixedToken(litciset(tokens)); }
  IF1<S> fixedToken(Set<S> set) { ret t -> contains(set, t) ? t : null; }
  
  IF1<S, Weekday> weekday() {
    ret s -> {
      int n = parseEnglishWeekday(s);
      ret n == 0 ? null : new Weekday(n);
    };
  }
  
  IF1<S, Month> monthName() {
    ret s -> {
      int n = parseEnglishMonthName(s);
      ret n == 0 ? null : new Month(n);
    };
  }
  
  <A, B> L<ParsedWithTokens<B>> parseToTheLeft(IF1<A, B> f, ParsedWithTokens p) {
    ret pwt_transform(f, pwt_precedingTokens(1, maxTokens, p.start()));
  }
  
  <A, B> L<ParsedWithTokens<B>> parseToTheRight(IF1<A, B> f, ParsedWithTokens p) {
    ret pwt_transform(f, pwt_followingTokens(1, maxTokens, p.remaining()));
  }
}