Duration/EN: Leverage TimeGrain for number.number hours

Summary: also kill redundant `isGrain` helper from `Time`.

Reviewed By: dwhit, haoxuany

Differential Revision: D18937649

fbshipit-source-id: ed658cc3bac70e6592dabae536a31a4c2da8a578

Duckling/Duration/EN/Rules.hs

@@ -101,7 +101,8 @@ ruleDurationDotNumeralHours :: Rule
 ruleDurationDotNumeralHours = Rule
   { name = "number.number hours"
   , pattern =
-    [ regex "(\\d+)\\.(\\d+) *h((ou)?rs?)?"
+    [ regex "(\\d+)\\.(\\d+)"
+    , Predicate $ isGrain TG.Hour
     ]
   , prod = \case
       (Token RegexMatch (GroupMatch (h:m:_)):_) -> do

Duckling/Time/DA/Rules.hs

@@ -17,6 +17,7 @@ import Data.Text (Text)
 import Prelude
 
 import Duckling.Dimensions.Types
+import Duckling.Duration.Helpers (isGrain)
 import Duckling.Numeral.Helpers (parseInt)
 import Duckling.Ordinal.Types (OrdinalData (..))
 import Duckling.Time.Helpers

Duckling/Time/DE/Rules.hs

@@ -18,13 +18,14 @@ import Data.Text (Text)
 import qualified Data.Text as Text
 
 import Duckling.Dimensions.Types
+import Duckling.Duration.Helpers (isGrain)
 import Duckling.Numeral.Helpers (parseInt)
-import Duckling.Ordinal.Types (OrdinalData (..))
+import Duckling.Ordinal.Types (OrdinalData(..))
 import Duckling.Regex.Types (GroupMatch(..))
 import Duckling.Time.Computed
 import Duckling.Time.Helpers
 import Duckling.Time.HolidayHelpers
-import Duckling.Time.Types (TimeData (..))
+import Duckling.Time.Types (TimeData(..))
 import Duckling.Types
 import qualified Duckling.Ordinal.Types as TOrdinal
 import qualified Duckling.Time.Types as TTime

Duckling/Time/EL/Rules.hs

@@ -10,7 +10,8 @@
 {-# LANGUAGE OverloadedStrings #-}
 
 module Duckling.Time.EL.Rules
-  ( rules ) where
+  ( rules
+  ) where
 
 import Data.HashMap.Strict (HashMap)
 import Data.Text (Text)
@@ -19,14 +20,14 @@ import qualified Data.HashMap.Strict as HashMap
 import qualified Data.Text as Text
 
 import Duckling.Dimensions.Types
-import Duckling.Duration.Helpers (duration)
+import Duckling.Duration.Helpers (duration, isGrain)
-import Duckling.Duration.Types (DurationData (DurationData))
+import Duckling.Duration.Types (DurationData(DurationData))
 import Duckling.Numeral.Helpers (parseInt, numeralMapEL)
-import Duckling.Numeral.Types (NumeralData (..))
+import Duckling.Numeral.Types (NumeralData(..))
-import Duckling.Ordinal.Types (OrdinalData (..), isBetween)
+import Duckling.Ordinal.Types (OrdinalData(..), isBetween)
 import Duckling.Regex.Types
 import Duckling.Time.Helpers
-import Duckling.Time.Types (TimeData (..))
+import Duckling.Time.Types (TimeData(..))
 import Duckling.Types
 import qualified Duckling.Numeral.Types as TNumeral
 import qualified Duckling.Ordinal.Types as TOrdinal

Duckling/Time/EN/Rules.hs

@@ -20,7 +20,7 @@ import Prelude
 import qualified Data.Text as Text
 
 import Duckling.Dimensions.Types
-import Duckling.Duration.Helpers (duration)
+import Duckling.Duration.Helpers (duration, isGrain)
 import Duckling.Duration.Types (DurationData (..))
 import Duckling.Numeral.Helpers (isNatural, parseInt)
 import Duckling.Numeral.Types (NumeralData (..))

Duckling/Time/ES/Rules.hs

@@ -10,17 +10,19 @@
 {-# LANGUAGE OverloadedStrings #-}
 
 module Duckling.Time.ES.Rules
-  ( rules ) where
+  ( rules
+  ) where
 
 import Prelude
 import qualified Data.Text as Text
 
 import Duckling.Dimensions.Types
+import Duckling.Duration.Helpers (isGrain)
 import Duckling.Numeral.Helpers (parseInt)
-import Duckling.Ordinal.Types (OrdinalData (..))
+import Duckling.Ordinal.Types (OrdinalData(..))
 import Duckling.Regex.Types
 import Duckling.Time.Helpers
-import Duckling.Time.Types (TimeData (..))
+import Duckling.Time.Types (TimeData(..))
 import Duckling.Types
 import qualified Duckling.Ordinal.Types as TOrdinal
 import qualified Duckling.Time.Types as TTime

Duckling/Time/GA/Rules.hs

@@ -10,18 +10,20 @@
 {-# LANGUAGE OverloadedStrings #-}
 
 module Duckling.Time.GA.Rules
-  ( rules ) where
+  ( rules
+  ) where
 
 import Data.Text (Text)
 import Prelude
 
 import Duckling.Dimensions.Types
+import Duckling.Duration.Helpers (isGrain)
 import Duckling.Numeral.Helpers (parseInt)
-import qualified Duckling.Ordinal.Types as TOrdinal
 import Duckling.Regex.Types
 import Duckling.Time.Helpers
-import qualified Duckling.TimeGrain.Types as TG
 import Duckling.Types
+import qualified Duckling.Ordinal.Types as TOrdinal
+import qualified Duckling.TimeGrain.Types as TG
 
 ruleArInn :: Rule
 ruleArInn = Rule

Duckling/Time/HE/Rules.hs

@@ -9,7 +9,8 @@
 {-# LANGUAGE OverloadedStrings #-}
 
 module Duckling.Time.HE.Rules
-  ( rules ) where
+  ( rules
+  ) where
 
 import Data.Maybe
 import Data.String
@@ -18,12 +19,13 @@ import Prelude
 import qualified Data.Text as Text
 
 import Duckling.Dimensions.Types
+import Duckling.Duration.Helpers (isGrain)
 import Duckling.Numeral.Helpers (parseInt)
-import Duckling.Numeral.Types (NumeralData (..))
+import Duckling.Numeral.Types (NumeralData(..))
-import Duckling.Ordinal.Types (OrdinalData (..))
+import Duckling.Ordinal.Types (OrdinalData(..))
 import Duckling.Regex.Types
 import Duckling.Time.Helpers
-import Duckling.Time.Types (TimeData (..))
+import Duckling.Time.Types (TimeData(..))
 import Duckling.Types
 import qualified Duckling.Numeral.Types as TNumeral
 import qualified Duckling.Ordinal.Types as TOrdinal

Duckling/Time/HR/Rules.hs

@@ -19,12 +19,13 @@ import Prelude
 import qualified Data.Text as Text
 
 import Duckling.Dimensions.Types
+import Duckling.Duration.Helpers (isGrain)
 import Duckling.Numeral.Helpers (parseInt)
-import Duckling.Numeral.Types (NumeralData (..))
+import Duckling.Numeral.Types (NumeralData(..))
-import Duckling.Ordinal.Types (OrdinalData (..))
+import Duckling.Ordinal.Types (OrdinalData(..))
 import Duckling.Regex.Types
 import Duckling.Time.Helpers
-import Duckling.Time.Types (TimeData (..))
+import Duckling.Time.Types (TimeData(..))
 import Duckling.Types
 import qualified Duckling.Numeral.Types as TNumeral
 import qualified Duckling.Ordinal.Types as TOrdinal

Duckling/Time/Helpers.hs

@@ -13,7 +13,7 @@ module Duckling.Time.Helpers
   ( -- Patterns
     hasNoDirection, isADayOfWeek, isAMonth, isAnHourOfDay, isAPartOfDay
   , isATimeOfDay, isDurationGreaterThan, isDOMInteger, isDOMOrdinal, isDOMValue
-  , isGrain, isGrainFinerThan, isGrainCoarserThan, isGrainOfTime
+  , isGrainFinerThan, isGrainCoarserThan, isGrainOfTime
   , isIntegerBetween, isNotLatent , isOrdinalBetween, isMidnightOrNoon
   , isOkWithThisNext, sameGrain, hasTimezone, hasNoTimezone, today
     -- Production
@@ -267,10 +267,6 @@ shiftTimezone providedSeries pred1 =
 -- -----------------------------------------------------------------
 -- Patterns
 
-isGrain :: TG.Grain -> Predicate
-isGrain value (Token TimeGrain grain) = grain == value
-isGrain _ _ = False
-
 isGrainFinerThan :: TG.Grain -> Predicate
 isGrainFinerThan value (Token Time TimeData{TTime.timeGrain = g}) = g < value
 isGrainFinerThan _ _ = False

Duckling/Time/IT/Rules.hs

@@ -10,19 +10,21 @@
 {-# LANGUAGE OverloadedStrings #-}
 
 module Duckling.Time.IT.Rules
-  ( rules ) where
+  ( rules
+  ) where
 
 import Data.Text (Text)
 import Prelude
 import qualified Data.Text as Text
 
 import Duckling.Dimensions.Types
+import Duckling.Duration.Helpers (isGrain)
 import Duckling.Numeral.Helpers (parseInt)
 import Duckling.Numeral.Types (NumeralData(..))
 import Duckling.Ordinal.Types (OrdinalData(..))
 import Duckling.Regex.Types
 import Duckling.Time.Helpers
-import Duckling.Time.Types (TimeData (..))
+import Duckling.Time.Types (TimeData(..))
 import Duckling.Types
 import qualified Duckling.Numeral.Types as TNumeral
 import qualified Duckling.Ordinal.Types as TOrdinal

Duckling/Time/KA/Rules.hs

@@ -21,15 +21,15 @@ import Prelude
 import qualified Data.Text as Text
 
 import Duckling.Dimensions.Types
-import Duckling.Duration.Helpers (duration)
+import Duckling.Duration.Helpers (duration, isGrain)
-import Duckling.Duration.Types (DurationData (..))
+import Duckling.Duration.Types (DurationData(..))
 import Duckling.Numeral.Helpers (isNatural, parseInt)
-import Duckling.Numeral.Types (NumeralData (..))
+import Duckling.Numeral.Types (NumeralData(..))
-import Duckling.Ordinal.Types (OrdinalData (..))
+import Duckling.Ordinal.Types (OrdinalData(..))
 import Duckling.Regex.Types
 import Duckling.Time.Computed
 import Duckling.Time.Helpers
-import Duckling.Time.Types (TimeData (..))
+import Duckling.Time.Types (TimeData(..))
 import Duckling.Types
 import qualified Duckling.Duration.Types as TDuration
 import qualified Duckling.Numeral.Types as TNumeral

Duckling/Time/KO/Rules.hs

@@ -16,11 +16,12 @@ import Prelude
 import qualified Data.Text as Text
 
 import Duckling.Dimensions.Types
+import Duckling.Duration.Helpers (isGrain)
 import Duckling.Numeral.Helpers (parseInt)
-import Duckling.Ordinal.Types (OrdinalData (..))
+import Duckling.Ordinal.Types (OrdinalData(..))
 import Duckling.Regex.Types
 import Duckling.Time.Helpers
-import Duckling.Time.Types (TimeData (..))
+import Duckling.Time.Types (TimeData(..))
 import Duckling.Types
 import qualified Duckling.Ordinal.Types as TOrdinal
 import qualified Duckling.Time.Types as TTime

Duckling/Time/NB/Rules.hs

@@ -10,17 +10,19 @@
 {-# LANGUAGE OverloadedStrings #-}
 
 module Duckling.Time.NB.Rules
-  ( rules ) where
+  ( rules
+  ) where
 
 import Data.Text (Text)
 import Prelude
 
 import Duckling.Dimensions.Types
+import Duckling.Duration.Helpers (isGrain)
 import Duckling.Numeral.Helpers (parseInt)
-import Duckling.Ordinal.Types (OrdinalData (..))
+import Duckling.Ordinal.Types (OrdinalData(..))
 import Duckling.Regex.Types
 import Duckling.Time.Helpers
-import Duckling.Time.Types (TimeData (..))
+import Duckling.Time.Types (TimeData(..))
 import Duckling.Types
 import qualified Data.Text as Text
 import qualified Duckling.Ordinal.Types as TOrdinal

Duckling/Time/NL/Rules.hs

@@ -18,14 +18,14 @@ import Prelude
 import qualified Data.Text as Text
 
 import Duckling.Dimensions.Types
-import Duckling.Duration.Helpers (duration)
+import Duckling.Duration.Helpers (duration, isGrain)
 import Duckling.Numeral.Helpers (parseInt)
-import Duckling.Numeral.Types (NumeralData (..))
+import Duckling.Numeral.Types (NumeralData(..))
-import Duckling.Ordinal.Types (OrdinalData (..))
+import Duckling.Ordinal.Types (OrdinalData(..))
 import Duckling.Regex.Types
 import Duckling.Time.Helpers
 import Duckling.Time.HolidayHelpers
-import Duckling.Time.Types (TimeData (..))
+import Duckling.Time.Types (TimeData(..))
 import Duckling.Types
 import qualified Duckling.Numeral.Types as TNumeral
 import qualified Duckling.Ordinal.Types as TOrdinal

Duckling/Time/PL/Rules.hs

@@ -10,17 +10,19 @@
 {-# LANGUAGE OverloadedStrings #-}
 
 module Duckling.Time.PL.Rules
-  ( rules ) where
+  ( rules
+  ) where
 
 import Prelude
 import qualified Data.Text as Text
 
 import Duckling.Dimensions.Types
+import Duckling.Duration.Helpers (isGrain)
 import Duckling.Numeral.Helpers (parseInt)
 import Duckling.Ordinal.Types (OrdinalData(..))
 import Duckling.Regex.Types
 import Duckling.Time.Helpers
-import Duckling.Time.Types (TimeData (..))
+import Duckling.Time.Types (TimeData(..))
 import Duckling.Time.Computed
 import Duckling.Types
 import qualified Duckling.Ordinal.Types as TOrdinal

Duckling/Time/PT/Rules.hs

@@ -18,15 +18,16 @@ import Prelude
 import qualified Data.Text as Text
 
 import Duckling.Dimensions.Types
+import Duckling.Duration.Helpers (isGrain)
 import Duckling.Numeral.Helpers (parseInt)
+import Duckling.Ordinal.Types (OrdinalData(..))
 import Duckling.Regex.Types
 import Duckling.Time.Helpers
-import Duckling.Time.Types (TimeData (..))
+import Duckling.Time.Types (TimeData(..))
 import Duckling.Types
-import Duckling.Ordinal.Types (OrdinalData (..))
+import qualified Duckling.Ordinal.Types as TOrdinal
 import qualified Duckling.Time.Types as TTime
 import qualified Duckling.TimeGrain.Types as TG
-import qualified Duckling.Ordinal.Types as TOrdinal
 
 ruleSHourmintimeofday :: Rule
 ruleSHourmintimeofday = Rule

Duckling/Time/RO/Rules.hs

@@ -16,10 +16,11 @@ import Data.Text (Text)
 import Prelude
 
 import Duckling.Dimensions.Types
+import Duckling.Duration.Helpers (isGrain)
 import Duckling.Numeral.Helpers (parseInt)
 import Duckling.Regex.Types
 import Duckling.Time.Helpers
-import Duckling.Time.Types (TimeData (..))
+import Duckling.Time.Types (TimeData(..))
 import Duckling.Types
 import qualified Data.Text as Text
 import qualified Duckling.Time.Types as TTime

Duckling/Time/SV/Rules.hs

@@ -10,17 +10,19 @@
 {-# LANGUAGE OverloadedStrings #-}
 
 module Duckling.Time.SV.Rules
-  ( rules ) where
+  ( rules
+  ) where
 
 import Data.Text (Text)
 import Prelude
 
 import Duckling.Dimensions.Types
+import Duckling.Duration.Helpers (isGrain)
 import Duckling.Numeral.Helpers (parseInt)
-import Duckling.Ordinal.Types (OrdinalData (..))
+import Duckling.Ordinal.Types (OrdinalData(..))
 import Duckling.Regex.Types
 import Duckling.Time.Helpers
-import Duckling.Time.Types (TimeData (..))
+import Duckling.Time.Types (TimeData(..))
 import Duckling.Types
 import qualified Data.Text as Text
 import qualified Duckling.Ordinal.Types as TOrdinal

Duckling/Time/UK/Rules.hs

@@ -10,18 +10,20 @@
 {-# LANGUAGE OverloadedStrings #-}
 
 module Duckling.Time.UK.Rules
-  ( rules ) where
+  ( rules
+  ) where
 
 import Prelude
 import Data.Text (Text)
 import qualified Data.Text as Text
 
 import Duckling.Dimensions.Types
+import Duckling.Duration.Helpers (isGrain)
 import Duckling.Numeral.Helpers (parseInt)
-import Duckling.Ordinal.Types (OrdinalData (..))
+import Duckling.Ordinal.Types (OrdinalData(..))
 import Duckling.Regex.Types
 import Duckling.Time.Helpers
-import Duckling.Time.Types (TimeData (..))
+import Duckling.Time.Types (TimeData(..))
 import Duckling.Types
 import qualified Duckling.Ordinal.Types as TOrdinal
 import qualified Duckling.Time.Types as TTime

Duckling/Time/VI/Rules.hs

@@ -9,19 +9,21 @@
 {-# LANGUAGE OverloadedStrings #-}
 
 module Duckling.Time.VI.Rules
-  ( rules ) where
+  ( rules
+  ) where
 
 import Prelude
 import Data.Text (Text)
 import qualified Data.Text as Text
 
 import Duckling.Dimensions.Types
+import Duckling.Duration.Helpers (isGrain)
 import Duckling.Numeral.Helpers (parseInt)
 import Duckling.Numeral.Types (NumeralData(..))
 import Duckling.Ordinal.Types (OrdinalData(..))
 import Duckling.Regex.Types
 import Duckling.Time.Helpers
-import Duckling.Time.Types (TimeData (..))
+import Duckling.Time.Types (TimeData(..))
 import Duckling.Types
 import qualified Duckling.Numeral.Types as TNumeral
 import qualified Duckling.Ordinal.Types as TOrdinal