Strip off TODO/FIXME

Summary: as the title says

Differential Revision: D4682120

fbshipit-source-id: 3f66286

Duckling/Dimensions/Types.hs

@@ -46,7 +46,6 @@ import Duckling.Volume.Types (VolumeData)
 -- -----------------------------------------------------------------
 -- Wrapper to house the existential
 
--- TODO: get rid of this t14593551
 data Some t = forall a . Some (t a)
 
 -- -----------------------------------------------------------------

Duckling/Duration/EN/Rules.hs

@@ -126,7 +126,6 @@ ruleDurationA = Rule
       _ -> Nothing
   }
 
--- TODO(jodent) precision t13807342
 ruleDurationPrecision :: Rule
 ruleDurationPrecision = Rule
   { name = "about|exactly <duration>"

Duckling/Duration/FR/Rules.hs

@@ -81,7 +81,6 @@ ruleTroisQuartsDHeure = Rule
   , prod = \_ -> Just . Token Duration $ duration TG.Minute 45
   }
 
--- TODO(jodent) precision t13807342
 ruleDurationEnviron :: Rule
 ruleDurationEnviron = Rule
   { name = "environ <duration>"

Duckling/Engine.hs

@@ -89,7 +89,6 @@ isRangeValid s (Range start end) =
     isDifferent :: Char -> Char -> Bool
     isDifferent a b = charClass a /= charClass b
 
--- TODO(jodent) use Attoparsec t12879001
 lookupRegex :: PCRE.Regex -> Int -> Text -> [Node]
 lookupRegex regex position s = nodes
   where
@@ -152,7 +151,6 @@ matchFirst sentence stash (rule@(Rule {pattern = p:ps}), position, route) =
 
 -- | Finds new matches resulting from newly added tokens.
 -- Produces new tokens from full matches.
--- TODO(jodent) partially order matches and find longest whitespace sequence
 parseString1 :: [Rule] -> Text -> Stash -> Stash -> [Match] -> (Stash, [Match])
 parseString1 rules sentence stash new matches =
   -- Produce full matches as new tokens

Duckling/Rules.hs

@@ -56,7 +56,6 @@ rulesFor lang targets
 
 -- | Returns all the rules for `lang`.
 -- We can't really use `allDimensions` as-is, since `TimeGrain` is not present.
--- TODO(jodent) t15599019
 allRules :: Lang -> [Rule]
 allRules lang = concatMap (rulesFor' lang) . HashSet.toList .
   explicitDimensions . HashSet.fromList $ allDimensions lang

Duckling/Time/EN/Rules.hs

@@ -45,7 +45,6 @@ ruleIntersect = Rule
       _ -> Nothing
   }
 
--- TODO(jodent) solve this in intersect (t14842790)
 ruleIntersect2 :: Rule
 ruleIntersect2 = Rule
   { name = "intersect2"
@@ -302,7 +301,6 @@ ruleYear = Rule
       _ -> Nothing
   }
 
--- FIXME (jodent) "8 tonight" intersection is not empty (2008-1-1) t14087284
 ruleYearPastLatent :: Rule
 ruleYearPastLatent = Rule
  { name = "past year (latent)"
@@ -873,7 +871,6 @@ ruleSeasons = Rule
 
   }
 
--- TODO(jodent) precision t13807342
 ruleTODPrecision :: Rule
 ruleTODPrecision = Rule
   { name = "<time-of-day> sharp|exactly"
@@ -1088,7 +1085,6 @@ ruleIntervalAfterTOD = Rule
       _ -> Nothing
   }
 
--- TODO(jodent) merge with previous rule
 ruleIntervalSinceTOD :: Rule
 ruleIntervalSinceTOD = Rule
   { name = "since <time-of-day>"
@@ -1203,7 +1199,6 @@ ruleMoreUSHolidays = map go moreUSHolidays
       , prod = \_ -> Just . Token Time $ nthDOWOfMonth n dow m
       }
 
--- TODO(jodent) nthDOWOfMonth (-1) 1 5
 -- Last Monday of May
 ruleMemorialDay :: Rule
 ruleMemorialDay = Rule

Duckling/Time/Helpers.hs

@@ -130,7 +130,6 @@ takeN n notImmediate f = mkSeriesPredicate series
             _ -> Nothing
           _ -> Nothing
 
--- TODO(jodent) use `timeSeqMap`
 -- | -1 is the first element in the past
 -- | 0 is the first element in the future
 takeNth :: Int -> Bool -> TTime.Predicate -> TTime.Predicate
@@ -186,7 +185,6 @@ takeLastOf cyclicPred basePred = timeSeqMap False f basePred
 timeCompose :: TTime.Predicate -> TTime.Predicate -> TTime.Predicate
 timeCompose pred1 pred2 = mkIntersectPredicate pred1 pred2
 
--- TODO(jodent) looks like dontReverse is redundant (check with :values)
 -- | Applies `f` to each interval yielded by `g`.
 -- | Intervals including "now" are in the future.
 timeSeqMap
@@ -344,7 +342,6 @@ isDOMValue = liftM2 (||) isDOMOrdinal isDOMInteger
 -- Production
 
 -- Pass the interval second
--- FIXME(jodent) check on explicit end and allow any order
 intersect :: (TimeData, TimeData) -> TimeData
 intersect (TimeData pred1 _ g1 _ _ d1, TimeData pred2 _ g2 _ _ d2)
   | g1 < g2 = TTime.timedata'