sclass EnglishDateParser > DateStructures {
  bool assumeFuture = true; // e.g. for "tuesday" [not used]
  LS tok;
  
  L<ParsedWithTokens<SomeDate>> longestParses(S s) {
    L<ParsedWithTokens<SomeDate>> l = pwt_filterByType SomeDate(allParses(s));
    new L<ParsedWithTokens<SomeDate>> topDogs;
    for (ParsedWithTokens<SomeDate> p : l)
      for (int i = p.iStart; i < p.iRemaining; i += 2)
        listPut(topDogs, i, pwt_winner(_get(topDogs, i), p));
    ret uniquify(nonNulls(topDogs));
  }
  
  SomeDate parse(S s) {
    ret getVar(first(longestParses(s)));
  }
  
  ItIt<ParsedWithTokens> allParses(S s) {
    tok = javaTok(s);
    
    new L<ParsedWithTokens> out;
    L<ParsedWithTokens<Int>> years = lazyListFromIterator(nestedIterator parseYear(lai_codeTokens(tok));
    print(+years);
    out.addAll(years);
    
    for (ParsedWithTokens<Int> year : years)
      for (ParsedWithTokens<S> slash : parseFixedToken("/", year.remaining()))
        for (ParsedWithTokens<Int> month : parseMonth(slash.remaining()))
          for (ParsedWithTokens<S> slash2 : parseFixedToken("/", month.remaining()))
            for (ParsedWithTokens<Int> day : parseDayOfMonth(slash2.remaining()))
              out.add(pwt_combine(new Day(day!, new Month(month!, new Year(year!))), year, day));
        
    ret itIt(out);
  }
  
  ItIt<ParsedWithTokens<Int>> parseNumber(ListAndIndex<S> toParse) {
    ret mapI_nonNulls(pwt_followingTokens(1, 2, toParse),
      p -> isInteger(p!) ? p.withValue(parseInt(p!)) : null);
  }
  
  ItIt<ParsedWithTokens<Int>> parseYear(ListAndIndex<S> toParse) {
    ret filterI(parseNumber(toParse), p -> between(p!, 1900, 2100));
  }
  
  ItIt<ParsedWithTokens<Int>> parseMonth(ListAndIndex<S> toParse) {
    ret filterI(parseNumber(toParse), p -> between(p!, 1, 12));
  }
  
  ItIt<ParsedWithTokens<Int>> parseDayOfMonth(ListAndIndex<S> toParse) {
    ret filterI(parseNumber(toParse), p -> between(p!, 1, 31));
  }
  
  ItIt<ParsedWithTokens<S>> parseFixedToken(S token, ListAndIndex<S> toParse) {
    ret filterI(pwt_followingTokens(1, 2, toParse), p -> eqic(p!, token));
  }
}