sclass EnglishDateParser > DateStructures {
  replace P with ParsedWithTokens.
  
  bool assumeFuture = true; // e.g. for "tuesday" [not used]
  LS tok;
  int maxTokens = 3;
  
  L<P<SomeDate>> longestParses(S s) {
    ret pwt_topDogs(pwt_filterByType SomeDate(allParses(s)));
  }
  
  SomeDate parse(S s) {
    ret getVar(first(longestParses(s)));
  }
  
  ItIt<P> allParses(S s) {
    // tokenize, initialize
    tok = javaTok(s);
    new L<P> out;
    L<ListAndIndex<S>> codeTokens = asList(lai_codeTokens(tok));
    
    // find numbers
    L<P<Int>> numbers = concatMap parseNumber(codeTokens);

    // 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 : print("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 = concatMap parseYear(codeTokens);
    out.addAll(years);
    
    L<P<Weekday>> weekdays = concatMap parseWeekday(codeTokens);
    out.addAll(weekdays);

    // month names
    L<P<Month>> monthNames = concatMap parseMonthName(codeTokens);
    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!)));
    /*for (P<Month> month : monthNames)
      for (P<Int> year : pwt_toTheRightOf(years, month))
        out.add(pwt_combine(new Month(month->month, new Year(year!)), month, year));*/

    // month name + ordinal, e.g. "March 4th"
    //for (P<Month> month : monthNames)
    
    // "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 : parseMonth(slash.remaining()))
          for (P<S> slash2 : parseToTheRight(fixedToken("/"), month))
            for (P<Int> day : parseDayOfMonth(slash2.remaining()))
              out.add(pwt_combine(new Day(day!, new Month(month!, new Year(year!))), year, day));
        
    ret itIt(out);
  }
  
  ItIt<P<Int>> parseNumber(ListAndIndex<S> toParse) {
    ret mapI_nonNulls(pwt_followingTokens(1, maxTokens, toParse),
      p -> isInteger(p!) ? p.withValue(parseInt(p!)) : null);
  }
  
  ItIt<P<Int>> parseYear(ListAndIndex<S> toParse) {
    ret filterI(parseNumber(toParse), p -> between(p!, 1900, 2100));
  }
  
  ItIt<P<Int>> parseMonth(ListAndIndex<S> toParse) {
    ret filterI(parseNumber(toParse), p -> between(p!, 1, 12));
  }
  
  ItIt<P<Int>> parseDayOfMonth(ListAndIndex<S> toParse) {
    ret filterI(parseNumber(toParse), p -> between(p!, 1, 31));
  }

  IF1<S> fixedToken(S... tokens) { ret fixedToken(litciset(tokens)); }
  IF1<S> fixedToken(Set<S> set) { ret t -> contains(set, t) ? t : null; }
  
  ItIt<P<S>> parseFixedToken(S token, ListAndIndex<S> toParse) {
    ret filterI(pwt_followingTokens(1, maxTokens, toParse), p -> eqic(p!, token));
  }
  
  ItIt<P<S>> parseFixedToken_before(S token, ListAndIndex<S> toParse) {
    ret filterI(pwt_precedingTokens(1, maxTokens, toParse), p -> eqic(p!, token));
  }
  
  ItIt<P<S>> parseOneOfFixedTokens(Set<S> tokens, ListAndIndex<S> toParse) {
    ret filterI(pwt_followingTokens(1, maxTokens, toParse), p -> contains(tokens, p!));
  }
  
  ItIt<P<Weekday>> parseWeekday(ListAndIndex<S> toParse) {
    ret pwt_mapI(s -> new Weekday(parseEnglishWeekday(s)), parseOneOfFixedTokens(englishWeekdays_ciSet(), toParse));
  }
  
  ItIt<P<Month>> parseMonthName(ListAndIndex<S> toParse) {
    ret pwt_mapI(s -> new Month(parseEnglishMonthName(s)), parseOneOfFixedTokens(englishMonthNames_ciSet(), toParse));
  }
  
  <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()));
  }
}